From 4ee3c63b48abc533d5b2f68702ce7f08e76742ce Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 23:43:14 -0700 Subject: [PATCH 01/26] chore(quest): claim quest/m2/ts-byte-views/arguments.md Quest-Claim: c39cdeba9d4b6c36 From 6a20d838a0f9a72f12479de223490686db0a67ea Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 23:56:54 -0700 Subject: [PATCH 02/26] perf(ts): pass byte slices to translated functions as their parts Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/codec/expected/bench.ts | 125 +++--- .../codec/expected/coding/decode.Decoder.ts | 9 +- .../codec/expected/coding/encode.Encoder.ts | 13 +- ts/fixtures/codec/expected/coding/varint.ts | 118 +++--- .../codec/expected/coding/version.Versions.ts | 6 +- ts/fixtures/codec/expected/harness.ts | 123 +++--- .../codec/expected/lite/group.Group.ts | 6 +- .../codec/expected/lite/probe.Probe.ts | 6 +- ts/fixtures/lang/brands.ts | 4 +- ts/fixtures/lang/expected/chars.ts | 14 +- ts/fixtures/lang/expected/chunks.ts | 71 ++-- ts/fixtures/lang/expected/collections.ts | 18 +- ts/fixtures/lang/expected/combinators.ts | 3 +- ts/fixtures/lang/expected/core/option.ts | 4 +- ts/fixtures/lang/expected/cows.ts | 4 +- ts/fixtures/lang/expected/durations.ts | 17 +- ts/fixtures/lang/expected/fmt.ts | 92 +++-- ts/fixtures/lang/expected/generics.ts | 3 +- ts/fixtures/lang/expected/harness.ts | 118 +++--- ts/fixtures/lang/expected/ints.ts | 60 ++- ts/fixtures/lang/expected/iters.ts | 45 ++- ts/fixtures/lang/expected/keys.ts | 97 +++-- ts/fixtures/lang/expected/refs.ts | 15 +- ts/fixtures/lang/expected/shapes.ts | 367 ++++++++++-------- ts/fixtures/lang/expected/splits.ts | 114 +++--- ts/fixtures/lang/expected/strs.ts | 28 +- ts/src/lower/body.rs | 52 ++- ts/src/lower/mir/mod.rs | 34 +- ts/src/lower/mir/scalar.rs | 144 ++++++- ts/src/lower/mod.rs | 5 + ts/tests/fixtures.rs | 4 +- 31 files changed, 1020 insertions(+), 699 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 5fedab81f..02f61f3c6 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -22,29 +22,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { if (input.length - 1 !== 0) { const selector: rt.u8 = input.data[input.start + 1]; if (op === 0) { - encoded(encodeVarints(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); + encoded(encodeVarints(input.data, input.start + 2, input.length - 2, form(selector), out), out); } else if (op === 1) { - decoded(decodeVarints(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); + decoded(decodeVarints(input.data, input.start + 2, input.length - 2, form(selector), out), out); } else if (op === 2) { - encoded(encodeFrames(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + encoded(encodeFrames(input.data, input.start + 2, input.length - 2, liteVersion(selector), out), out); } else if (op === 3) { - decoded(decodeFrames(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + decoded(decodeFrames(input.data, input.start + 2, input.length - 2, liteVersion(selector), out), out); } else if (op === 4) { - encoded(encodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + encoded(encodeGroup(input.data, input.start + 2, input.length - 2, liteVersion(selector), out), out); } else if (op === 6) { - iterate(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + iterate(selector, input.data, input.start + 2, input.length - 2, out); } else if (op === 7) { - decoded(decodeSplit(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + decoded(decodeSplit(input.data, input.start + 2, input.length - 2, liteVersion(selector), out), out); } else if (op === 8) { - ordered(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + ordered(input.data, input.start + 2, input.length - 2, out); } else if (op === 9) { - rescale(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + rescale(selector, input.data, input.start + 2, input.length - 2, out); } else if (op === 10) { - stamp(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + stamp(input.data, input.start + 2, input.length - 2, out); } else if (op === 11) { - interleave(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + interleave(input.data, input.start + 2, input.length - 2, out); } else { - decoded(decodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + decoded(decodeGroup(input.data, input.start + 2, input.length - 2, liteVersion(selector), out), out); } return out; } @@ -66,10 +66,10 @@ export function decoded(result: rt.Result, o } /** The same value, `count` times. */ -export function encodeVarints(data: rt.ByteSlice, form_: Form.Form, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); +export function encodeVarints(dataData: Uint8Array, dataStart: number, dataLen: number, form_: Form.Form, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const count: rt.u64 = _6[0]; - const value: rt.u64 = takeU64(_6[1])[0]; + const value: rt.u64 = takeU64(_6[1].data, _6[1].start, _6[1].length)[0]; const w: Encoder.Encoder = Encoder.new(out, form_); let iterStart: rt.usize = 0; const iterEnd: rt.usize = rt.u64Low(count); @@ -83,8 +83,8 @@ export function encodeVarints(data: rt.ByteSlice, form_: Form.Form, out: rt.Byte } /** Every varint on the wire: how many, and the last. */ -export function decodeVarints(wire: rt.ByteSlice, form_: Form.Form, out: rt.ByteVec): rt.Result { - const r: Decoder.Decoder = Decoder.new(wire, form_); +export function decodeVarints(wireData: Uint8Array, wireStart: number, wireLen: number, form_: Form.Form, out: rt.ByteVec): rt.Result { + const r: Decoder.Decoder = Decoder.new(wireData, wireStart, wireLen, form_); let count: rt.usize = 0; let last: rt.u64 = 0; while (!Decoder.isEmpty(r)) { @@ -106,20 +106,20 @@ export function decodeVarints(wire: rt.ByteSlice, form_: Form.Form, out: rt.Byte * zigzag timestamp delta, then the size. The first frame has no delta and its own size, * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ -export function encodeFrames(data: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { +export function encodeFrames(dataData: Uint8Array, dataStart: number, dataLen: number, version: Version.Version, out: rt.ByteVec): rt.Result { let _32!: rt.usize; let _38!: [rt.i64, rt.u64]; - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); + const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const count: rt.u64 = _6[0]; - const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); + const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1].data, _6[1].start, _6[1].length); const delta: rt.u64 = _9[0]; - const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); + const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1].data, _9[1].start, _9[1].length); const first: rt.u64 = _12[0]; - const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); + const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1].data, _12[1].start, _12[1].length); const size: rt.u64 = _15[0]; - const _18: [rt.u64, rt.ByteSlice] = takeU64(_15[1]); + const _18: [rt.u64, rt.ByteSlice] = takeU64(_15[1].data, _15[1].start, _15[1].length); const keyEvery: rt.u64 = _18[0]; - const keySize: rt.u64 = takeU64(_18[1])[0]; + const keySize: rt.u64 = takeU64(_18[1].data, _18[1].start, _18[1].length)[0]; const _24: rt.i64 = rt.i64Cast(delta); const _23: [rt.i64, rt.usize] = [_24, rt.u64Low(keyEvery)]; const delta2: rt.i64 = _24; @@ -159,8 +159,8 @@ export function encodeFrames(data: rt.ByteSlice, version: Version.Version, out: } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ -export function decodeFrames(wire: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { - const r: Decoder.Decoder = Decoder.new(wire, Form.from$From_Version(version)); +export function decodeFrames(wireData: Uint8Array, wireStart: number, wireLen: number, version: Version.Version, out: rt.ByteVec): rt.Result { + const r: Decoder.Decoder = Decoder.new(wireData, wireStart, wireLen, Form.from$From_Version(version)); let count: rt.usize = 0; let total: rt.u64 = 0; let last: rt.i64 = 0; @@ -192,8 +192,8 @@ export function decodeFrames(wire: rt.ByteSlice, version: Version.Version, out: * decoded again from its start on the next. How many, their total size, the last delta, * and how many decodes came up short. */ -export function decodeSplit(data: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); +export function decodeSplit(dataData: Uint8Array, dataStart: number, dataLen: number, version: Version.Version, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const read2: rt.usize = rt.max(rt.u64Low(_6[0]), 1); let start: rt.usize = 0; let end: rt.usize = 0; @@ -207,7 +207,8 @@ export function decodeSplit(data: rt.ByteSlice, version: Version.Version, out: r if (!(start < end)) { continue l2; } - const r: Decoder.Decoder = Decoder.new(rt.byteSliceRange(_6[1], start, end), Form.from$From_Version(version)); + const _27: rt.ByteSlice = rt.byteSliceRange(_6[1], start, end); + const r: Decoder.Decoder = Decoder.new(_27.data, _27.start, _27.length, Form.from$From_Version(version)); const _32: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError> = frameHeader(r); if (_32.ok) { const delta: rt.i64 = _32.value[0]; @@ -250,9 +251,9 @@ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], Dec } /** One size-prefixed GROUP header, starting at the first frame. */ -export function encodeGroup(data: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); - const group: Group.Group = { subscribe: _6[0], sequence: takeU64(_6[1])[0], frameStart: 0 }; +export function encodeGroup(dataData: Uint8Array, dataStart: number, dataLen: number, version: Version.Version, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); + const group: Group.Group = { subscribe: _6[0], sequence: takeU64(_6[1].data, _6[1].start, _6[1].length)[0], frameStart: 0 }; return Group.encode$Encode_Version(group, Encoder.new(out, Form.from$From_Version(version)), version); } @@ -261,14 +262,14 @@ export function encodeGroup(data: rt.ByteSlice, version: Version.Version, out: r * up, summed over a quarter of the key space, and removed again. The sum of the values * found. */ -export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _15!: rt.u32; let _28!: rt.u32; let _66!: rt.u32; const _10: (a0: rt.u32) => rt.u32 = (i4: rt.u32): rt.u32 => { return rt.u32Rem(rt.u32Mul(i4, 40503), 1 << 16); }; - const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); + const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(dataData, dataStart, dataLen)[0], 65536)); const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; let iterStart: rt.u32 = 0; const iterEnd: rt.u32 = count2; @@ -306,32 +307,32 @@ export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { * One iterator chain over every byte, picked by `chain`, with closures that cost little * next to the iterator protocol they run through. */ -export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function iterate(chain: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { if (chain === 0) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): rt.u8 => { + putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_211: rt.u8): rt.u8 => { return _211 >> 1; }), (_212: rt.u8): boolean => { return (_212 & 1) === 0; }))); } else if (chain === 1) { - rt.byteVecPush(out, rt.iterAny(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { + rt.byteVecPush(out, rt.iterAny(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_210: rt.u8): boolean => { return _210 === 255; }) ? 1 : 0); } else if (chain === 2) { - putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): boolean => { + putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_28: rt.u8): boolean => { return (_28 & 1) === 1; })).length); } else if (chain === 3) { - putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { + putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; }), rt.u32Add, 0) as rt.u64); } else if (chain === 4) { - putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { + putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { return (acc ^ _3 as rt.u32) >>> 0; }) as rt.u64); } else { let last: rt.usize = 0; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))); while (true) { const _33: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_33 === rt.DONE) { @@ -351,18 +352,18 @@ export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `Timestamp::convert` in `u128`, or the same in `u64` (selector 1), which overflows * sooner. How many converted, how many overflowed, and the last converted. */ -export function rescale(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function rescale(selector: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _26!: rt.usize; let scaled!: rt.u64 | undefined; - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); + const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const count: rt.u64 = _6[0]; - const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); + const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1].data, _6[1].start, _6[1].length); const start: rt.u64 = _9[0]; - const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); + const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1].data, _9[1].start, _9[1].length); const step: rt.u64 = _12[0]; - const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); + const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1].data, _12[1].start, _12[1].length); const from: rt.u64 = _15[0]; - const to: rt.u64 = takeU64(_15[1])[0]; + const to: rt.u64 = takeU64(_15[1].data, _15[1].start, _15[1].length)[0]; let converted: rt.u64 = 0; let overflowed: rt.u64 = 0; let last: rt.u64 = 0; @@ -415,14 +416,14 @@ export function bounded(value: rt.u128): rt.u64 | undefined { * A track's frames stamped one duration apart by [`Timestamp::checked_add`], as a * publisher stamps them. How many were stamped, how many overflowed, and the last. */ -export function stamp(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u64, rt.ByteSlice] = takeU64(data); +export function stamp(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _5: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const count: rt.u64 = _5[0]; - const _8: [rt.u64, rt.ByteSlice] = takeU64(_5[1]); + const _8: [rt.u64, rt.ByteSlice] = takeU64(_5[1].data, _5[1].start, _5[1].length); const start: rt.u64 = _8[0]; - const _11: [rt.u64, rt.ByteSlice] = takeU64(_8[1]); + const _11: [rt.u64, rt.ByteSlice] = takeU64(_8[1].data, _8[1].start, _8[1].length); const step: rt.u64 = _11[0]; - const scale: rt.u64 = takeU64(_11[1])[0]; + const scale: rt.u64 = takeU64(_11[1].data, _11[1].start, _11[1].length)[0]; let time: Timestamp.Timestamp = { value: start, scale }; let stamped: rt.u64 = 0; let overflowed: rt.u64 = 0; @@ -451,13 +452,13 @@ export function stamp(data: rt.ByteSlice, out: rt.ByteVec): void { * comparison per frame taken. How many came from each track, and how many times the * interleave switched tracks. */ -export function interleave(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u64, rt.ByteSlice] = takeU64(data); +export function interleave(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _5: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const count: rt.u64 = _5[0]; - const _9: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_5[1]); + const _9: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_5[1].data, _5[1].start, _5[1].length); const a: Timestamp.Timestamp = copy$Timestamp(_9[0]); const aStep: rt.u64 = _9[1]; - const _12: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_9[2]); + const _12: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_9[2].data, _9[2].start, _9[2].length); const b: Timestamp.Timestamp = copy$Timestamp(_12[0]); const bStep: rt.u64 = _12[1]; let fromA: rt.u64 = 0; @@ -485,17 +486,17 @@ export function interleave(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A track's first timestamp and its frame duration: start, step, and scale. */ -export function track(data: rt.ByteSlice): [Timestamp.Timestamp, rt.u64, rt.ByteSlice] { - const _4: [rt.u64, rt.ByteSlice] = takeU64(data); +export function track(dataData: Uint8Array, dataStart: number, dataLen: number): [Timestamp.Timestamp, rt.u64, rt.ByteSlice] { + const _4: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); const value: rt.u64 = _4[0]; - const _7: [rt.u64, rt.ByteSlice] = takeU64(_4[1]); + const _7: [rt.u64, rt.ByteSlice] = takeU64(_4[1].data, _4[1].start, _4[1].length); const step: rt.u64 = _7[0]; - const _10: [rt.u64, rt.ByteSlice] = takeU64(_7[1]); + const _10: [rt.u64, rt.ByteSlice] = takeU64(_7[1].data, _7[1].start, _7[1].length); return [{ value, scale: _10[0] }, step, _10[1]] as [Timestamp.Timestamp, rt.u64, rt.ByteSlice]; } -export function decodeGroup(wire: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { - const _6: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(wire, version); +export function decodeGroup(wireData: Uint8Array, wireStart: number, wireLen: number, version: Version.Version, out: rt.ByteVec): rt.Result { + const _6: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(wireData, wireStart, wireLen, version); if (_6.ok) { const val: [Group.Group, rt.usize] = _6.value; const group: Group.Group = val[0]; diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 1dd9b473e..acdf6cf82 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -30,8 +30,8 @@ export interface Decoder { } /** Read `buf`, with varints in the given form. */ -function new_(buf: rt.ByteSlice, form: Form.Form): Decoder { - return { buf, form, len: buf.length, need: 0, control: undefined, uncounted: 0 }; +function new_(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): Decoder { + return { buf: new rt.ByteSlice(bufData, bufStart, bufLen), form, len: bufLen, need: 0, control: undefined, uncounted: 0 }; } /** @@ -81,7 +81,7 @@ export function rest(self: Decoder): rt.ByteSlice { export function sub(self: Decoder, len: rt.usize): rt.Result { const _4: rt.Result = slice(self, len); if (_4.ok) { - return rt.Ok(new_(_4.value, self.form)); + return rt.Ok(new_(_4.value.data, _4.value.start, _4.value.length, self.form)); } return _4; } @@ -127,7 +127,8 @@ export function bool(self: Decoder): rt.Result /** Read a varint. */ export function varint(self: Decoder): rt.Result { let _0!: rt.Result; - const _2: rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> = read(self.buf, self.form); + const _13: rt.ByteSlice = self.buf; + const _2: rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> = read(_13.data, _13.start, _13.length, self.form); if (_2.ok) { const value: rt.u64 = _2.value[0]; self.buf = _2.value[1]; diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index 85498266b..48fdfc43f 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -27,8 +27,8 @@ function new_(buf: rt.ByteVec, form: Form.Form): Encoder { } /** Write raw bytes. */ -export function slice(self: Encoder, v: rt.ByteSlice): void { - rt.byteVecExtendFromSlice(self.buf, v); +export function slice(self: Encoder, vData: Uint8Array, vStart: number, vLen: number): void { + rt.byteVecExtendFromSlice(self.buf, new rt.ByteSlice(vData, vStart, vLen)); } /** Write a single byte. */ @@ -71,10 +71,10 @@ export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { - const _3: rt.Result = varint(self, v.length as rt.u64); +export function bytes(self: Encoder, vData: Uint8Array, vStart: number, vLen: number): rt.Result { + const _3: rt.Result = varint(self, vLen as rt.u64); if (_3.ok) { - slice(self, v); + slice(self, vData, vStart, vLen); return rt.OK; } return _3; @@ -82,7 +82,8 @@ export function bytes(self: Encoder, v: rt.ByteSlice): rt.Result { - return bytes(self, rt.stringAsBytes(v)); + const _3: rt.ByteSlice = rt.stringAsBytes(v); + return bytes(self, _3.data, _3.start, _3.length); } /** diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 7ff15c5d0..c6a89e563 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -191,94 +191,94 @@ export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ -export function read(buf: rt.ByteSlice, form: Form.Form): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { +export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { if (form.tag === "Quic") { - return readQuic(buf); + return readQuic(bufData, bufStart, bufLen); } - return readLeadingOnes(buf, form.seven); + return readLeadingOnes(bufData, bufStart, bufLen, form.seven); } -export function readQuic(buf: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { - if (buf.length !== 0) { - const first: rt.u8 = buf.data[buf.start]; +export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { + if (bufLen !== 0) { + const first: rt.u8 = bufData[bufStart]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { - if (buf.length >= 8) { - return rt.Ok([fromHalves((((buf.data[buf.start] & 63) << 24) | (buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3]) >>> 0, ((buf.data[buf.start + 4] << 24) | (buf.data[buf.start + 5] << 16) | (buf.data[buf.start + 6] << 8) | buf.data[buf.start + 7]) >>> 0), new rt.ByteSlice(buf.data, buf.start + 8, buf.length - 8)] as [rt.u64, rt.ByteSlice]); + if (bufLen >= 8) { + return rt.Ok([fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0), new rt.ByteSlice(bufData, bufStart + 8, bufLen - 8)] as [rt.u64, rt.ByteSlice]); } return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - if (buf.length >= 4) { - return rt.Ok([(((buf.data[buf.start] & 63) << 24) | (buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3]) >>> 0 as rt.u64, new rt.ByteSlice(buf.data, buf.start + 4, buf.length - 4)] as [rt.u64, rt.ByteSlice]); + if (bufLen >= 4) { + return rt.Ok([(((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64, new rt.ByteSlice(bufData, bufStart + 4, bufLen - 4)] as [rt.u64, rt.ByteSlice]); } return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - if (buf.length >= 2) { - return rt.Ok([(((buf.data[buf.start] & 63) << 8) | buf.data[buf.start + 1]) as rt.u64, new rt.ByteSlice(buf.data, buf.start + 2, buf.length - 2)] as [rt.u64, rt.ByteSlice]); + if (bufLen >= 2) { + return rt.Ok([(((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64, new rt.ByteSlice(bufData, bufStart + 2, bufLen - 2)] as [rt.u64, rt.ByteSlice]); } return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - 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.Ok([first as rt.u64, new rt.ByteSlice(bufData, bufStart + 1, bufLen - 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> { +export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { let _8_0!: rt.u64; let _8_1Data!: Uint8Array; let _8_1Start!: number; let _8_1Len!: number; - if (buf.length !== 0) { - const first: rt.u8 = buf.data[buf.start]; + if (bufLen !== 0) { + const first: rt.u8 = bufData[bufStart]; const _9: rt.u32 = rt.u8LeadingOnes(first); if (_9 === 0) { _8_0 = first as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 1; - _8_1Len = buf.length - 1; + _8_1Data = bufData; + _8_1Start = bufStart + 1; + _8_1Len = bufLen - 1; } else if (_9 === 1) { - if (buf.length >= 2) { - _8_0 = (((buf.data[buf.start] & 63) << 8) | buf.data[buf.start + 1]) as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 2; - _8_1Len = buf.length - 2; + if (bufLen >= 2) { + _8_0 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + _8_1Data = bufData; + _8_1Start = bufStart + 2; + _8_1Len = bufLen - 2; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 2) { - if (buf.length >= 3) { - _8_0 = (((buf.data[buf.start] & 31) << 16) | (buf.data[buf.start + 1] << 8) | buf.data[buf.start + 2]) as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 3; - _8_1Len = buf.length - 3; + if (bufLen >= 3) { + _8_0 = (((bufData[bufStart] & 31) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2]) as rt.u64; + _8_1Data = bufData; + _8_1Start = bufStart + 3; + _8_1Len = bufLen - 3; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 3) { - if (buf.length >= 4) { - _8_0 = (((buf.data[buf.start] & 15) << 24) | (buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3]) >>> 0 as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 4; - _8_1Len = buf.length - 4; + if (bufLen >= 4) { + _8_0 = (((bufData[bufStart] & 15) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + _8_1Data = bufData; + _8_1Start = bufStart + 4; + _8_1Len = bufLen - 4; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 4) { - if (buf.length >= 5) { - _8_0 = fromHalves(((buf.data[buf.start] & 7)) as rt.u32, ((buf.data[buf.start + 1] << 24) | (buf.data[buf.start + 2] << 16) | (buf.data[buf.start + 3] << 8) | buf.data[buf.start + 4]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 5; - _8_1Len = buf.length - 5; + if (bufLen >= 5) { + _8_0 = fromHalves(((bufData[bufStart] & 7)) as rt.u32, ((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 5; + _8_1Len = bufLen - 5; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 5) { - if (buf.length >= 6) { - _8_0 = fromHalves(((buf.data[buf.start] & 3) << 8) | buf.data[buf.start + 1], ((buf.data[buf.start + 2] << 24) | (buf.data[buf.start + 3] << 16) | (buf.data[buf.start + 4] << 8) | buf.data[buf.start + 5]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 6; - _8_1Len = buf.length - 6; + if (bufLen >= 6) { + _8_0 = fromHalves(((bufData[bufStart] & 3) << 8) | bufData[bufStart + 1], ((bufData[bufStart + 2] << 24) | (bufData[bufStart + 3] << 16) | (bufData[bufStart + 4] << 8) | bufData[bufStart + 5]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 6; + _8_1Len = bufLen - 6; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } @@ -286,28 +286,28 @@ export function readLeadingOnes(buf: rt.ByteSlice, seven: boolean): rt.Result<[r if (!seven) { return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); } - if (buf.length >= 7) { - _8_0 = fromHalves(((buf.data[buf.start] & 1) << 16) | (buf.data[buf.start + 1] << 8) | buf.data[buf.start + 2], ((buf.data[buf.start + 3] << 24) | (buf.data[buf.start + 4] << 16) | (buf.data[buf.start + 5] << 8) | buf.data[buf.start + 6]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 7; - _8_1Len = buf.length - 7; + if (bufLen >= 7) { + _8_0 = fromHalves(((bufData[bufStart] & 1) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2], ((bufData[bufStart + 3] << 24) | (bufData[bufStart + 4] << 16) | (bufData[bufStart + 5] << 8) | bufData[bufStart + 6]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 7; + _8_1Len = bufLen - 7; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 7) { - if (buf.length >= 8) { - _8_0 = fromHalves((buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3], ((buf.data[buf.start + 4] << 24) | (buf.data[buf.start + 5] << 16) | (buf.data[buf.start + 6] << 8) | buf.data[buf.start + 7]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 8; - _8_1Len = buf.length - 8; + if (bufLen >= 8) { + _8_0 = fromHalves((bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3], ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 8; + _8_1Len = bufLen - 8; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - } else if (buf.length >= 9) { - _8_0 = fromHalves(((buf.data[buf.start + 1] << 24) | (buf.data[buf.start + 2] << 16) | (buf.data[buf.start + 3] << 8) | buf.data[buf.start + 4]) >>> 0, ((buf.data[buf.start + 5] << 24) | (buf.data[buf.start + 6] << 16) | (buf.data[buf.start + 7] << 8) | buf.data[buf.start + 8]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 9; - _8_1Len = buf.length - 9; + } else if (bufLen >= 9) { + _8_0 = fromHalves(((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0, ((bufData[bufStart + 5] << 24) | (bufData[bufStart + 6] << 16) | (bufData[bufStart + 7] << 8) | bufData[bufStart + 8]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 9; + _8_1Len = bufLen - 9; } else { return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 30f95c7bb..ff4220113 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -10,11 +10,11 @@ import * as Version from "../coding/version.Version.ts"; import type * as version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$Decode_Form(buf: rt.ByteSlice, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { - const r: Decoder.Decoder = Decoder.new(buf, version); +export function decodeSlice$Decode_Form(bufData: Uint8Array, bufStart: number, bufLen: number, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { + const r: Decoder.Decoder = Decoder.new(bufData, bufStart, bufLen, version); const _6: rt.Result = decode$Decode_Form(r, version); if (_6.ok) { - return rt.Ok([_6.value, rt.usizeSub(buf.length, Decoder.remaining(r))]); + return rt.Ok([_6.value, rt.usizeSub(bufLen, Decoder.remaining(r))]); } return _6; } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 65ef06ba3..3325217d9 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -21,23 +21,23 @@ export function run(input: rt.ByteSlice): rt.ByteVec { if (input.length !== 0) { const _8: rt.u8 = rt.u8Rem(input.data[input.start], 9); if (_8 === 0) { - decodeScript(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + decodeScript(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 1) { - encodeScript(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + encodeScript(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 2) { - zigzag(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + zigzag(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 3) { - sizes(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + sizes(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 4) { - roundtrip$Versions(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + roundtrip$Versions(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 5) { - roundtripLite$Group(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + roundtripLite$Group(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 6) { - roundtripLite$Probe(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + roundtripLite$Probe(input.data, input.start + 1, input.length - 1, out); } else if (_8 === 7) { - encodeMessages(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + encodeMessages(input.data, input.start + 1, input.length - 1, out); } else { - errors(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + errors(input.data, input.start + 1, input.length - 1, out); } return out; } @@ -87,7 +87,8 @@ export function putUsize(out: rt.ByteVec, value: rt.usize): void { } /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ -export function takeU64(data: rt.ByteSlice): [rt.u64, rt.ByteSlice] { +export function takeU64(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u64, rt.ByteSlice] { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, 8); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -189,16 +190,16 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void * Read primitives as a script says until one fails: the script is the first * `data[1]` bytes after the form selector, and the wire is everything after it. */ -export function decodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const selector: rt.u8 = data.data[data.start]; - if (data.length - 1 !== 0) { - const mid: number = rt.min(data.length - 2, data.data[data.start + 1] as rt.usize); - if (mid > data.length - 2) { +export function decodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const selector: rt.u8 = dataData[dataStart]; + if (dataLen - 1 !== 0) { + const mid: number = rt.min(dataLen - 2, dataData[dataStart + 1] as rt.usize); + if (mid > dataLen - 2) { rt.panic("mid > len"); } - const r: Decoder.Decoder = Decoder.new(new rt.ByteSlice(data.data, data.start + 2 + mid, data.length - 2 - mid), form(selector)); - for (const _21 of rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, mid))) { + const r: Decoder.Decoder = Decoder.new(dataData, dataStart + 2 + mid, dataLen - 2 - mid, form(selector)); + for (const _21 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { const _26: rt.Result = decodeStep(r, _21, out); if (_26.ok) { rt.byteVecPush(out, 0); @@ -301,26 +302,31 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt } /** Write primitives as a script says, taking each value from the data that follows. */ -export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { +export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let result!: rt.Result; let _47!: rt.u64 | undefined; let _74!: Prefix.Prefix; - if (data.length !== 0) { - const selector: rt.u8 = data.data[data.start]; - if (data.length - 1 !== 0) { - const mid: number = rt.min(data.length - 2, data.data[data.start + 1] as rt.usize); - if (mid > data.length - 2) { + if (dataLen !== 0) { + const selector: rt.u8 = dataData[dataStart]; + if (dataLen - 1 !== 0) { + const mid: number = rt.min(dataLen - 2, dataData[dataStart + 1] as rt.usize); + if (mid > dataLen - 2) { rt.panic("mid > len"); } - let values: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 2 + mid, data.length - 2 - mid); + let valuesData: Uint8Array = dataData; + let valuesStart: number = dataStart + 2 + mid; + let valuesLen: number = dataLen - 2 - mid; const buf: rt.ByteVec = new rt.ByteVec(); const _20: Form.Form = form(selector); const w: Encoder.Encoder = Encoder.new(buf, _20); const prefixes: Prefix.Prefix[] = []; - for (const step of rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, mid))) { - const _30: [rt.u64, rt.ByteSlice] = takeU64(values); + for (const step of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { + const _30: [rt.u64, rt.ByteSlice] = takeU64(valuesData, valuesStart, valuesLen); const value: rt.u64 = _30[0]; - values = _30[1]; + const slice: rt.ByteSlice = _30[1]; + valuesData = slice.data; + valuesStart = slice.start; + valuesLen = slice.length; const _33: rt.u8 = rt.u8Rem(step, 10); if (_33 === 0) { Encoder.u8(w, rt.u64Low(value) & 0xff); @@ -346,7 +352,7 @@ export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_33 === 5) { const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; const _51: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.u64ToBeBytes(value)), 0, part); - result = Encoder.bytes(w, _51); + result = Encoder.bytes(w, _51.data, _51.start, _51.length); } else if (_33 === 6) { const _60: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(rt.byteSliceFrom(rt.u64ToBeBytes(value)))); if (_60.ok) { @@ -399,17 +405,17 @@ export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { } } -export function zigzag(data: rt.ByteSlice, out: rt.ByteVec): void { - const value: rt.u64 = takeU64(data)[0]; +export function zigzag(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const value: rt.u64 = takeU64(dataData, dataStart, dataLen)[0]; const signed: rt.i64 = rt.i64Cast(value); putU64(out, varint_zigzag(signed)); putU64(out, rt.u64Cast(unzigzag(value))); putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); } -export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { +export function sizes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _9!: rt.u8; - const value: rt.u64 = takeU64(data)[0]; + const value: rt.u64 = takeU64(dataData, dataStart, dataLen)[0]; let iterStart: rt.u8 = 0; const iterEnd: rt.u8 = 3; while ((_9 = iterStart++) < iterEnd) { @@ -423,10 +429,10 @@ export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Decode a `T` from the wire, then encode what came out. */ -export function roundtrip$Versions(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const form_: Form.Form = form(data.data[data.start]); - const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$Decode_Form(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), form_); +export function roundtrip$Versions(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const form_: Form.Form = form(dataData[dataStart]); + const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$Decode_Form(dataData, dataStart + 1, dataLen - 1, form_); if (_8.ok) { const value: Versions.Versions = _8.value[0]; putUsize(out, _8.value[1]); @@ -444,10 +450,10 @@ 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 { - 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); +export function roundtripLite$Group(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const version: Version.Version = liteVersion(dataData[dataStart]); + const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(dataData, dataStart + 1, dataLen - 1, version); if (_8.ok) { const value: Group.Group = _8.value[0]; putUsize(out, _8.value[1]); @@ -466,10 +472,10 @@ 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 { - 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); +export function roundtripLite$Probe(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const version: Version.Version = liteVersion(dataData[dataStart]); + const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$Decode_Version(dataData, dataStart + 1, dataLen - 1, version); if (_8.ok) { const value: Probe.Probe = _8.value[0]; putUsize(out, _8.value[1]); @@ -488,18 +494,18 @@ 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 { - 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)); +export function encodeMessages(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const version: Version.Version = liteVersion(dataData[dataStart]); + const _10: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart + 1, dataLen - 1); const subscribe: rt.u64 = _10[0]; - const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1]); + const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1].data, _10[1].start, _10[1].length); const sequence: rt.u64 = _13[0]; - const _16: [rt.u64, rt.ByteSlice] = takeU64(_13[1]); + const _16: [rt.u64, rt.ByteSlice] = takeU64(_13[1].data, _13[1].start, _13[1].length); const frameStart: rt.u64 = _16[0]; - const _19: [rt.u64, rt.ByteSlice] = takeU64(_16[1]); + const _19: [rt.u64, rt.ByteSlice] = takeU64(_16[1].data, _16[1].start, _16[1].length); const bitrate: rt.u64 = _19[0]; - const rtt: rt.u64 = takeU64(_19[1])[0]; + const rtt: rt.u64 = takeU64(_19[1].data, _19[1].start, _19[1].length)[0]; encodeMessage$Group({ subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }, version, out); encodeMessage$Probe({ bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }, version, out); const versions: Versions.Versions = Versions.from$From_Versions([{ _0: subscribe }, { _0: sequence }]); @@ -543,13 +549,12 @@ 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 { +export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let err!: DecodeError.DecodeError; b0: { - if (data.length !== 0) { - const selector: rt.u8 = data.data[data.start]; - const data2: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); - const value: rt.u64 = takeU64(data2)[0]; + if (dataLen !== 0) { + const selector: rt.u8 = dataData[dataStart]; + const value: rt.u64 = takeU64(dataData, dataStart + 1, dataLen - 1)[0]; const _10: rt.u8 = rt.u8Rem(selector, 8); if (_10 === 0) { err = { tag: "InvalidMessage", _0: value } as DecodeError.DecodeError; @@ -560,7 +565,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(data2)); + const _20: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1))); if (_20.ok) { err = { tag: "Missing" } as DecodeError.DecodeError; } else { diff --git a/ts/fixtures/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index 466659227..96dc164bf 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -11,11 +11,11 @@ import { decodeWith$Group_decode_closure0 } from "../lite/message.ts"; import * as Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$Decode_Version(buf: rt.ByteSlice, version: Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { - const r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); +export function decodeSlice$Decode_Version(bufData: Uint8Array, bufStart: number, bufLen: number, version: Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { + const r: Decoder.Decoder = Decoder.new(bufData, bufStart, bufLen, Form.from$From_Version(version)); const _6: rt.Result = decode$Decode_Version(r, version); if (_6.ok) { - return rt.Ok([_6.value, rt.usizeSub(buf.length, Decoder.remaining(r))]); + return rt.Ok([_6.value, rt.usizeSub(bufLen, Decoder.remaining(r))]); } return _6; } diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index ad182b2d3..ef959c3c0 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -13,11 +13,11 @@ import * as Version from "../lite/version.Version.ts"; import type * as Control from "../stats.Control.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$Decode_Version(buf: rt.ByteSlice, version: Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { - const r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); +export function decodeSlice$Decode_Version(bufData: Uint8Array, bufStart: number, bufLen: number, version: Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { + const r: Decoder.Decoder = Decoder.new(bufData, bufStart, bufLen, Form.from$From_Version(version)); const _6: rt.Result = decode$Decode_Version(r, version); if (_6.ok) { - return rt.Ok([_6.value, rt.usizeSub(buf.length, Decoder.remaining(r))]); + return rt.Ok([_6.value, rt.usizeSub(bufLen, Decoder.remaining(r))]); } return _6; } diff --git a/ts/fixtures/lang/brands.ts b/ts/fixtures/lang/brands.ts index 17f935230..706883cf3 100644 --- a/ts/fixtures/lang/brands.ts +++ b/ts/fixtures/lang/brands.ts @@ -9,9 +9,9 @@ import { returnedNever, tailBreak } from "./shapes.ts"; export function mixed(data: rt.ByteSlice): void { returnedNever(7, 1); - const meters: Meters.Meters = { _0: tailBreak(data) as rt.u64 }; + const meters: Meters.Meters = { _0: tailBreak(data.data, data.start, data.length) as rt.u64 }; // @ts-expect-error A `u16` is not a `u8`. - returnedNever(tailBreak(data), 1); + returnedNever(tailBreak(data.data, data.start, data.length), 1); // @ts-expect-error A `u32` is not a `usize`. returnedNever(1, 0xffffffff as rt.u32); // @ts-expect-error A `u64` is not a `u8`, even as a number. diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 52f986a5e..402b0ccd1 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -5,9 +5,9 @@ import { unwrapOr$Option_char } from "./core/option.ts"; import { put } from "./fmt.ts"; /** The scalars to try: the edges, then each big-endian `u32` in `data`, zero-padded. */ -export function scalars(data: rt.ByteSlice): rt.u32[] { +export function scalars(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32[] { const all: rt.u32[] = [0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice(); - let rest: rt.ByteSlice = data; + let rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); while (true) { if (!((rest.length === 0))) { const buf: Uint8Array = rt.bytes(4); @@ -65,10 +65,10 @@ export function class_(c: rt.char): rt.u8 { return 2; } -export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function chars(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { - for (const _10 of scalars(data)) { + for (const _10 of scalars(dataData, dataStart, dataLen)) { const _14: rt.char | undefined = rt.charFromU32(_10); if (_14 === undefined) { rt.byteVecPush(out, 255); @@ -79,7 +79,7 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 1) { - for (const n2 of scalars(data)) { + for (const n2 of scalars(dataData, dataStart, dataLen)) { const c2: rt.char = unwrapOr$Option_char(rt.charFromU32(n2), (n2 & 0xff) as rt.char); rt.byteVecPush(out, c2 & 0xff); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(c2 & 0xffff))); @@ -92,7 +92,7 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16))); } } else if (_4 === 2) { - const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { + const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(dataData, dataStart, dataLen)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); })); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; @@ -119,7 +119,7 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_128 as rt.u32))); } } else { - for (const _140 of scalars(data)) { + for (const _140 of scalars(dataData, dataStart, dataLen)) { const _144: rt.char | undefined = rt.charFromU32(_140); if (_144 !== undefined) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(_144, f)]; diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index edc869d4c..49cd2a845 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -4,35 +4,36 @@ import * as rt from "./rt.ts"; 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 { - if (data.length >= 2) { - return { tag: new rt.ByteSlice(data.data, data.start, 2), rest: new rt.ByteSlice(data.data, data.start + 2, data.length - 2) }; +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Header.Header | undefined { + if (dataLen >= 2) { + return { tag: new rt.ByteSlice(dataData, dataStart, 2), rest: new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2) }; } return undefined; } -export function take4(data: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { - return 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 take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { + return okOr$Option_u8s_u8s_u8((dataLen >= 4 ? [new rt.ByteSlice(dataData, dataStart, 4), new rt.ByteSlice(dataData, dataStart + 4, dataLen - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, dataLen & 0xff); } -export function word(chunk: rt.ByteSlice): rt.u32 { - return ((chunk.data[chunk.start] << 24) | (chunk.data[chunk.start + 1] << 16) | (chunk.data[chunk.start + 2] << 8) | chunk.data[chunk.start + 3]) >>> 0; +export function word(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): rt.u32 { + return ((chunkData[chunkStart] << 24) | (chunkData[chunkStart + 1] << 16) | (chunkData[chunkStart + 2] << 8) | chunkData[chunkStart + 3]) >>> 0; } -export function pick(a: rt.ByteSlice, b: rt.ByteSlice, first: boolean): rt.ByteSlice { +export function pick(aData: Uint8Array, aStart: number, aLen: number, bData: Uint8Array, bStart: number, bLen: number, first: boolean): rt.ByteSlice { if (!first) { - return b; + return new rt.ByteSlice(bData, bStart, bLen); } - return a; + return new rt.ByteSlice(aData, aStart, aLen); } -export function reader(chunk: rt.ByteSlice): (a0: rt.usize) => rt.u8 { +export function reader(chunkData: Uint8Array, chunkStart: number, chunkLen: number): (a0: rt.usize) => rt.u8 { + const captured = new rt.ByteSlice(chunkData, chunkStart, chunkLen); return (i: rt.usize): rt.u8 => { const _3: rt.usize = rt.usizeRem(i, 2); if (!(_3 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _3); } - return chunk.data[chunk.start + _3]; + return captured.data[captured.start + _3]; }; } @@ -42,26 +43,26 @@ export function bump(chunk: rt.ByteSlice): void { chunk.data[chunk.start + 1] = chunk.data[chunk.start + 1] ^ 255; } -export function ends(chunk: rt.ByteSlice): [rt.u8, rt.ByteSlice, rt.u8] { - return [chunk.data[chunk.start], new rt.ByteSlice(chunk.data, chunk.start + 1, 2), chunk.data[chunk.start + 3]] as [rt.u8, rt.ByteSlice, rt.u8]; +export function ends(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): [rt.u8, rt.ByteSlice, rt.u8] { + return [chunkData[chunkStart], new rt.ByteSlice(chunkData, chunkStart + 1, 2), chunkData[chunkStart + 3]] as [rt.u8, rt.ByteSlice, rt.u8]; } -export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let chosen2!: rt.ByteSlice; const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - const _6: Header.Header | undefined = header(data); + const _6: Header.Header | undefined = header(dataData, dataStart, dataLen); if (_6 !== undefined) { const h: Header.Header = _6; rt.byteVecExtendFromSlice(out, h.tag); rt.byteVecPush(out, h.tag.data[h.tag.start + 1]); rt.byteVecPush(out, h.rest.length & 0xff); } - const _18: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> = take4(data); + const _18: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> = take4(dataData, dataStart, dataLen); if (_18.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(_18.value[0])))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(_18.value[0].data, _18.value[0].start, _18.value[0].length)))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((_18.value[0].data[_18.value[0].start + 1] << 8) | _18.value[0].data[_18.value[0].start + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(_18.value[0]); + const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(_18.value[0].data, _18.value[0].start, _18.value[0].length); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); rt.byteVecExtendFromSlice(out, _18.value[1]); } else { @@ -69,7 +70,7 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_4 === 1) { const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4)); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), 4)); while (true) { const _64: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_64 === rt.DONE) { @@ -91,24 +92,24 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(before)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(after)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(buf)); - const pair: Uint8Array = Uint8Array.of(data.length & 0xff, 3); + const pair: Uint8Array = Uint8Array.of(dataLen & 0xff, 3); bump(rt.byteSliceFrom(pair)); bump(rt.byteSliceFrom(pair)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pair)); } else if (_4 === 2) { - 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 => { + if (dataLen >= 2) { + const b: rt.ByteSlice = mapOr$Option_u8s_u8s_u8s_chunks_closure0((dataLen - 2 >= 2 ? [new rt.ByteSlice(dataData, dataStart + 2, 2), new rt.ByteSlice(dataData, dataStart + 4, dataLen - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, dataData, dataStart, 2, (_22: [rt.ByteSlice, rt.ByteSlice]): rt.ByteSlice => { return _22[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)); + const chosen: rt.ByteSlice = pick(dataData, dataStart, 2, b.data, b.start, b.length, rt.usizeRem(dataLen, 2) === 0); + const read: (a0: rt.usize) => rt.u8 = reader(chosen.data, chosen.start, chosen.length); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(read(0), read(1), read(3)))); + const captured = new rt.ByteSlice(dataData, dataStart, 2); 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 = a.data[a.start + i2]; + const _3: rt.u8 = captured.data[captured.start + i2]; if (!(i2 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } @@ -116,11 +117,11 @@ 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, part2.length & 0xff); + rt.byteVecPush(out, (dataLen - 2) & 0xff); } } else if (_4 === 3) { const lit: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); - const _143: rt.u8 | undefined = rt.byteSliceFirst(data); + const _143: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); b8: { if (_143 !== undefined) { if (rt.u8Rem(_143, 2) === 0) { @@ -134,13 +135,13 @@ 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.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(lit), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - if (data.length >= 3) { - const chunk: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 3); + if (dataLen >= 3) { + const chunk: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, 3); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); } } else if (_4 === 4) { - const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { + const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): Uint8Array => { const b2: rt.u8 = _2; return Uint8Array.of(b2, rt.u8WrappingAdd(b2, 3)); })); @@ -177,9 +178,9 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return p2.data[p2.start + 1]; }))); } else { - let restData2: Uint8Array = data.data; - let restStart2: number = data.start; - let restLen2: number = data.length; + let restData2: Uint8Array = dataData; + let restStart2: number = dataStart; + let restLen2: number = dataLen; let sum: rt.u32 = 0; while (true) { const _261Data: Uint8Array = restData2; diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index ac12c629c..4f9eb3d4e 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -48,11 +48,12 @@ export function rankByte(r: Rank.Rank): rt.u8 { } /** A `HashMap` by each kind of key, through a script of inserts, lookups, and removals. */ -export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function hashMaps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _174!: rt.usize; let _299!: rt.usize; let _377!: rt.u8; let _429!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _443: (a0: Nibble.Nibble) => rt.u64 = (n: Nibble.Nibble): rt.u64 => { const h2: rt.Hasher = rt.hasher(); Nibble.hash$Hash_DefaultHasher(n, h2); @@ -451,7 +452,8 @@ export function claim(map: rt.HashMap, k: rt.u8, n: rt.u16): } /** `HashSet` and `BTreeSet`, each with the same script. */ -export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function sets(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _4: rt.u8 = rt.u8Rem(kind, 3); if (_4 === 0) { const hashed: rt.HashSet = rt.hashNew() as rt.HashSet; @@ -566,11 +568,12 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `BTreeMap`: ordered by the key's `Ord`, through inserts, removals, and ranges. */ -export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function btreeMaps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let within!: rt.ByteVec; let _164!: rt.usize; let _344!: rt.usize; let _401!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; @@ -846,8 +849,9 @@ export function touch(q: rt.VecDeque): rt.VecDeque { } /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ -export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { +export function deques(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let drained2!: rt.ByteVec; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; for (const b of rt.byteSliceView(data)) { @@ -947,8 +951,9 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } /** `vec![a, b]` and `vec![x; n]`, of bytes, numbers, `Copy` tuples, and types that clone. */ -export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function vecs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let name!: string; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 = unwrapOr$Option_u8(rt.byteSliceFirst(data), 0); const b: rt.u8 = unwrapOr$Option_u8(rt.byteSliceGet(data, 1), 0); const n: rt.usize = rt.usizeRem(unwrapOr$Option_u8(rt.byteSliceGet(data, 2), 0) as rt.usize, 5); @@ -1040,7 +1045,8 @@ export function hold(pair: [rt.u8, rt.u8]): Holder.Holder { * A `Copy` aggregate a std call stores by value is the container's own copy: changing * one stored element leaves the value it came from and the other elements as they were. */ -export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { +export function stores(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 = unwrapOr$Option_u8(rt.byteSliceFirst(data), 0); const b: rt.u8 = unwrapOr$Option_u8(rt.byteSliceGet(data, 1), 0); const pair: [rt.u8, rt.u8] = same([a, b] as [rt.u8, rt.u8]); diff --git a/ts/fixtures/lang/expected/combinators.ts b/ts/fixtures/lang/expected/combinators.ts index e2f5a3d05..b0eeb0a75 100644 --- a/ts/fixtures/lang/expected/combinators.ts +++ b/ts/fixtures/lang/expected/combinators.ts @@ -6,7 +6,8 @@ import { isSomeAnd$Option_u8_options_closure0, isNoneOr$Option_u8_options_closur import { isOkAnd$Result_u8_u16_results_closure5, isErrAnd$Result_u8_u16_results_closure6, ok$Result_u8_u16, err$Result_u8_u16, asRef$Result_u8_u16, map$Result_Vec_u8_String_Vec_u8_owned_closure6, map$Result_u8_u16_u8_options_closure13, mapOr$Result_u8_u16_u8_results_closure7, mapOrElse$Result_u8_u16_u8_results_closure8_results_closure9, mapErr$Result_u32s_u8_u16_from, mapErr$Result_u8_u16_u16_results_closure14, inspect$Result_u8_u16_results_closure12, inspectErr$Result_u8_u16_results_closure13, unwrapOrDefault$Result_u8_u16, and$Result_u8_u16_u8, andThen$Result_u8_u16_u8_results_closure3, or$Result_u8_u16_u16, orElse$Result_u8_u16_u16_results_closure4, unwrapOr$Result_u8_u16, unwrapOrElse$Result_u8_u16_results_closure11, unwrapOrElse$Result_u8_u8_panics_closure1, copied$Result_u8_u16, clone$Clone_Result_Vec_u8_String } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ -export function combinators(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function combinators(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 | undefined = filter$Option_u8_combinators_closure0(rt.byteSliceFirst(data), (x: rt.u8): boolean => { return rt.u8Rem(x, 3) !== 0; }); diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index d4e9229d9..8bbe2bb53 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -338,9 +338,9 @@ export function mapOr$Option_u8s_u8s_u8_splits_closure0(self: [rt.ByteSlice, rt. 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 { +export function mapOr$Option_u8s_u8s_u8s_chunks_closure0(self: [rt.ByteSlice, rt.ByteSlice] | undefined, defaultData: Uint8Array, defaultStart: number, defaultLen: number, f: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice { if (self === undefined) { - return default_; + return new rt.ByteSlice(defaultData, defaultStart, defaultLen); } return f(self); } diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index 8c07877e7..4f287b8ec 100644 --- a/ts/fixtures/lang/expected/cows.ts +++ b/ts/fixtures/lang/expected/cows.ts @@ -21,12 +21,12 @@ export function cow(s: string, owned: boolean): string { return s; } -export function cows(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function cows(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let shared!: rt.Arc; let r!: rt.Result; let unwind: number = 0; try { - const s: string = text(data); + const s: string = text(dataData, dataStart, dataLen); const owned: boolean = (kind & 128) !== 0; const first: string = unwrapOr$Option_Cow_str(rt.iterToOption(rt.strSplit(s, "/").next()), ""); const _14: rt.u8 = rt.u8Rem(kind, 6); diff --git a/ts/fixtures/lang/expected/durations.ts b/ts/fixtures/lang/expected/durations.ts index 67fed57d5..84031236e 100644 --- a/ts/fixtures/lang/expected/durations.ts +++ b/ts/fixtures/lang/expected/durations.ts @@ -6,7 +6,8 @@ import * as Window from "./durations.Window.ts"; import { put } from "./fmt.ts"; /** A `u64` and a `u32` from the front of `data`, big-endian and zero-padded. */ -export function take(data: rt.ByteSlice): [rt.u64, rt.u32, rt.ByteSlice] { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u64, rt.u32, rt.ByteSlice] { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(12); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -26,8 +27,8 @@ export function take(data: rt.ByteSlice): [rt.u64, rt.u32, rt.ByteSlice] { } /** A `Duration` from the front of `data`, whose nanoseconds never carry. */ -export function duration(data: rt.ByteSlice): [rt.Duration, rt.ByteSlice] { - const _5: [rt.u64, rt.u32, rt.ByteSlice] = take(data); +export function duration(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.Duration, rt.ByteSlice] { + const _5: [rt.u64, rt.u32, rt.ByteSlice] = take(dataData, dataStart, dataLen); return [rt.durationNew(_5[0], rt.u32Rem(_5[1], 1000000000)), _5[2]] as [rt.Duration, rt.ByteSlice]; } @@ -46,10 +47,10 @@ export function putOpt(out: rt.ByteVec, d: rt.Duration | undefined): void { } } -export function durations(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.Duration, rt.ByteSlice] = duration(data); +export function durations(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _6: [rt.Duration, rt.ByteSlice] = duration(dataData, dataStart, dataLen); const a: rt.Duration = _6[0]; - const _9: [rt.Duration, rt.ByteSlice] = duration(_6[1]); + const _9: [rt.Duration, rt.ByteSlice] = duration(_6[1].data, _6[1].start, _6[1].length); const b: rt.Duration = _9[0]; const word: Uint8Array = rt.bytes(4); const k: rt.usize = rt.min(_9[1].length, rt.byteSliceFrom(word).length); @@ -57,10 +58,10 @@ export function durations(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const n: rt.u32 = rt.u32FromBeBytes(word); const _24: rt.u8 = rt.u8Rem(kind, 10); if (_24 === 0) { - const _28: [rt.u64, rt.u32, rt.ByteSlice] = take(data); + const _28: [rt.u64, rt.u32, rt.ByteSlice] = take(dataData, dataStart, dataLen); putDuration(out, rt.durationNew(_28[0], _28[1])); } else if (_24 === 1) { - const units: rt.u64 = take(data)[0]; + const units: rt.u64 = take(dataData, dataStart, dataLen)[0]; putDuration(out, rt.durationFromSecs(units)); putDuration(out, rt.durationFromMillis(units)); putDuration(out, rt.durationFromMicros(units)); diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 1563eb18a..f4e84d57e 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -26,12 +26,12 @@ export function put(out: rt.ByteVec, s: string): void { } /** Integers of every width, with each spec. */ -export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 12); if (_4 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const n: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n)); const v: rt.u8 = rt.u8FromBeBytes(buf); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8Debug(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8UpperHex(v, f)]; put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[1]), " ", rt.fmtSpec({ width: 3 }, args2[1])])); @@ -42,8 +42,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f))); } else if (_4 === 1) { const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(data, 0, n2)); + const n2: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n2)); const v2: rt.u16 = rt.u16FromBeBytes(buf2); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16Debug(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16UpperHex(v2, f)]; put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rt.fmtSpec({ alternate: true }, args8[2]), " ", rt.fmtSpec({ alternate: true }, args8[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rt.fmtSpec({ alternate: true }, args8[1]), " ", rt.fmtSpec({ width: 3 }, args8[1])])); @@ -54,8 +54,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f))); } else if (_4 === 2) { const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(data, 0, n3)); + const n3: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf3).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n3)); const v3: rt.u32 = rt.u32FromBeBytes(buf3); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32Debug(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32UpperHex(v3, f)]; put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rt.fmtSpec({ alternate: true }, args14[2]), " ", rt.fmtSpec({ alternate: true }, args14[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rt.fmtSpec({ alternate: true }, args14[1]), " ", rt.fmtSpec({ width: 3 }, args14[1])])); @@ -66,8 +66,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f))); } else if (_4 === 3) { const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(data, 0, n4)); + const n4: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf4).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n4)); const v4: rt.u64 = rt.u64FromBeBytes(buf4); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64Debug(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64UpperHex(v4, f)]; put(out, rt.fmtFormat([args20[0], " ", args20[1], " ", rt.fmtSpec({ width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rt.fmtSpec({ alternate: true }, args20[2]), " ", rt.fmtSpec({ alternate: true }, args20[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rt.fmtSpec({ alternate: true }, args20[1]), " ", rt.fmtSpec({ width: 3 }, args20[1])])); @@ -78,8 +78,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f))); } else if (_4 === 4) { const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(data, 0, n5)); + const n5: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf5).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n5)); const v5: rt.u128 = rt.u128FromBeBytes(buf5); const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128Debug(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128UpperHex(v5, f)]; put(out, rt.fmtFormat([args26[0], " ", args26[1], " ", rt.fmtSpec({ width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rt.fmtSpec({ alternate: true }, args26[2]), " ", rt.fmtSpec({ alternate: true }, args26[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rt.fmtSpec({ alternate: true }, args26[1]), " ", rt.fmtSpec({ width: 3 }, args26[1])])); @@ -90,8 +90,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f))); } else if (_4 === 5) { const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(data, 0, n6)); + const n6: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf6).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n6)); const v6: rt.usize = rt.usizeFromBeBytes(buf6); const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeDebug(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeUpperHex(v6, f)]; put(out, rt.fmtFormat([args32[0], " ", args32[1], " ", rt.fmtSpec({ width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rt.fmtSpec({ alternate: true }, args32[2]), " ", rt.fmtSpec({ alternate: true }, args32[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rt.fmtSpec({ alternate: true }, args32[1]), " ", rt.fmtSpec({ width: 3 }, args32[1])])); @@ -102,8 +102,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f))); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(data, 0, n7)); + const n7: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf7).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n7)); const v7: rt.i8 = rt.i8FromBeBytes(buf7); const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8Debug(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8UpperHex(v7, f)]; put(out, rt.fmtFormat([args38[0], " ", args38[1], " ", rt.fmtSpec({ width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rt.fmtSpec({ alternate: true }, args38[2]), " ", rt.fmtSpec({ alternate: true }, args38[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rt.fmtSpec({ alternate: true }, args38[1]), " ", rt.fmtSpec({ width: 3 }, args38[1])])); @@ -114,8 +114,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f))); } else if (_4 === 7) { const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(data, 0, n8)); + const n8: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf8).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n8)); const v8: rt.i16 = rt.i16FromBeBytes(buf8); const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16Debug(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16UpperHex(v8, f)]; put(out, rt.fmtFormat([args44[0], " ", args44[1], " ", rt.fmtSpec({ width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rt.fmtSpec({ alternate: true }, args44[2]), " ", rt.fmtSpec({ alternate: true }, args44[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rt.fmtSpec({ alternate: true }, args44[1]), " ", rt.fmtSpec({ width: 3 }, args44[1])])); @@ -126,8 +126,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f))); } else if (_4 === 8) { const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(data, 0, n9)); + const n9: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf9).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n9)); const v9: rt.i32 = rt.i32FromBeBytes(buf9); const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32Debug(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32UpperHex(v9, f)]; put(out, rt.fmtFormat([args50[0], " ", args50[1], " ", rt.fmtSpec({ width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rt.fmtSpec({ alternate: true }, args50[2]), " ", rt.fmtSpec({ alternate: true }, args50[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rt.fmtSpec({ alternate: true }, args50[1]), " ", rt.fmtSpec({ width: 3 }, args50[1])])); @@ -138,8 +138,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f))); } else if (_4 === 9) { const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(data, 0, n10)); + const n10: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf10).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n10)); const v10: rt.i64 = rt.i64FromBeBytes(buf10); const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64Debug(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64UpperHex(v10, f)]; put(out, rt.fmtFormat([args56[0], " ", args56[1], " ", rt.fmtSpec({ width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rt.fmtSpec({ alternate: true }, args56[2]), " ", rt.fmtSpec({ alternate: true }, args56[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rt.fmtSpec({ alternate: true }, args56[1]), " ", rt.fmtSpec({ width: 3 }, args56[1])])); @@ -150,8 +150,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f))); } else if (_4 === 10) { const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(data, 0, n11)); + const n11: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf11).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n11)); const v11: rt.i128 = rt.i128FromBeBytes(buf11); const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128Debug(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128UpperHex(v11, f)]; put(out, rt.fmtFormat([args62[0], " ", args62[1], " ", rt.fmtSpec({ width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rt.fmtSpec({ alternate: true }, args62[2]), " ", rt.fmtSpec({ alternate: true }, args62[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rt.fmtSpec({ alternate: true }, args62[1]), " ", rt.fmtSpec({ width: 3 }, args62[1])])); @@ -162,8 +162,8 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f))); } else { const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(data, 0, n12)); + const n12: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf12).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n12)); const v12: rt.isize = rt.isizeFromBeBytes(buf12); const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeDebug(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeUpperHex(v12, f)]; put(out, rt.fmtFormat([args68[0], " ", args68[1], " ", rt.fmtSpec({ width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rt.fmtSpec({ alternate: true }, args68[2]), " ", rt.fmtSpec({ alternate: true }, args68[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rt.fmtSpec({ alternate: true }, args68[1]), " ", rt.fmtSpec({ width: 3 }, args68[1])])); @@ -176,8 +176,9 @@ export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Strings padded and escaped, and bytes that may not be UTF-8. */ -export function strings(data: rt.ByteSlice, out: rt.ByteVec): void { +export function strings(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let flag!: boolean; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); for (const _9 of rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 3)))) { const _15: rt.usize = rt.usizeRem(_9 as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); if (!(_15 < 14)) { @@ -228,11 +229,12 @@ export function strings(data: rt.ByteSlice, out: rt.ByteVec): void { } } -export function nested(data: rt.ByteSlice): Nested.Nested { +export function nested(dataData: Uint8Array, dataStart: number, dataLen: number): Nested.Nested { let _22!: Shape.Shape; let _49!: Pair.Pair | undefined; let _61!: rt.Result; let _90!: Kind.Kind; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return unwrapOr$Option_u8(rt.byteSliceGet(data, i), 0); }; @@ -279,11 +281,12 @@ export function nested(data: rt.ByteSlice): Nested.Nested { } /** Derived `Debug` of every shape, compact and pretty, with options passed to fields. */ -export function derived(data: rt.ByteSlice, out: rt.ByteVec): void { +export function derived(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return unwrapOr$Option_u8(rt.byteSliceGet(data, i), 0); }; - const value: Nested.Nested = nested(data); + const value: Nested.Nested = nested(data.data, data.start, data.length); const args2: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$Debug(value, f)]; put(out, rt.fmtFormat([args2[0]])); const args4: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$Debug(value, f)]; @@ -333,23 +336,28 @@ export function note(log: rt.ByteVec, v: rt.u8): rt.u8 { } /** Arguments that read `log` before and after one changes it, through a reference. */ -export function logged(log: rt.ByteVec, data: rt.ByteSlice): string { +export function logged(log: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): string { const _7: rt.usize = log.length; - rt.idx(data, 0); - const _10: rt.u8 = note(log, data.data[data.start]); - const _16: rt.usize = rt.usizeRem(log.length, data.length); - rt.idx(data, _16); + if (0 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + 0); + } + const _10: rt.u8 = note(log, dataData[dataStart]); + const _16: rt.usize = rt.usizeRem(log.length, dataLen); + if (_16 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _16); + } const _24: rt.usize = log.length; - const part = data.data[data.start + _16]; + const part = dataData[dataStart + _16]; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_7, f), (f: rt.Formatter) => rt.u8Display(_10, f), (f: rt.Formatter) => rt.u8Display(part, f), (f: rt.Formatter) => rt.usizeDisplay(_24, f)]; return rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ -export function written(data: rt.ByteSlice, out: rt.ByteVec): void { +export function written(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _116!: rt.u8 | undefined; + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return unwrapOr$Option_u8(rt.byteSliceGet(data, i), 0); + return unwrapOr$Option_u8(rt.byteSliceGet(captured, i), 0); }; const hex: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; const args2: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$Display(hex, f), (f: rt.Formatter) => Hex.fmt$Debug(hex, f)]; @@ -396,8 +404,8 @@ export function written(data: rt.ByteSlice, out: rt.ByteVec): void { const _222: Noted.Noted = { _0: 2 }; const args20: rt.Fmt[] = [(f: rt.Formatter) => Noted.fmt$Display(_218, f), (f: rt.Formatter) => Noted.fmt$Display(_222, f)]; put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args20[1])])); - if (!((data.length === 0))) { - put(out, logged(log, data)); + if (!((dataLen === 0))) { + put(out, logged(log, dataData, dataStart, dataLen)); } const _241: rt.u8 = at(13); const part2 = note(log, _241); @@ -420,7 +428,8 @@ export function written(data: rt.ByteSlice, out: rt.ByteVec): void { * Widths and precisions from arguments, by position and by name, and one past * `u16::MAX`, which panics. */ -export function counts(data: rt.ByteSlice, out: rt.ByteVec): void { +export function counts(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return unwrapOr$Option_u8(rt.byteSliceGet(data, i), 0); }; @@ -467,11 +476,12 @@ export function rounding(out: rt.ByteVec): void { } /** Panics, each with the message native Rust formats. */ -export function panics(kind: rt.u8, rest: rt.ByteSlice, out: rt.ByteVec): void { +export function panics(kind: rt.u8, restData: Uint8Array, restStart: number, restLen: number, out: rt.ByteVec): void { let r!: rt.Result; let r2!: rt.Result; let r4!: rt.Result; let r5!: rt.Result; + const rest: rt.ByteSlice = new rt.ByteSlice(restData, restStart, restLen); const n: rt.u8 = unwrapOr$Option_u8(rt.byteSliceFirst(rest), 0); const _7: rt.u8 = rt.u8Rem(kind, 20); if (_7 === 0) { diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 3edcdde70..4937fc51e 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -15,7 +15,8 @@ import type * as Shape from "./shapes.Shape.ts"; import type * as Track from "./shapes.Track.ts"; /** Each method once per instance: `Wrap` of a struct, an enum, a number, and itself. */ -export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { +export function methods(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return unwrapOr$Option_u8(rt.byteSliceGet(data, i), 0); }; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 6c59f3c9a..1b59cede4 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -28,130 +28,130 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const kind: rt.u8 = _10[1]; const _14: rt.u8 = rt.u8Rem(op, 54); if (_14 === 0) { - u8Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + u8Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 1) { - u16Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + u16Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 2) { - u32Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + u32Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 3) { - u64Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + u64Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 4) { - u128Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + u128Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 5) { - usizeOp(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + usizeOp(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 6) { - i8Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i8Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 7) { - i16Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i16Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 8) { - i32Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i32Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 9) { - i64Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i64Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 10) { - i128Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i128Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 11) { - isizeOp(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + isizeOp(kind, 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(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i8Neg(input.data, input.start + 2, input.length - 2, out); } else if (_28 === 1) { - i16Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i16Neg(input.data, input.start + 2, input.length - 2, out); } else if (_28 === 2) { - i32Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i32Neg(input.data, input.start + 2, input.length - 2, out); } else if (_28 === 3) { - i64Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i64Neg(input.data, input.start + 2, input.length - 2, out); } else if (_28 === 4) { - i128Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + i128Neg(input.data, input.start + 2, input.length - 2, out); } else { - isizeNeg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + isizeNeg(input.data, input.start + 2, input.length - 2, out); } } else if (_14 === 13) { if (input.length - 2 === 0) { - cast(kind, rt.u8Div(kind, 12), new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + cast(kind, rt.u8Div(kind, 12), input.data, input.start + 2, input.length - 2, out); } else { - cast(kind, input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + cast(kind, input.data[input.start + 2], input.data, input.start + 3, input.length - 3, out); } } else if (_14 === 14) { - convert(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + convert(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 15) { - copies(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + copies(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 16) { - loops(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + loops(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 17) { - patterns(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + patterns(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 18) { - closures(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + closures(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 19) { - discriminants(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + discriminants(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 20) { - library(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + library(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 21) { - ints(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + ints(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 22) { - strings(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + strings(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 23) { - derived(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + derived(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 24) { - written(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + written(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 25) { - panics(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + panics(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 26) { - methods(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + methods(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 27) { - adaptors(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + adaptors(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 28) { - consumers(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + consumers(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 29) { - ranges(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + ranges(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 30) { - options(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + options(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 31) { - own(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + own(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 32) { - values(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + values(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 33) { - order(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + order(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 34) { - hashMaps(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + hashMaps(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 35) { - sets(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + sets(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 36) { - btreeMaps(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + btreeMaps(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 37) { - deques(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + deques(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 38) { - flows(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + flows(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 39) { - keys(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + keys(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 40) { - chars(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + chars(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 41) { - strs(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + strs(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 42) { - vecs(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + vecs(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 43) { - slices(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + slices(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 44) { - stores(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + stores(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 45) { - chunks(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + chunks(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 46) { - cows(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + cows(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 47) { - durations(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + durations(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 48) { - combinators(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + combinators(kind, 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); + splits(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 50) { - refs(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + refs(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 51) { - counts(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + counts(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 52) { rounding(out); } else { - skips(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + skips(kind, input.data, input.start + 2, input.length - 2, out); } return out; } diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 9abf18060..7d91ab21a 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -4,7 +4,8 @@ import * as rt from "./rt.ts"; import { unwrapOr$Option_u8 } from "./core/option.ts"; /** Apply operation `op` to operands taken from `data`. */ -export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function u8Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.u8) => void = (out2: rt.ByteVec, v: rt.u8): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); @@ -110,7 +111,8 @@ export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function u16Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.u16) => void = (out2: rt.ByteVec, v: rt.u16): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); @@ -216,7 +218,8 @@ export function u16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function u32Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.u32) => void = (out2: rt.ByteVec, v: rt.u32): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); @@ -322,7 +325,8 @@ export function u32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function u64Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.u64) => void = (out2: rt.ByteVec, v: rt.u64): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v)))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); @@ -428,7 +432,8 @@ export function u64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function u128Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.u128) => void = (out2: rt.ByteVec, v: rt.u128): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v))); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); @@ -534,7 +539,8 @@ export function u128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function usizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function usizeOp(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.usize) => void = (out2: rt.ByteVec, v: rt.usize): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); @@ -640,7 +646,8 @@ export function usizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function i8Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.i8) => void = (out2: rt.ByteVec, v: rt.i8): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); @@ -746,7 +753,8 @@ export function i8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function i16Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.i16) => void = (out2: rt.ByteVec, v: rt.i16): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); @@ -852,7 +860,8 @@ export function i16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function i32Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.i32) => void = (out2: rt.ByteVec, v: rt.i32): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); @@ -958,7 +967,8 @@ export function i32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function i64Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.i64) => void = (out2: rt.ByteVec, v: rt.i64): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v)))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); @@ -1064,7 +1074,8 @@ export function i64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function i128Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.i128) => void = (out2: rt.ByteVec, v: rt.i128): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v))); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); @@ -1170,7 +1181,8 @@ export function i128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function isizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function isizeOp(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _50: (a0: rt.ByteVec, a1: rt.isize) => void = (out2: rt.ByteVec, v: rt.isize): void => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); @@ -1276,7 +1288,8 @@ export function isizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function i8Neg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i8Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = Uint8Array.of(0); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1284,7 +1297,8 @@ export function i8Neg(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function i16Neg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i16Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(2); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1292,7 +1306,8 @@ export function i16Neg(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function i32Neg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i32Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1300,7 +1315,8 @@ export function i32Neg(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function i64Neg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i64Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1308,7 +1324,8 @@ export function i64Neg(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function i128Neg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i128Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(16); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1316,7 +1333,8 @@ export function i128Neg(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function isizeNeg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function isizeNeg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1324,7 +1342,8 @@ export function isizeNeg(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ -export function cast(from: rt.u8, to: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function cast(from: rt.u8, to: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _5: rt.u8 = rt.u8Rem(from, 12); if (_5 === 0) { const buf: Uint8Array = Uint8Array.of(0); @@ -1990,7 +2009,8 @@ export function cast(from: rt.u8, to: rt.u8, data: rt.ByteSlice, out: rt.ByteVec } /** Conversions that check, and ones that cannot fail. */ -export function convert(data: rt.ByteSlice, out: rt.ByteVec): void { +export function convert(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index d60fa1c8a..d3164a6ba 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -14,7 +14,8 @@ import * as Tag from "./iters.Tag.ts"; import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ -export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function adaptors(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); b0: { const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { @@ -76,7 +77,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, skipped.length & 0xff); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(mapped)); } else if (_4 === 4) { - const words: rt.ByteVec[] = chunksByZero$ChunksByZero_u8s(data); + const words: rt.ByteVec[] = chunksByZero$ChunksByZero_u8s(data.data, data.start, data.length); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); })))); @@ -154,10 +155,10 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** The runs between zero bytes. */ -export function chunksByZero$ChunksByZero_u8s(self: rt.ByteSlice): rt.ByteVec[] { +export function chunksByZero$ChunksByZero_u8s(selfData: Uint8Array, selfStart: number, selfLen: number): rt.ByteVec[] { const words: rt.ByteVec[] = []; let word: rt.ByteVec = new rt.ByteVec(); - for (const b of rt.byteSliceView(self)) { + for (const b of rt.byteSliceView(new rt.ByteSlice(selfData, selfStart, selfLen))) { if (!(b === 0)) { rt.byteVecPush(word, b); } else { @@ -171,7 +172,8 @@ export function chunksByZero$ChunksByZero_u8s(self: rt.ByteSlice): rt.ByteVec[] } /** Consumers, and how far each reads: `log` records every item a closure sees. */ -export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function consumers(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const log: rt.ByteVec = new rt.ByteVec(); const _5: rt.u8 = rt.u8Rem(kind, 6); if (_5 === 0) { @@ -314,7 +316,7 @@ export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { * `nth` and `nth_back` through each adaptor, of a source whose reads `by_ref` or * `inspect` shows: each reads on past a `take`'s limit, or stops at it, as std's does. */ -export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function skips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let item!: rt.u8 | undefined; let item2!: rt.u8 | undefined; let item3!: rt.u8 | undefined; @@ -343,6 +345,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let item26!: rt.u8 | undefined; let item27!: [rt.u8, rt.u8] | undefined; let item28!: Uint8Array | undefined; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const n: rt.usize = mapOr$Option_u8_usize_shares_closure1(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { return rt.usizeRem(_2 as rt.usize, 4); }); @@ -723,7 +726,8 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Ranges as values and as iterators. */ -export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ranges(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 = unwrapOr$Option_u8(rt.byteSliceFirst(data), 0); const b: rt.u8 = unwrapOr$Option_u8(rt.byteSliceGet(data, 1), 0); const range: rt.Range = new rt.Range(a, b); @@ -809,15 +813,16 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { for (const _295 of rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)))) { rt.byteVecPush(out, _295 & 0xff); } - updates(a, b, data, out); + updates(a, b, data.data, data.start, data.length, out); } /** * Struct update syntax on std's ranges: the fields written run before the base, and * the rest are read from it. */ -export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function updates(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _29!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const base: rt.Range = new rt.Range(a, b); rt.byteVecPush(out, 208); const _7: rt.u8 = rt.u8Div(b, 2); @@ -862,7 +867,8 @@ export function fullRange(out: rt.ByteVec): undefined { } /** Iterators of `Option`, which keep each `None` apart from their end. */ -export function options(data: rt.ByteSlice, out: rt.ByteVec): void { +export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _83: (a0: rt.u8, a1: rt.ByteVec) => rt.u8 | undefined = (b2: rt.u8, calls2: rt.ByteVec): rt.u8 | undefined => { rt.byteVecPush(calls2, b2); return map$Option_u8_u8_options_closure3_closure0(rt.u8CheckedSub(b2, 1), (b3: rt.u8): rt.u8 => { @@ -970,7 +976,8 @@ export function second$Map_Iter_u8_options_closure0(items: rt.Iter { - return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.usizeSaturatingSub(data.length, 2)))); +export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, dataData: Uint8Array, dataStart: number, dataLen: number): rt.Iter { + return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.usizeSaturatingSub(dataLen, 2)))); } /** The odd bytes, from a function returning `impl Iterator`. */ -export function odds(data: rt.ByteSlice): rt.Iter { - return rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): boolean => { +export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Iter { + return rt.iterFilter(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (b: rt.u8): boolean => { return rt.u8Rem(b, 2) === 1; }); } /** Iterators as values: returned, stored, and printed. */ -export function values(data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = tail(rt.byteSliceFrom(Uint8Array.of(1, 2, 3)), data); +export function values(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const _5: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); + const iter: rt.Iter = tail(_5.data, _5.start, _5.length, data.data, data.start, data.length); while (true) { const _8: rt.u8 | rt.Done = iter.next(); if (_8 === rt.DONE) { @@ -1031,7 +1040,7 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { } const held: Held.Held = { it: rt.iterSlice(rt.byteSliceView(data)) }; rt.byteVecPush(out, Held.skipOne(held)); - const iter2: rt.Iter = odds(data); + const iter2: rt.Iter = odds(data.data, data.start, data.length); while (true) { const _21: rt.u8 | rt.Done = iter2.next(); if (_21 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 0517eeb18..6e0b02755 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -170,8 +170,8 @@ export function find$String_str(keys_: string[], q: string): rt.u8 { } /** The index of the first of `keys` that borrows as `q`. */ -export function find$u8_u8(keys_: rt.ByteSlice, q: rt.u8): rt.u8 { - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(keys_))); +export function find$u8_u8(keysData: Uint8Array, keysStart: number, keysLen: number, q: rt.u8): rt.u8 { + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(keysData, keysStart, keysLen)))); while (true) { const _7: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_7 === rt.DONE) { @@ -186,18 +186,18 @@ export function find$u8_u8(keys_: rt.ByteSlice, q: rt.u8): rt.u8 { } /** Run one case. */ -export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function keys(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 5); if (_4 === 0) { - options(data, out); + options(dataData, dataStart, dataLen, out); } else if (_4 === 1) { - arcs(data, out); + arcs(dataData, dataStart, dataLen, out); } else if (_4 === 2) { - borrows(data, out); + borrows(dataData, dataStart, dataLen, out); } else if (_4 === 3) { - defaults(data, out); + defaults(dataData, dataStart, dataLen, out); } else { - places(data, out); + places(dataData, dataStart, dataLen, out); } } @@ -268,11 +268,12 @@ export function compare$Skewed(l: Skewed.Skewed, r: Skewed.Skewed): rt.u8 { * The comparisons a type's `PartialEq` and `PartialOrd` inherit: `!=` as `!eq`, and * the orderings from `partial_cmp`, false when it is `None`, whatever `eq` says. */ -export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { +export function defaults(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _7!: rt.usize; let m!: Name.Name; let n!: Name.Name; let _177!: Name.Name; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let unwind: number = 0; try { let iterStart: rt.usize = 1; @@ -397,7 +398,7 @@ export function seen(k: rt.u8, hop_: Hop.Hop | undefined, horizon: Horizon.Horiz * Borrows compared, ordered, and hashed as what they point at, through one reference * or two, shared or mutable. */ -export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { +export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _7!: rt.usize; let m!: Name.Name; let n!: Name.Name; @@ -405,14 +406,18 @@ export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { let unwind: number = 0; try { let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_7 = iterStart++) < iterEnd) { const i: rt.usize = _7; const _15: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _15); - const _14: rt.u8 = data.data[data.start + _15]; - rt.idx(data, i); - const _13: [rt.u8, rt.u8] = [_14, data.data[data.start + i]]; + if (_15 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); + } + const _14: rt.u8 = dataData[dataStart + _15]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _13: [rt.u8, rt.u8] = [_14, dataData[dataStart + i]]; const c: rt.u8 = _14; const d: rt.u8 = _13[1]; const _24: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; @@ -467,7 +472,7 @@ export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { } /** `Option`s compared, ordered, and hashed, alone and in keys. */ -export function options(data: rt.ByteSlice, out: rt.ByteVec): void { +export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _10!: rt.usize; let m!: rt.Arc; let n!: rt.Arc; @@ -481,14 +486,18 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { const sorted: rt.BTreeMap<[rt.u8, Horizon.Horizon], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, Horizon.cmp$Ord])) as rt.BTreeMap<[rt.u8, Horizon.Horizon], rt.u8>; const ways: rt.HashMap<[Way.Way | undefined, boolean], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashOption(Way.hash$Hash_DefaultHasher), rt.hashInt]), rt.eqTuple([rt.eqOption(Way.eq$PartialEq), rt.same]))) as rt.HashMap<[Way.Way | undefined, boolean], rt.u8>; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_10 = iterStart++) < iterEnd) { const i: rt.usize = _10; const _18: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _18); - const _17: rt.u8 = data.data[data.start + _18]; - rt.idx(data, i); - const _16: [rt.u8, rt.u8] = [_17, data.data[data.start + i]]; + if (_18 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _18); + } + const _17: rt.u8 = dataData[dataStart + _18]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _16: [rt.u8, rt.u8] = [_17, dataData[dataStart + i]]; const c: rt.u8 = _17; const d: rt.u8 = _16[1]; const _27: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; @@ -613,7 +622,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { } /** `Arc`s compared, ordered, and hashed as what they hold, and borrowed as it. */ -export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _7!: rt.usize; let a!: Name.Name; let b!: Name.Name; @@ -631,15 +640,19 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { _166 = false; _165 = false; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_7 = iterStart++) < iterEnd) { const i: rt.usize = _7; const _16: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _16); - _14 = name(data.data[data.start + _16]); + if (_16 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _16); + } + _14 = name(dataData[dataStart + _16]); unwind = 81; - rt.idx(data, i); - const _20: Name.Name = name(data.data[data.start + i]); + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _20: Name.Name = name(dataData[dataStart + i]); unwind = 84; _166 = true; a = _14; @@ -653,8 +666,10 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, (rt.u64Eq(hashOf$Arc_str(a.text), hashOf$Arc_str(b.text)) ? 1 : 0) | (((rt.u64Eq(hashOf$Name(a), hashOf$Name(b)) ? 1 : 0) << 1) & 0xff)); const text: string = a.text.value; rt.byteVecPush(out, text === b.text.value ? 1 : 0); - rt.idx(data, i); - const _106: rt.usize = rt.usizeRem(data.data[data.start + i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _106: rt.usize = rt.usizeRem(dataData[dataStart + i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); if (!(_106 < 6)) { rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); } @@ -675,9 +690,9 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { _165 = false; _166 = false; } - const _130: rt.u8 | undefined = rt.byteSliceFirst(data); + const _130: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); if (_130 !== undefined) { - rt.byteVecPush(out, find$u8_u8(data, _130)); + rt.byteVecPush(out, find$u8_u8(dataData, dataStart, dataLen, _130)); } liar = new rt.Arc({}); unwind = 76; @@ -763,14 +778,14 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { * give: numbers, a wide number, and a tuple, by keys JS compares and by keys found * through their hash. */ -export function places(data: rt.ByteSlice, out: rt.ByteVec): void { +export function places(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _154!: rt.usize; let _257!: rt.u8; const counts: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const wide: rt.HashMap = rt.hashNew() as rt.HashMap; const hops: rt.HashMap = rt.hashNew(rt.hashing(Hop.hash$Hash_DefaultHasher, Hop.eq$PartialEq)) as rt.HashMap; const pairs: rt.BTreeMap = rt.btreeNew(Hop.cmp$Ord) as rt.BTreeMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))); while (true) { const _11: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_11 === rt.DONE) { @@ -856,14 +871,16 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { p.v[1] = p.v[1] ^ p.v[0]; } const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _150: rt.usize = rt.usizeMul(data.length, 4); + const _150: rt.usize = rt.usizeMul(dataLen, 4); let iterStart: rt.usize = 0; const iterEnd: rt.usize = _150; while ((_154 = iterStart++) < iterEnd) { const j: rt.usize = _154; - const _159: rt.usize = rt.usizeRem(j, data.length); - rt.idx(data, _159); - const b2: rt.u8 = data.data[data.start + _159]; + const _159: rt.usize = rt.usizeRem(j, dataLen); + if (_159 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _159); + } + const b2: rt.u8 = dataData[dataStart + _159]; const v: rt.Place = rt.entryOrInsertMut(rt.entry(tree, rt.u16Mul(j & 0xffff, 37) ^ b2 as rt.u16), j & 0xffff); v.v = rt.u16WrappingAdd(v.v, b2 as rt.u16); } @@ -877,12 +894,12 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_179[1]))); } const touchy: rt.BTreeMap = rt.btreeNew(Touchy.cmp$Ord) as rt.BTreeMap; - const _195: rt.Place = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: data.length & 0xff }), (): rt.u8 => { + const _195: rt.Place = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: dataLen & 0xff }), (): rt.u8 => { return 7; }); _195.v = rt.u8Add(_195.v, 1); const hashy: rt.HashMap = rt.hashNew(rt.hashing(Touchy.hash$Hash_DefaultHasher, Touchy.eq$PartialEq)) as rt.HashMap; - const _203: rt.Place = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: data.length & 0xff }), (): rt.u8 => { + const _203: rt.Place = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: dataLen & 0xff }), (): rt.u8 => { return 0; }); _203.v = rt.u8Add(_203.v, 2); @@ -893,7 +910,7 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { ((): void => { c2.v = rt.usizeAdd(c2.v, 1); })(); - const spare: rt.usize[] = [data.length, 8]; + const spare: rt.usize[] = [dataLen, 8]; const c3: rt.Place = rt.entryOrInsertMut(rt.entry(counts, 1), 3); const swapped = c3.v; c3.v = spare[0]; diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 5318f70a2..4968fad7a 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -46,9 +46,9 @@ export function takeLargest(seen: rt.Place, next: rt.u8): rt. } /** A `&mut Option` passed on from inside a closure std calls. */ -export function largestOf(seen: rt.Place, items: rt.ByteSlice): rt.u8 { +export function largestOf(seen: rt.Place, itemsData: Uint8Array, itemsStart: number, itemsLen: number): rt.u8 { let taken: rt.u8 = 0; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(items)), (_2: rt.u8): void => { + rt.iterForEach(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(itemsData, itemsStart, itemsLen))), (_2: rt.u8): void => { if (takeLargest(seen, _2) !== undefined) { taken = rt.u8WrappingAdd(taken, 1); } @@ -106,9 +106,9 @@ export function pushTo(s: rt.Place, c: rt.char): void { } } -export function skip(remaining: rt.Place, data: rt.ByteSlice): rt.usize { +export function skip(remaining: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): rt.usize { let skipped: rt.usize = 0; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _6: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -150,8 +150,9 @@ export function fill(seen: rt.Place, s: rt.Place, nex return rt.u8WrappingAdd(unwrapOr$Option_u8(seen.v, 238), rt.stringLen(s.v) & 0xff); } -export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function refs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _133!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _238: (a0: rt.Place, a1: rt.u8) => void = (x3: rt.Place, b7: rt.u8): void => { bump(x3, b7); }; @@ -197,7 +198,7 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { shiftWide(rt.place(() => wide, (value4) => wide = value4), by); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(wide))); let seen: rt.u8 | undefined = undefined; - rt.byteVecPush(out, largestOf(rt.place(() => seen, (value5) => seen = value5), data)); + rt.byteVecPush(out, largestOf(rt.place(() => seen, (value5) => seen = value5), data.data, data.start, data.length)); rt.byteVecPush(out, unwrapOr$Option_u8(seen, 238)); let slot: rt.u8 | undefined = by; if (slot !== undefined) { @@ -247,7 +248,7 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, sum); rt.byteVecPush(out, at & 0xff); let remaining: rt.usize = rt.u8Rem(by, 5) as rt.usize; - rt.byteVecPush(out, skip(rt.place(() => remaining, (value16) => remaining = value16), data) & 0xff); + rt.byteVecPush(out, skip(rt.place(() => remaining, (value16) => remaining = value16), data.data, data.start, data.length) & 0xff); rt.byteVecPush(out, remaining & 0xff); const _177: [Pair.Pair, Pair.Pair] = [{ n: 1 }, { n: 2 }]; const a: Pair.Pair = _177[0]; diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 6dee5b7b5..f49dd4fb7 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -74,10 +74,10 @@ export function dir(byte: rt.u8): Dir.Dir | undefined { return undefined; } -export function shape(data: rt.ByteSlice): Shape.Shape { - if (data.length !== 0) { - const kind: rt.u8 = data.data[data.start]; - const rest: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); +export function shape(dataData: Uint8Array, dataStart: number, dataLen: number): Shape.Shape { + if (dataLen !== 0) { + const kind: rt.u8 = dataData[dataStart]; + const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const at: (a0: rt.usize) => rt.i32 = (i: rt.usize): rt.i32 => { return rt.i32Sub(unwrapOr$Option_u8(rt.byteSliceGet(rest, i), 0) as rt.i32, 128); }; @@ -94,11 +94,11 @@ export function shape(data: rt.ByteSlice): Shape.Shape { } /** `Copy` aggregates: a copy changes apart from its original. */ -export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { +export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _211!: Uint8Array; let poll!: rt.Poll; let _246!: rt.u8; - const p: Point.Point = Point.new(unwrapOr$Option_u8(rt.byteSliceFirst(data), 0) as rt.i32, 7); + const p: Point.Point = Point.new(unwrapOr$Option_u8(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0) as rt.i32, 7); const q: Point.Point = copy$Point(p); q.x = rt.i32Add(q.x, 100); Point.bump(q); @@ -134,26 +134,26 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const old2 = a; a = _66; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.x & 0xff, b.x & 0xff, old2.x & 0xff))); - const boxed: Moved.Moved = { _0: data.length & 0xff, _1: 0 }; + const boxed: Moved.Moved = { _0: dataLen & 0xff, _1: 0 }; boxed._1 = rt.u16Add(boxed._1, 1); boxed._1 = rt.u16Add(boxed._1, 2); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed._0))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(boxed._1))); - let n: rt.u32 = data.length as rt.u32; + let n: rt.u32 = dataLen as rt.u32; const both: [rt.u32, rt.u32] = [n, n]; n = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n)))); - const word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); + const word: Uint8Array = Uint8Array.of(0, 0, 0, dataLen & 0xff); const converted: rt.u32 = rt.u32FromBeBytes(word); word[0] = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32)))); - const cell: Uint8Array = Uint8Array.of(data.length & 0xff); + const cell: Uint8Array = Uint8Array.of(dataLen & 0xff); rt.byteVecPush(out, writeThenRead(copy$u8s(cell), rt.byteSliceFrom(cell))); - const source: Uint8Array = Uint8Array.of(data.length & 0xff); + const source: Uint8Array = Uint8Array.of(dataLen & 0xff); const returned: Uint8Array = same(copy$u8s(source)); source[0] = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(returned[0], source[0]))); - rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); + rt.byteVecPush(out, copyThenWrite([dataLen & 0xff, 0] as [rt.u8, rt.u8])); const marked: boolean = mark(out, 1) === 0; mark(out, 2); rt.byteVecPush(out, marked ? 1 : 0); @@ -172,7 +172,7 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const err: Point.Point = copy$Point(rt.resultUnwrapErr(fail, rt.u8Debug)); err.y = 3; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Debug).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Debug).y & 0xff))); - const shape_: Shape.Shape = copy$Shape(shape(data)); + const shape_: Shape.Shape = copy$Shape(shape(dataData, dataStart, dataLen)); const before: Shape.Shape = copy$Shape(shape_); if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { @@ -201,10 +201,10 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_211)); } - if (rt.usizeRem(data.length, 2) === 0) { + if (rt.usizeRem(dataLen, 2) === 0) { poll = rt.Pending as rt.Poll; } else { - poll = Uint8Array.of(data.length & 0xff) as rt.Poll; + poll = Uint8Array.of(dataLen & 0xff) as rt.Poll; } const polled_: rt.Poll = copy$Poll_u8s(poll); if (poll !== rt.Pending) { @@ -226,16 +226,16 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _246); } - shares(data, out); - unwritten(data, out); + shares(dataData, dataStart, dataLen, out); + unwritten(dataData, dataStart, dataLen, out); } /** * `Copy` aggregates written into only in another module, behind a type parameter, or * through a box. Each copy keeps its value. */ -export function unwritten(data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.u8 = data.length & 0xff; +export function unwritten(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { + const n: rt.u8 = dataLen & 0xff; const track: Track.Track = { mark: { at: n } }; const seen: Mark.Mark = Track.mark(track); advance(track); @@ -272,11 +272,12 @@ export function bump(slot: rt.Mutex): void { * `Copy` aggregates holding shared references: a copy has its own values, and shares * what its references point at with the original's. */ -export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { +export function shares(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let res!: rt.Result<[rt.Mutex, rt.u8], rt.u8>; let n!: rt.u8; let arc!: rt.Arc; let flow!: rt.Result>; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let unwind: number = 0; try { const a: rt.u8 = unwrapOr$Option_u8(rt.byteSliceFirst(data), 0); @@ -539,11 +540,12 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { * Aggregates written with their fields out of declaration order evaluate them as * written: each field logs as it runs. */ -export function order(data: rt.ByteSlice, out: rt.ByteVec): void { +export function order(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let taken!: Shape.Shape; let _75!: rt.usize; + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return unwrapOr$Option_u8(rt.byteSliceGet(data, i2), 0); + return unwrapOr$Option_u8(rt.byteSliceGet(captured, i2), 0); }; const _5: rt.u16 = mark(out, at(0)) & 0xffff; const _10: rt.u16 = mark(out, at(1)) & 0xffff; @@ -575,8 +577,8 @@ export function order(data: rt.ByteSlice, out: rt.ByteVec): void { while ((_75 = iterStart++) < iterEnd) { sum = rt.usizeAdd(sum, _75); } - const len: rt.usize = data.length; - const _83: rt.ByteSlice = logged(data, out); + const len: rt.usize = dataLen; + const _83: rt.ByteSlice = logged(dataData, dataStart, dataLen, out); const _85: rt.usize = rt.min(mark(out, 14), len); const _87: rt.usize = rt.usizeDiv(rt.min(mark(out, 15), len), 2); const _103: rt.usize = sum; @@ -591,7 +593,7 @@ export function order(data: rt.ByteSlice, out: rt.ByteVec): void { const _143: [rt.usize, rt.usize] = [mark(out, 18), mark(out, 19)]; rt.byteVecPush(out, part & 0xff); rt.byteVecPush(out, _143[0] & 0xff); - indexed(data, out); + indexed(dataData, dataStart, dataLen, out); } /** @@ -599,9 +601,10 @@ export function order(data: rt.ByteSlice, out: rt.ByteVec): void { * evaluate what comes before those first: each logs as it runs, or changes what an * earlier operand read. */ -export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { +export function indexed(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return unwrapOr$Option_u8(rt.byteSliceGet(data, i), 0); + return unwrapOr$Option_u8(rt.byteSliceGet(captured, i), 0); }; const _7: rt.ByteVec = listed(out, at(0)); rt.byteVecPush(out, 225); @@ -616,7 +619,8 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteSliceCopyWithin(_30, 2, _30.length, 1); const _36: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); rt.byteSliceCopyWithin(_36, 3, _36.length, 0); - const _41: rt.ByteSlice = logged(rt.byteSliceFrom(bytes), out); + const _42: rt.ByteSlice = rt.byteSliceFrom(bytes); + const _41: rt.ByteSlice = logged(_42.data, _42.start, _42.length, out); rt.byteVecPush(out, 230); rt.idx(_41, 1); const second: rt.u8 = _41.data[_41.start + 1]; @@ -634,11 +638,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 mid: number = rt.usizeDiv(data.length, 2); - if (mid > data.length) { + const mid: number = rt.usizeDiv(dataLen, 2); + if (mid > dataLen) { 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); + ends([new rt.ByteSlice(dataData, dataStart, mid), new rt.ByteSlice(dataData, dataStart + mid, dataLen - 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]; @@ -677,9 +681,9 @@ export function twice(b: rt.u8): rt.u8 { } /** `data`, logging that it was read. */ -export function logged(data: rt.ByteSlice, out: rt.ByteVec): rt.ByteSlice { +export function logged(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): rt.ByteSlice { rt.byteVecPush(out, 238); - return data; + return new rt.ByteSlice(dataData, dataStart, dataLen); } /** `n`'s byte, incremented. */ @@ -696,10 +700,10 @@ export function reset(m: Moved.Moved): rt.u16 { } /** Fieldless enums cast to every width, past their discriminant's range and sign. */ -export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { +export function discriminants(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let wide!: Wide.Wide; let signed!: Signed.Signed; - for (const b of rt.byteSliceView(data)) { + for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _10: rt.u8 = rt.u8Rem(b, 3); if (_10 === 0) { wide = "Low" as Wide.Wide; @@ -732,7 +736,7 @@ export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { * Loops: labeled, `while let`, ranges, values out of `break`, loops that end a function, * and values of type `!`. */ -export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { +export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _24!: rt.usize; let _34!: rt.usize; let steps!: rt.u8; @@ -748,7 +752,7 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { } } }; - const stack: rt.ByteVec = rt.byteSliceToByteVec(data); + const stack: rt.ByteVec = rt.byteSliceToByteVec(new rt.ByteSlice(dataData, dataStart, dataLen)); let popped: rt.u32 = 0; while (true) { const _5: rt.u8 | undefined = rt.byteVecPop(stack); @@ -767,22 +771,28 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(popped))); let found = undefined as [rt.usize, rt.usize] | undefined; let iterStart: rt.usize = 0; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; l3: while ((_24 = iterStart++) < iterEnd) { const i: rt.usize = _24; let iterStart2: rt.usize = rt.usizeAdd(i, 1); - const iterEnd2: rt.usize = data.length; + const iterEnd2: rt.usize = dataLen; while (true) { if (!((_34 = iterStart2++) < iterEnd2)) { continue l3; } const j: rt.usize = _34; - rt.idx(data, i); - const _39: rt.u8 = data.data[data.start + i]; - rt.idx(data, j); - if (!(_39 === data.data[data.start + j])) { - rt.idx(data, j); - if (data.data[data.start + j] === 0) { + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _39: rt.u8 = dataData[dataStart + i]; + if (j >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + j); + } + if (!(_39 === dataData[dataStart + j])) { + if (j >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + j); + } + if (dataData[dataStart + j] === 0) { continue l3; } } else { @@ -796,7 +806,7 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { } else { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(found[0] & 0xff, found[1] & 0xff))); } - let n: rt.u64 = data.length as rt.u64; + let n: rt.u64 = dataLen as rt.u64; b6: { while (!rt.u64Le(n, 1)) { if (!(rt.u64Rem(n, 2) === 0)) { @@ -824,7 +834,7 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { count = rt.u8Add(count, 1); } rt.byteVecPush(out, count); - const lo: rt.i32 = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); + const lo: rt.i32 = rt.i32Neg(rt.usizeRem(dataLen, 4) | 0); const r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); const first: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; r.end = r.start; @@ -845,22 +855,22 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { while ((_136 = iterStart4++) < iterEnd4) { rt.byteVecPush(out, _136 & 0xff); } - rt.byteVecPush(out, firstRepeat(data)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(data)))); - rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(data, 0) as rt.u32))); - rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); - drain(data, out); - rt.byteVecPush(out, returnedLoop(data)); - branchLoops(data, out); - diverging(data, out); + rt.byteVecPush(out, firstRepeat(dataData, dataStart, dataLen)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(dataData, dataStart, dataLen)))); + rt.byteVecPush(out, armLoop(dataData, dataStart, dataLen)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(dataData, dataStart, dataLen, 0) as rt.u32))); + rt.byteVecPush(out, _158(rt.u8Mul(dataLen & 0xff, 7))); + drain(dataData, dataStart, dataLen, out); + rt.byteVecPush(out, returnedLoop(dataData, dataStart, dataLen)); + branchLoops(dataData, dataStart, dataLen, out); + diverging(dataData, dataStart, dataLen, out); } /** * Values of type `!` where a value goes, triggered by the first two bytes so most * inputs run every case to its end. */ -export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { +export function diverging(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _15: (a0: rt.u8) => rt.u8 = (b2: rt.u8): rt.u8 => { if (!(b2 === 253)) { return rt.u8Div(b2, 3); @@ -868,15 +878,15 @@ export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b2, f)]; rt.panicFmt(["closure ", args2[0]]); }; - const head: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); + const head: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.min(dataLen, 2)); const b: rt.u8 = unwrapOr$Option_u8(rt.byteSliceFirst(head), 0); - rt.byteVecPush(out, returnedNever(b, data.length)); - rt.byteVecPush(out, brokenNever(head)); + rt.byteVecPush(out, returnedNever(b, dataLen)); + rt.byteVecPush(out, brokenNever(head.data, head.start, head.length)); rt.byteVecPush(out, _15(b)); - rt.byteVecPush(out, guardedReturn(head)); - rt.byteVecPush(out, boundNever(head, out)); + rt.byteVecPush(out, guardedReturn(head.data, head.start, head.length)); + rt.byteVecPush(out, boundNever(head.data, head.start, head.length, out)); rt.byteVecPush(out, closureNever(b)); - genericNever(b, data.length); + genericNever(b, dataLen); } /** @@ -980,17 +990,17 @@ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { } /** A `return` of a `match` that guards, whose arms fall through to the next. */ -export function guardedReturn(data: rt.ByteSlice): rt.u8 { - if (!((data.length === 0))) { - if (data.length === 2) { - const a: rt.u8 = data.data[data.start]; - const b: rt.u8 = data.data[data.start + 1]; +export function guardedReturn(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (!((dataLen === 0))) { + if (dataLen === 2) { + const a: rt.u8 = dataData[dataStart]; + const b: rt.u8 = dataData[dataStart + 1]; if (a > b) { return rt.u8Sub(a, b); } } - if (data.length >= 1) { - if (data.data[data.start] > 128) { + if (dataLen >= 1) { + if (dataData[dataStart] > 128) { return 1; } } @@ -1000,19 +1010,23 @@ export function guardedReturn(data: rt.ByteSlice): rt.u8 { } /** A loop ending the function, left by `break` with values that never exist. */ -export function brokenNever(data: rt.ByteSlice): rt.u8 { +export function brokenNever(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { let i: rt.usize = 0; - while (!(i >= data.length)) { + while (!(i >= dataLen)) { const _6: rt.usize = i; - rt.idx(data, _6); - const value = data.data[data.start + _6]; + if (_6 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _6); + } + const value = dataData[dataStart + _6]; if (value === 251) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; rt.panicFmt(["broken at ", args2[0]]); } else if (value === 252) { const _19: rt.usize = i; - rt.idx(data, _19); - bail(data.data[data.start + _19]); + if (_19 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _19); + } + bail(dataData[dataStart + _19]); } else { if (value === 0) { return i & 0xff; @@ -1027,19 +1041,23 @@ export function brokenNever(data: rt.ByteSlice): rt.u8 { * Values that never exist where a value is needed: bound, and passed. A loop that * only `return` leaves gives the function's result. */ -export function boundNever(data: rt.ByteSlice, _out: rt.ByteVec): rt.u8 { +export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: number, _out: rt.ByteVec): rt.u8 { let i: rt.usize = 0; - while (!(i >= data.length)) { + while (!(i >= dataLen)) { const _8: rt.usize = i; - rt.idx(data, _8); - const value = data.data[data.start + _8]; + if (_8 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _8); + } + const value = dataData[dataStart + _8]; if (value === 239) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; rt.panicFmt(["bound at ", args2[0]]); } else if (value === 240) { const _22: rt.usize = i; - rt.idx(data, _22); - bail(data.data[data.start + _22]); + if (_22 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _22); + } + bail(dataData[dataStart + _22]); } else { if (value === 0) { return i & 0xff; @@ -1047,10 +1065,12 @@ export function boundNever(data: rt.ByteSlice, _out: rt.ByteVec): rt.u8 { if (value === 128) { while (true) { i = rt.usizeAdd(i, 1); - if (!(i >= data.length)) { + if (!(i >= dataLen)) { const _32: rt.usize = i; - rt.idx(data, _32); - if (data.data[data.start + _32] < 128) { + if (_32 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _32); + } + if (dataData[dataStart + _32] < 128) { break; } } else { @@ -1066,7 +1086,8 @@ export function boundNever(data: rt.ByteSlice, _out: rt.ByteVec): rt.u8 { } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ -export function branchLoops(data: rt.ByteSlice, out: rt.ByteVec): void { +export function branchLoops(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let i: rt.usize = 0; l1: while (rt.usizeAdd(i, 1) < data.length) { const w: rt.ByteSlice = rt.byteSliceRange(data, i, rt.usizeAdd(i, 2)); @@ -1108,7 +1129,8 @@ export function branchLoops(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A loop that only `return` leaves, returned itself, around loops that `break`. */ -export function returnedLoop(data: rt.ByteSlice): rt.u8 { +export function returnedLoop(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let i: rt.usize = 0; while (!(i >= data.length)) { for (const b of rt.byteSliceView(rt.byteSliceRange(data, i))) { @@ -1126,25 +1148,33 @@ export function returnedLoop(data: rt.ByteSlice): rt.u8 { } /** A loop that ends the function, left only by `return` from nested scopes. */ -export function firstRepeat(data: rt.ByteSlice): rt.u8 { +export function firstRepeat(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { let i: rt.usize = 0; - l2: while (!(i >= data.length)) { + l2: while (!(i >= dataLen)) { let j: rt.usize = rt.usizeAdd(i, 1); - while (j < data.length) { + while (j < dataLen) { const _14: rt.usize = j; - rt.idx(data, _14); - if (!(data.data[data.start + _14] === 0)) { + if (_14 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _14); + } + if (!(dataData[dataStart + _14] === 0)) { const _21: rt.usize = i; - rt.idx(data, _21); - const _20: rt.u8 = data.data[data.start + _21]; + if (_21 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _21); + } + const _20: rt.u8 = dataData[dataStart + _21]; const _25: rt.usize = j; - rt.idx(data, _25); - if (!(_20 === data.data[data.start + _25])) { + if (_25 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _25); + } + if (!(_20 === dataData[dataStart + _25])) { j = rt.usizeAdd(j, 1); } else { const _29: rt.usize = j; - rt.idx(data, _29); - return data.data[data.start + _29] ^ (i & 0xff); + if (_29 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _29); + } + return dataData[dataStart + _29] ^ (i & 0xff); } } else { i = rt.usizeAdd(j, 1); @@ -1157,7 +1187,8 @@ export function firstRepeat(data: rt.ByteSlice): rt.u8 { } /** A loop that ends the function, left by `break` with a value from nested scopes. */ -export function tailBreak(data: rt.ByteSlice): rt.u16 { +export function tailBreak(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u16 { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let i: rt.usize = 0; l2: while (true) { if (!(i >= data.length)) { @@ -1206,36 +1237,42 @@ export function tailBreak(data: rt.ByteSlice): rt.u16 { } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ -export function armLoop(data: rt.ByteSlice): rt.u8 { +export function armLoop(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { let k: rt.usize = 0; - const _3: rt.u8 | undefined = rt.byteSliceFirst(data); + const _3: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); if (_3 !== undefined) { if (_3 >= 128) { return rt.u8Div(_3, 2); } } - while (!(k >= data.length)) { + while (!(k >= dataLen)) { const _13: rt.usize = k; - rt.idx(data, _13); - if (!(data.data[data.start + _13] >= 128)) { + if (_13 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _13); + } + if (!(dataData[dataStart + _13] >= 128)) { k = rt.usizeAdd(k, 1); } else { const _17: rt.usize = k; - rt.idx(data, _17); - return rt.u8Sub(data.data[data.start + _17], 128); + if (_17 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _17); + } + return rt.u8Sub(dataData[dataStart + _17], 128); } } return 238; } /** A generic function ending in a loop. */ -export function position$u8(items: rt.ByteSlice, want: rt.u8): rt.usize { +export function position$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: number, want: rt.u8): rt.usize { let i: rt.usize = 0; while (true) { - if (!(i === items.length)) { + if (!(i === itemsLen)) { const _9: rt.usize = i; - rt.idx(items, _9); - if (!((items.data[items.start + _9] === want))) { + if (_9 >= itemsLen) { + rt.panic("index out of bounds: the len is " + itemsLen + " but the index is " + _9); + } + if (!((itemsData[itemsStart + _9] === want))) { i = rt.usizeAdd(i, 1); } else { return i; @@ -1247,39 +1284,41 @@ export function position$u8(items: rt.ByteSlice, want: rt.u8): rt.usize { } /** A unit function ending in a loop. */ -export function drain(data: rt.ByteSlice, out: rt.ByteVec): void { +export function drain(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let i: rt.usize = 0; - while (!(i >= data.length)) { + while (!(i >= dataLen)) { const _10: rt.usize = i; - rt.idx(data, _10); - rt.byteVecPush(out, data.data[data.start + _10] ^ 90); + if (_10 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _10); + } + rt.byteVecPush(out, dataData[dataStart + _10] ^ 90); i = rt.usizeAdd(i, 2); } } /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ -export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { +export function patterns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let class_!: rt.u8; let area!: rt.i64; let either!: rt.Result; let v!: rt.u8; - if (!(data.length === 0)) { - if (!(data.length === 1)) { - if (!(data.length >= 2)) { + if (!(dataLen === 0)) { + if (!(dataLen === 1)) { + if (!(dataLen >= 2)) { 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, (data.length - 2) & 0xff); + } else if (!((dataData[dataStart] === dataData[dataStart + (dataLen - 1)]))) { + rt.byteVecPush(out, dataData[dataStart] ^ dataData[dataStart + 1]); + rt.byteVecPush(out, (dataLen - 2) & 0xff); } else { rt.byteVecPush(out, 2); } } else { - rt.byteVecPush(out, data.data[data.start]); + rt.byteVecPush(out, dataData[dataStart]); } } else { rt.byteVecPush(out, 0); } - for (const _33 of rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 4)))) { + for (const _33 of rt.byteSliceView(rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.min(dataLen, 4)))) { b3: { const b: rt.u8 = _33; if (b === 0) { @@ -1311,11 +1350,11 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, class_); } b6: { - if (data.length >= 2) { - const _56: Dir.Dir | undefined = dir(data.data[data.start]); + if (dataLen >= 2) { + const _56: Dir.Dir | undefined = dir(dataData[dataStart]); if (_56 !== undefined) { const d: Dir.Dir = _56; - if (data.data[data.start + 1] > 10) { + if (dataData[dataStart + 1] > 10) { rt.byteVecPush(out, from$From_Dir_u8(d)); break b6; } @@ -1323,7 +1362,7 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, 238); } - const shape_: Shape.Shape = shape(data); + const shape_: Shape.Shape = shape(dataData, dataStart, dataLen); b8: { if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { @@ -1344,10 +1383,10 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { area = 0; } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(area))); - if (!(rt.usizeRem(data.length, 2) === 0)) { + if (!(rt.usizeRem(dataLen, 2) === 0)) { either = rt.Err(160); } else { - either = rt.Ok(data.length & 0xff); + either = rt.Ok(dataLen & 0xff); } if (either.ok) { v = either.value; @@ -1356,19 +1395,19 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, v); rt.byteVecPush(out, rt.u8Add(rt.byteSliceFrom(Uint8Array.of()).length & 0xff, rt.iterSum(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of()))), rt.u8Add, 0))); - const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); - const slice = rt.byteSliceRange(rt.byteSliceFrom(bytes), 1, 3); - slice.data[slice.start] = 9; + const bytes: Uint8Array = Uint8Array.of(dataLen & 0xff, 1, 2); + const slice2 = rt.byteSliceRange(rt.byteSliceFrom(bytes), 1, 3); + slice2.data[slice2.start] = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }], out))))); - const parsed: rt.Result = rt.Ok(data.length & 0xff); + const parsed: rt.Result = rt.Ok(dataLen & 0xff); const a2: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rt.u8 }).value, (parsed as { ok: true; value: rt.u8 }).value, early(a2)))); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(parsed, f, rt.u8Debug, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - payloads(data, out); - known(data, out); - rematched(data, out); + payloads(dataData, dataStart, dataLen, out); + known(dataData, dataStart, dataLen, out); + rematched(dataData, dataStart, dataLen, out); } /** `n`'s result: `Ok` for an even `n`. */ @@ -1383,7 +1422,7 @@ export function parity(n: rt.u8): rt.Result { * Payloads changed through a borrow, which changes the enum holding them where it is * and none of its copies. */ -export function payloads(data: rt.ByteSlice, out: rt.ByteVec): void { +export function payloads(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { let _86!: rt.u8; let _104!: rt.u8; let _109!: rt.u8; @@ -1391,7 +1430,7 @@ export function payloads(data: rt.ByteSlice, out: rt.ByteVec): void { let _133!: rt.u8; let _143!: rt.u8; let _149!: rt.u8; - const n: rt.u8 = data.length & 0xff; + const n: rt.u8 = dataLen & 0xff; let res: rt.Result = parity(n); const before: rt.Result = res; if (!res.ok) { @@ -1515,7 +1554,7 @@ export function payloads(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Enums matched where the variant they were made with is in sight. */ -export function known(data: rt.ByteSlice, out: rt.ByteVec): void { +export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { let _15!: rt.u8; let _18!: rt.u8; let _21!: rt.u8; @@ -1525,7 +1564,7 @@ export function known(data: rt.ByteSlice, out: rt.ByteVec): void { let _45!: rt.u8; let _52!: rt.u8; let _56!: rt.u8; - const n: rt.u8 = data.length & 0xff; + const n: rt.u8 = dataLen & 0xff; const ready = n as rt.Poll; const idle = rt.Pending as rt.Poll; const none = undefined as Point.Point | undefined; @@ -1615,7 +1654,7 @@ export function known(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Enums matched again where an enclosing match decided their variant. */ -export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { +export function rematched(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _5!: rt.u8; let _15!: rt.u8; let _19!: rt.u8; @@ -1631,7 +1670,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { let _127!: rt.u8; let _131!: Shape.Shape; let _189!: rt.u8; - const s: Shape.Shape = shape(data); + const s: Shape.Shape = shape(dataData, dataStart, dataLen); if (s.tag === "Dot") { _5 = 2; } else if (s.tag === "Line") { @@ -1654,7 +1693,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { _19 = s.width & 0xff; } rt.byteVecPush(out, _19); - const d: Dir.Dir | undefined = dir(data.length & 0xff); + const d: Dir.Dir | undefined = dir(dataLen & 0xff); if (d === undefined) { _29 = 15; } else if (d === "North") { @@ -1663,7 +1702,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { _29 = { North: 1, East: 2, South: 4, West: 8 }[d] & 0xff; } rt.byteVecPush(out, _29); - const order_: rt.Ordering = rt.cmp(data.length & 0xff, 2); + const order_: rt.Ordering = rt.cmp(dataLen & 0xff, 2); if (order_ === -1) { _43 = 17; } else { @@ -1678,7 +1717,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _50); } - if (!(data.length > 1)) { + if (!(dataLen > 1)) { r = rt.Err(2); } else { r = rt.Ok(1); @@ -1692,13 +1731,13 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _58); } let assigned = -1 as rt.Ordering; - if (data.length > 3) { + if (dataLen > 3) { assigned = 1; } if (assigned === 0) { rt.byteVecPush(out, 34); } - const flow: rt.Result = step(0, data.length & 0xff); + const flow: rt.Result = step(0, dataLen & 0xff); if (!flow.ok) { if ((flow as rt.Result).ok) { _76 = ((flow as rt.Result) as { ok: true; value: rt.u16 }).value & 0xff; @@ -1708,10 +1747,10 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _76); } const counts: rt.HashMap = rt.hashNew() as rt.HashMap; - if (rt.usizeRem(data.length, 2) === 0) { - rt.hashInsert(counts, data.length & 0xff, 35); + if (rt.usizeRem(dataLen, 2) === 0) { + rt.hashInsert(counts, dataLen & 0xff, 35); } - const entry: rt.Entry | undefined = rt.entry(counts, data.length & 0xff); + const entry: rt.Entry | undefined = rt.entry(counts, dataLen & 0xff); if (entry !== undefined) { if ((entry as rt.Entry | undefined) === undefined) { _97 = 37; @@ -1724,7 +1763,8 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } let m: Shape.Shape = s; if (m.tag === "Dot") { - m = shape(rt.byteSliceRange(data, rt.min(data.length, 1))); + const _110: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.min(dataLen, 1)); + m = shape(_110.data, _110.start, _110.length); if (m.tag === "Line") { _107 = 18; } else { @@ -1771,9 +1811,9 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { let iterStart2: rt.i32 = 0; const iterEnd2: rt.i32 = 4; while (iterStart2++ < iterEnd2) { - rt.byteVecPush(out, Machine.run(machine, data.length & 0xff)); + rt.byteVecPush(out, Machine.run(machine, dataLen & 0xff)); } - const filled: Filled.Filled = { shape: copy$Option_Shape(map$Option_Dir_Shape_rematched_closure1(dir(data.length & 0xff), (_2: Dir.Dir): Shape.Shape => { + const filled: Filled.Filled = { shape: copy$Option_Shape(map$Option_Dir_Shape_rematched_closure1(dir(dataLen & 0xff), (_2: Dir.Dir): Shape.Shape => { return copy$Shape(s); })) }; let iterStart3: rt.i32 = 0; @@ -1781,9 +1821,10 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { while (iterStart3++ < iterEnd3) { rt.byteVecPush(out, Filled.run(filled)); } - let original: Shape.Shape = shape(data); + let original: Shape.Shape = shape(dataData, dataStart, dataLen); if (original.tag === "Dot") { - original = shape(rt.byteSliceFrom(Uint8Array.of(1))); + const _183: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + original = shape(_183.data, _183.start, _183.length); rt.byteVecPush(out, 24); if (original.tag === "Line") { _189 = 25; @@ -1792,20 +1833,21 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _189); } - reseated(data, out); + reseated(dataData, dataStart, dataLen, out); } /** * A reference pointed elsewhere without an assignment to it: through a `&mut` to it, * a reborrow of that, a closure, and a call. */ -export function reseated(data: rt.ByteSlice, out: rt.ByteVec): void { +export function reseated(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _12!: rt.u8; let _19!: rt.u8; let _26!: rt.u8; let _37!: rt.u8; let _51!: rt.u8; - const _5: [Shape.Shape, Shape.Shape] = [shape(data), shape(rt.byteSliceFrom(Uint8Array.of(1)))]; + const _8: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + const _5: [Shape.Shape, Shape.Shape] = [shape(dataData, dataStart, dataLen), shape(_8.data, _8.start, _8.length)]; const a: Shape.Shape = _5[0]; const b: Shape.Shape = _5[1]; let r: Shape.Shape = a; @@ -1899,7 +1941,8 @@ export function early(n: rt.u8): rt.u8 { } /** Closures capturing by reference and by move, and functions as values. */ -export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { +export function closures(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let sum: rt.u32 = 0; const add: (a0: rt.u8) => void = (v: rt.u8): void => { sum = rt.u32Add(sum, v as rt.u32); @@ -1947,8 +1990,9 @@ export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): r } /** Options, results, `?`, and strings. */ -export function library(data: rt.ByteSlice, out: rt.ByteVec): void { +export function library(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let parsed!: rt.Result; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { const _4: rt.u8 | undefined = rt.u8CheckedAdd(a2, b2); if (_4 !== undefined) { @@ -2098,11 +2142,12 @@ export function polled(x: rt.u8): rt.Poll; let option!: rt.u8 | undefined; let _116!: rt.u8; let _132!: boolean; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let total: rt.u16 = 0; for (const x of rt.byteSliceView(data)) { const flow: rt.Result = step(total, x); diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index 8f52357aa..9173d501f 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -6,11 +6,11 @@ import { unwrapOr$Option_u8, mapOr$Option_u8s_u8s_u8_splits_closure0, okOr$Optio import type * as Short from "./splits.Short.ts"; /** The first byte, then a big-endian `u16`, by `?` on `ok_or`. */ -export function header(data: rt.ByteSlice): rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> { - if (data.length !== 0) { - const a: rt.u8 = data.data[data.start]; - if (data.length - 1 >= 2) { - return rt.Ok([a, (data.data[data.start + 1] << 8) | data.data[data.start + 2], new rt.ByteSlice(data.data, data.start + 3, data.length - 3)] as [rt.u8, rt.u16, rt.ByteSlice]); +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> { + if (dataLen !== 0) { + const a: rt.u8 = dataData[dataStart]; + if (dataLen - 1 >= 2) { + return rt.Ok([a, (dataData[dataStart + 1] << 8) | dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)] as [rt.u8, rt.u16, rt.ByteSlice]); } return rt.Err({ tag: "Need", _0: 2 } as Short.Short); } @@ -18,11 +18,11 @@ export function header(data: rt.ByteSlice): rt.Result<[rt.u8, rt.u16, rt.ByteSli } /** Two bytes, by `?` on an `Option`. */ -export function two(data: rt.ByteSlice): [rt.u8, rt.u8, rt.ByteSlice] | undefined { - if (data.length !== 0) { - const a: rt.u8 = data.data[data.start]; - if (data.length - 1 !== 0) { - return [a, data.data[data.start + 1], new rt.ByteSlice(data.data, data.start + 2, data.length - 2)] as [rt.u8, rt.u8, rt.ByteSlice]; +export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u8, rt.u8, rt.ByteSlice] | undefined { + if (dataLen !== 0) { + const a: rt.u8 = dataData[dataStart]; + if (dataLen - 1 !== 0) { + return [a, dataData[dataStart + 1], new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)] as [rt.u8, rt.u8, rt.ByteSlice]; } return undefined; } @@ -30,13 +30,13 @@ export function two(data: rt.ByteSlice): [rt.u8, rt.u8, rt.ByteSlice] | undefine } /** `n` bytes, or how many it needed. */ -export function take(data: rt.ByteSlice, n: rt.usize): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { - return 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); +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { + return okOr$Option_u8s_u8s_Short((n <= dataLen ? [new rt.ByteSlice(dataData, dataStart, n), new rt.ByteSlice(dataData, dataStart + n, dataLen - 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)); +export function second(dataData: Uint8Array, dataStart: number, dataLen: number, e: rt.u8 | undefined): rt.Result { + const _4: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> = copy$Result_u8s_u8s_Option_u8(okOr$Option_u8s_u8s_Option_u8((1 <= dataLen ? [new rt.ByteSlice(dataData, dataStart, 1), new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, e)); if (_4.ok) { return rt.Ok(unwrapOr$Option_u8(rt.byteSliceFirst(_4.value[1]), 0)); } @@ -44,8 +44,8 @@ export function second(data: rt.ByteSlice, e: rt.u8 | undefined): rt.Result { +export function opaque(sData: Uint8Array, sStart: number, sLen: number): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, sLen))), sLen & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { return rt.u8WrappingAdd(a ^ (a >> 3), b); }); } @@ -56,15 +56,15 @@ export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { return n; } -export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, 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 restData: Uint8Array = dataData; + let restStart: number = dataStart; + let restLen: number = dataLen; let sum: rt.u8 = 0; while (true) { const _9Data: Uint8Array = restData; @@ -86,49 +86,48 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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) { + const mid3: number = rt.u8Rem(unwrapOr$Option_u8(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0), 8) as rt.usize; + if (mid3 > dataLen) { rt.panic("mid > len"); } rt.byteVecPush(out, mid3 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(data.data, data.start + mid3, data.length - mid3)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(dataData, dataStart + mid3, dataLen - mid3)); } else if (_4 === 2) { - const _33: rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> = header(data); + const _33: rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> = header(dataData, dataStart, dataLen); 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])); + rt.byteVecPush(out, opaque(_33.value[2].data, _33.value[2].start, _33.value[2].length)); } 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) { + const mid2: number = rt.usizeDiv(dataLen, 2); + if (mid2 > dataLen) { 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(dataData, dataStart, mid2) ^ _58); } - rt.byteVecPush(out, opaque(new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2))); + rt.byteVecPush(out, opaque(dataData, dataStart + mid2, dataLen - mid2)); } else if (_4 === 4) { - const mid: number = rt.usizeDiv(data.length, 3); - if (mid > data.length) { + const mid: number = rt.usizeDiv(dataLen, 3); + if (mid > dataLen) { rt.panic("mid > len"); } - let pair_0Data: Uint8Array = data.data; - let pair_0Start: number = data.start; + let pair_0Data: Uint8Array = dataData; + let pair_0Start: number = dataStart; 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 pair_1Data: Uint8Array = dataData; + let pair_1Start: number = dataStart + mid; + let pair_1Len: number = dataLen - mid; + const _73: rt.usize = rt.usizeRem(dataLen, 3); let iterStart2: rt.usize = 0; const iterEnd2: rt.usize = _73; while (iterStart2++ < iterEnd2) { @@ -155,19 +154,24 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, new rt.ByteSlice(pair_0Data, pair_0Start, pair_0Len)); } else if (_4 === 5) { - let rest2: rt.ByteSlice = data; + let restData2: Uint8Array = dataData; + let restStart2: number = dataStart; + let restLen2: number = dataLen; while (true) { - const _94: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(rest2); + const _94: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(restData2, restStart2, restLen2); if (_94 !== undefined) { rt.byteVecPush(out, _94[0] ^ _94[1]); - rest2 = _94[2]; + const slice: rt.ByteSlice = _94[2]; + restData2 = slice.data; + restStart2 = slice.start; + restLen2 = slice.length; } else { break; } } - rt.byteVecPush(out, rest2.length & 0xff); + rt.byteVecPush(out, restLen2 & 0xff); } else if (_4 === 6) { - const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(data, 4); + const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(new rt.ByteSlice(dataData, dataStart, dataLen), 4); b5: { if (split !== undefined) { const _197: rt.ByteSlice = split[0]; @@ -181,9 +185,9 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } - const _129: rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> = take(data, 3); + const _129: rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> = take(dataData, dataStart, dataLen, 3); if (_129.ok) { - rt.byteVecPush(out, opaque(_129.value[0])); + rt.byteVecPush(out, opaque(_129.value[0].data, _129.value[0].start, _129.value[0].length)); rt.byteVecPush(out, _129.value[1].length & 0xff); } else { const e: Short.Short = _129.error; @@ -196,26 +200,26 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } 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); + if (dataLen !== 0) { + rt.byteVecPush(out, dataData[dataStart]); + rt.byteVecPush(out, (dataLen - 1) & 0xff); } else { rt.byteVecPush(out, first2); } - if (rt.usizeRem(data.length, 2) === 0) { + if (rt.usizeRem(dataLen, 2) === 0) { err = { tag: "Empty" } as Short.Short; } else { - err = { tag: "Need", _0: data.length } as Short.Short; + err = { tag: "Need", _0: dataLen } as Short.Short; } const _1602: Short.Short = err; - if (data.length !== 0) { - rt.byteVecPush(out, data.data[data.start]); + if (dataLen !== 0) { + rt.byteVecPush(out, dataData[dataStart]); } 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)); + const _170: rt.Result = second(dataData, dataStart, dataLen, rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen))); if (_170.ok) { rt.byteVecPush(out, _170.value); } else if (_170.error === undefined) { @@ -223,8 +227,8 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { rt.byteVecPush(out, _170.error ^ 85); } - if (2 <= data.length) { - rt.byteVecPush(out, data.data[data.start + 1] ^ ((data.length - 2) & 0xff)); + if (2 <= dataLen) { + rt.byteVecPush(out, dataData[dataStart + 1] ^ ((dataLen - 2) & 0xff)); } } } diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 7d63fb879..e0be6bb62 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -6,9 +6,9 @@ import { put } from "./fmt.ts"; import * as Named from "./strs.Named.ts"; /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(dataData: Uint8Array, dataStart: number, dataLen: number): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -24,8 +24,8 @@ export function text(data: rt.ByteSlice): string { } /** Whether the `i`th step reads from the back: by the byte's high bit. */ -export function fromBack(data: rt.ByteSlice, i: rt.usize): boolean { - const _3: rt.u8 | undefined = rt.byteSliceGet(data, i); +export function fromBack(dataData: Uint8Array, dataStart: number, dataLen: number, i: rt.usize): boolean { + const _3: rt.u8 | undefined = rt.byteSliceGet(new rt.ByteSlice(dataData, dataStart, dataLen), i); if (_3 !== undefined) { if ((_3 & 128) !== 0) { return true; @@ -58,13 +58,13 @@ export function putSeen(out: rt.ByteVec, seen: rt.char[]): void { rt.byteVecPush(out, 253); } -export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function strs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let c!: rt.char | undefined; let part!: string | undefined; let part3!: string | undefined; let item!: [rt.usize, string] | undefined; let _237!: rt.char; - const s: string = text(data); + const s: string = text(dataData, dataStart, dataLen); const _7: rt.usize = rt.u8Rem(rt.u8Div(kind, 8), 16) as rt.usize; if (!(_7 < 16)) { rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _7); @@ -76,7 +76,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const it: rt.Iter = rt.strChars(s); let i: rt.usize = 0; while (true) { - if (!fromBack(data, i)) { + if (!fromBack(dataData, dataStart, dataLen, i)) { c = rt.iterToOption(it.next()); } else { c = rt.iterToOption(it.nextBack()); @@ -104,7 +104,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const parts: rt.Iter = rt.strSplit(s, String.fromCodePoint(sep)); let i2: rt.usize = 0; while (true) { - if (!fromBack(data, i2)) { + if (!fromBack(dataData, dataStart, dataLen, i2)) { part = rt.iterToOption(parts.next()); } else { part = rt.iterToOption(parts.nextBack()); @@ -132,7 +132,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); let i3: rt.usize = 0; while (true) { - if (!fromBack(data, i3)) { + if (!fromBack(dataData, dataStart, dataLen, i3)) { part3 = rt.iterToOption(parts2.next()); } else { part3 = rt.iterToOption(parts2.nextBack()); @@ -178,7 +178,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const found2: rt.Iter<[rt.usize, string]> = rt.strMatchIndices(s, String.fromCodePoint(sep)); let i4: rt.usize = 0; while (true) { - if (!fromBack(data, i4)) { + if (!fromBack(dataData, dataStart, dataLen, i4)) { item = rt.iterToOption(found2.next()); } else { item = rt.iterToOption(found2.nextBack()); @@ -273,10 +273,10 @@ export function pattern(kind: rt.u8, s: string): string { * `&s[a..b]` by byte offsets, and the `str` methods by a `&str` pattern, which an empty * one matches before each char and after the last. */ -export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _209!: [rt.usize, rt.usize]; let sliced!: string; - const s: string = text(data); + const s: string = text(dataData, dataStart, dataLen); const p: string = pattern(kind, s); b0: { const _8: rt.u8 = rt.u8Rem(kind, 8); @@ -364,10 +364,10 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.usizeSaturatingSub(rt.usizeAdd(rt.stringLen(s), 1), rt.usizeRem(b2 as rt.usize, 4)); }; - if (!(data.length >= 2)) { + if (!(dataLen >= 2)) { _209 = [0, 0] as [rt.usize, rt.usize]; } else { - _209 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rt.usize, rt.usize]; + _209 = [at2(dataData[dataStart]), at2(dataData[dataStart + 1])] as [rt.usize, rt.usize]; } const a: rt.usize = _209[0]; const b: rt.usize = _209[1]; diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 504d125d7..ebae844e7 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -15,6 +15,9 @@ pub struct Body<'b, 'a, 'tcx> { pub args: GenericArgsRef<'tcx>, /// Every name in the function, so none shadows another. names: FxHashSet, + /// Which of the function's parameters are byte slices it takes as their parts, by + /// [`Translator::parted`], until its own body takes them. + pub parted: Vec, } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { @@ -23,6 +26,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { t, args, names: FxHashSet::default(), + parted: Vec::new(), } } @@ -115,6 +119,11 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { if let Some(class) = super::mir::coroutine::of_async_fn(self.t, instance, span) { return Expr::New(Box::new(Expr::Sym(class)), values); } + let parted = self.t.parted(instance); + let values = match parted.is_empty() { + true => values, + false => self.slice_args(values, &parted, out), + }; let sym = self.t.callee(instance, span); let call = Expr::Sym(sym).call(values); // The crate's own `next` returns an item or `rt.DONE`, and its caller an `Option`. @@ -218,6 +227,46 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } + /// `values`, with each byte slice `parted` marks as its `data`, `start`, and `length`, + /// evaluated in the order `values` are: a slice made in place gives its parts, and a + /// path or a tuple's part is read three times, but anything else is held first, after + /// what comes before it. + fn slice_args(&mut self, values: Vec, parted: &[bool], out: &mut Vec) -> Vec { + let mut args: Vec = Vec::with_capacity(values.len() + 2); + for (value, &parted) in values.into_iter().zip(parted) { + if !parted { + args.push(value); + continue; + } + let mut made = &value; + while let Expr::Located(_, e) | Expr::As(e, _) = made { + made = e; + } + if let Some(parts) = super::mir::made_slice(made) { + args.extend(parts.iter().cloned()); + continue; + } + let slice = match &value { + Expr::Index(base, i) if base.is_path() && i.is_constant() => value, + _ if value.is_path() => value, + _ => { + for arg in &mut args { + if !arg.is_constant() { + let name = self.fresh("arg"); + let value = std::mem::replace(arg, Expr::ident(&name)); + out.push(StmtKind::decl(false, name, None, Some(value)).at(None)); + } + } + let name = self.fresh("slice"); + out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); + Expr::ident(name) + } + }; + args.extend(["data", "start", "length"].map(|key| slice.clone().member(key))); + } + args + } + /// A function item as a value. pub fn fn_value(&mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgsRef<'tcx>, span: Span) -> Expr { let tcx = self.t.tcx; @@ -232,7 +281,8 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { if let Some(sym) = self.t.bound_fn(instance, span) { return Expr::Sym(sym); } - if self.t.lowers(instance) { + // One that takes byte slices as their parts is wrapped to take them whole. + if self.t.lowers(instance) && self.t.parted(instance).is_empty() { return Expr::Sym(self.t.callee(instance, span)); } } diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index d1bd3c203..f22a34254 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -30,7 +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; +pub use self::place::{made_slice, slice_member}; use super::Translator; use super::body::Body; @@ -47,10 +47,13 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> super::iter::check_impl(t, def_id); } let ret_ty = mir.return_ty(); + let parted = t.parted(instance); let mut b = Body::new(t, instance.args); + b.parted = parted; let mut fx = Fx::new(&mut b, &mir, Env::Plain, span); - let params = fx.params(); + let mut params = fx.params(); let body = fx.lower(); + fx.mark_unread_parts(&mut params, &body); let ret_span = fx.local_span(mir::RETURN_PLACE); let ret = match (next, ret_ty.kind()) { (true, ty::Adt(_, args)) => { @@ -298,6 +301,13 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { steady: FxHashSet, /// Those slices, with their types, which need declarations. scalar_binds: Vec<(String, Type)>, + /// The parameters that are byte slices passed as their parts. + parted: FxHashSet, + /// Those not held as their parts, each made from its parts on entry: its name, then + /// its parts'. + rebuilt: Vec<(Local, String, [String; 3])>, + /// The names of the parameters that are parts. + part_params: Vec, /// The tests and payload reads TypeScript may have narrowed stale. narrowing: decided::Narrowing<'tcx>, /// The statement or terminator being lowered. @@ -308,6 +318,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { pub fn new(b: &'m mut Body<'b, 'a, 'tcx>, mir: &'m mir::Body<'tcx>, env: Env, span: Span) -> Self { let tcx = b.t.tcx; let n = mir.local_decls.len(); + let parted = match env { + Env::Plain => std::mem::take(&mut b.parted), + _ => Vec::new(), + }; + let parted = mir.args_iter().zip(parted).filter(|&(_, p)| p).map(|(l, _)| l).collect(); let mut fx = Fx { b, mir, @@ -362,6 +377,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { scalars: FxHashMap::default(), steady: FxHashSet::default(), scalar_binds: Vec::new(), + parted, + rebuilt: Vec::new(), + part_params: Vec::new(), narrowing: decided::narrowing(tcx, mir), at: mir::START_BLOCK.start_location(), }; @@ -1350,6 +1368,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Slot::Var(name) => name.clone(), _ => self.b.fresh("_"), }; + if self.parted.contains(&local) { + params.extend(self.part_params(local, name)); + continue; + } let ty = self.b.t.ty(ty, self.local_span(local)); params.push(Param { name, ty: Some(ty) }); } @@ -1360,6 +1382,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { pub fn lower(&mut self) -> Vec { // A parameter changed in place gets its own copy, since the caller's may be shared. let mut entry = Vec::new(); + // A slice passed as its parts that isn't held so, made from them. + for (local, name, parts) in std::mem::take(&mut self.rebuilt) { + let slice = Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.map(Expr::ident).to_vec()); + let ty = Type::Rt("ByteSlice", Vec::new()); + entry.push(StmtKind::decl(self.defs[local] > 0, name, Some(ty), Some(slice)).at(None)); + } for local in self.mir.args_iter() { let ty = self.mir.local_decls[local].ty; if self.mutated[local] @@ -3349,7 +3377,7 @@ fn place_declaration(stmts: &mut [Stmt], name: &str, ty: &Type, total: usize, mu } /// How many times the statements name `name`, read or assigned. -fn list_names(stmts: &[Stmt], name: &str) -> usize { +pub(super) fn list_names(stmts: &[Stmt], name: &str) -> usize { stmts.iter().map(|s| stmt_names(s, name)).sum() } diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 8277b4032..aeaed96f0 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -180,6 +180,51 @@ fn uninhabited(ty: Ty<'_>) -> bool { ty.is_never() || matches!(ty.kind(), ty::Adt(adt, _) if adt.is_enum() && adt.variants().is_empty()) } +impl<'tcx> crate::lower::Translator<'_, 'tcx> { + /// Which of `instance`'s parameters it takes as a byte slice's parts, its `data`, + /// `start`, and `length`, rather than an `rt.ByteSlice`: each `&[u8]` or `&[u8; N]` of a + /// function only translated code calls directly, so not a root, a closure, or an + /// `async fn`. Empty if none. + pub(crate) fn parted(&self, instance: ty::Instance<'tcx>) -> Vec { + let tcx = self.tcx; + let ty::InstanceKind::Item(did) = instance.def else { + return Vec::new(); + }; + // A census writes nothing, and the outside passes a root's arguments whole. + if self.refusals.is_some() + || self.roots.contains(&instance) + || !self.lowers(instance) + || tcx.is_closure_like(did) + || tcx.asyncness(did).is_async() + || crate::lower::iter::is_next(tcx, did) + { + return Vec::new(); + } + let sig = tcx.fn_sig(did).instantiate(tcx, instance.args).skip_norm_wip(); + let parted: Vec = tcx + .instantiate_bound_regions_with_erased(sig) + .inputs() + .iter() + .map(|&ty| { + let ty = tcx + .try_normalize_erasing_regions(self.typing_env_pub(), ty::Unnormalized::new_wip(ty)) + .unwrap_or(ty); + slice_ref(ty) + }) + .collect(); + match parted.contains(&true) { + true => parted, + false => Vec::new(), + } + } +} + +/// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rt.ByteSlice`. +fn slice_ref(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Ref(_, inner, rustc_ast::Mutability::Not) + if super::place::byte_slice(*inner) || crate::lower::byte_array(*inner)) +} + /// A local held as its parts. #[derive(Debug)] pub(super) struct Scalar<'tcx> { @@ -273,11 +318,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { 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) - } + _ if slice_ref(ty) => Some(Shape::Slice), ty::Tuple(tys) if tys.is_empty() => Some(Shape::Unit), ty::Tuple(tys) => { let fields = tys.iter().map(|t| self.shape(t)).collect::>>()?; @@ -469,14 +510,60 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } + /// Which arguments a call of `func` takes as a byte slice's parts, as + /// [`Translator::parted`](crate::lower::Translator::parted) says. + pub(super) fn parted_call(&self, func: &Operand<'tcx>) -> Vec { + let ty::FnDef(def_id, args) = *func.ty(&self.mir.local_decls, self.tcx).kind() else { + return Vec::new(); + }; + match ty::Instance::try_resolve(self.tcx, self.b.t.typing_env_pub(), def_id, args.skip_binder()) { + Ok(Some(instance)) => self.b.t.parted(instance), + _ => Vec::new(), + } + } + + /// The parameters a byte slice `local`, named `name`, is passed as: its parts' variables + /// if it is held as its parts, or else names for them, from which it is made on entry. + pub(super) fn part_params(&mut self, local: Local, name: String) -> Vec { + let names: [String; 3] = match self.scalars.get(&local) { + Some(scalar) => <[String; 3]>::try_from(scalar.vars.clone()).expect("a slice's three parts"), + None => { + let names = ["Data", "Start", "Len"].map(|key| self.b.fresh(&format!("{name}{key}"))); + self.rebuilt.push((local, name, names.clone())); + names + } + }; + self.part_params.extend(names.iter().cloned()); + let tys = [Type::Builtin("Uint8Array"), Type::Builtin("number"), Type::Builtin("number")]; + names + .into_iter() + .zip(tys) + .map(|(name, ty)| crate::ts::Param { name, ty: Some(ty) }) + .collect() + } + + /// Mark the parameters that are parts `body` never reads, as `noUnusedParameters` + /// wants: a slice of which only the length is read, say. + pub(super) fn mark_unread_parts(&mut self, params: &mut [crate::ts::Param], body: &[Stmt]) { + for param in params { + if self.part_params.contains(¶m.name) + && !param.name.starts_with('_') + && super::list_names(body, ¶m.name) == 0 + { + param.name = self.b.fresh(&format!("_{}", param.name)); + } + } + } + /// Find the locals to hold as their parts. pub(super) fn find_scalars(&mut self) { let mir = self.mir; let mut shapes: FxHashMap> = FxHashMap::default(); for local in mir.local_decls.indices() { - if self.is_arg(local) + let parted = self.parted.contains(&local); + if self.is_arg(local) && !parted || local == mir::RETURN_PLACE - || self.defs[local] == 0 + || self.defs[local] == 0 && !parted || self.borrowed[local] || self.stepped.contains(&local) || self.next_results.contains(&local) @@ -529,6 +616,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let mut copies: Vec = Vec::new(); // Statements and terminators that take their reads of these apart. let mut taken: FxHashSet = FxHashSet::default(); + // And the slices calls take as their parts. + let mut passed: FxHashSet<(Location, Place<'tcx>)> = FxHashSet::default(); // Those some def gives parts that are not one object's already. let mut parted: FxHashSet = FxHashSet::default(); for (bb, data) in mir.basic_blocks.iter_enumerated() { @@ -601,6 +690,17 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } + // A slice passed as its parts. + for (arg, parted) in args.iter().zip(self.parted_call(func)) { + if let (Operand::Copy(p) | Operand::Move(p), true) = (&arg.node, parted) + && let Some(shape) = shapes.get(&p.local) + && let (node, n) = walk(shape, p.projection) + && n == p.projection.len() + && matches!(node.shape, Shape::Slice) + { + passed.insert((at, *p)); + } + } // A slice's length, read by std. if let ty::FnDef(def_id, _) = *func.ty(&mir.local_decls, tcx).kind() && library::is_std(tcx, def_id) @@ -611,12 +711,17 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } - // Held as the parts of the one object it is, a local saves nothing. - bad.extend(shapes.keys().filter(|l| !parted.contains(l))); + // Held as the parts of the one object it is, a local saves nothing; a parameter + // passed as its parts is made on entry. + bad.extend(shapes.keys().filter(|l| !parted.contains(l) && !self.parted.contains(l))); + for &local in shapes.keys().filter(|l| self.parted.contains(l)) { + copies.extend((0..3).map(|part| (local, part, None))); + } // What reads them otherwise, and which reads make their objects. struct Reads<'s, 'tcx> { shapes: &'s FxHashMap>, taken: &'s FxHashSet, + passed: &'s FxHashSet<(Location, Place<'tcx>)>, made: Vec, bad: FxHashSet, } @@ -640,7 +745,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } PlaceContext::NonMutatingUse(_) => {} } - if self.taken.contains(&at) { + if self.taken.contains(&at) || self.passed.contains(&(at, *place)) { return; } let (node, n) = walk(shape, place.projection); @@ -670,6 +775,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let mut reads = Reads { shapes, taken: &taken, + passed: &passed, made: Vec::new(), bad: FxHashSet::default(), }; @@ -877,6 +983,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) } + /// Whether `local` is assigned once, and not a parameter, which its caller assigns first. + fn once(&self, local: Local) -> bool { + self.defs[local] == 1 && !self.is_arg(local) + } + /// Name the variables of `local`'s parts, from its own name `base`. pub(super) fn name_scalar(&mut self, local: Local, base: &str) { let Some(scalar) = self.scalars.get(&local) else { @@ -884,10 +995,15 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { }; let mut parts = Vec::new(); scalar.shape.parts("", &mut parts); - let vars = parts + let vars: Vec = parts .iter() .map(|(suffix, _)| self.b.fresh(&format!("{base}{suffix}"))) .collect(); + // A parameter's parts are the parameters, which hold the same until assigned. + if self.parted.contains(&local) && self.defs[local] == 0 { + self.steady.extend(vars.iter().cloned()); + self.scalars.get_mut(&local).expect("checked above").held = Some(vars.iter().map(Expr::ident).collect()); + } self.scalars.get_mut(&local).expect("checked above").vars = vars; } @@ -897,7 +1013,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let mut locals: Vec = self .scalars .iter() - .filter(|(_, s)| s.assigned) + .filter(|(l, s)| s.assigned && !self.is_arg(**l)) .map(|(l, _)| *l) .collect(); locals.sort(); @@ -929,7 +1045,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let scalar = &self.scalars[&local]; match &scalar.held { Some(held) => held[parts].iter().map(|e| (e.clone(), true)).collect(), - None if self.defs[local] == 1 => { + None if self.once(local) => { let n = parts.len(); self.err(span, "a local held as its parts read before its assignment"); vec![(Expr::undefined(), true); n] @@ -1350,7 +1466,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// Set `local`'s parts to `parts`, leaving those of a variant it isn't as they are. fn set_scalar(&mut self, local: Local, parts: Vec>, out: &mut Vec) { let vars = self.scalars[&local].vars.clone(); - if self.defs[local] == 1 { + if self.once(local) { let mut held = Vec::with_capacity(parts.len()); for (part, var) in parts.into_iter().zip(&vars) { held.push(match part { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 7a7c4d8ff..20ac96ce3 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -44,6 +44,8 @@ pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config) -> Option { for path in &config.printable { t.printable(path); } + // What the outside calls takes its arguments whole. + t.roots = t.instances.keys().copied().collect(); t.drain(); if t.failed { return None; @@ -194,6 +196,8 @@ pub struct Translator<'a, 'tcx> { site: Option<(Span, DefId)>, /// The hand-written TypeScript the config binds items to. bindings: bind::Bindings<'tcx>, + /// The instances the config's roots name, which the outside calls. + roots: rustc_data_structures::fx::FxHashSet>, } /// A local struct or enum, and how it is represented. @@ -263,6 +267,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { sites: Default::default(), site: None, bindings: Default::default(), + roots: Default::default(), }) } diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index e535faa9e..299cb062e 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -205,9 +205,8 @@ fn codec() { /// A caller of two functions of a type, through its module, as moq's TypeScript calls /// the codec. const SHAKE: &str = r#"import * as Decoder from "./coding/decode.Decoder.ts"; -import * as rt from "./rt.ts"; -export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(rt.byteSliceFrom(buf), { tag: "Quic" })); +export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(buf, 0, buf.length, { tag: "Quic" })); "#; /// Bun's and esbuild's tree-shaken bundles of [`SHAKE`] keep the functions it calls and @@ -255,7 +254,6 @@ fn shake(out: &Path) { "ByteSlice", "Ok", "Panic", - "byteSliceFrom", "checked", "clamp", "idx", From 81808c50630e9877e6e043a85f6dd6c0314f8b7f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 00:17:15 -0700 Subject: [PATCH 03/26] test(ts): differential cases for byte slices passed as their parts Co-Authored-By: Claude Opus 5.5 --- ts/MIGRATE.md | 3 + ts/README.md | 9 +- ts/fixtures/lang/expected/args.Scale.ts | 15 ++ ts/fixtures/lang/expected/args.ts | 171 +++++++++++++++++++++++ ts/fixtures/lang/expected/core/option.ts | 22 +++ ts/fixtures/lang/expected/harness.ts | 5 +- ts/fixtures/lang/src/args.rs | 134 ++++++++++++++++++ ts/fixtures/lang/src/harness.rs | 7 +- ts/fixtures/lang/src/lib.rs | 9 +- ts/src/lower/mir/mod.rs | 7 +- ts/src/lower/mir/scalar.rs | 12 +- 11 files changed, 381 insertions(+), 13 deletions(-) create mode 100644 ts/fixtures/lang/expected/args.Scale.ts create mode 100644 ts/fixtures/lang/expected/args.ts create mode 100644 ts/fixtures/lang/src/args.rs diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index 563cd4a88..8e6431bcf 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,6 +2,9 @@ ## Unreleased +- A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter as + its `data`, `start`, and `length`: `read(buf, form)` is + `read(buf.data, buf.start, buf.length, form)`. A root still takes an `rt.ByteSlice`. - The runtime no longer exports `ownedNth`, `ownedNthBack`, `ownedSkip`, `ownedTake`, or `ownedStepBy`: `iterNth`, `iterNthBack`, `iterSkip`, `iterTake`, and `iterStepBy` take what drops an item last. `rt.Iter`'s `nthItem` and `nthBackItem` are `nth` and diff --git a/ts/README.md b/ts/README.md index 77830760e..619ca1ba6 100644 --- a/ts/README.md +++ b/ts/README.md @@ -376,8 +376,13 @@ they need. often than before stays one. `just ts bench` measured the codec's varint decode at 0.49 times the objects' time in Chrome, 0.57 in Firefox, 0.64 in Node, and 0.56 in Bun at the geometric mean, and frame decode at 0.61, 0.56, 0.70, and 0.61, with the A/A route - within 0.04 and encode no slower. A parameter, a return, and a field are still a - `ByteSlice` ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). + within 0.04 and encode no slower. A return and a field are still a `ByteSlice` + ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). +- A function only translated code calls takes each `&[u8]` or `&[u8; N]` parameter as + three, its `data`, `start`, and `length`, which its body holds as that local's parts: + not a root, which the outside calls, a closure, or an `async fn`. One whose object the + body would make more often than once, or that it borrows, is made on entry, and the + function as a value is an arrow that takes the slice whole. BENCH - 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/lang/expected/args.Scale.ts b/ts/fixtures/lang/expected/args.Scale.ts new file mode 100644 index 000000000..f8a9773cb --- /dev/null +++ b/ts/fixtures/lang/expected/args.Scale.ts @@ -0,0 +1,15 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export interface Scale { + _0: rt.u8; +} + +export function weigh$Weigh(self: Scale, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), self._0, (a: rt.u8, b: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(a, b ^ 90); + }); +} + +//# sourceMappingURL=args.Scale.ts.map diff --git a/ts/fixtures/lang/expected/args.ts b/ts/fixtures/lang/expected/args.ts new file mode 100644 index 000000000..d8288f2ae --- /dev/null +++ b/ts/fixtures/lang/expected/args.ts @@ -0,0 +1,171 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as Scale from "./args.Scale.ts"; +import { map$Option_u8_u8s_u8s_args_closure1, map$Option_u8s_u8_opaque, mapOr$Option_u8s_usize_len } from "./core/option.ts"; + +/** A use that needs the slice itself. */ +export function opaque(sData: Uint8Array, sStart: number, sLen: number): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, sLen))), sLen & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(a ^ (a >> 3), b); + }); +} + +/** A parameter reassigned from its own tail. */ +export function sum(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + let sum_: rt.u8 = 0; + while (true) { + const _4Data: Uint8Array = dataData; + const _4Start: number = dataStart; + const _4Len: number = dataLen; + if (_4Len !== 0) { + sum_ = rt.u8WrappingAdd(sum_, _4Data[_4Start]); + dataData = _4Data; + dataStart = _4Start + 1; + dataLen = _4Len - 1; + } else { + return sum_; + } + } +} + +/** A parameter only measured. */ +export function len(_dataData: Uint8Array, _dataStart: number, dataLen: number): rt.usize { + return dataLen; +} + +/** A parameter borrowed, which makes it whole on entry. */ +export function byRef(dataData: Uint8Array, dataStart: number, dataLen: number): rt.usize { + return lenOf(new rt.ByteSlice(dataData, dataStart, dataLen)); +} + +export function lenOf(data: rt.ByteSlice): rt.usize { + return data.length; +} + +/** A parameter made whole in a loop, which makes it whole on entry. */ +export function kept(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.u8): rt.ByteSlice[] { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const all: rt.ByteSlice[] = []; + const _6: rt.u8 = rt.u8Rem(n, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _6; + while (true) { + if (!(iterStart++ < iterEnd)) { + return all; + } + all.push(data); + } +} + +/** A reference to an array of bytes. */ +export function word(wData: Uint8Array, wStart: number, _wLen: number): rt.u32 { + return ((wData[wStart] << 24) | (wData[wStart + 1] << 16) | (wData[wStart + 2] << 8) | wData[wStart + 3]) >>> 0; +} + +/** Two slices, perhaps the same. */ +export function both(aData: Uint8Array, aStart: number, aLen: number, bData: Uint8Array, bStart: number, bLen: number): rt.u8 { + return opaque(aData, aStart, aLen) ^ (len(bData, bStart, bLen) & 0xff); +} + +/** A recursive count of the bytes before a zero. */ +export function depth(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); + if (_2 !== undefined) { + if (_2[0] !== 0) { + return rt.u8Add(1, depth(_2[1].data, _2[1].start, _2[1].length)); + } + } + return 0; +} + +/** A slice chosen by a call that does something. */ +export function pick(out: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): rt.ByteSlice { + rt.byteVecPush(out, 187); + return rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.usizeDiv(dataLen, 2)); +} + +export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { + rt.byteVecPush(out, 238); + return n; +} + +export function pair(n: rt.u8, sData: Uint8Array, sStart: number, sLen: number): rt.u8 { + return n ^ opaque(sData, sStart, sLen); +} + +export function weigh$Scale(w: Scale.Scale, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + return Scale.weigh$Weigh(w, dataData, dataStart, dataLen); +} + +export function args(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let f!: (a0: rt.ByteSlice) => rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const _4: rt.u8 = rt.u8Rem(kind, 6); + if (_4 === 0) { + rt.byteVecPush(out, sum(data.data, data.start, data.length)); + rt.byteVecPush(out, len(data.data, data.start, data.length) & 0xff); + rt.byteVecPush(out, byRef(data.data, data.start, data.length) & 0xff); + rt.byteVecPush(out, rt.iterFold(rt.iterMap(rt.iterSlice(kept(data.data, data.start, data.length, kind)), (s: rt.ByteSlice): rt.u8 => { + const _33: rt.ByteSlice = s; + return opaque(_33.data, _33.start, _33.length); + }), 0, (a05: rt.u8, a1: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(a05, a1); + })); + } else if (_4 === 1) { + if (data.length >= 4) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(word(data.data, data.start, 4), 1)))); + rt.byteVecPush(out, both(data.data, data.start + 4, data.length - 4, data.data, data.start + 4, data.length - 4)); + const _35: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 4); + rt.byteVecPush(out, both(_35.data, _35.start, _35.length, data.data, data.start + 4, data.length - 4)); + } + const _38: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 64)); + rt.byteVecPush(out, depth(_38.data, _38.start, _38.length)); + } else if (_4 === 2) { + rt.iterExtendBytes(out, rt.iterOption(map$Option_u8s_u8_opaque(map$Option_u8_u8s_u8s_args_closure1((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_2: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _2[1]; + }), (a0: rt.ByteSlice): rt.u8 => { + return opaque(a0.data, a0.start, a0.length); + }))); + if (!(rt.usizeRem(data.length, 2) === 0)) { + f = (a03: rt.ByteSlice): rt.u8 => { + return sum(a03.data, a03.start, a03.length); + }; + } else { + f = (a02: rt.ByteSlice): rt.u8 => { + return opaque(a02.data, a02.start, a02.length); + }; + } + rt.byteVecPush(out, f(data)); + rt.byteVecPush(out, mapOr$Option_u8s_usize_len(map$Option_u8_u8s_u8s_args_closure1((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), 0, (a04: rt.ByteSlice): rt.usize => { + return len(a04.data, a04.start, a04.length); + }) & 0xff); + } else if (_4 === 3) { + const _60: rt.u8 = code(out, 1); + const _61: rt.ByteSlice = pick(out, data.data, data.start, data.length); + rt.byteVecPush(out, pair(_60, _61.data, _61.start, _61.length)); + } else if (_4 === 4) { + const seen: rt.ByteVec = new rt.ByteVec(); + const note: (a0: rt.u8) => void = (b2: rt.u8): void => { + rt.byteVecPush(seen, b2 ^ opaque(data.data, data.start, data.length)); + }; + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3); + while (true) { + const _70: rt.u8 | rt.Done = iter.next(); + if (_70 === rt.DONE) { + break; + } + note(_70); + } + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen)); + } else { + rt.byteVecPush(out, weigh$Scale({ _0: kind }, data.data, data.start, data.length)); + const _86: Scale.Scale = { _0: 3 }; + const _87: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 2)); + rt.byteVecPush(out, Scale.weigh$Weigh(_86, _87.data, _87.start, _87.length)); + } +} + +//# sourceMappingURL=args.ts.map diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 8bbe2bb53..89f57b516 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -2,6 +2,7 @@ import * as rt from "../rt.ts"; import { copy$u8s_u8s } from "../lib.ts"; +import { opaque, len } from "../args.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"; @@ -191,6 +192,20 @@ export function map$Option_u8_u8_options_closure3_closure0(self: rt.u8 | undefin return f(self); } +export function map$Option_u8_u8s_u8s_args_closure1(self: [rt.u8, rt.ByteSlice] | undefined, f: (a0: [rt.u8, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$Option_u8s_u8_opaque(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { + if (self === undefined) { + return undefined; + } + return opaque(self.data, self.start, self.length); +} + export function map$Option_usize_str_str_slices_closure2(self: [rt.usize, string] | undefined, f: (a0: [rt.usize, string]) => string): string | undefined { if (self === undefined) { return undefined; @@ -345,6 +360,13 @@ export function mapOr$Option_u8s_u8s_u8s_chunks_closure0(self: [rt.ByteSlice, rt return f(self); } +export function mapOr$Option_u8s_usize_len(self: rt.ByteSlice | undefined, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return len(self.data, self.start, self.length); +} + export function mapOr$Option_usize_str_slices_closure1_closure0_closure0(self: rt.usize | undefined, default_: string, f: (a0: rt.usize) => string): string { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 1b59cede4..395a55014 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { args } from "./args.ts"; import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; import { hashMaps, sets, btreeMaps, deques, vecs, stores } from "./collections.ts"; @@ -26,7 +27,7 @@ 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, 54); + const _14: rt.u8 = rt.u8Rem(op, 55); if (_14 === 0) { u8Op(kind, input.data, input.start + 2, input.length - 2, out); } else if (_14 === 1) { @@ -150,6 +151,8 @@ export function run(input: rt.ByteSlice): rt.ByteVec { counts(input.data, input.start + 2, input.length - 2, out); } else if (_14 === 52) { rounding(out); + } else if (_14 === 53) { + args(kind, input.data, input.start + 2, input.length - 2, out); } else { skips(kind, input.data, input.start + 2, input.length - 2, out); } diff --git a/ts/fixtures/lang/src/args.rs b/ts/fixtures/lang/src/args.rs new file mode 100644 index 000000000..1912a9ebb --- /dev/null +++ b/ts/fixtures/lang/src/args.rs @@ -0,0 +1,134 @@ +//! Byte slices passed to the crate's own functions, which take them as their parts. + +/// A use that needs the slice itself. +#[inline(never)] +fn opaque(s: &[u8]) -> u8 { + s.iter().fold(s.len() as u8, |a, b| (a ^ (a >> 3)).wrapping_add(*b)) +} + +/// A parameter reassigned from its own tail. +fn sum(mut data: &[u8]) -> u8 { + let mut sum = 0u8; + while let Some((&b, rest)) = data.split_first() { + sum = sum.wrapping_add(b); + data = rest; + } + sum +} + +/// A parameter only measured. +fn len(data: &[u8]) -> usize { + data.len() +} + +/// A parameter borrowed, which makes it whole on entry. +fn by_ref(data: &[u8]) -> usize { + let r = &data; + len_of(r) +} + +fn len_of(data: &&[u8]) -> usize { + data.len() +} + +/// A parameter made whole in a loop, which makes it whole on entry. +fn kept(data: &[u8], n: u8) -> Vec<&[u8]> { + let mut all = Vec::new(); + for _ in 0..n % 4 { + all.push(data); + } + all +} + +/// A reference to an array of bytes. +fn word(w: &[u8; 4]) -> u32 { + u32::from_be_bytes(*w) +} + +/// Two slices, perhaps the same. +fn both(a: &[u8], b: &[u8]) -> u8 { + opaque(a) ^ len(b) as u8 +} + +/// A recursive count of the bytes before a zero. +fn depth(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) if b != 0 => 1 + depth(rest), + _ => 0, + } +} + +/// A slice chosen by a call that does something. +fn pick<'a>(out: &mut Vec, data: &'a [u8]) -> &'a [u8] { + out.push(0xbb); + &data[data.len() / 2..] +} + +fn code(out: &mut Vec, n: u8) -> u8 { + out.push(0xee); + n +} + +fn pair(n: u8, s: &[u8]) -> u8 { + n ^ opaque(s) +} + +trait Weigh { + fn weigh(&self, data: &[u8]) -> u8; +} + +struct Scale(u8); + +impl Weigh for Scale { + fn weigh(&self, data: &[u8]) -> u8 { + data.iter().fold(self.0, |a, b| a.wrapping_add(*b ^ 0x5a)) + } +} + +fn weigh(w: &W, data: &[u8]) -> u8 { + w.weigh(data) +} + +pub fn args(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 6 { + 0 => { + out.push(sum(data)); + out.push(len(data) as u8); + out.push(by_ref(data) as u8); + out.push(kept(data, kind).iter().map(|s| opaque(s)).fold(0, u8::wrapping_add)); + } + 1 => { + if let Some((w, rest)) = data.split_first_chunk::<4>() { + out.extend_from_slice(&word(w).wrapping_add(1).to_be_bytes()); + out.push(both(rest, rest)); + out.push(both(w, rest)); + } + out.push(depth(&data[..data.len().min(64)])); + } + 2 => { + // As values: a function item, and a pointer to it. + out.extend(data.split_first().map(|(_, rest)| rest).map(opaque)); + let f: fn(&[u8]) -> u8 = if data.len() % 2 == 0 { opaque } else { sum }; + out.push(f(data)); + out.push(data.split_first().map(|(_, rest)| rest).map_or(0, len) as u8); + } + 3 => { + // The earlier argument runs first. + let n = pair(code(out, 1), pick(out, data)); + out.push(n); + } + 4 => { + // Captured by a closure. + let mut seen = Vec::new(); + let mut note = |b: u8| seen.push(b ^ opaque(data)); + for &b in data.iter().take(3) { + note(b); + } + out.extend_from_slice(&seen); + } + _ => { + out.push(weigh(&Scale(kind), data)); + out.push(Scale(3).weigh(&data[data.len().min(2)..])); + } + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 614171e3d..428838e5f 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,8 +2,8 @@ //! case and the rest is its input. use crate::{ - chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, refs, shapes, splits, - strs, + args, 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 @@ -22,7 +22,7 @@ pub fn run(input: &[u8]) -> Vec { return out; }; let (op, kind) = (*op, *kind); - match op % 54 { + match op % 55 { 0 => ints::u8_op(kind, data, &mut out), 1 => ints::u16_op(kind, data, &mut out), 2 => ints::u32_op(kind, data, &mut out), @@ -86,6 +86,7 @@ pub fn run(input: &[u8]) -> Vec { 50 => refs::refs(data, &mut out), 51 => fmt::counts(data, &mut out), 52 => fmt::rounding(&mut out), + 53 => args::args(kind, data, &mut out), _ => iters::skips(kind, data, &mut out), } out diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 25671b6a0..7cca1ea44 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -1,13 +1,14 @@ //! 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, 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. +//! `Duration`, control flow, patterns, byte slices split apart and passed as their +//! parts, `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. +mod args; mod chars; mod chunks; mod collections; diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index f22a34254..da67b20f1 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -322,7 +322,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Env::Plain => std::mem::take(&mut b.parted), _ => Vec::new(), }; - let parted = mir.args_iter().zip(parted).filter(|&(_, p)| p).map(|(l, _)| l).collect(); + let parted = mir + .args_iter() + .zip(parted) + .filter(|&(_, p)| p) + .map(|(l, _)| l) + .collect(); let mut fx = Fx { b, mir, diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index aeaed96f0..974ba12ef 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -534,7 +534,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } }; self.part_params.extend(names.iter().cloned()); - let tys = [Type::Builtin("Uint8Array"), Type::Builtin("number"), Type::Builtin("number")]; + let tys = [ + Type::Builtin("Uint8Array"), + Type::Builtin("number"), + Type::Builtin("number"), + ]; names .into_iter() .zip(tys) @@ -713,7 +717,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } // Held as the parts of the one object it is, a local saves nothing; a parameter // passed as its parts is made on entry. - bad.extend(shapes.keys().filter(|l| !parted.contains(l) && !self.parted.contains(l))); + bad.extend( + shapes + .keys() + .filter(|l| !parted.contains(l) && !self.parted.contains(l)), + ); for &local in shapes.keys().filter(|l| self.parted.contains(l)) { copies.extend((0..3).map(|part| (local, part, None))); } From 159cc27c7ee0947e69a0d01d8a33f2816d7df9ed Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 00:57:08 -0700 Subject: [PATCH 04/26] docs(ts): measure byte slices passed as their parts Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/arguments.md | 10 ++++++++++ ts/README.md | 10 +++++++--- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/quest/m2/ts-byte-views/arguments.md b/quest/m2/ts-byte-views/arguments.md index 46a95102f..57b62d868 100644 --- a/quest/m2/ts-byte-views/arguments.md +++ b/quest/m2/ts-byte-views/arguments.md @@ -19,4 +19,14 @@ also passed slices as parts looked 20-40% faster on varint and 30% on frames lit - Only functions outside the API boundary that are never used as a value, as for returns. - Report each workload in Chrome, Firefox, Node, and Bun; Chrome decides. +Measured on 2026-10-28, on a quiet host, from +[#160](https://github.com/kixelated/rust2/pull/160): parts as arguments alone are even with +`main` in Chrome (varint decode 0.98-0.99x, frame decode 1.01-1.05x, A/A within 0.05), and +Node's varint decode is 1.11-1.15x slower. On top of them, a hand edit returning the error +or `undefined` with the payload in a module-level scratch was faster in Node (varint 1.27x, +frames 1.25x) and Firefox (1.18x, 1.10x), but mixed in Chrome: QUIC varints 1.08-1.25x and +frames lite-06 1.19-1.25x faster, leading-ones varints 4-12% and group 6% slower. A hand +edit splitting `Decoder::buf` into three fields on `main` made Chrome's varint decode 1.19x +slower. + Public API: the translator's output for byte slices. diff --git a/ts/README.md b/ts/README.md index 619ca1ba6..184daca4a 100644 --- a/ts/README.md +++ b/ts/README.md @@ -380,9 +380,13 @@ they need. ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). - A function only translated code calls takes each `&[u8]` or `&[u8; N]` parameter as three, its `data`, `start`, and `length`, which its body holds as that local's parts: - not a root, which the outside calls, a closure, or an `async fn`. One whose object the - body would make more often than once, or that it borrows, is made on entry, and the - function as a value is an arrow that takes the slice whole. BENCH + not a root, which the outside calls, a closure, or an `async fn`. One the body borrows, + or would make whole twice on a path or in a loop, is made on entry, and the function as + a value is an arrow that takes the slice whole. `just ts bench` measured it + no faster than passing the slice whole, since V8 already removes what an inlined call + doesn't keep: Chrome's varint decode at 0.98-0.99 times the time and frame decode at + 1.01-1.05 over two runs, with the A/A route within 0.05, Firefox and Bun within their + noise, and Node's varint decode at 1.11-1.15. - A `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 From 6e5d2b6cd088a1166292a5326ac6c62b010c6f6d Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 00:59:17 -0700 Subject: [PATCH 05/26] style(ts): format the harness's imports Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/src/harness.rs | 4 ++-- ts/src/lower/mir/mod.rs | 39 +++++++++++---------------------- ts/src/lower/mir/rvalue.rs | 12 ++++------ 3 files changed, 19 insertions(+), 36 deletions(-) diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index e563f5d35..cec260687 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,8 +2,8 @@ //! case and the rest is its input. use crate::{ - args, chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, nested, refs, shapes, - splits, strs, + args, chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, nested, refs, + shapes, splits, strs, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 5a391f72b..3be96ca81 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -738,10 +738,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { for (bb, data) in mir.basic_blocks.iter_enumerated() { for (i, pair) in data.statements.windows(2).enumerate() { if let (Some((t, x)), Some((x2, t2))) = (moved(&pair[0]), moved(&pair[1])) - && x == x2 - && t == t2 - && t != x - && mentions.0[t] == 2 + && x == x2 && t == t2 + && t != x && mentions.0[t] == 2 { self.noops.insert((bb, i)); self.noops.insert((bb, i + 1)); @@ -2176,8 +2174,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { && let Some(Stmt { kind: StmtKind::Expr(Expr::Assign(_, value)), .. - }) = out.last() - && let Some(parts) = parts_of(value) + }) = out.last() && let Some(parts) = parts_of(value) { self.var_parts.insert(local, parts); } @@ -3192,26 +3189,16 @@ fn reads_only(name: &str) -> bool { matches!( op, "Add" - | "Sub" - | "Mul" - | "Div" - | "Rem" - | "Neg" - | "Shl" - | "Shr" - | "And" - | "Or" - | "Xor" - | "Not" - | "Eq" - | "Ne" - | "Lt" - | "Le" - | "Gt" - | "Ge" - | "Max" - | "Min" - | "Cast" + | "Sub" | "Mul" + | "Div" | "Rem" + | "Neg" | "Shl" + | "Shr" | "And" + | "Or" | "Xor" + | "Not" | "Eq" + | "Ne" | "Lt" + | "Le" | "Gt" + | "Ge" | "Max" + | "Min" | "Cast" | "Low" ) } diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index e90f57a0c..c7fffaf65 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -628,14 +628,10 @@ pub fn effect<'tcx>(rvalue: &Rvalue<'tcx>, fx: &Fx<'_, '_, '_, 'tcx>) -> bool { && !matches!( op, BinOp::Eq - | BinOp::Ne - | BinOp::Lt - | BinOp::Le - | BinOp::Gt - | BinOp::Ge - | BinOp::BitAnd - | BinOp::BitOr - | BinOp::BitXor + | BinOp::Ne | BinOp::Lt + | BinOp::Le | BinOp::Gt + | BinOp::Ge | BinOp::BitAnd + | BinOp::BitOr | BinOp::BitXor ) } Rvalue::UnaryOp(UnOp::Neg, _) => true, From 5b0bec7c85be7256752b81276bf0a586061ad6b3 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 00:59:43 -0700 Subject: [PATCH 06/26] style(ts): undo a stray rustfmt of main's code Co-Authored-By: Claude Opus 5.5 --- ts/src/lower/mir/mod.rs | 39 +++++++++++++++++++++++++------------- ts/src/lower/mir/rvalue.rs | 12 ++++++++---- 2 files changed, 34 insertions(+), 17 deletions(-) diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 3be96ca81..5a391f72b 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -738,8 +738,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { for (bb, data) in mir.basic_blocks.iter_enumerated() { for (i, pair) in data.statements.windows(2).enumerate() { if let (Some((t, x)), Some((x2, t2))) = (moved(&pair[0]), moved(&pair[1])) - && x == x2 && t == t2 - && t != x && mentions.0[t] == 2 + && x == x2 + && t == t2 + && t != x + && mentions.0[t] == 2 { self.noops.insert((bb, i)); self.noops.insert((bb, i + 1)); @@ -2174,7 +2176,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { && let Some(Stmt { kind: StmtKind::Expr(Expr::Assign(_, value)), .. - }) = out.last() && let Some(parts) = parts_of(value) + }) = out.last() + && let Some(parts) = parts_of(value) { self.var_parts.insert(local, parts); } @@ -3189,16 +3192,26 @@ fn reads_only(name: &str) -> bool { matches!( op, "Add" - | "Sub" | "Mul" - | "Div" | "Rem" - | "Neg" | "Shl" - | "Shr" | "And" - | "Or" | "Xor" - | "Not" | "Eq" - | "Ne" | "Lt" - | "Le" | "Gt" - | "Ge" | "Max" - | "Min" | "Cast" + | "Sub" + | "Mul" + | "Div" + | "Rem" + | "Neg" + | "Shl" + | "Shr" + | "And" + | "Or" + | "Xor" + | "Not" + | "Eq" + | "Ne" + | "Lt" + | "Le" + | "Gt" + | "Ge" + | "Max" + | "Min" + | "Cast" | "Low" ) } diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index c7fffaf65..e90f57a0c 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -628,10 +628,14 @@ pub fn effect<'tcx>(rvalue: &Rvalue<'tcx>, fx: &Fx<'_, '_, '_, 'tcx>) -> bool { && !matches!( op, BinOp::Eq - | BinOp::Ne | BinOp::Lt - | BinOp::Le | BinOp::Gt - | BinOp::Ge | BinOp::BitAnd - | BinOp::BitOr | BinOp::BitXor + | BinOp::Ne + | BinOp::Lt + | BinOp::Le + | BinOp::Gt + | BinOp::Ge + | BinOp::BitAnd + | BinOp::BitOr + | BinOp::BitXor ) } Rvalue::UnaryOp(UnOp::Neg, _) => true, From 25970f9d0d3821e74538778727d133ecd0b0bb1d Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 20:21:36 -0700 Subject: [PATCH 07/26] chore(quest): fold byte slices passed as parts into returns Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/README.md | 5 +-- quest/m2/ts-byte-views/arguments.md | 32 ---------------- quest/m2/ts-byte-views/fields.md | 2 +- quest/m2/ts-byte-views/returns.md | 57 ++++++++++++++++------------- 4 files changed, 34 insertions(+), 62 deletions(-) delete mode 100644 quest/m2/ts-byte-views/arguments.md diff --git a/quest/m2/ts-byte-views/README.md b/quest/m2/ts-byte-views/README.md index bc527cf2d..6a946afb1 100644 --- a/quest/m2/ts-byte-views/README.md +++ b/quest/m2/ts-byte-views/README.md @@ -17,7 +17,7 @@ kept them as `(data, start, length)` made Chrome's varint decode 2.3-2.9x and fr Decided with the maintainer on 2026-10-27: scalar-replace values built of byte slices, scalars, tuples, `Option`, `Result`, and `ControlFlow`, materializing an object only where -one escapes, in three pieces that each land and measure alone (the children below). +one escapes, in pieces that each land and measure alone (the children below). The precedents are `stepped` iterators, `range_nexts`, and `place_opts`, which a general pass could later absorb. @@ -30,6 +30,5 @@ Public API: the translator's output for byte slices. ## Required -- [Byte slices passed as parts](/quest/m2/ts-byte-views/arguments.md) - a function takes a slice's parts as arguments -- [Byte slices returned](/quest/m2/ts-byte-views/returns.md) - a function returns a split's parts without an object +- [Byte slices passed and returned as parts](/quest/m2/ts-byte-views/returns.md) - a function takes a slice's parts and returns a split's parts without an object - [Byte slices in fields](/quest/m2/ts-byte-views/fields.md) - a private slice field is three fields diff --git a/quest/m2/ts-byte-views/arguments.md b/quest/m2/ts-byte-views/arguments.md deleted file mode 100644 index 57b62d868..000000000 --- a/quest/m2/ts-byte-views/arguments.md +++ /dev/null @@ -1,32 +0,0 @@ -# [M] Byte slices passed as parts - -## Goal - -A translated function that takes a byte slice outside the API boundary takes its parts -(`data`, `start`, `length`) as arguments instead of an `rt.ByteSlice`, and Chrome's varint -and frame decode on `just ts bench` are faster than `main`, with every differential test -passing. - -## Plan - -Decided with the maintainer on 2026-10-27, from -[#138](https://github.com/kixelated/rust2/pull/138): its per-function scratch return made -Chrome slower than `main` (varint quic/1B 12.0 to 15.2 ns, frames 3B-reads 152 to 208 ns), -since V8 already removes most of `main`'s temporaries once it inlines. A hand edit that -also passed slices as parts looked 20-40% faster on varint and 30% on frames lite-06, but -18% slower on group lite-06, on an overloaded host, so measure on a quiet one first. - -- Only functions outside the API boundary that are never used as a value, as for returns. -- Report each workload in Chrome, Firefox, Node, and Bun; Chrome decides. - -Measured on 2026-10-28, on a quiet host, from -[#160](https://github.com/kixelated/rust2/pull/160): parts as arguments alone are even with -`main` in Chrome (varint decode 0.98-0.99x, frame decode 1.01-1.05x, A/A within 0.05), and -Node's varint decode is 1.11-1.15x slower. On top of them, a hand edit returning the error -or `undefined` with the payload in a module-level scratch was faster in Node (varint 1.27x, -frames 1.25x) and Firefox (1.18x, 1.10x), but mixed in Chrome: QUIC varints 1.08-1.25x and -frames lite-06 1.19-1.25x faster, leading-ones varints 4-12% and group 6% slower. A hand -edit splitting `Decoder::buf` into three fields on `main` made Chrome's varint decode 1.19x -slower. - -Public API: the translator's output for byte slices. diff --git a/quest/m2/ts-byte-views/fields.md b/quest/m2/ts-byte-views/fields.md index 422248c9d..8f1ee9ecf 100644 --- a/quest/m2/ts-byte-views/fields.md +++ b/quest/m2/ts-byte-views/fields.md @@ -26,4 +26,4 @@ three `#private` fields. ## Required -- [Byte slices returned](/quest/m2/ts-byte-views/returns.md) - the measurement this one builds on +- [Byte slices passed and returned as parts](/quest/m2/ts-byte-views/returns.md) - the measurement this one builds on diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index a0655d749..c87ff9f41 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -1,34 +1,39 @@ -# [M] Byte slices returned +# [L] Byte slices passed and returned as parts ## Goal -A translated function that returns a value built of byte slices and scalars, such as -`Result<(&[u8], T), E>`, hands its parts to the caller without an object, and Chrome's -varint and frame decode on `just ts bench` are faster than with slices passed as parts -alone, with every differential test passing. +A translated function outside the API boundary takes each byte slice parameter as its parts +(`data`, `start`, `length`), and one that returns a `Result` of byte slices and scalars, such +as `Result<(u64, &[u8]), E>`, returns the error or `undefined`, with its payload in a +module-level out slot. Chrome's varint and frame decode on `just ts bench` are faster than +`main`, no workload is meaningfully slower in any engine, and every differential test passes. ## Plan -The [epic's](/quest/m2/ts-byte-views/README.md) hand edit measured Chrome 1.84x on varint -decode and 1.65x on frames with locals and returns, against [#120](https://github.com/kixelated/rust2/pull/120). - -Decided with the maintainer on 2026-10-27, from -[#138](https://github.com/kixelated/rust2/pull/138): remeasure after -[arguments as parts](/quest/m2/ts-byte-views/arguments.md). #138 built a per-function -scratch object (the function returns which variant it made and writes the parts into its -module-level scratch), and it measured slower than `main` in Chrome (varint quic/1B 12.0 -to 15.2 ns, frames 3B-reads 152 to 208 ns). One shared scratch per return type, reading -only the branch taken, measured about even; module `let`s measured 0.93x. Its branch keeps -the code. Pick the ABI only if it beats arguments alone. - -- Only functions outside the API boundary that are never used as a value: not roots, fn - pointers, or closures. -- The callee writes its scratch at the JS `return`, after its MIR drops ran, so a `Drop` - that re-enters cannot overwrite it; the caller reads it at once, and temporary folding - never delays that read. +Decided with the maintainer on 2026-10-28: this absorbs passing slices as parts, which +[#160](https://github.com/kixelated/rust2/pull/160) implemented. Alone, parts gain nothing in +Chrome, since V8 already removes a slice object that doesn't escape once it inlines, and +Node's varint decode is 11-15% slower. They land only with the return ABI ("e1"). +[#138](https://github.com/kixelated/rust2/pull/138)'s per-function scratch measured slower +than `main`: copying between scratches when one function returns another's result cost the +most. One out slot per payload type, which a forwarded result already fills, avoids that. + +- Only functions outside the API boundary: not roots or closures. A function used as a + value is wrapped in an arrow that rebuilds the `Result`. +- The callee writes its slot at the JS `return`, after its MIR drops ran; the caller reads + it at once, before any other call. +- Start the slot's number fields as `undefined`, not `0`, so V8 keeps them tagged. A field + that starts as a small integer turns into a boxed double once a value past 2^31 is + stored, and a function too big for V8 to inline (over 460 bytes of bytecode, as + `read_leading_ones` is) then boxes every write and the caller unboxes every read. This + is why the first hand edit was slower than `main` on leading-ones varints. +- Measured by hand edits of the codec's translation against `main`, Chrome first (2026-10-28, + on a busy host, so confirm on a quiet one): with the slot's fields tagged, Chrome's varint + and frame decode were each about 1.25x faster and group decode 1.06x, Node 1.33x and + 1.40x, Firefox 1.21x and 1.10x, Bun even and 1.12x. Leading-ones varints of 8 bytes + measured 0.84x, within that run's noise. +- Open: with parameters as parts, Chrome's `time/` convert workloads ran 7-12% slower than + `main` in every run on 2026-10-28, with the same instruction count and the same inlining. + Find out why before landing. Public API: the translator's output for byte slices. - -## Required - -- [Byte slices passed as parts](/quest/m2/ts-byte-views/arguments.md) - the measured win, landed first From fe5dc9afde3687cd9329b7de30e283ccf5ce12d7 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 22:04:38 -0700 Subject: [PATCH 08/26] feat(ts): return a Result's byte slices in a module-level slot A function only translated code calls that returns a Result of byte slices and scalars returns its error or undefined and writes the Ok's parts into a slot shared per payload type, whose fields start undefined so V8 keeps them tagged. Callers read the slot at once; a call returned as is forwards it. Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/returns.md | 16 +- ts/README.md | 13 +- .../codec/expected/coding/decode.Decoder.ts | 114 ++- ts/fixtures/codec/expected/coding/varint.ts | 66 +- ts/fixtures/codec/expected/harness.ts | 24 +- ts/fixtures/lang/expected/chunks.ts | 61 +- ts/fixtures/lang/expected/core/bool.ts | 7 + ts/fixtures/lang/expected/core/option.ts | 25 +- ts/fixtures/lang/expected/core/result.ts | 15 + ts/fixtures/lang/expected/harness.ts | 65 +- ts/fixtures/lang/expected/returns.At.ts | 27 + ts/fixtures/lang/expected/returns.Error.ts | 14 + ts/fixtures/lang/expected/returns.Guard.ts | 26 + ts/fixtures/lang/expected/returns.Split.ts | 24 + ts/fixtures/lang/expected/returns.ts | 426 ++++++++++++ ts/fixtures/lang/expected/splits.ts | 81 ++- ts/fixtures/lang/src/harness.rs | 4 +- ts/fixtures/lang/src/lib.rs | 15 +- ts/fixtures/lang/src/returns.rs | 237 +++++++ ts/src/lower/body.rs | 45 +- ts/src/lower/mir/call.rs | 6 +- ts/src/lower/mir/mod.rs | 37 +- ts/src/lower/mir/scalar.rs | 651 +++++++++++++++--- ts/src/lower/mod.rs | 6 + ts/src/print.rs | 12 + ts/src/program.rs | 4 +- ts/src/ts.rs | 6 + ts/tests/fixtures.rs | 2 +- 28 files changed, 1771 insertions(+), 258 deletions(-) create mode 100644 ts/fixtures/lang/expected/returns.At.ts create mode 100644 ts/fixtures/lang/expected/returns.Error.ts create mode 100644 ts/fixtures/lang/expected/returns.Guard.ts create mode 100644 ts/fixtures/lang/expected/returns.Split.ts create mode 100644 ts/fixtures/lang/expected/returns.ts create mode 100644 ts/fixtures/lang/src/returns.rs diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index c87ff9f41..e874532ac 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -32,8 +32,18 @@ most. One out slot per payload type, which a forwarded result already fills, avo and frame decode were each about 1.25x faster and group decode 1.06x, Node 1.33x and 1.40x, Firefox 1.21x and 1.10x, Bun even and 1.12x. Leading-ones varints of 8 bytes measured 0.84x, within that run's noise. -- Open: with parameters as parts, Chrome's `time/` convert workloads ran 7-12% slower than - `main` in every run on 2026-10-28, with the same instruction count and the same inlining. - Find out why before landing. +- Decided with the maintainer on 2026-10-28: the translator writes the slot ("e1e"), its + fields starting as `undefined`. Land only if Chrome's varint and frame decode both beat + `main` on a quiet host, with the A/A route under 5% at the median and the max. +- Std's functions keep returning their `Result` whole, as their callers take it apart + already. A slot sits beside the first function in source order that writes it, so its + place doesn't depend on the order translation reaches them. `?`'s `Err` assigns a + result held as its parts, so a function with early returns writes the slot at each. +- Chrome's `time/` convert workloads, 7-12% slower than `main` in single runs, are V8's + variance between realms, not parts: the same code differed as much between two workers + of one run (`time/u64` 60 against 55, `btree/256` 113 against 152), and over 12 launches + each the medians matched (`time/` 58.2 on `main`, 58.0 here), with the same instruction + counts and inlining. One realm's A/A route doesn't capture this, so compare those + workloads over repeated runs. Public API: the translator's output for byte slices. diff --git a/ts/README.md b/ts/README.md index 11c826534..32fbb8ec6 100644 --- a/ts/README.md +++ b/ts/README.md @@ -463,8 +463,8 @@ they need. often than before stays one. `just ts bench` measured the codec's varint decode at 0.49 times the objects' time in Chrome, 0.57 in Firefox, 0.64 in Node, and 0.56 in Bun at the geometric mean, and frame decode at 0.61, 0.56, 0.70, and 0.61, with the A/A route - within 0.04 and encode no slower. A return and a field are still a `ByteSlice` - ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). + within 0.04 and encode no slower. A field is still a `ByteSlice`, as is a return but + for the `Result`s below ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). - A function only translated code calls takes each `&[u8]` or `&[u8; N]` parameter as three, its `data`, `start`, and `length`, which its body holds as that local's parts: not a root, which the outside calls, a closure, or an `async fn`. One the body borrows, @@ -474,6 +474,15 @@ they need. doesn't keep: Chrome's varint decode at 0.98-0.99 times the time and frame decode at 1.01-1.05 over two runs, with the A/A route within 0.05, Firefox and Bun within their noise, and Node's varint decode at 1.11-1.15. +- A function of the crate's that only translated code calls and that returns a `Result` + of byte slices and scalars, such as `Result<(u64, &[u8]), E>`, whose error is one JS + value that is never `undefined`, returns the error or `undefined`. It writes the `Ok`'s + parts into a module-level slot, which every function returning that payload type + shares, at its JS `return`, after its drops, and its caller reads them at once, so one + that returns another's result as is returns the call. The slot's fields start as + `undefined`, so V8 keeps them tagged: one that starts as a small integer would box + every `u64` past 2^31 that a function too big to inline writes. The function as a value + is an arrow that rebuilds the `Result`. - A `BTreeMap` is a B+ tree of up to 64 keys a node, O(log n) as std's B-tree is: its leaves hold the keys and values and link to their neighbors, which iterators walk from either end, and its branches hold each child's lower bound. A node's slots shift in a diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index acdf6cf82..92607659e 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -2,7 +2,7 @@ import * as rt from "../rt.ts"; import * as DecodeError from "../coding/decode.DecodeError.ts"; -import { read } from "../coding/varint.ts"; +import { read, readOut } from "../coding/varint.ts"; import type * as Form from "../coding/varint.Form.ts"; import { mapErr$Result_usize_TryFromIntError_DecodeError_bytes_closure0, inspectErr$Result_u8s_DecodeError_bytes_closure1 } from "../core/result.ts"; import type * as Control from "../stats.Control.ts"; @@ -61,15 +61,20 @@ export function isEmpty(self: Decoder): boolean { } /** Read `len` raw bytes. */ -export function slice(self: Decoder, len: rt.usize): rt.Result { +export function slice(self: Decoder, len: rt.usize): DecodeError.DecodeError | undefined { const slice_: rt.ByteSlice = self.buf; if (len <= slice_.length) { self.buf = new rt.ByteSlice(slice_.data, slice_.start + len, slice_.length - len); - return rt.Ok(new rt.ByteSlice(slice_.data, slice_.start, len)); + sliceOut.pData = slice_.data; + sliceOut.pStart = slice_.start; + sliceOut.pLen = len; + return undefined; } - return rt.Err(short(self, len)); + return short(self, len); } +export const sliceOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; + /** Read every remaining byte. */ export function rest(self: Decoder): rt.ByteSlice { const taken = self.buf; @@ -79,33 +84,48 @@ export function rest(self: Decoder): rt.ByteSlice { /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ export function sub(self: Decoder, len: rt.usize): rt.Result { - const _4: rt.Result = slice(self, len); - if (_4.ok) { - return rt.Ok(new_(_4.value.data, _4.value.start, _4.value.length, self.form)); + const err: DecodeError.DecodeError | undefined = slice(self, len); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + return rt.Ok(new_(part, part2, part3, self.form)); } - return _4; + return rt.Err(err as DecodeError.DecodeError); } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - const _3: rt.Result = slice(self, 1); - if (_3.ok) { - rt.idx(_3.value, 0); - return rt.Ok(_3.value.data[_3.value.start]); + const err: DecodeError.DecodeError | undefined = slice(self, 1); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + if (0 >= part3) { + rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); + } + return rt.Ok(part[part2]); } - return _3; + return rt.Err(err as DecodeError.DecodeError); } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const _2: rt.Result = slice(self, 2); - if (_2.ok) { - rt.idx(_2.value, 0); - const _9: rt.u8 = _2.value.data[_2.value.start]; - rt.idx(_2.value, 1); - return rt.Ok((_9 << 8) | _2.value.data[_2.value.start + 1]); + const err: DecodeError.DecodeError | undefined = slice(self, 2); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + if (0 >= part3) { + rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); + } + const _9: rt.u8 = part[part2]; + if (1 >= part3) { + rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 1); + } + return rt.Ok((_9 << 8) | part[part2 + 1]); } - return _2; + return rt.Err(err as DecodeError.DecodeError); } /** Read a byte that must be 0 or 1. */ @@ -128,15 +148,19 @@ export function bool(self: Decoder): rt.Result export function varint(self: Decoder): rt.Result { let _0!: rt.Result; const _13: rt.ByteSlice = self.buf; - const _2: rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> = read(_13.data, _13.start, _13.length, self.form); - if (_2.ok) { - const value: rt.u64 = _2.value[0]; - self.buf = _2.value[1]; + const err2: DecodeError.DecodeError | undefined = read(_13.data, _13.start, _13.length, self.form); + const part: rt.u64 = readOut.p_0; + const part2: Uint8Array = readOut.p_1Data; + const part3: number = readOut.p_1Start; + const part4: number = readOut.p_1Len; + if (err2 === undefined) { + const value: rt.u64 = part; + self.buf = new rt.ByteSlice(part2, part3, part4); _0 = rt.Ok(value); - } else if (_2.error.tag === "Short") { + } else if ((err2 as DecodeError.DecodeError).tag === "Short") { _0 = rt.Err(short(self, rt.usizeAdd(self.buf.length, 1))); } else { - _0 = _2 as rt.Result; + _0 = rt.Err(err2 as DecodeError.DecodeError); } return _0; } @@ -151,7 +175,8 @@ export function varintOpt(self: Decoder): rt.Result { +export function bytes(self: Decoder): DecodeError.DecodeError | undefined { + let _0!: rt.Result; const start: rt.ByteSlice = self.buf; const _6: rt.Result = varint(self); if (_6.ok) { @@ -159,26 +184,45 @@ export function bytes(self: Decoder): rt.Result { + const err: DecodeError.DecodeError | undefined = slice(self, _3.value); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + const _15: (a0: DecodeError.DecodeError) => void = (_22: DecodeError.DecodeError): void => { self.buf = start; - }); + }; + _0 = inspectErr$Result_u8s_DecodeError_bytes_closure1((err !== undefined ? rt.Err(err as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part, part2, part3))) as rt.Result, _15); + } else { + _0 = _3; } - return _3; + } else { + _0 = _6; + } + const result: rt.Result = _0; + if (!result.ok) { + return result.error; } - return _6; + const slice_: rt.ByteSlice = result.value; + sliceOut.pData = slice_.data; + sliceOut.pStart = slice_.start; + sliceOut.pLen = slice_.length; + return undefined; } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - const _5: rt.Result = bytes(self); - if (_5.ok) { - const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(_5.value)); + const err: DecodeError.DecodeError | undefined = bytes(self); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part, part2, part3))); if (_2.ok) { return rt.Ok(_2.value); } return rt.Err(DecodeError.from$From_FromUtf8Error((_2 as { ok: false; error: rt.FromUtf8Error }).error)); } - return _5; + return rt.Err(err as DecodeError.DecodeError); } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index c6a89e563..996be3650 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -191,40 +191,58 @@ export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ -export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { +export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): DecodeError.DecodeError | undefined { if (form.tag === "Quic") { return readQuic(bufData, bufStart, bufLen); } return readLeadingOnes(bufData, bufStart, bufLen, form.seven); } -export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { +export const readOut: { p_0: rt.u64; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): DecodeError.DecodeError | undefined { if (bufLen !== 0) { const first: rt.u8 = bufData[bufStart]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { if (bufLen >= 8) { - return rt.Ok([fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0), new rt.ByteSlice(bufData, bufStart + 8, bufLen - 8)] as [rt.u64, rt.ByteSlice]); + readOut.p_0 = fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 8; + readOut.p_1Len = bufLen - 8; + return undefined; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } if (bufLen >= 4) { - return rt.Ok([(((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64, new rt.ByteSlice(bufData, bufStart + 4, bufLen - 4)] as [rt.u64, rt.ByteSlice]); + readOut.p_0 = (((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 4; + readOut.p_1Len = bufLen - 4; + return undefined; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } if (bufLen >= 2) { - return rt.Ok([(((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64, new rt.ByteSlice(bufData, bufStart + 2, bufLen - 2)] as [rt.u64, rt.ByteSlice]); + readOut.p_0 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 2; + readOut.p_1Len = bufLen - 2; + return undefined; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } - return rt.Ok([first as rt.u64, new rt.ByteSlice(bufData, bufStart + 1, bufLen - 1)] as [rt.u64, rt.ByteSlice]); + readOut.p_0 = first as rt.u64; + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 1; + readOut.p_1Len = bufLen - 1; + return undefined; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } -export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { +export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): DecodeError.DecodeError | undefined { let _8_0!: rt.u64; let _8_1Data!: Uint8Array; let _8_1Start!: number; @@ -244,7 +262,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 2; _8_1Len = bufLen - 2; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (_9 === 2) { if (bufLen >= 3) { @@ -253,7 +271,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 3; _8_1Len = bufLen - 3; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (_9 === 3) { if (bufLen >= 4) { @@ -262,7 +280,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 4; _8_1Len = bufLen - 4; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (_9 === 4) { if (bufLen >= 5) { @@ -271,7 +289,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 5; _8_1Len = bufLen - 5; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (_9 === 5) { if (bufLen >= 6) { @@ -280,11 +298,11 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 6; _8_1Len = bufLen - 6; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (_9 === 6) { if (!seven) { - return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + return { tag: "InvalidValue" } as DecodeError.DecodeError; } if (bufLen >= 7) { _8_0 = fromHalves(((bufData[bufStart] & 1) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2], ((bufData[bufStart + 3] << 24) | (bufData[bufStart + 4] << 16) | (bufData[bufStart + 5] << 8) | bufData[bufStart + 6]) >>> 0); @@ -292,7 +310,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 7; _8_1Len = bufLen - 7; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (_9 === 7) { if (bufLen >= 8) { @@ -301,7 +319,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 8; _8_1Len = bufLen - 8; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } } else if (bufLen >= 9) { _8_0 = fromHalves(((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0, ((bufData[bufStart + 5] << 24) | (bufData[bufStart + 6] << 16) | (bufData[bufStart + 7] << 8) | bufData[bufStart + 8]) >>> 0); @@ -309,11 +327,15 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 9; _8_1Len = bufLen - 9; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } - return rt.Ok([_8_0, new rt.ByteSlice(_8_1Data, _8_1Start, _8_1Len)] as [rt.u64, rt.ByteSlice]); + readOut.p_0 = _8_0; + readOut.p_1Data = _8_1Data; + readOut.p_1Start = _8_1Start; + readOut.p_1Len = _8_1Len; + return undefined; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return { tag: "Short" } as DecodeError.DecodeError; } /** diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 94e25ce62..29bca0691 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -270,12 +270,15 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _31; } } else if (_5 === 5) { - const _40: rt.Result = Decoder.bytes(r); - if (_40.ok) { - putUsize(out, _40.value.length); - rt.byteVecExtendFromSlice(out, _40.value); + const err2: DecodeError.DecodeError | undefined = Decoder.bytes(r); + const part4: Uint8Array = Decoder.sliceOut.pData; + const part5: number = Decoder.sliceOut.pStart; + const part6: number = Decoder.sliceOut.pLen; + if (err2 === undefined) { + putUsize(out, part6); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part4, part5, part6)); } else { - return _40; + return rt.Err(err2 as DecodeError.DecodeError); } } else if (_5 === 6) { const _49: rt.Result = Decoder.string(r); @@ -285,11 +288,14 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _49; } } else if (_5 === 7) { - const _57: rt.Result = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); - if (_57.ok) { - rt.byteVecExtendFromSlice(out, _57.value); + const err: DecodeError.DecodeError | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + const part: Uint8Array = Decoder.sliceOut.pData; + const part2: number = Decoder.sliceOut.pStart; + const part3: number = Decoder.sliceOut.pLen; + if (err === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part, part2, part3)); } else { - return _57; + return rt.Err(err as DecodeError.DecodeError); } } else if (_5 === 8) { const _67: rt.Result = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index 49cd2a845..bb66ac6f1 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; 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"; +import { mapOr$Option_u8s_u8s_u8s_chunks_closure0 } from "./core/option.ts"; export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Header.Header | undefined { if (dataLen >= 2) { @@ -11,10 +11,21 @@ export function header(dataData: Uint8Array, dataStart: number, dataLen: number) return undefined; } -export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { - return okOr$Option_u8s_u8s_u8((dataLen >= 4 ? [new rt.ByteSlice(dataData, dataStart, 4), new rt.ByteSlice(dataData, dataStart + 4, dataLen - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, dataLen & 0xff); +export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + if (!(dataLen >= 4)) { + return dataLen & 0xff; + } + take4Out.p_0Data = dataData; + take4Out.p_0Start = dataStart; + take4Out.p_0Len = 4; + take4Out.p_1Data = dataData; + take4Out.p_1Start = dataStart + 4; + take4Out.p_1Len = dataLen - 4; + return undefined; } +export const take4Out: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + export function word(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): rt.u32 { return ((chunkData[chunkStart] << 24) | (chunkData[chunkStart + 1] << 16) | (chunkData[chunkStart + 2] << 8) | chunkData[chunkStart + 3]) >>> 0; } @@ -58,15 +69,21 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, h.tag.data[h.tag.start + 1]); rt.byteVecPush(out, h.rest.length & 0xff); } - const _18: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> = take4(dataData, dataStart, dataLen); - if (_18.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(_18.value[0].data, _18.value[0].start, _18.value[0].length)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((_18.value[0].data[_18.value[0].start + 1] << 8) | _18.value[0].data[_18.value[0].start + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(_18.value[0].data, _18.value[0].start, _18.value[0].length); + const err: rt.u8 | undefined = take4(dataData, dataStart, dataLen); + const part2: Uint8Array = take4Out.p_0Data; + const part3: number = take4Out.p_0Start; + const part4: number = take4Out.p_0Len; + const part5: Uint8Array = take4Out.p_1Data; + const part6: number = take4Out.p_1Start; + const part7: number = take4Out.p_1Len; + if (err === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(part2, part3, part4)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part2[part3 + 1] << 8) | part2[part3 + 2]) << 16) >> 16))); + const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part2, part3, part4); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); - rt.byteVecExtendFromSlice(out, _18.value[1]); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part5, part6, part7)); } else { - rt.byteVecPush(out, _18.error); + rt.byteVecPush(out, err as rt.u8); } } else if (_4 === 1) { const buf: Uint8Array = rt.bytes(4); @@ -136,8 +153,8 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chosen2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(lit), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); if (dataLen >= 3) { - const chunk: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, 3); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Debug)]; + const chunk2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, 3); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); } } else if (_4 === 4) { @@ -178,26 +195,26 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat return p2.data[p2.start + 1]; }))); } else { - let restData2: Uint8Array = dataData; - let restStart2: number = dataStart; - let restLen2: number = dataLen; + let restData3: Uint8Array = dataData; + let restStart3: number = dataStart; + let restLen3: number = dataLen; let sum: rt.u32 = 0; while (true) { - const _261Data: Uint8Array = restData2; - const _261Start: number = restStart2; - const _261Len: number = restLen2; + const _261Data: Uint8Array = restData3; + const _261Start: number = restStart3; + const _261Len: number = restLen3; if (_261Len >= 3) { sum = rt.u32WrappingAdd((((sum << 5) >>> 0) | (sum >>> 27)) >>> 0, ((_261Data[_261Start] << 8) | _261Data[_261Start + 2]) as rt.u32); rt.byteVecPush(out, _261Data[_261Start + 1]); - restData2 = _261Data; - restStart2 = _261Start + 3; - restLen2 = _261Len - 3; + restData3 = _261Data; + restStart3 = _261Start + 3; + restLen3 = _261Len - 3; } else { break; } } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sum))); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData2, restStart2, restLen2)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData3, restStart3, restLen3)); } } diff --git a/ts/fixtures/lang/expected/core/bool.ts b/ts/fixtures/lang/expected/core/bool.ts index c88ef0114..d66d2fa59 100644 --- a/ts/fixtures/lang/expected/core/bool.ts +++ b/ts/fixtures/lang/expected/core/bool.ts @@ -136,4 +136,11 @@ export function then$bool_u8_library_closure4(self: boolean, f: () => rt.u8): rt return f(); } +export function then$bool_u8s_tail_closure0(self: boolean, f: () => rt.ByteSlice): rt.ByteSlice | undefined { + if (!self) { + return undefined; + } + return f(); +} + //# sourceMappingURL=bool.ts.map diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 16aeb03db..5718f37ba 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1,7 +1,6 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import { copy$u8s_u8s } from "../lib.ts"; import { opaque, len } from "../args.ts"; import type * as Nibble from "../collections.Nibble.ts"; import type * as Rank from "../collections.Rank.ts"; @@ -16,12 +15,12 @@ import { side, order } from "../keys.ts"; import type * as Hop from "../keys.Hop.ts"; import type * as Side from "../keys.Side.ts"; import type * as Way from "../keys.Way.ts"; +import type * as Error from "../returns.Error.ts"; import { from$From_Dir_u8 } from "../shapes.ts"; 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 shapes_Shape from "../shapes.Shape.ts"; -import type * as Short from "../splits.Short.ts"; export function isSomeAnd$Option_u8_bools_closure0(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { if (self === undefined) { @@ -303,6 +302,13 @@ export function map$Option_u8s_u8_opaque(self: rt.ByteSlice | undefined, _: (a0: return opaque(self.data, self.start, self.length); } +export function map$Option_u8s_u8_returns_closure2(self: rt.ByteSlice | undefined, f: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$Option_unit_Option_u8_made_closure3(self: undefined | rt.None, f: (a0: undefined) => rt.u8 | undefined): rt.u8 | undefined | rt.None { if (self === rt.None) { return rt.None; @@ -611,27 +617,34 @@ 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> { +export function okOr$Option_u8s_Error(self: rt.ByteSlice | undefined, err: Error.Error): rt.Result { 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> { +export function okOr$Option_u8s_Option_u8(self: rt.ByteSlice | undefined, err: rt.u8 | undefined): rt.Result { if (self === undefined) { return rt.Err(err); } - return rt.Ok(copy$u8s_u8s(self)); + return rt.Ok(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> { +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_unit(self: rt.ByteSlice | undefined, _: undefined): rt.Result { + if (self === undefined) { + return rt.ERR; + } + return rt.Ok(self); +} + export function okOrElse$Option_Vec_u8_String_owned_closure5(self: rt.ByteVec | undefined, err: () => string): rt.Result { if (self === undefined) { return rt.Err(err()); diff --git a/ts/fixtures/lang/expected/core/result.ts b/ts/fixtures/lang/expected/core/result.ts index e547bf26e..663858c0f 100644 --- a/ts/fixtures/lang/expected/core/result.ts +++ b/ts/fixtures/lang/expected/core/result.ts @@ -3,6 +3,7 @@ import * as rt from "../rt.ts"; import { copy$usize_u8, drop$Result_usize_u8_Arc_dyn_Any } from "../lib.ts"; import type * as Any from "../core/any.Any.ts"; +import type * as Error from "../returns.Error.ts"; export function isOkAnd$Result_u8_u16_results_closure5(self: rt.Result, f: (a0: rt.u8) => boolean): boolean { if (self.ok) { @@ -88,6 +89,13 @@ export function mapOr$Result_u8_u16_u8_results_closure7(self: rt.Result, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { + if (self.ok) { + return self.value.length; + } + return default_; +} + export function mapOrElse$Result_u8_u16_u8_results_closure8_results_closure9(self: rt.Result, default_: (a0: rt.u16) => rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { if (self.ok) { return f(self.value); @@ -151,6 +159,13 @@ export function andThen$Result_u8_u16_u8_results_closure3(self: rt.Result, op: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.Result): rt.Result { + if (self.ok) { + return op(self.value); + } + return self as rt.Result; +} + export function or$Result_u8_u16_u16(self: rt.Result, res: rt.Result): rt.Result { if (self.ok) { return self; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 2e7083d41..8d5da01fb 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -24,6 +24,7 @@ import { keys, overrides } from "./keys.ts"; import { locks, relock } from "./locks.ts"; import { nested } from "./nested.ts"; import { refs } from "./refs.ts"; +import { returns } from "./returns.ts"; import { copies, order, discriminants, loops, patterns, closures, library, flows } from "./shapes.ts"; import { splits } from "./splits.ts"; import { strs, slices } from "./strs.ts"; @@ -63,45 +64,45 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return neg(a013, a113.data, a113.start, a113.length, a213); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::cast", (a014: rt.u8, a114: rt.ByteSlice, a214: rt.ByteVec): void => { return cast(a014, a114.data, a114.start, a114.length, a214); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::convert", (_222: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::convert", (_225: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void => { convert(data.data, data.start, data.length, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::copies", (_223: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::copies", (_226: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): void => { copies(data2.data, data2.start, data2.length, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::loops", (_224: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::loops", (_227: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): void => { loops(data3.data, data3.start, data3.length, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::patterns", (_225: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::patterns", (_228: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): void => { patterns(data4.data, data4.start, data4.length, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::closures", (_226: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::closures", (_229: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): void => { closures(data5.data, data5.start, data5.length, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::discriminants", (_227: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::discriminants", (_230: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): void => { discriminants(data6.data, data6.start, data6.length, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::library", (_228: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::library", (_231: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): void => { library(data7.data, data7.start, data7.length, out7); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::ints", (a015: rt.u8, a115: rt.ByteSlice, a215: rt.ByteVec): void => { return ints(a015, a115.data, a115.start, a115.length, a215); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::strings", (_229: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::strings", (_232: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): void => { strings(data8.data, data8.start, data8.length, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::derived", (_230: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::derived", (_233: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): void => { derived(data9.data, data9.start, data9.length, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::written", (_231: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::written", (_234: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): void => { written(data10.data, data10.start, data10.length, out10); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::panics", (a016: rt.u8, a116: rt.ByteSlice, a216: rt.ByteVec): void => { return panics(a016, a116.data, a116.start, a116.length, a216); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["generics::methods", (_232: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["generics::methods", (_235: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): void => { methods(data11.data, data11.start, data11.length, out11); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::adaptors", (a017: rt.u8, a117: rt.ByteSlice, a217: rt.ByteVec): void => { return adaptors(a017, a117.data, a117.start, a117.length, a217); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::consumers", (a018: rt.u8, a118: rt.ByteSlice, a218: rt.ByteVec): void => { return consumers(a018, a118.data, a118.start, a118.length, a218); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranges", (_233: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranges", (_236: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): void => { ranges(data12.data, data12.start, data12.length, out12); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::options", (_234: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::options", (_237: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): void => { options(data13.data, data13.start, data13.length, out13); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::own", (_235: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::own", (_238: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): void => { own(data14.data, data14.start, data14.length, out14); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::values", (_236: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::values", (_239: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): void => { values(data15.data, data15.start, data15.length, out15); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::order", (_237: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::order", (_240: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): void => { order(data16.data, data16.start, data16.length, out16); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::hash_maps", (a019: rt.u8, a119: rt.ByteSlice, a219: rt.ByteVec): void => { return hashMaps(a019, a119.data, a119.start, a119.length, a219); @@ -109,9 +110,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return sets(a020, a120.data, a120.start, a120.length, a220); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::btree_maps", (a021: rt.u8, a121: rt.ByteSlice, a221: rt.ByteVec): void => { return btreeMaps(a021, a121.data, a121.start, a121.length, a221); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::deques", (_238: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::deques", (_241: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): void => { deques(data17.data, data17.start, data17.length, out17); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::flows", (_239: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::flows", (_242: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): void => { flows(data18.data, data18.start, data18.length, out18); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::keys", (a022: rt.u8, a122: rt.ByteSlice, a222: rt.ByteVec): void => { return keys(a022, a122.data, a122.start, a122.length, a222); @@ -119,11 +120,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return chars(a023, a123.data, a123.start, a123.length, a223); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::strs", (a024: rt.u8, a124: rt.ByteSlice, a224: rt.ByteVec): void => { return strs(a024, a124.data, a124.start, a124.length, a224); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::vecs", (_240: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::vecs", (_243: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): void => { vecs(data19.data, data19.start, data19.length, out19); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::slices", (a025: rt.u8, a125: rt.ByteSlice, a225: rt.ByteVec): void => { return slices(a025, a125.data, a125.start, a125.length, a225); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::stores", (_241: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::stores", (_244: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): void => { stores(data20.data, data20.start, data20.length, out20); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["chunks::chunks", (a026: rt.u8, a126: rt.ByteSlice, a226: rt.ByteVec): void => { return chunks(a026, a126.data, a126.start, a126.length, a226); @@ -137,11 +138,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return splits(a030, a130.data, a130.start, a130.length, a230); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["nested::nested", (a031: rt.u8, a131: rt.ByteSlice, a231: rt.ByteVec): void => { return nested(a031, a131.data, a131.start, a131.length, a231); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["refs::refs", (_242: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["refs::refs", (_245: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): void => { refs(data21.data, data21.start, data21.length, out21); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_243: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_246: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { counts(data22.data, data22.start, data22.length, out22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_244: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_247: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { rounding(out23); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", (a032: rt.u8, a132: rt.ByteSlice, a232: rt.ByteVec): void => { return skips(a032, a132.data, a132.start, a132.length, a232); @@ -157,30 +158,32 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return atomics(a037, a137.data, a137.start, a137.length, a237); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::overrides", (a038: rt.u8, a138: rt.ByteSlice, a238: rt.ByteVec): void => { return overrides(a038, a138.data, a138.start, a138.length, a238); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_245: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_248: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { dyns(data23.data, data23.start, data23.length, out24); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cells::cells", (a039: rt.u8, a139: rt.ByteSlice, a239: rt.ByteVec): void => { return cells(a039, a139.data, a139.start, a139.length, a239); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::shared", (_246: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::shared", (_249: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): void => { shared(data24.data, data24.start, data24.length, out25); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranked", (a040: rt.u8, a140: rt.ByteSlice, a240: rt.ByteVec): void => { return ranked(a040, a140.data, a140.start, a140.length, a240); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["captures::captures", (a041: rt.u8, a141: rt.ByteSlice, a241: rt.ByteVec): void => { return captures(a041, a141.data, a141.start, a141.length, a241); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::locks", (_247: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::locks", (_250: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): void => { locks(data25.data, data25.start, data25.length, out26); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::relock", (_248: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::relock", (_251: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): void => { relock(data26.data, data26.start, data26.length, out27); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["defaults::defaults", (_249: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["defaults::defaults", (_252: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): void => { defaults(data27.data, data27.start, data27.length, out28); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::arcs", (_250: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::arcs", (_253: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): void => { arcs(data28.data, data28.start, data28.length, out29); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::rcs", (_251: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::rcs", (_254: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): void => { rcs(data29.data, data29.start, data29.length, out30); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::anys", (_252: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::anys", (_255: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): void => { anys(data30.data, data30.start, data30.length, out31); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["args::args", (a042: rt.u8, a142: rt.ByteSlice, a242: rt.ByteVec): void => { return args(a042, a142.data, a142.start, a142.length, a242); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["returns::returns", (a043: rt.u8, a143: rt.ByteSlice, a243: rt.ByteVec): void => { + return returns(a043, a143.data, a143.start, a143.length, a243); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; } diff --git a/ts/fixtures/lang/expected/returns.At.ts b/ts/fixtures/lang/expected/returns.At.ts new file mode 100644 index 000000000..bf24fbcc4 --- /dev/null +++ b/ts/fixtures/lang/expected/returns.At.ts @@ -0,0 +1,27 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import type * as Error from "./returns.Error.ts"; + +export interface At { + _0: rt.usize; +} + +export function split$Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): Error.Error | undefined { + const mid: number = self._0; + const _5 = { tag: "Short", _0: self._0 } as Error.Error; + if (!(mid <= dataLen)) { + return _5; + } + splitOut.p_0Data = dataData; + splitOut.p_0Start = dataStart; + splitOut.p_0Len = mid; + splitOut.p_1Data = dataData; + splitOut.p_1Start = dataStart + mid; + splitOut.p_1Len = dataLen - mid; + return undefined; +} + +export const splitOut: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +//# sourceMappingURL=returns.At.ts.map diff --git a/ts/fixtures/lang/expected/returns.Error.ts b/ts/fixtures/lang/expected/returns.Error.ts new file mode 100644 index 000000000..68fd7edad --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Error.ts @@ -0,0 +1,14 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export type Error = { tag: "Short"; _0: rt.usize } | { tag: "Bad" }; + +export function code(self: Error): rt.u8 { + if (self.tag === "Short") { + return self._0 & 0xff; + } + return 255; +} + +//# sourceMappingURL=returns.Error.ts.map diff --git a/ts/fixtures/lang/expected/returns.Guard.ts b/ts/fixtures/lang/expected/returns.Guard.ts new file mode 100644 index 000000000..3846901c5 --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Guard.ts @@ -0,0 +1,26 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { narrow } from "./returns.ts"; + +/** A guard whose drop writes the slot after its function's call did. */ +export class Guard { + _0: rt.ByteSlice; + _1: rt.u8; + + constructor(_0: rt.ByteSlice, _1: rt.u8) { + this._0 = _0; + this._1 = _1; + } + + [Symbol.dispose](): void { + drop$Drop(this); + } +} + +export function drop$Drop(self: Guard): void { + const _3: rt.ByteSlice = rt.byteSliceRange(self._0, rt.usizeRem(self._1 as rt.usize, 2)); + narrow(_3.data, _3.start, _3.length); +} + +//# sourceMappingURL=returns.Guard.ts.map diff --git a/ts/fixtures/lang/expected/returns.Split.ts b/ts/fixtures/lang/expected/returns.Split.ts new file mode 100644 index 000000000..ae1f35518 --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Split.ts @@ -0,0 +1,24 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as returns_At from "./returns.At.ts"; +import type * as Error from "./returns.Error.ts"; + +export class At { + v: returns_At.At; + + constructor(v: returns_At.At) { + this.v = v; + } + + split$Split(a: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], Error.Error> { + const err = returns_At.split$Split(this.v, a.data, a.start, a.length); + const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], Error.Error> = err === undefined ? rt.Ok([new rt.ByteSlice(returns_At.splitOut.p_0Data, returns_At.splitOut.p_0Start, returns_At.splitOut.p_0Len), new rt.ByteSlice(returns_At.splitOut.p_1Data, returns_At.splitOut.p_1Start, returns_At.splitOut.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]) : rt.Err(err as Error.Error); + return result; + } +} + +export type Split = + | { split$Split: (a0: rt.ByteSlice) => rt.Result<[rt.ByteSlice, rt.ByteSlice], Error.Error> }; + +//# sourceMappingURL=returns.Split.ts.map diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts new file mode 100644 index 000000000..346f9ef5a --- /dev/null +++ b/ts/fixtures/lang/expected/returns.ts @@ -0,0 +1,426 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { then$bool_u8s_tail_closure0 } from "./core/bool.ts"; +import { unwrapOr$Option_u8, map$Option_u8_u8s_u8s_args_closure1, map$Option_u8s_u8_returns_closure2, okOr$Option_u8s_Error, okOr$Option_u8s_Option_u8, okOr$Option_u8s_unit } from "./core/option.ts"; +import { mapOr$Result_u8s_Error_usize_len, andThen$Result_u8s_u8s_Error_u8s_returns_closure3 } from "./core/result.ts"; +import * as At from "./returns.At.ts"; +import * as Error from "./returns.Error.ts"; +import * as Guard from "./returns.Guard.ts"; +import * as Split from "./returns.Split.ts"; + +/** A slice alone, with returns from several places. */ +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Error.Error | undefined { + if (!(n > 200)) { + if (!(n <= dataLen)) { + return { tag: "Short", _0: rt.usizeSub(n, dataLen) } as Error.Error; + } + takeOut.pData = dataData; + takeOut.pStart = dataStart; + takeOut.pLen = n; + return undefined; + } + return { tag: "Bad" } as Error.Error; +} + +export const takeOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; + +/** The same slice type through another function, which shares its slot. */ +export function tail(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Error.Error | undefined { + const _4: boolean = n <= dataLen; + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); + const _0: rt.Result = okOr$Option_u8s_Error(then$bool_u8s_tail_closure0(_4, (): rt.ByteSlice => { + return rt.byteSliceRange(captured, n); + }), { tag: "Short", _0: n } as Error.Error); + if (!_0.ok) { + return _0.error; + } + const slice: rt.ByteSlice = _0.value; + takeOut.pData = slice.data; + takeOut.pStart = slice.start; + takeOut.pLen = slice.length; + return undefined; +} + +/** A number past 2^31 and the rest. */ +export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): Error.Error | undefined { + if (dataLen >= 8) { + wideOut.p_0 = rt.u64FromBeBytes(rt.byteSliceToArray(new rt.ByteSlice(dataData, dataStart, 8))); + wideOut.p_1Data = dataData; + wideOut.p_1Start = dataStart + 8; + wideOut.p_1Len = dataLen - 8; + return undefined; + } + return { tag: "Short", _0: 8 } as Error.Error; +} + +export const wideOut: { p_0: rt.u64; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number): Error.Error | undefined { + if (dataLen !== 0) { + const b: rt.u8 = dataData[dataStart]; + if (b === 255) { + return { tag: "Bad" } as Error.Error; + } + wideOut.p_0 = b as rt.u64; + wideOut.p_1Data = dataData; + wideOut.p_1Start = dataStart + 1; + wideOut.p_1Len = dataLen - 1; + return undefined; + } + return { tag: "Short", _0: 1 } as Error.Error; +} + +/** What either returns, returned as is. */ +export function number(dataData: Uint8Array, dataStart: number, dataLen: number, wide_: boolean): Error.Error | undefined { + if (!wide_) { + return narrow(dataData, dataStart, dataLen); + } + return wide(dataData, dataStart, dataLen); +} + +/** Each byte before a zero counted, recursively. */ +export function count(dataData: Uint8Array, dataStart: number, dataLen: number): Error.Error | undefined { + if (dataLen === 0) { + return { tag: "Short", _0: 1 } as Error.Error; + } + if (dataData[dataStart] === 0) { + wideOut.p_0 = 0; + wideOut.p_1Data = dataData; + wideOut.p_1Start = dataStart + 1; + wideOut.p_1Len = dataLen - 1; + return undefined; + } + const err: Error.Error | undefined = count(dataData, dataStart + 1, dataLen - 1); + const part: rt.u64 = wideOut.p_0; + const part2: Uint8Array = wideOut.p_1Data; + const part3: number = wideOut.p_1Start; + const part4: number = wideOut.p_1Len; + if (err === undefined) { + wideOut.p_0 = rt.u64Add(part, 1); + wideOut.p_1Data = part2; + wideOut.p_1Start = part3; + wideOut.p_1Len = part4; + return undefined; + } + return err as Error.Error; +} + +/** Two slices, and a reference to an array. */ +export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + if (dataLen >= 2) { + const mid: number = rt.usizeDiv(dataLen - 2, 2); + if (mid > dataLen - 2) { + rt.panic("mid > len"); + } + halvesOut.p_0Data = dataData; + halvesOut.p_0Start = dataStart + 2; + halvesOut.p_0Len = mid; + halvesOut.p_1Data = dataData; + halvesOut.p_1Start = dataStart; + halvesOut.p_1Len = 2; + halvesOut.p_2Data = dataData; + halvesOut.p_2Start = dataStart + 2 + mid; + halvesOut.p_2Len = dataLen - 2 - mid; + return undefined; + } + return dataLen & 0xff; +} + +export const halvesOut: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; + +/** Calls whose results are both held while the slot is written again between them. */ +export function both(dataData: Uint8Array, dataStart: number, dataLen: number): Error.Error | undefined { + const err: Error.Error | undefined = narrow(dataData, dataStart, dataLen); + const part: rt.u64 = wideOut.p_0; + const part2: Uint8Array = wideOut.p_1Data; + const part3: number = wideOut.p_1Start; + const part4: number = wideOut.p_1Len; + if (err === undefined) { + const a: rt.u64 = part; + const err2: Error.Error | undefined = number(part2, part3, part4, rt.u64Rem(a, 2) === 1); + const part5: rt.u64 = wideOut.p_0; + const part6: Uint8Array = wideOut.p_1Data; + const part7: number = wideOut.p_1Start; + const part8: number = wideOut.p_1Len; + if (err2 === undefined) { + const b: rt.u64 = part5; + const err3: Error.Error | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); + const part9: Uint8Array = takeOut.pData; + const part10: number = takeOut.pStart; + const part11: number = takeOut.pLen; + if (err3 === undefined) { + const err4: Error.Error | undefined = take(part9, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); + const part14: number = takeOut.pLen; + if (err4 === undefined) { + const _35_1: rt.u64 = rt.u64Xor(b, part14 as rt.u64); + bothOut.p_0 = a; + bothOut.p_1 = _35_1; + bothOut.p_2Data = part9; + bothOut.p_2Start = part10; + bothOut.p_2Len = part11; + return undefined; + } + return err4 as Error.Error; + } + return err3 as Error.Error; + } + return err2 as Error.Error; + } + return err as Error.Error; +} + +export const bothOut: { p_0: rt.u64; p_1: rt.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0: undefined as never, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; + +export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, otherData: Uint8Array, otherStart: number, otherLen: number): Error.Error | undefined { + const err: Error.Error | undefined = narrow(dataData, dataStart, dataLen); + const part: rt.u64 = wideOut.p_0; + const part2: Uint8Array = wideOut.p_1Data; + const part3: number = wideOut.p_1Start; + const part4: number = wideOut.p_1Len; + rt.drop(new Guard.Guard(new rt.ByteSlice(otherData, otherStart, otherLen), dataLen & 0xff)); + if (err !== undefined) { + return err as Error.Error; + } + wideOut.p_0 = part; + wideOut.p_1Data = part2; + wideOut.p_1Start = part3; + wideOut.p_1Len = part4; + return undefined; +} + +/** Errors that are no single value: `()`, and an `Option`. */ +export function unitErr(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result { + return okOr$Option_u8s_unit(map$Option_u8_u8s_u8s_args_closure1((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), undefined); +} + +export function noneErr(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result { + const _2: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); + if (_2 !== undefined) { + if (_2 === 0) { + return rt.ERR; + } + if (_2 > 240) { + return rt.Err(_2); + } + } + return okOr$Option_u8s_Option_u8(map$Option_u8_u8s_u8s_args_closure1((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), undefined as rt.u8 | undefined); +} + +export function splitWith$At(s: At.At, dataData: Uint8Array, dataStart: number, dataLen: number): Error.Error | undefined { + return At.split$Split(s, dataData, dataStart, dataLen); +} + +export function push(out: rt.ByteVec, r: rt.Result): void { + if (r.ok) { + rt.byteVecPush(out, r.value.length & 0xff); + rt.byteVecExtendFromSlice(out, rt.byteSliceRange(r.value, 0, rt.min(r.value.length, 4))); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, Error.code(r.error)))); + } +} + +export function pushNumber(out: rt.ByteVec, r: rt.Result<[rt.u64, rt.ByteSlice], Error.Error>): void { + if (r.ok) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(r.value[0]))); + rt.byteVecPush(out, r.value[1].length & 0xff); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, Error.code(r.error)))); + } +} + +export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let f!: (a0: rt.ByteSlice) => rt.Result<[rt.u64, rt.ByteSlice], Error.Error>; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const _4: rt.u8 = rt.u8Rem(kind, 6); + if (_4 === 0) { + const err15: Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); + const part46: Uint8Array = takeOut.pData; + const part47: number = takeOut.pStart; + const part48: number = takeOut.pLen; + push(out, (err15 !== undefined ? rt.Err(err15 as Error.Error) : rt.Ok(new rt.ByteSlice(part46, part47, part48))) as rt.Result); + const err16: Error.Error | undefined = take(data.data, data.start, data.length, 201); + const part49: Uint8Array = takeOut.pData; + const part50: number = takeOut.pStart; + const part51: number = takeOut.pLen; + push(out, (err16 !== undefined ? rt.Err(err16 as Error.Error) : rt.Ok(new rt.ByteSlice(part49, part50, part51))) as rt.Result); + const err17: Error.Error | undefined = tail(data.data, data.start, data.length, 3); + const part52: Uint8Array = takeOut.pData; + const part53: number = takeOut.pStart; + const part54: number = takeOut.pLen; + push(out, (err17 !== undefined ? rt.Err(err17 as Error.Error) : rt.Ok(new rt.ByteSlice(part52, part53, part54))) as rt.Result); + const err18: Error.Error | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + const part55: rt.u64 = wideOut.p_0; + const part56: Uint8Array = wideOut.p_1Data; + const part57: number = wideOut.p_1Start; + const part58: number = wideOut.p_1Len; + pushNumber(out, (err18 !== undefined ? rt.Err(err18 as Error.Error) : rt.Ok([part55, new rt.ByteSlice(part56, part57, part58)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], Error.Error>); + const err19: Error.Error | undefined = count(data.data, data.start, data.length); + const part59: rt.u64 = wideOut.p_0; + const part60: Uint8Array = wideOut.p_1Data; + const part61: number = wideOut.p_1Start; + const part62: number = wideOut.p_1Len; + pushNumber(out, (err19 !== undefined ? rt.Err(err19 as Error.Error) : rt.Ok([part59, new rt.ByteSlice(part60, part61, part62)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], Error.Error>); + } else if (_4 === 1) { + const kept: rt.Result[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { + const err12 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); + return err12 === undefined ? rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)) : rt.Err(err12 as Error.Error); + })); + const err13: Error.Error | undefined = tail(data.data, data.start, data.length, 1); + const part38: Uint8Array = takeOut.pData; + const part39: number = takeOut.pStart; + const part40: number = takeOut.pLen; + for (const _29 of kept) { + push(out, _29); + } + push(out, (err13 !== undefined ? rt.Err(err13 as Error.Error) : rt.Ok(new rt.ByteSlice(part38, part39, part40))) as rt.Result); + const err14: Error.Error | undefined = both(data.data, data.start, data.length); + const part41: rt.u64 = bothOut.p_0; + const part42: rt.u64 = bothOut.p_1; + const part45: number = bothOut.p_2Len; + if (err14 === undefined) { + const a: rt.u64 = part41; + const b: rt.u64 = part42; + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); + rt.byteVecPush(out, part45 & 0xff); + } else { + rt.byteVecPush(out, Error.code(err14 as Error.Error)); + } + } else if (_4 === 2) { + if (!(rt.usizeRem(data.length, 2) === 0)) { + f = (a02: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], Error.Error> => { + const err9 = narrow(a02.data, a02.start, a02.length); + const result3: rt.Result<[rt.u64, rt.ByteSlice], Error.Error> = err9 === undefined ? rt.Ok([wideOut.p_0, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]) : rt.Err(err9 as Error.Error); + return result3; + }; + } else { + f = (a0: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], Error.Error> => { + const err8 = wide(a0.data, a0.start, a0.length); + const result2: rt.Result<[rt.u64, rt.ByteSlice], Error.Error> = err8 === undefined ? rt.Ok([wideOut.p_0, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]) : rt.Err(err8 as Error.Error); + return result2; + }; + } + pushNumber(out, f(data)); + for (const _71 of rt.iterToArray(rt.iterMap(rt.iterSlice([data, rt.byteSliceRange(data, rt.min(data.length, 3))]), (a03: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], Error.Error> => { + const err10 = count(a03.data, a03.start, a03.length); + const result4: rt.Result<[rt.u64, rt.ByteSlice], Error.Error> = err10 === undefined ? rt.Ok([wideOut.p_0, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]) : rt.Err(err10 as Error.Error); + return result4; + }))) { + pushNumber(out, _71); + } + rt.iterExtendBytes(out, rt.iterOption(map$Option_u8s_u8_returns_closure2(map$Option_u8_u8s_u8s_args_closure1((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), (s: rt.ByteSlice): rt.u8 => { + const err11: Error.Error | undefined = tail(s.data, s.start, s.length, 2); + const part35: Uint8Array = takeOut.pData; + const part36: number = takeOut.pStart; + const part37: number = takeOut.pLen; + return mapOr$Result_u8s_Error_usize_len((err11 !== undefined ? rt.Err(err11 as Error.Error) : rt.Ok(new rt.ByteSlice(part35, part36, part37))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { + return a04.length; + }) & 0xff; + }))); + } else if (_4 === 3) { + const err5: rt.u8 | undefined = halves(data.data, data.start, data.length); + const part19: number = halvesOut.p_0Len; + const part20: Uint8Array = halvesOut.p_1Data; + const part21: number = halvesOut.p_1Start; + const part22: number = halvesOut.p_1Len; + const part23: Uint8Array = halvesOut.p_2Data; + const part24: number = halvesOut.p_2Start; + const part25: number = halvesOut.p_2Len; + if (err5 === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part20, part21, part22)); + rt.byteVecPush(out, part19 & 0xff); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part23, part24, part25)); + } else { + rt.byteVecPush(out, err5 as rt.u8); + } + const other: Uint8Array = Uint8Array.of(255, 1, 2); + const _96: rt.ByteSlice = rt.byteSliceFrom(other); + const err6: Error.Error | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); + const part26: rt.u64 = wideOut.p_0; + const part27: Uint8Array = wideOut.p_1Data; + const part28: number = wideOut.p_1Start; + const part29: number = wideOut.p_1Len; + pushNumber(out, (err6 !== undefined ? rt.Err(err6 as Error.Error) : rt.Ok([part26, new rt.ByteSlice(part27, part28, part29)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], Error.Error>); + const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); + const err7: Error.Error | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); + const part30: rt.u64 = wideOut.p_0; + const part31: Uint8Array = wideOut.p_1Data; + const part32: number = wideOut.p_1Start; + const part33: number = wideOut.p_1Len; + pushNumber(out, (err7 !== undefined ? rt.Err(err7 as Error.Error) : rt.Ok([part30, new rt.ByteSlice(part31, part32, part33)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], Error.Error>); + } else if (_4 === 4) { + const _104: rt.Result = unitErr(data.data, data.start, data.length); + if (_104.ok) { + rt.byteVecPush(out, _104.value.length & 0xff); + } else { + rt.byteVecPush(out, 238); + } + const _109: rt.Result = noneErr(data.data, data.start, data.length); + if (_109.ok) { + rt.byteVecPush(out, _109.value.length & 0xff); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, unwrapOr$Option_u8(_109.error, 0)))); + } + } else { + const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; + const err: Error.Error | undefined = splitWith$At(at, data.data, data.start, data.length); + const part3: number = At.splitOut.p_0Len; + const part6: number = At.splitOut.p_1Len; + if (err === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part3 & 0xff, part6 & 0xff))); + } else { + rt.byteVecPush(out, Error.code(err as Error.Error)); + } + const _141: rt.Result<[rt.ByteSlice, rt.ByteSlice], Error.Error> = new Split.At(at).split$Split(data); + if (_141.ok) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_141.value[1].length & 0xff, _141.value[0].length & 0xff))); + } else { + rt.byteVecPush(out, Error.code(_141.error)); + } + const err2: Error.Error | undefined = At.split$Split(at, data.data, data.start, data.length); + const part7: Uint8Array = At.splitOut.p_0Data; + const part8: number = At.splitOut.p_0Start; + const part9: number = At.splitOut.p_0Len; + const part10: Uint8Array = At.splitOut.p_1Data; + const part11: number = At.splitOut.p_1Start; + const part12: number = At.splitOut.p_1Len; + const _155: rt.Result = andThen$Result_u8s_u8s_Error_u8s_returns_closure3((err2 !== undefined ? rt.Err(err2 as Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { + const err3 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); + return err3 === undefined ? rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)) : rt.Err(err3 as Error.Error); + }); + if (_155.ok) { + rt.byteVecPush(out, _155.value.length & 0xff); + } else { + rt.byteVecPush(out, Error.code(_155.error)); + } + let restData2: Uint8Array = data.data; + let restStart2: number = data.start; + let restLen2: number = data.length; + let sum: rt.u64 = 0; + while (true) { + const err4: Error.Error | undefined = narrow(restData2, restStart2, restLen2); + const part13: rt.u64 = wideOut.p_0; + const part14: Uint8Array = wideOut.p_1Data; + const part15: number = wideOut.p_1Start; + const part16: number = wideOut.p_1Len; + if (err4 === undefined) { + sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13); + restData2 = part14; + restStart2 = part15; + restLen2 = part16; + } else { + break; + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sum))); + } +} + +//# sourceMappingURL=returns.ts.map diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index fb521a459..ffad7a721 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -2,21 +2,30 @@ 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 { unwrapOr$Option_u8, mapOr$Option_u8s_u8s_u8_splits_closure0, okOr$Option_u8s_u8s_Option_u8 } from "./core/option.ts"; +import * as At from "./returns.At.ts"; import type * as Short from "./splits.Short.ts"; /** The first byte, then a big-endian `u16`, by `?` on `ok_or`. */ -export function header(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> { +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Short.Short | undefined { if (dataLen !== 0) { const a: rt.u8 = dataData[dataStart]; if (dataLen - 1 >= 2) { - return rt.Ok([a, (dataData[dataStart + 1] << 8) | dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)] as [rt.u8, rt.u16, rt.ByteSlice]); + const _20_1: rt.u16 = (dataData[dataStart + 1] << 8) | dataData[dataStart + 2]; + headerOut.p_0 = a; + headerOut.p_1 = _20_1; + headerOut.p_2Data = dataData; + headerOut.p_2Start = dataStart + 3; + headerOut.p_2Len = dataLen - 3; + return undefined; } - return rt.Err({ tag: "Need", _0: 2 } as Short.Short); + return { tag: "Need", _0: 2 } as Short.Short; } - return rt.Err({ tag: "Empty" } as Short.Short); + return { tag: "Empty" } as Short.Short; } +export const headerOut: { p_0: rt.u8; p_1: rt.u16; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0: undefined as never, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; + /** Two bytes, by `?` on an `Option`. */ export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u8, rt.u8, rt.ByteSlice] | undefined { if (dataLen !== 0) { @@ -30,8 +39,17 @@ export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [ } /** `n` bytes, or how many it needed. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { - return okOr$Option_u8s_u8s_Short((n <= dataLen ? [new rt.ByteSlice(dataData, dataStart, n), new rt.ByteSlice(dataData, dataStart + n, dataLen - n)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, { tag: "Need", _0: n } as Short.Short); +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Short.Short | undefined { + if (!(n <= dataLen)) { + return { tag: "Need", _0: n } as Short.Short; + } + At.splitOut.p_0Data = dataData; + At.splitOut.p_0Start = dataStart; + At.splitOut.p_0Len = n; + At.splitOut.p_1Data = dataData; + At.splitOut.p_1Start = dataStart + n; + At.splitOut.p_1Len = dataLen - n; + return undefined; } /** The byte after the first, or an error that is itself an enum, held whole. */ @@ -93,17 +111,22 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, mid4 & 0xff); rt.byteVecExtendFromSlice(out, new rt.ByteSlice(dataData, dataStart + mid4, dataLen - mid4)); } else if (_4 === 2) { - const _33: rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> = header(dataData, dataStart, dataLen); - if (_33.ok) { - const a2: rt.u8 = _33.value[0]; - const b3: rt.u16 = _33.value[1]; + const err3: Short.Short | undefined = header(dataData, dataStart, dataLen); + const part7: rt.u8 = headerOut.p_0; + const part8: rt.u16 = headerOut.p_1; + const part9: Uint8Array = headerOut.p_2Data; + const part10: number = headerOut.p_2Start; + const part11: number = headerOut.p_2Len; + if (err3 === undefined) { + const a2: rt.u8 = part7; + const b3: rt.u16 = part8; rt.byteVecPush(out, a2); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(b3))); - rt.byteVecPush(out, opaque(_33.value[2].data, _33.value[2].start, _33.value[2].length)); - } else if (_33.error.tag === "Empty") { + rt.byteVecPush(out, opaque(part9, part10, part11)); + } else if ((err3 as Short.Short).tag === "Empty") { rt.byteVecPush(out, 240); } else { - rt.byteVecPush(out, 241 ^ (_33.error._0 & 0xff)); + rt.byteVecPush(out, 241 ^ (((err3 as Short.Short) as { tag: "Need"; _0: rt.usize })._0 & 0xff)); } } else if (_4 === 3) { const mid3: number = rt.usizeDiv(dataLen, 2); @@ -184,22 +207,22 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, aLen2 & 0xff); rt.byteVecPush(out, opaque(bData2, bStart2, bLen2)); } else if (_4 === 5) { - let restData2: Uint8Array = dataData; - let restStart2: number = dataStart; - let restLen2: number = dataLen; + let restData3: Uint8Array = dataData; + let restStart3: number = dataStart; + let restLen3: number = dataLen; while (true) { - const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(restData2, restStart2, restLen2); + const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(restData3, restStart3, restLen3); if (_124 !== undefined) { rt.byteVecPush(out, _124[0] ^ _124[1]); const slice: rt.ByteSlice = _124[2]; - restData2 = slice.data; - restStart2 = slice.start; - restLen2 = slice.length; + restData3 = slice.data; + restStart3 = slice.start; + restLen3 = slice.length; } else { break; } } - rt.byteVecPush(out, restLen2 & 0xff); + rt.byteVecPush(out, restLen3 & 0xff); } else if (_4 === 6) { const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(new rt.ByteSlice(dataData, dataStart, dataLen), 4); b5: { @@ -215,12 +238,16 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } - const _159: rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> = take(dataData, dataStart, dataLen, 3); - if (_159.ok) { - rt.byteVecPush(out, opaque(_159.value[0].data, _159.value[0].start, _159.value[0].length)); - rt.byteVecPush(out, _159.value[1].length & 0xff); + const err2: Short.Short | undefined = take(dataData, dataStart, dataLen, 3); + const part: Uint8Array = At.splitOut.p_0Data; + const part2: number = At.splitOut.p_0Start; + const part3: number = At.splitOut.p_0Len; + const part6: number = At.splitOut.p_1Len; + if (err2 === undefined) { + rt.byteVecPush(out, opaque(part, part2, part3)); + rt.byteVecPush(out, part6 & 0xff); } else { - const e: Short.Short = _159.error; + const e: Short.Short = err2 as Short.Short; if (e.tag === "Empty") { _169 = 0; } else { diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 0066775b0..3b81e1769 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -3,7 +3,8 @@ use crate::{ args, atomics, captures, cells, chars, chunks, collections, combinators, counts, cows, defaults, durations, dyns, - edits, floats, fmt, generics, ints, iters, keys, locks, nested, refs, shapes, splits, strs, utf8, wrappers, + edits, floats, fmt, generics, ints, iters, keys, locks, nested, refs, returns, shapes, splits, strs, utf8, + wrappers, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -95,6 +96,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("counts::rcs", |_, data, out| counts::rcs(data, out)), ("dyns::anys", |_, data, out| dyns::anys(data, out)), ("args::args", args::args), + ("returns::returns", returns::returns), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 2a4028d2b..4402736ad 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -1,12 +1,12 @@ //! The language the driver translates, exercised against native Rust: every integer //! width's arithmetic and casts, `f64`, `char`s and the `str` methods over them, -//! `Cow`, `Duration`, control flow, patterns, byte slices split apart and passed as -//! their parts, `Copy` aggregates, closures and what they write of what they captured, -//! traits, generic types, formatting, collections, UTF-8 decoding, `&mut` to values JS -//! copies, the standard library calls it maps, `Option`'s and `Result`'s combinators from -//! core's MIR, `Option`s of values that can already be `undefined`, atomics, trait -//! objects, one-time cells, mutexes, the defaults of std types, and the counts of shared -//! pointers. +//! `Cow`, `Duration`, control flow, patterns, byte slices split apart, passed as +//! their parts, and returned in a slot, `Copy` aggregates, closures and what they write +//! of what they captured, traits, generic types, formatting, collections, UTF-8 +//! decoding, `&mut` to values JS copies, the standard library calls it maps, `Option`'s +//! and `Result`'s combinators from core's MIR, `Option`s of values that can already be +//! `undefined`, atomics, trait objects, one-time cells, mutexes, the defaults of std +//! types, and the counts of shared pointers. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. @@ -35,6 +35,7 @@ mod keys; mod locks; mod nested; mod refs; +mod returns; mod shapes; mod splits; mod strs; diff --git a/ts/fixtures/lang/src/returns.rs b/ts/fixtures/lang/src/returns.rs new file mode 100644 index 000000000..1264a8fcb --- /dev/null +++ b/ts/fixtures/lang/src/returns.rs @@ -0,0 +1,237 @@ +//! Results of byte slices returned by the crate's own functions, which hand back an +//! `Ok`'s parts in a slot their caller reads at once. + +#[derive(Debug, Clone, Copy, PartialEq)] +enum Error { + Short(usize), + Bad, +} + +impl Error { + fn code(self) -> u8 { + match self { + Error::Short(n) => n as u8, + Error::Bad => 0xff, + } + } +} + +/// A slice alone, with returns from several places. +fn take(data: &[u8], n: usize) -> Result<&[u8], Error> { + if n > 200 { + return Err(Error::Bad); + } + match data.split_at_checked(n) { + Some((head, _)) => Ok(head), + None => Err(Error::Short(n - data.len())), + } +} + +/// The same slice type through another function, which shares its slot. +fn tail(data: &[u8], n: usize) -> Result<&[u8], Error> { + (n <= data.len()).then(|| &data[n..]).ok_or(Error::Short(n)) +} + +/// A number past 2^31 and the rest. +fn wide(data: &[u8]) -> Result<(u64, &[u8]), Error> { + let (head, rest) = data.split_first_chunk::<8>().ok_or(Error::Short(8))?; + Ok((u64::from_be_bytes(*head), rest)) +} + +fn narrow(data: &[u8]) -> Result<(u64, &[u8]), Error> { + let (&b, rest) = data.split_first().ok_or(Error::Short(1))?; + match b { + 0xff => Err(Error::Bad), + _ => Ok((b as u64, rest)), + } +} + +/// What either returns, returned as is. +fn number(data: &[u8], wide_: bool) -> Result<(u64, &[u8]), Error> { + if wide_ { + return wide(data); + } + narrow(data) +} + +/// Each byte before a zero counted, recursively. +fn count(data: &[u8]) -> Result<(u64, &[u8]), Error> { + match data.split_first() { + Some((0, rest)) => Ok((0, rest)), + Some((_, rest)) => { + let (n, rest) = count(rest)?; + Ok((n + 1, rest)) + } + None => Err(Error::Short(1)), + } +} + +/// Two slices, and a reference to an array. +fn halves(data: &[u8]) -> Result<(&[u8], &[u8; 2], &[u8]), u8> { + let (tag, rest) = data.split_first_chunk::<2>().ok_or(data.len() as u8)?; + let (a, b) = rest.split_at(rest.len() / 2); + Ok((a, tag, b)) +} + +/// Calls whose results are both held while the slot is written again between them. +fn both(data: &[u8]) -> Result<(u64, u64, &[u8]), Error> { + let (a, rest) = narrow(data)?; + let (b, rest) = number(rest, a % 2 == 1)?; + let rest = tail(rest, (a % 3) as usize)?; + let head = take(rest, (b % 4) as usize)?; + Ok((a, b ^ head.len() as u64, rest)) +} + +/// A guard whose drop writes the slot after its function's call did. +struct Guard<'a>(&'a [u8], u8); + +impl Drop for Guard<'_> { + fn drop(&mut self) { + let _ = narrow(&self.0[self.1 as usize % 2..]); + } +} + +fn guarded<'a>(data: &'a [u8], other: &[u8]) -> Result<(u64, &'a [u8]), Error> { + let _guard = Guard(other, data.len() as u8); + narrow(data) +} + +/// Errors that are no single value: `()`, and an `Option`. +fn unit_err(data: &[u8]) -> Result<&[u8], ()> { + data.split_first().map(|(_, rest)| rest).ok_or(()) +} + +fn none_err(data: &[u8]) -> Result<&[u8], Option> { + match data.first() { + Some(0) => Err(None), + Some(&b) if b > 0xf0 => Err(Some(b)), + _ => data.split_first().map(|(_, rest)| rest).ok_or(None), + } +} + +trait Split { + fn split<'a>(&self, data: &'a [u8]) -> Result<(&'a [u8], &'a [u8]), Error>; +} + +struct At(usize); + +impl Split for At { + fn split<'a>(&self, data: &'a [u8]) -> Result<(&'a [u8], &'a [u8]), Error> { + data.split_at_checked(self.0).ok_or(Error::Short(self.0)) + } +} + +fn split_with<'a, S: Split>(s: &S, data: &'a [u8]) -> Result<(&'a [u8], &'a [u8]), Error> { + s.split(data) +} + +fn push(out: &mut Vec, r: Result<&[u8], Error>) { + match r { + Ok(s) => { + out.push(s.len() as u8); + out.extend_from_slice(&s[..s.len().min(4)]); + } + Err(e) => out.extend_from_slice(&[0xee, e.code()]), + } +} + +fn push_number(out: &mut Vec, r: Result<(u64, &[u8]), Error>) { + match r { + Ok((n, rest)) => { + out.extend_from_slice(&n.to_be_bytes()); + out.push(rest.len() as u8); + } + Err(e) => out.extend_from_slice(&[0xee, e.code()]), + } +} + +pub fn returns(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 6 { + 0 => { + push(out, take(data, kind as usize % 7)); + push(out, take(data, 201)); + push(out, tail(data, 3)); + push_number(out, number(data, kind % 2 == 0)); + push_number(out, count(data)); + } + 1 => { + // Kept whole: in a collection, and read later, after other calls wrote the slot. + let kept: Vec> = (0..4).map(|n| take(data, n * 3)).collect(); + let last = tail(data, 1); + for r in kept { + push(out, r); + } + push(out, last); + match both(data) { + Ok((a, b, rest)) => { + out.extend_from_slice(&a.to_be_bytes()); + out.extend_from_slice(&b.to_be_bytes()); + out.push(rest.len() as u8); + } + Err(e) => out.push(e.code()), + } + } + 2 => { + // As values: a function item, and a pointer to it. + let f: fn(&[u8]) -> Result<(u64, &[u8]), Error> = if data.len() % 2 == 0 { wide } else { narrow }; + push_number(out, f(data)); + let all: Vec<_> = [data, &data[data.len().min(3)..]].into_iter().map(count).collect(); + for r in all { + push_number(out, r); + } + out.extend( + data.split_first() + .map(|(_, rest)| rest) + .map(|s| tail(s, 2).map_or(0, <[u8]>::len) as u8), + ); + } + 3 => { + match halves(data) { + Ok((a, tag, b)) => { + out.extend_from_slice(tag); + out.push(a.len() as u8); + out.extend_from_slice(b); + } + Err(n) => out.push(n), + } + let other = [0xff, 1, 2]; + push_number(out, guarded(data, &other)); + push_number(out, guarded(data, &other[1..])); + } + 4 => { + match unit_err(data) { + Ok(s) => out.push(s.len() as u8), + Err(()) => out.push(0xee), + } + match none_err(data) { + Ok(s) => out.push(s.len() as u8), + Err(e) => out.extend_from_slice(&[0xee, e.unwrap_or(0)]), + } + } + _ => { + let at = At(kind as usize % 5); + match split_with(&at, data) { + Ok((a, b)) => out.extend_from_slice(&[a.len() as u8, b.len() as u8]), + Err(e) => out.push(e.code()), + } + // Through a trait object. + let dynamic: &dyn Split = &at; + match dynamic.split(data) { + Ok((a, b)) => out.extend_from_slice(&[b.len() as u8, a.len() as u8]), + Err(e) => out.push(e.code()), + } + match at.split(data).and_then(|(a, b)| take(b, a.len())) { + Ok(s) => out.push(s.len() as u8), + Err(e) => out.push(e.code()), + } + // A loop that calls again while the last result is still read. + let mut rest = data; + let mut sum = 0u64; + while let Ok((n, more)) = narrow(rest) { + sum = sum.wrapping_mul(31).wrapping_add(n); + rest = more; + } + out.extend_from_slice(&sum.to_be_bytes()); + } + } +} diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index dfa8ee60f..357c08329 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -18,6 +18,9 @@ pub struct Body<'b, 'a, 'tcx> { /// Which of the function's parameters are byte slices it takes as their parts, by /// [`Translator::parted`], until its own body takes them. pub parted: Vec, + /// Where the function hands back its `Ok`'s parts, by [`Translator::slotted`], until + /// its own body takes it. + pub slotted: Option>, } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { @@ -27,6 +30,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { args, names: FxHashSet::default(), parted: Vec::new(), + slotted: None, } } @@ -124,13 +128,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { if let Some(class) = super::mir::coroutine::of_async_fn(self.t, instance, span) { return Expr::New(Box::new(Expr::Sym(class)), values); } - let parted = self.t.parted(instance); - let values = match parted.is_empty() { - true => values, - false => self.slice_args(values, &parted, out), - }; - let sym = self.t.callee(instance, span); - let call = Expr::Sym(sym).call(values); + let call = self.direct_call(instance, values, span, out); // The crate's own `next` returns an item or `rt.DONE`, and its caller an `Option`. if super::iter::is_next(tcx, did) { let sig = tcx.fn_sig(did).instantiate(tcx, instance.args).skip_norm_wip(); @@ -142,6 +140,17 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { let none = self.t.none_arg(option_args.type_at(0)); return Expr::rt("iterToOption", [call].into_iter().chain(none).collect()); } + // One that hands back its `Ok`'s parts, made whole here, before anything else can + // write its slot. + if let Some(slotted) = self.t.slotted(instance) { + let err = self.fresh("err"); + out.push(StmtKind::decl(false, err.clone(), None, Some(call)).at(None)); + let value = slotted.rebuild(self.t, &err, span); + let result = self.fresh("result"); + let ty = self.t.ty(slotted.ret, span); + out.push(StmtKind::decl(false, result.clone(), Some(ty), Some(value)).at(None)); + return Expr::ident(result); + } return call; } if let Some(referent) = library::referent(tcx, def_id, gargs, instance) { @@ -242,6 +251,23 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } + /// A call of `instance`, whose body translates, with `values`, each byte slice it takes + /// as its parts split into them. + pub fn direct_call( + &mut self, + instance: Instance<'tcx>, + values: Vec, + span: Span, + out: &mut Vec, + ) -> Expr { + let parted = self.t.parted(instance); + let values = match parted.is_empty() { + true => values, + false => self.slice_args(values, &parted, out), + }; + Expr::Sym(self.t.callee(instance, span)).call(values) + } + /// `values`, with each byte slice `parted` marks as its `data`, `start`, and `length`, /// evaluated in the order `values` are: a slice made in place gives its parts, and a /// path or a tuple's part is read three times, but anything else is held first, after @@ -296,8 +322,9 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { if let Some(sym) = self.t.bound_fn(instance, span) { return Expr::Sym(sym); } - // One that takes byte slices as their parts is wrapped to take them whole. - if self.t.lowers(instance) && self.t.parted(instance).is_empty() { + // One that takes byte slices as their parts, or hands back its `Ok`'s, is wrapped + // to take and return them whole. + if self.t.lowers(instance) && self.t.parted(instance).is_empty() && self.t.slotted(instance).is_none() { return Expr::Sym(self.t.callee(instance, span)); } } diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 8a53b451a..0c47a4b9a 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -28,6 +28,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out: &mut Vec, ) { let tcx = self.tcx; + if self.forwards(dest) { + self.forward_call(args, span, out); + return; + } if let Some(local) = dest.as_local() && self.scalars.contains_key(&local) { @@ -201,7 +205,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// first, but for a `Copy` aggregate std `keeps`, copied unless moved out of a local's /// own value, which the analysis then made the local's own. Each argument `pointees` /// marks is what an `rt.Place` it is reads, as std's mappings take a `&mut` parameter. - fn operands( + pub(super) fn operands( &mut self, translated: bool, pointees: &[bool], diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 3cf05fd32..4871fb244 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -30,6 +30,7 @@ use rustc_span::{Span, Spanned}; use self::cfg::Exit; pub use self::place::{made_slice, slice_member}; +pub use self::scalar::Slotted; use super::Translator; use super::body::Body; @@ -47,8 +48,10 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> } let ret_ty = mir.return_ty(); let parted = t.parted(instance); + let slotted = t.slotted(instance); let mut b = Body::new(t, instance.args); b.parted = parted; + b.slotted = slotted.clone(); let mut fx = Fx::new(&mut b, &mir, Env::Plain, span); let mut params = fx.params(); let body = fx.lower(); @@ -58,6 +61,10 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> (true, ty::Adt(_, args)) => { Type::Union(vec![fx.b.t.ty(args.type_at(0), ret_span), Type::Rt("Done", Vec::new())]) } + // The error, or `undefined` once the `Ok`'s parts are in the slot. + (_, ty::Adt(_, args)) if slotted.is_some() => { + Type::Union(vec![fx.b.t.ty(args.type_at(1), ret_span), Type::Builtin("undefined")]) + } _ => fx.b.t.ret_ty(ret_ty, ret_span), }; Some(ts::Function { @@ -316,6 +323,12 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { rebuilt: Vec<(Local, String, [String; 3])>, /// The names of the parameters that are parts. part_params: Vec, + /// Where this function hands back its `Ok`'s parts, if it does. + slot: Option>, + /// The calls, by block, of functions that hand back theirs. + slotted_calls: FxHashMap, Slotted<'tcx>)>, + /// The assignments of the result that return right where they are. + returning: FxHashSet, /// The tests and payload reads TypeScript may have narrowed stale. narrowing: decided::Narrowing<'tcx>, /// The statement or terminator being lowered. @@ -326,9 +339,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { pub fn new(b: &'m mut Body<'b, 'a, 'tcx>, mir: &'m mir::Body<'tcx>, env: Env, span: Span) -> Self { let tcx = b.t.tcx; let n = mir.local_decls.len(); - let parted = match env { - Env::Plain => std::mem::take(&mut b.parted), - _ => Vec::new(), + let (parted, slot) = match env { + Env::Plain => (std::mem::take(&mut b.parted), b.slotted.take()), + _ => (Vec::new(), None), }; let parted = mir .args_iter() @@ -390,6 +403,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { parted, rebuilt: Vec::new(), part_params: Vec::new(), + slot, + slotted_calls: FxHashMap::default(), + returning: FxHashSet::default(), narrowing, at: mir::START_BLOCK.start_location(), }; @@ -557,7 +573,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.find_stepped(); self.unborrow_passed(); self.find_halves(); + self.find_slotted_calls(); self.find_scalars(); + self.find_returning(); for local in mir.local_decls.indices() { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { @@ -2197,6 +2215,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { statement_index: i, }; self.statement(stmt, out); + if self.returning.contains(&self.at) { + self.flush(out); + return Exit::End; + } } } if let Some(&to) = self.redirect.get(&bb) { @@ -2433,6 +2455,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { TerminatorKind::FalseEdge { real_target, .. } | TerminatorKind::FalseUnwind { real_target, .. } => { Exit::Goto(real_target.as_usize()) } + TerminatorKind::Return if let Some(slot) = self.slot.clone() => { + self.slot_return(&slot, span, out); + self.flush(out); + Exit::End + } TerminatorKind::Return if !self.mir.local_decls[mir::RETURN_PLACE].ty.is_never() => { let ret = self.mir.local_decls[mir::RETURN_PLACE].ty; let value = match self.zero_sized(ret) { @@ -2506,6 +2533,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } => { self.call(func, args, *destination, *fn_span, out); match target { + Some(_) if self.returning.contains(&self.at) => { + self.flush(out); + Exit::End + } Some(target) => Exit::Goto(target.as_usize()), None => { self.flush(out); diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 03623c837..7dc1e3404 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -7,7 +7,8 @@ //! other read makes the object there. A local whose object would be made more than once //! on a path, or in a loop that doesn't make its parts again, stays an object, so //! nothing is made more often than before, as does one only ever assigned an object's -//! parts, which saves none. +//! parts, which saves none. A function that hands back a `Result` in a slot holds its +//! result so, to write the `Ok`'s parts there, and its callers read them back as parts. use rustc_abi::VariantIdx; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -26,7 +27,7 @@ use crate::ts::{Expr, Key, Stmt, StmtKind, Type}; /// How a local held as its parts lays them out. #[derive(Clone, Debug)] -pub(super) enum Shape<'tcx> { +pub enum Shape<'tcx> { /// No JS value: `()`. Unit, /// One JS value, held whole: a number, a reference to one, or an error. @@ -181,42 +182,275 @@ fn uninhabited(ty: Ty<'_>) -> bool { } impl<'tcx> crate::lower::Translator<'_, 'tcx> { - /// Which of `instance`'s parameters it takes as a byte slice's parts, its `data`, - /// `start`, and `length`, rather than an `rt.ByteSlice`: each `&[u8]` or `&[u8; N]` of a - /// function only translated code calls directly, so not a root, a closure, or an - /// `async fn`. Empty if none. - pub(crate) fn parted(&self, instance: ty::Instance<'tcx>) -> Vec { + /// The item of `instance` if only translated code calls it directly, so it can take + /// and return what the outside can't: not a root, a closure, an `async fn`, or the + /// crate's own `next`, and not in a census, which writes nothing. + fn inside(&self, instance: ty::Instance<'tcx>) -> Option { let tcx = self.tcx; let ty::InstanceKind::Item(did) = instance.def else { - return Vec::new(); + return None; }; - // A census writes nothing, and the outside passes a root's arguments whole. - if self.census + let outside = self.census || self.roots.contains(&instance) || !self.lowers(instance) || tcx.is_closure_like(did) || tcx.asyncness(did).is_async() - || crate::lower::iter::is_next(tcx, did) - { - return Vec::new(); - } + || crate::lower::iter::is_next(tcx, did); + (!outside).then_some(did) + } + + /// `instance`'s parameter types, then its result's, their regions erased and their + /// types normalized. + fn inside_sig(&self, did: rustc_hir::def_id::DefId, instance: ty::Instance<'tcx>) -> (Vec>, Ty<'tcx>) { + let tcx = self.tcx; let sig = tcx.fn_sig(did).instantiate(tcx, instance.args).skip_norm_wip(); - let parted: Vec = tcx - .instantiate_bound_regions_with_erased(sig) - .inputs() - .iter() - .map(|&ty| { - let ty = tcx - .try_normalize_erasing_regions(self.typing_env_pub(), ty::Unnormalized::new_wip(ty)) - .unwrap_or(ty); - slice_ref(ty) - }) - .collect(); + let sig = tcx.instantiate_bound_regions_with_erased(sig); + let normalize = |ty: Ty<'tcx>| { + tcx.try_normalize_erasing_regions(self.typing_env_pub(), ty::Unnormalized::new_wip(ty)) + .unwrap_or(ty) + }; + ( + sig.inputs().iter().map(|&ty| normalize(ty)).collect(), + normalize(sig.output()), + ) + } + + /// Which of `instance`'s parameters it takes as a byte slice's parts, its `data`, + /// `start`, and `length`, rather than an `rt.ByteSlice`: each `&[u8]` or `&[u8; N]` of a + /// function only translated code calls directly. Empty if none. + pub(crate) fn parted(&self, instance: ty::Instance<'tcx>) -> Vec { + let Some(did) = self.inside(instance) else { + return Vec::new(); + }; + let parted: Vec = self.inside_sig(did, instance).0.into_iter().map(slice_ref).collect(); match parted.contains(&true) { true => parted, false => Vec::new(), } } + + /// Where `instance` hands back its `Ok`'s parts, if it does: a function of the crate's + /// that only translated code calls directly, and that returns a `Result` of byte slices and scalars, such as + /// `Result<(u64, &[u8]), E>`, returns its error or `undefined`, and writes the `Ok`'s + /// parts into a module-level slot its caller reads at once. Its error must be one value + /// that is never `undefined`. + pub(crate) fn slotted(&mut self, instance: ty::Instance<'tcx>) -> Option> { + if let Some(slotted) = self.slotted.get(&instance) { + return slotted.clone(); + } + let slotted = self.find_slot(instance); + self.slotted.insert(instance, slotted.clone()); + slotted + } + + fn find_slot(&mut self, instance: ty::Instance<'tcx>) -> Option> { + let did = self.inside(instance)?; + // Std's are small, and their callers take the result apart as they are. + if !self.crates.translates(did) { + return None; + } + let ret = self.inside_sig(did, instance).1; + let ty::Adt(adt, args) = ret.kind() else { + return None; + }; + if Std::of(self.tcx, adt.did()) != Some(Std::Result) || self.drops(ret) { + return None; + } + let (ok, err) = (args.type_at(0), args.type_at(1)); + if uninhabited(ok) || uninhabited(err) || matches!(err.kind(), ty::FnDef(..)) { + return None; + } + let shape = self.shape(ok)?; + let erased = self.erases_to(err); + if !shape.has_slice() + || shape.has_enum() + || !matches!(self.shape(err), Some(Shape::Leaf(_))) + || erased.undefined + || erased.none + || erased.param + || erased.pending + || erased.outer_pending + { + return None; + } + let mut parts = Vec::new(); + shape.parts("", &mut parts); + let fields: Vec = parts.iter().map(|(suffix, _)| format!("p{suffix}")).collect(); + let sym = match self.slots.get(&ok) { + Some(&sym) => sym, + None => self.slot(ok, instance, &parts, &fields), + }; + self.place_slot(sym, instance); + Some(Slotted { + sym, + ret, + err, + ok: shape, + fields, + }) + } + + /// The slot of `Ok` payloads of type `ok`, which every function returning one shares: + /// each of `fields` starts `undefined`, so V8 keeps it tagged rather than boxing every + /// number past 2^31 that a function too big to inline writes. + fn slot( + &mut self, + ok: Ty<'tcx>, + instance: ty::Instance<'tcx>, + parts: &[(String, Part<'tcx>)], + fields: &[String], + ) -> crate::ts::SymId { + let span = self.tcx.def_span(instance.def_id()); + let sym = self.program.sym(crate::program::Symbol { + module: Vec::new(), + base: String::new(), + suffix: String::new(), + owner: None, + kind: crate::program::SymKind::Const, + order: u32::MAX, + instance: String::new(), + name: String::new(), + alias: None, + }); + let tys: Vec = parts.iter().map(|(_, part)| self.part_ty(*part, span)).collect(); + let never = Expr::As(Box::new(Expr::undefined()), Type::Builtin("never")); + self.program.items.push(crate::ts::Item::Const { + sym, + ty: Type::Object(fields.iter().cloned().zip(tys).collect()), + init: Expr::Object( + fields + .iter() + .map(|field| (Key::Name(field.clone()), never.clone())) + .collect(), + ), + }); + self.slots.insert(ok, sym); + sym + } + + /// Put the slot `sym` beside `instance`, named for it, if it comes first in the source + /// of the functions that share it, whatever order translation reaches them in. + fn place_slot(&mut self, sym: crate::ts::SymId, instance: ty::Instance<'tcx>) { + let owner = self.instance(instance); + let (order, module) = (self.program.syms[owner].order, self.program.syms[owner].module.clone()); + let slot = &self.program.syms[sym]; + if !slot.base.is_empty() && (order, &module) >= (slot.order, &slot.module) { + return; + } + let base = format!( + "{}Out", + crate::lower::camel(self.tcx.item_name(instance.def_id()).as_str()) + ); + let slot = &mut self.program.syms[sym]; + (slot.order, slot.module, slot.base) = (order, module, base); + } + + /// The type of a variable or field that holds `part`. + fn part_ty(&mut self, part: Part<'tcx>, span: Span) -> Type { + match part { + Part::Flag => Type::Builtin("boolean"), + Part::Data => Type::Builtin("Uint8Array"), + Part::Number => Type::Builtin("number"), + Part::Value(ty) => self.held_ty(ty, span), + } + } + + /// How a local of `ty` is laid out as its parts, if it can be. + pub(crate) fn shape(&self, ty: Ty<'tcx>) -> Option> { + let tcx = self.tcx; + match ty.kind() { + _ if slice_ref(ty) => Some(Shape::Slice), + ty::Tuple(tys) if tys.is_empty() => Some(Shape::Unit), + ty::Tuple(tys) => { + let fields = tys.iter().map(|t| self.shape(t)).collect::>>()?; + Some(Shape::Tuple(ty, fields)) + } + ty::Adt(adt, args) + if matches!( + Std::of(tcx, adt.did()), + Some(Std::Option | Std::Result | Std::ControlFlow) + ) => + { + let variant = |v: usize| -> Option>>> { + let tys: Vec> = adt + .variant(VariantIdx::from_usize(v)) + .fields + .iter() + .map(|f| f.ty(tcx, args).skip_norm_wip()) + .collect(); + if tys.iter().any(|t| uninhabited(*t)) { + return Some(None); + } + Some(Some( + tys.into_iter().map(|t| self.shape(t)).collect::>>()?, + )) + }; + Some(Shape::Enum(ty, [variant(0)?, variant(1)?])) + } + ty::Ref(_, _, rustc_ast::Mutability::Mut) | ty::RawPtr(..) => None, + _ if self.needs_copy(ty) => None, + _ => Some(Shape::Leaf(ty)), + } + } +} + +/// Where a function hands back its `Ok`'s parts: the module-level slot it writes them +/// into, and their layout. +#[derive(Clone, Debug)] +pub struct Slotted<'tcx> { + pub sym: crate::ts::SymId, + /// The `Result` the function returns in Rust. + pub ret: Ty<'tcx>, + /// Its error type. + pub err: Ty<'tcx>, + /// The `Ok` payload's layout, which has no enum. + pub ok: Shape<'tcx>, + /// Each part's field in the slot, in order. + pub fields: Vec, +} + +impl<'tcx> Slotted<'tcx> { + /// The slot's field `i`, read or written. + pub fn field(&self, i: usize) -> Expr { + Expr::Sym(self.sym).member(self.fields[i].clone()) + } + + /// What a caller that keeps the result whole makes of what the call returned, `err` + /// (a name), read at once: the `Ok` of the slot's parts, or the `Err`. + pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, err: &str, span: Span) -> Expr { + let parts: Vec = (0..self.fields.len()).map(|i| self.field(i)).collect(); + let ok = build_plain(t, &self.ok, &parts, span); + let err_ty = t.ty(self.err, span); + Expr::Cond( + Box::new(Expr::ident(err).binary("===", Expr::undefined())), + Box::new(Expr::rt("Ok", vec![ok])), + Box::new(Expr::rt("Err", vec![Expr::As(Box::new(Expr::ident(err)), err_ty)])), + ) + } +} + +/// The value of `shape`, which has no enum, its `parts` make. +fn build_plain<'tcx>( + t: &mut crate::lower::Translator<'_, 'tcx>, + shape: &Shape<'tcx>, + parts: &[Expr], + span: Span, +) -> Expr { + match shape { + Shape::Unit => Expr::undefined(), + Shape::Leaf(_) => parts[0].clone(), + Shape::Slice => Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.to_vec()), + Shape::Tuple(ty, fields) => { + let mut at = 0; + let mut items = Vec::with_capacity(fields.len()); + for field in fields { + items.push(build_plain(t, field, &parts[at..at + field.size()], span)); + at += field.size(); + } + Expr::As(Box::new(Expr::Array(items)), t.ty(*ty, span)) + } + Shape::Enum(..) => unreachable!("a slot's payload has no enum"), + } } /// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rt.ByteSlice`. @@ -298,9 +532,15 @@ fn walk<'s, 'tcx>(shape: &'s Shape<'tcx>, elems: &[PlaceElem<'tcx>]) -> (Node<'s enum Producer { SplitFirst, SplitFirstChunk(u64), - SplitAt { checked: bool }, + SplitAt { + checked: bool, + }, OkOr, Branch, + /// `?`'s `Err` of a `Result`'s residual, its error converted. + FromResidual, + /// A function that hands back its `Ok`'s parts in its slot. + Slotted, } /// A part of a local, by index, and the part of another held local it copies, if any. @@ -316,52 +556,24 @@ struct Made { impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// How a local of `ty` is laid out as its parts, if it can be. fn shape(&self, ty: Ty<'tcx>) -> Option> { - let tcx = self.tcx; - match ty.kind() { - _ if slice_ref(ty) => Some(Shape::Slice), - ty::Tuple(tys) if tys.is_empty() => Some(Shape::Unit), - ty::Tuple(tys) => { - let fields = tys.iter().map(|t| self.shape(t)).collect::>>()?; - Some(Shape::Tuple(ty, fields)) - } - ty::Adt(adt, args) - if matches!( - Std::of(tcx, adt.did()), - Some(Std::Option | Std::Result | Std::ControlFlow) - ) => - { - let variant = |v: usize| -> Option>>> { - let tys: Vec> = adt - .variant(VariantIdx::from_usize(v)) - .fields - .iter() - .map(|f| f.ty(tcx, args).skip_norm_wip()) - .collect(); - if tys.iter().any(|t| uninhabited(*t)) { - return Some(None); - } - Some(Some( - tys.into_iter().map(|t| self.shape(t)).collect::>>()?, - )) - }; - Some(Shape::Enum(ty, [variant(0)?, variant(1)?])) - } - ty::Ref(_, _, rustc_ast::Mutability::Mut) | ty::RawPtr(..) => None, - _ if self.b.t.needs_copy(ty) => None, - _ => Some(Shape::Leaf(ty)), - } + self.b.t.shape(ty) } - /// The std call `func` makes into a local of `shape`, if its parts can be made from - /// its arguments': a split of bytes, `ok_or` of an `Option`, or `?` on a `Result` or - /// `Option`, each of a local held as its parts. + /// The call `func`, ending `block`, makes into a local of `shape`, if its parts can be + /// made from its arguments': a split of bytes, `ok_or` of an `Option`, or `?` on a + /// `Result` or `Option`, each of a local held as its parts, or the `Err` that `?` + /// returns; or from a slot. fn producer( &self, + block: BasicBlock, func: &Operand<'tcx>, args: &[Spanned>], shape: &Shape<'tcx>, shapes: &FxHashMap>, ) -> Option { + if self.slotted_calls.contains_key(&block) { + return Some(Producer::Slotted); + } let tcx = self.tcx; let ty::FnDef(def_id, gargs) = *func.ty(&self.mir.local_decls, tcx).kind() else { return None; @@ -406,6 +618,15 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { { Some(Producer::Branch) } + ("FromResidual", "from_residual") + if matches!(shape, Shape::Enum(ty, [Some(_), Some(_)]) if self.b.t.std_of(*ty) == Some(Std::Result)) + && gargs + .types() + .nth(1) + .is_some_and(|t| self.b.t.std_of(t) == Some(Std::Result)) => + { + Some(Producer::FromResidual) + } _ => None, } } @@ -510,6 +731,20 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } + /// Find the calls of functions that hand back their `Ok`'s parts in a slot. + pub(super) fn find_slotted_calls(&mut self) { + for (bb, data) in self.mir.basic_blocks.iter_enumerated() { + if let TerminatorKind::Call { func, .. } = &data.terminator().kind + && let ty::FnDef(def_id, args) = *func.ty(&self.mir.local_decls, self.tcx).kind() + && let Ok(Some(instance)) = + ty::Instance::try_resolve(self.tcx, self.b.t.typing_env_pub(), def_id, args.skip_binder()) + && let Some(slotted) = self.b.t.slotted(instance) + { + self.slotted_calls.insert(bb, (instance, slotted)); + } + } + } + /// Which arguments a call of `func` takes as a byte slice's parts, as /// [`Translator::parted`](crate::lower::Translator::parted) says. pub(super) fn parted_call(&self, func: &Operand<'tcx>) -> Vec { @@ -566,7 +801,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { for local in mir.local_decls.indices() { let parted = self.parted.contains(&local); if self.is_arg(local) && !parted - || local == mir::RETURN_PLACE + || local == mir::RETURN_PLACE && self.slot.is_none() || self.defs[local] == 0 && !parted || self.borrowed[local] || self.stepped.contains(&local) @@ -681,7 +916,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { if let Some(local) = destination.as_local().filter(|l| shapes.contains_key(l)) { def_blocks.entry(local).or_default().insert(bb); taken.insert(at); - match self.producer(func, args, &shapes[&local], shapes) { + match self.producer(bb, func, args, &shapes[&local], shapes) { Some(producer) => { parted.insert(local); let size = shapes[&local].size(); @@ -715,12 +950,13 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } - // Held as the parts of the one object it is, a local saves nothing; a parameter - // passed as its parts is made on entry. + // Held as the parts of the one object it is, a local saves nothing, but for the + // result, whose parts go to the slot; a parameter passed as its parts is made on + // entry. bad.extend( shapes .keys() - .filter(|l| !parted.contains(l) && !self.parted.contains(l)), + .filter(|&&l| !parted.contains(&l) && !self.parted.contains(&l) && l != mir::RETURN_PLACE), ); for &local in shapes.keys().filter(|l| self.parted.contains(l)) { copies.extend((0..3).map(|part| (local, part, None))); @@ -921,7 +1157,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { }; let (node, _) = walk(shapes.get(&p.local)?, p.projection); match producer { - Producer::SplitFirst | Producer::SplitFirstChunk(_) | Producer::SplitAt { .. } => None, + Producer::SplitFirst + | Producer::SplitFirstChunk(_) + | Producer::SplitAt { .. } + | Producer::FromResidual + | Producer::Slotted => None, // The `Option`'s flag, then its value, then the error. Producer::OkOr => (part >= 1 && part < node.shape.size()).then_some((p.local, node.at + part)), Producer::Branch => { @@ -1031,12 +1271,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.scalars[&local].shape.parts("", &mut parts); let vars = self.scalars[&local].vars.clone(); for ((_, part), name) in parts.into_iter().zip(vars) { - let ty = match part { - Part::Flag => Type::Builtin("boolean"), - Part::Data => Type::Builtin("Uint8Array"), - Part::Number => Type::Builtin("number"), - Part::Value(ty) => self.b.t.held_ty(ty, span), - }; + let ty = self.b.t.part_ty(part, span); out.push(StmtKind::Declare { name, ty }.at(None)); } } @@ -1168,7 +1403,16 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { Rvalue::Aggregate(kind, ops) => self.scalar_aggregate(&shape, kind, ops, span, out), _ => unreachable!("checked by find_scalars"), }; - self.set_scalar(local, parts, out); + self.set_or_return(local, parts, span, out); + } + + /// Set `local`'s parts to `parts`, or return them, if this assigns the result right + /// before a return. + fn set_or_return(&mut self, local: Local, parts: Vec>, span: Span, out: &mut Vec) { + match local == mir::RETURN_PLACE && self.returning.contains(&self.at) { + true => self.slot_return_parts(parts.into_iter().map(|p| p.map(|(e, _)| e)).collect(), span, out), + false => self.set_scalar(local, parts, out), + } } /// Assign `local`, held as its parts, the result of the std call `func`. @@ -1182,7 +1426,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) { let shapes: FxHashMap> = self.scalars.iter().map(|(l, s)| (*l, s.shape.clone())).collect(); let producer = self - .producer(func, args, &shapes[&local], &shapes) + .producer(self.at.block, func, args, &shapes[&local], &shapes) .expect("checked by find_scalars"); let shape = shapes[&local].clone(); let pure = |e: Expr, steady: bool| Some((e, steady)); @@ -1262,6 +1506,60 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { parts.extend(err.into_iter().map(Some)); parts } + Producer::Slotted => self.slotted_call(local, args, span, out), + // The `Err` of the residual's error, converted. + Producer::FromResidual => { + let residual = args[0].node.ty(&self.mir.local_decls, self.tcx); + let (ty::Adt(_, from), Shape::Enum(ty, _)) = (residual.kind(), &shape) else { + unreachable!("checked by producer") + }; + let ty::Adt(_, to) = ty.kind() else { + unreachable!("a `Result` is an ADT") + }; + let (from, to) = (from.type_at(1), to.type_at(1)); + let error = match &args[0].node { + Operand::Copy(p) | Operand::Move(p) if self.scalar_enum(*p) => { + self.held_arg(&args[0].node, span, out).remove(0).0 + } + op => match self.operand(op, span, out) { + // Held back, and read here, where folding it would read it. + Expr::Ident(name) + if let Some(i) = self.pending.iter().position(|p| p.name == name) + && let p = &self.pending[i] + && !p.effect + && !p.copy + && let Expr::Call(f, items) = &p.value + && matches!(&**f, Expr::Rt(n) if n == "Err") + && items.len() == 1 => + { + let Expr::Call(_, mut items) = self.pending.remove(i).value else { + unreachable!("checked above") + }; + items.pop().expect("checked above") + } + // Made in place: its error. + Expr::Call(f, mut items) if matches!(&*f, Expr::Rt(n) if n == "Err") && items.len() == 1 => { + items.pop().expect("checked above") + } + value => { + let value = self.path(value, "residual", out); + // The residual is an `Err`. + let err = Type::Object(vec![ + ("ok".into(), Type::Builtin("false")), + ("error".into(), self.b.t.ty(from, span)), + ]); + Expr::As(Box::new(value), err).member("error") + } + }, + }; + let mut pre = Vec::new(); + let error = self.b.convert(error, from, to, span, &mut pre); + self.emit(pre, None, false, out); + let mut parts = vec![None; shape.size()]; + parts[0] = Some((Expr::lit("true"), true)); + *parts.last_mut().expect("an error") = Some(self.leaf(error)); + parts + } // The parts of what it was applied to, whose `Some` continues, where the flag is // whether it breaks. Producer::Branch => { @@ -1275,7 +1573,204 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { parts } }; - self.set_scalar(local, parts, out); + self.set_or_return(local, parts, span, out); + } + + /// The parts of what a function that hands back its `Ok`'s parts returns into `local`: + /// whether it is an error, then the slot's fields, read now before anything else can + /// write them, then the error. + fn slotted_call( + &mut self, + local: Local, + args: &[Spanned>], + span: Span, + out: &mut Vec, + ) -> Vec> { + let slotted = self.slotted_calls[&self.at.block].1.clone(); + let call = self.slotted_raw(local, args, span, out); + let err = self.b.fresh("err"); + let err_ty = self.b.t.ty(slotted.err, span); + self.steady.insert(err.clone()); + self.scalar_binds.push(( + err.clone(), + Type::Union(vec![err_ty.clone(), Type::Builtin("undefined")]), + )); + let stmt = StmtKind::Expr(Expr::ident(&err).assign(call)).at(None); + self.emit(vec![stmt], Some(&err), false, out); + let mut parts = vec![Some((Expr::ident(&err).binary("!==", Expr::undefined()), true))]; + let mut kinds = Vec::new(); + slotted.ok.parts("", &mut kinds); + for (i, (_, part)) in kinds.into_iter().enumerate() { + let ty = self.b.t.part_ty(part, span); + parts.push(Some(self.steady_value(slotted.field(i), "part", ty, out))); + } + parts.push(Some((Expr::As(Box::new(Expr::ident(&err)), err_ty), true))); + parts + } + + /// The call, ending the block being lowered, of a function that hands back its `Ok`'s + /// parts, into `local`: what it returns, its error or `undefined`. + fn slotted_raw(&mut self, local: Local, args: &[Spanned>], span: Span, out: &mut Vec) -> Expr { + let instance = self.slotted_calls[&self.at.block].0; + let result = self.mir.local_decls[local].ty; + let values = self.operands(true, &[], args, result, span, out); + let values = values.into_iter().map(Expr::typed).collect(); + let mut pre = Vec::new(); + let call = self.b.direct_call(instance, values, span, &mut pre); + self.emit(pre, None, false, out); + match self.b.t.loc(span) { + Some(loc) => Expr::Located(loc, Box::new(call)), + None => call, + } + } + + /// Whether the call ending the block being lowered returns what it returns as is, as a + /// function's result right before a return, through the same slot. + pub(super) fn forwards(&self, dest: Place<'tcx>) -> bool { + dest.as_local() == Some(mir::RETURN_PLACE) + && self.returning.contains(&self.at) + && (self.slotted_calls.get(&self.at.block).zip(self.slot.as_ref())) + .is_some_and(|((_, callee), slot)| callee.sym == slot.sym) + } + + /// Return what the call ending the block being lowered returns, its `Ok`'s parts left + /// in the slot it shares. + pub(super) fn forward_call(&mut self, args: &[Spanned>], span: Span, out: &mut Vec) { + let call = self.slotted_raw(mir::RETURN_PLACE, args, span, out); + let loc = self.b.t.loc(span); + self.emit(vec![StmtKind::Return(Some(call)).at(loc)], None, false, out); + } + + /// The assignments of the result, a statement's or a call's, after which nothing runs + /// before a return: each returns there, and its block ends. Those that only make the + /// result's parts can if it is held as them, and a call that forwards the slot always. + pub(super) fn find_returning(&mut self) { + if self.slot.is_none() { + return; + } + let held = self.scalars.contains_key(&mir::RETURN_PLACE); + let mir = self.mir; + for (bb, data) in mir.basic_blocks.iter_enumerated() { + if data.is_cleanup { + continue; + } + let n = data.statements.len(); + let def = match &data.terminator().kind { + TerminatorKind::Call { + destination, + target: Some(target), + .. + } if destination.as_local() == Some(mir::RETURN_PLACE) => { + let forwards = (self.slotted_calls.get(&bb).zip(self.slot.as_ref())) + .is_some_and(|((_, callee), slot)| callee.sym == slot.sym); + ((held || forwards) && self.reaches_return(*target)).then_some(n) + } + TerminatorKind::Goto { .. } | TerminatorKind::Return if held => (0..n) + .rev() + .find(|&i| !self.idle(bb, i)) + .filter( + |&i| matches!(&data.statements[i].kind, StatementKind::Assign(a) if a.0.as_local() == Some(mir::RETURN_PLACE)), + ) + .filter(|_| match data.terminator().kind { + TerminatorKind::Goto { target, .. } => self.reaches_return(target), + _ => true, + }), + _ => None, + }; + if let Some(i) = def { + self.returning.insert(Location { + block: bb, + statement_index: i, + }); + } + } + } + + /// Whether statement `i` of `bb` does nothing. + fn idle(&self, bb: BasicBlock, i: usize) -> bool { + matches!( + self.mir.basic_blocks[bb].statements[i].kind, + StatementKind::StorageDead(_) | StatementKind::StorageLive(_) | StatementKind::Nop + ) || self.noops.contains(&(bb, i)) + } + + /// Whether `bb` returns, through blocks that do nothing but go on. + fn reaches_return(&self, mut bb: BasicBlock) -> bool { + let mut seen = FxHashSet::default(); + while seen.insert(bb) { + let data = &self.mir.basic_blocks[bb]; + if data.is_cleanup || !(0..data.statements.len()).all(|i| self.idle(bb, i)) { + return false; + } + match data.terminator().kind { + TerminatorKind::Return => return true, + TerminatorKind::Goto { target, .. } => bb = target, + _ => return false, + } + } + false + } + + /// Return from a function that hands back its `Ok`'s parts, at a `Return`. + pub(super) fn slot_return(&mut self, slot: &Slotted<'tcx>, span: Span, out: &mut Vec) { + let n = slot.fields.len(); + if self.scalars.contains_key(&mir::RETURN_PLACE) { + let parts = (self.scalar_parts(mir::RETURN_PLACE, 0..n + 2, span).into_iter()) + .map(|(e, _)| Some(e)) + .collect(); + return self.slot_return_parts(parts, span, out); + } + // A result made whole, as another call returns it, taken apart here. + let loc = self.b.t.loc(span); + let mut pre = Vec::new(); + let value = self.place_expr(Place::return_place(), span, &mut pre); + self.emit(pre, None, false, out); + let ty = self.b.t.ty(slot.ret, span); + let (result, _) = self.steady_value(value, "result", ty, out); + let check = StmtKind::If { + cond: result.clone().member("ok").not(), + then: vec![StmtKind::Return(Some(result.clone().member("error"))).at(loc)], + els: Vec::new(), + }; + self.emit(vec![check.at(None)], None, false, out); + let parts = self.take_apart(result.member("value"), &slot.ok, span, out); + self.slot_write(slot, parts.into_iter().map(|(e, _)| Some(e)).collect(), span, out); + } + + /// Return the result's `parts`: its error, if the flag says it is one, or else + /// `undefined` once the `Ok`'s parts are in the slot. + fn slot_return_parts(&mut self, parts: Vec>, span: Span, out: &mut Vec) { + let slot = self.slot.clone().expect("a function with a slot"); + let loc = self.b.t.loc(span); + let n = slot.fields.len(); + let flag = parts[0].clone().expect("a result's flag"); + let err = parts[n + 1].clone().unwrap_or_else(Expr::undefined); + match &flag { + Expr::Lit(t) if t == "false" => {} + Expr::Lit(t) if t == "true" => { + self.emit(vec![StmtKind::Return(Some(err)).at(loc)], None, false, out); + return; + } + _ => { + let check = StmtKind::If { + cond: flag, + then: vec![StmtKind::Return(Some(err)).at(loc)], + els: Vec::new(), + }; + self.emit(vec![check.at(None)], None, false, out); + } + } + self.slot_write(&slot, parts[1..=n].to_vec(), span, out); + } + + /// Write the `Ok`'s parts `ok` into the slot, and return `undefined`. + fn slot_write(&mut self, slot: &Slotted<'tcx>, ok: Vec>, span: Span, out: &mut Vec) { + let loc = self.b.t.loc(span); + let mut stmts: Vec = (ok.into_iter().enumerate()) + .map(|(i, part)| StmtKind::Expr(slot.field(i).assign(part.unwrap_or_else(Expr::undefined))).at(None)) + .collect(); + stmts.push(StmtKind::Return(Some(Expr::undefined())).at(loc)); + self.emit(stmts, None, false, out); } /// The parts of `op`, a local held as its parts read whole, as `ok_or` and `?` take it. diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 6b9aff4b8..1f3376734 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -223,6 +223,10 @@ pub struct Translator<'a, 'tcx> { bindings: bind::Bindings<'tcx>, /// The instances the config's roots name, which the outside calls. roots: rustc_data_structures::fx::FxHashSet>, + /// Where each instance hands back its `Ok`'s parts, if it does, by [`Self::slotted`]. + slotted: rustc_data_structures::fx::FxHashMap, Option>>, + /// The slot of each `Ok` payload type, which every function returning one shares. + slots: rustc_data_structures::fx::FxHashMap, SymId>, } /// The crates that translate as one program: the package, and every crate it depends on @@ -396,6 +400,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { site: None, bindings: Default::default(), roots: Default::default(), + slotted: Default::default(), + slots: Default::default(), }) } diff --git a/ts/src/print.rs b/ts/src/print.rs index 92c25a6c2..f49416899 100644 --- a/ts/src/print.rs +++ b/ts/src/print.rs @@ -259,6 +259,10 @@ impl Refs { } } Item::Function(f) => self.function(program, f), + Item::Const { ty, init, .. } => { + self.ty(program, ty); + self.expr(program, init); + } } } @@ -574,6 +578,14 @@ impl Printer<'_> { } } Item::Function(f) => self.function(f, true), + Item::Const { sym, ty, init } => { + let name = self.program.syms[*sym].name.clone(); + let ty = self.ty(ty); + self.start(); + self.write(&format!("export const {name}: {ty} = ")); + self.expr(init, 0); + self.write(";\n"); + } } } diff --git a/ts/src/program.rs b/ts/src/program.rs index 75f989708..d3dabd718 100644 --- a/ts/src/program.rs +++ b/ts/src/program.rs @@ -68,6 +68,8 @@ pub enum SymKind { /// A class's method, called on its receiver: drop glue's `[Symbol.dispose]`, and a /// coroutine's `poll`. Method, + /// A module-level `const`. + Const, } #[derive(Debug)] @@ -363,7 +365,7 @@ pub(crate) fn unique(taken: &mut HashSet, base: &str) -> String { pub fn item_sym(item: &Item) -> SymId { match item { - Item::Struct { sym, .. } | Item::Union { sym, .. } => *sym, + Item::Struct { sym, .. } | Item::Union { sym, .. } | Item::Const { sym, .. } => *sym, Item::Function(f) => f.sym, } } diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 574dec5ba..3bf9e211d 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -473,4 +473,10 @@ pub enum Item { doc: Option, }, Function(Function), + /// A module-level `const`, such as where functions hand back a result's parts. + Const { + sym: SymId, + ty: Type, + init: Expr, + }, } diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 52a9ba022..b5e5cd656 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -255,7 +255,6 @@ fn shake(out: &Path) { "Ok", "Panic", "checked", - "idx", "max", "panic", "saturate", @@ -265,6 +264,7 @@ fn shake(out: &Path) { "usizeSub", // The translation's, and the caller. "new_", + "sliceOut", "run", "short", "slice", From 60159e62fffd28f06a03d1faa97067cf4fc44e0f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Thu, 29 Oct 2026 00:40:32 -0700 Subject: [PATCH 09/26] test(ts): refresh snapshots after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/counts.ts | 8 +- ts/fixtures/lang/expected/harness.ts | 70 ++++++------ ts/fixtures/lang/expected/refs.ts | 152 +++++++++++++++++++++++++-- ts/fixtures/lang/expected/returns.ts | 2 +- 4 files changed, 185 insertions(+), 47 deletions(-) diff --git a/ts/fixtures/lang/expected/counts.ts b/ts/fixtures/lang/expected/counts.ts index cf0479438..e68623ad7 100644 --- a/ts/fixtures/lang/expected/counts.ts +++ b/ts/fixtures/lang/expected/counts.ts @@ -159,13 +159,13 @@ export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, o * handles to itself; then kept, dropped, or dropped with a handle outside. Each puts what it read and what * dropped. */ -export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cyclicArcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let node!: rt.Arc; let _95: boolean = false; const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const kept: rt.Arc[] = []; const outside: rt.Weak[] = []; - for (const op of rt.byteSliceView(data)) { + for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _15: rt.Arc> = rt.arcClone(log); _95 = true; const noisy: Noisy.Noisy = new Noisy.Noisy(op, _15); @@ -250,13 +250,13 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { * handles to itself; then kept, dropped, or dropped with a handle outside. Each puts what it read and what * dropped. */ -export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cyclicRcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let node!: rt.Arc; let _95: boolean = false; const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const kept: rt.Arc[] = []; const outside: rt.Weak[] = []; - for (const op of rt.byteSliceView(data)) { + for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _15: rt.Arc> = rt.arcClone(log); _95 = true; const noisy: Noisy.Noisy = new Noisy.Noisy(op, _15); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 8d5da01fb..7aeae3a4b 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -9,7 +9,7 @@ import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; import { hashMaps, sets, btreeMaps, deques, vecs, stores } from "./collections.ts"; import { combinators } from "./combinators.ts"; -import { arcs, rcs } from "./counts.ts"; +import { arcs, cyclicArcs, cyclicRcs, rcs } from "./counts.ts"; import { cows } from "./cows.ts"; import { defaults } from "./defaults.ts"; import { durations } from "./durations.ts"; @@ -64,45 +64,45 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return neg(a013, a113.data, a113.start, a113.length, a213); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::cast", (a014: rt.u8, a114: rt.ByteSlice, a214: rt.ByteVec): void => { return cast(a014, a114.data, a114.start, a114.length, a214); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::convert", (_225: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::convert", (_231: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void => { convert(data.data, data.start, data.length, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::copies", (_226: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::copies", (_232: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): void => { copies(data2.data, data2.start, data2.length, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::loops", (_227: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::loops", (_233: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): void => { loops(data3.data, data3.start, data3.length, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::patterns", (_228: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::patterns", (_234: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): void => { patterns(data4.data, data4.start, data4.length, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::closures", (_229: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::closures", (_235: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): void => { closures(data5.data, data5.start, data5.length, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::discriminants", (_230: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::discriminants", (_236: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): void => { discriminants(data6.data, data6.start, data6.length, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::library", (_231: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::library", (_237: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): void => { library(data7.data, data7.start, data7.length, out7); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::ints", (a015: rt.u8, a115: rt.ByteSlice, a215: rt.ByteVec): void => { return ints(a015, a115.data, a115.start, a115.length, a215); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::strings", (_232: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::strings", (_238: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): void => { strings(data8.data, data8.start, data8.length, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::derived", (_233: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::derived", (_239: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): void => { derived(data9.data, data9.start, data9.length, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::written", (_234: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::written", (_240: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): void => { written(data10.data, data10.start, data10.length, out10); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::panics", (a016: rt.u8, a116: rt.ByteSlice, a216: rt.ByteVec): void => { return panics(a016, a116.data, a116.start, a116.length, a216); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["generics::methods", (_235: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["generics::methods", (_241: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): void => { methods(data11.data, data11.start, data11.length, out11); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::adaptors", (a017: rt.u8, a117: rt.ByteSlice, a217: rt.ByteVec): void => { return adaptors(a017, a117.data, a117.start, a117.length, a217); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::consumers", (a018: rt.u8, a118: rt.ByteSlice, a218: rt.ByteVec): void => { return consumers(a018, a118.data, a118.start, a118.length, a218); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranges", (_236: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranges", (_242: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): void => { ranges(data12.data, data12.start, data12.length, out12); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::options", (_237: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::options", (_243: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): void => { options(data13.data, data13.start, data13.length, out13); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::own", (_238: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::own", (_244: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): void => { own(data14.data, data14.start, data14.length, out14); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::values", (_239: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::values", (_245: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): void => { values(data15.data, data15.start, data15.length, out15); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::order", (_240: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::order", (_246: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): void => { order(data16.data, data16.start, data16.length, out16); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::hash_maps", (a019: rt.u8, a119: rt.ByteSlice, a219: rt.ByteVec): void => { return hashMaps(a019, a119.data, a119.start, a119.length, a219); @@ -110,9 +110,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return sets(a020, a120.data, a120.start, a120.length, a220); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::btree_maps", (a021: rt.u8, a121: rt.ByteSlice, a221: rt.ByteVec): void => { return btreeMaps(a021, a121.data, a121.start, a121.length, a221); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::deques", (_241: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::deques", (_247: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): void => { deques(data17.data, data17.start, data17.length, out17); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::flows", (_242: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::flows", (_248: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): void => { flows(data18.data, data18.start, data18.length, out18); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::keys", (a022: rt.u8, a122: rt.ByteSlice, a222: rt.ByteVec): void => { return keys(a022, a122.data, a122.start, a122.length, a222); @@ -120,11 +120,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return chars(a023, a123.data, a123.start, a123.length, a223); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::strs", (a024: rt.u8, a124: rt.ByteSlice, a224: rt.ByteVec): void => { return strs(a024, a124.data, a124.start, a124.length, a224); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::vecs", (_243: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::vecs", (_249: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): void => { vecs(data19.data, data19.start, data19.length, out19); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::slices", (a025: rt.u8, a125: rt.ByteSlice, a225: rt.ByteVec): void => { return slices(a025, a125.data, a125.start, a125.length, a225); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::stores", (_244: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::stores", (_250: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): void => { stores(data20.data, data20.start, data20.length, out20); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["chunks::chunks", (a026: rt.u8, a126: rt.ByteSlice, a226: rt.ByteVec): void => { return chunks(a026, a126.data, a126.start, a126.length, a226); @@ -138,11 +138,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return splits(a030, a130.data, a130.start, a130.length, a230); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["nested::nested", (a031: rt.u8, a131: rt.ByteSlice, a231: rt.ByteVec): void => { return nested(a031, a131.data, a131.start, a131.length, a231); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["refs::refs", (_245: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["refs::refs", (_251: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): void => { refs(data21.data, data21.start, data21.length, out21); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_246: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_252: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { counts(data22.data, data22.start, data22.length, out22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_247: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_253: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { rounding(out23); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", (a032: rt.u8, a132: rt.ByteSlice, a232: rt.ByteVec): void => { return skips(a032, a132.data, a132.start, a132.length, a232); @@ -158,28 +158,32 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) return atomics(a037, a137.data, a137.start, a137.length, a237); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::overrides", (a038: rt.u8, a138: rt.ByteSlice, a238: rt.ByteVec): void => { return overrides(a038, a138.data, a138.start, a138.length, a238); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_248: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_254: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { dyns(data23.data, data23.start, data23.length, out24); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cells::cells", (a039: rt.u8, a139: rt.ByteSlice, a239: rt.ByteVec): void => { return cells(a039, a139.data, a139.start, a139.length, a239); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::shared", (_249: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::shared", (_255: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): void => { shared(data24.data, data24.start, data24.length, out25); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranked", (a040: rt.u8, a140: rt.ByteSlice, a240: rt.ByteVec): void => { return ranked(a040, a140.data, a140.start, a140.length, a240); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["captures::captures", (a041: rt.u8, a141: rt.ByteSlice, a241: rt.ByteVec): void => { return captures(a041, a141.data, a141.start, a141.length, a241); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::locks", (_250: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::locks", (_256: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): void => { locks(data25.data, data25.start, data25.length, out26); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::relock", (_251: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::relock", (_257: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): void => { relock(data26.data, data26.start, data26.length, out27); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["defaults::defaults", (_252: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["defaults::defaults", (_258: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): void => { defaults(data27.data, data27.start, data27.length, out28); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::arcs", (_253: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::arcs", (_259: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): void => { arcs(data28.data, data28.start, data28.length, out29); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::rcs", (_254: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::rcs", (_260: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): void => { rcs(data29.data, data29.start, data29.length, out30); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::anys", (_255: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): void => { - anys(data30.data, data30.start, data30.length, out31); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::cyclic_arcs", (_261: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): void => { + cyclicArcs(data30.data, data30.start, data30.length, out31); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::cyclic_rcs", (_262: rt.u8, data31: rt.ByteSlice, out32: rt.ByteVec): void => { + cyclicRcs(data31.data, data31.start, data31.length, out32); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::anys", (_263: rt.u8, data32: rt.ByteSlice, out33: rt.ByteVec): void => { + anys(data32.data, data32.start, data32.length, out33); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["args::args", (a042: rt.u8, a142: rt.ByteSlice, a242: rt.ByteVec): void => { return args(a042, a142.data, a142.start, a142.length, a242); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["returns::returns", (a043: rt.u8, a143: rt.ByteSlice, a243: rt.ByteVec): void => { diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 6feb0c78d..eb2bd8513 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -2,11 +2,12 @@ import * as rt from "./rt.ts"; import { copy$Option_u8_u8, copy$u32s } from "./lib.ts"; -import { thenSome$bool_u32 } from "./core/bool.ts"; -import { unwrapOr$Option_u32, unwrapOr$Option_u8, unwrapOr$Option_u8_u8, unwrapOrDefault$Option_String, map$Option_u8_u8_elements_closure8, map$Option_u8_u8_u8_elements_closure9, map$Option_u8_u8_u8_u8_lent_closure2, mapOr$Option_Option_u8_u8_refs_closure2_closure0, mapOr$Option_String_u8_refs_closure1, mapOr$Option_u32_u32_lent_closure4, mapOr$Option_u8_bool_take_largest_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, andThen$Option_u32_u32_lent_closure3, filter$Option_u8_u8_lent_closure1, or$Option_u8 } from "./core/option.ts"; +import { thenSome$bool_u32, then$bool_Vec_u8_restock_closure0 } from "./core/bool.ts"; +import { unwrapOr$Option_u32, unwrapOr$Option_u8, unwrapOr$Option_u8_u8, unwrapOrDefault$Option_String, unwrapOrDefault$Option_Vec_u8, map$Option_u8_u8_elements_closure8, map$Option_u8_u8_u8_elements_closure9, map$Option_u8_u8_u8_u8_lent_closure2, mapOr$Option_Option_u8_u8_refs_closure2_closure0, mapOr$Option_String_u8_refs_closure1, mapOr$Option_u32_u32_lent_closure4, mapOr$Option_u8_bool_take_largest_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, andThen$Option_u32_u32_lent_closure3, filter$Option_u8_u8_lent_closure1, or$Option_u8 } from "./core/option.ts"; import * as Counts from "./refs.Counts.ts"; import * as Cursor from "./refs.Cursor.ts"; import type * as Fetch from "./refs.Fetch.ts"; +import * as Listing from "./refs.Listing.ts"; import type * as Pair from "./refs.Pair.ts"; import type * as Pair2 from "./refs.Pair2.ts"; @@ -39,9 +40,9 @@ export function takeLargest(seen: rt.Place, next: rt.u8): rt. if (!(next === 0)) { return undefined; } - const taken = seen.v; + const taken_ = seen.v; seen.v = undefined; - return taken; + return taken_; } const old = seen.v; seen.v = next; @@ -59,13 +60,13 @@ export function rename(name: rt.Place, b: rt.u8): string | u /** A `&mut Option` passed on from inside a closure std calls. */ export function largestOf(seen: rt.Place, itemsData: Uint8Array, itemsStart: number, itemsLen: number): rt.u8 { - let taken: rt.u8 = 0; + let taken_: rt.u8 = 0; rt.iterForEach(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(itemsData, itemsStart, itemsLen))), (_2: rt.u8): void => { if (takeLargest(seen, _2) !== undefined) { - taken = rt.u8WrappingAdd(taken, 1); + taken_ = rt.u8WrappingAdd(taken_, 1); } }); - return taken; + return taken_; } /** moq-net's `&mut Box`: changed through, and replaced whole. */ @@ -106,9 +107,9 @@ export function refuse(f: rt.Place): void { export function pushTo(s: rt.Place, c: rt.char): void { s.v = s.v + String.fromCodePoint(c); if (c === 122) { - const taken = s.v; + const taken_ = s.v; s.v = ""; - const iter: rt.Iter = rt.iterTake(rt.strChars(taken), 2); + const iter: rt.Iter = rt.iterTake(rt.strChars(taken_), 2); while (true) { const _12: rt.char | rt.Done = iter.next(); if (_12 === rt.DONE) { @@ -482,9 +483,142 @@ export function lent(dataData: Uint8Array, dataStart: number, dataLen: number, o } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(unwrapOr$Option_u32(_154, 61166)))); } + defaulted(data.data, data.start, data.length, out); + taken(data.data, data.start, data.length, out); elements(data.data, data.start, data.length, out); } +/** Filled in place by its default, through a `&mut` and from a closure, then reset. */ +export function defaulted(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let listing: Listing.Listing | undefined = undefined; + for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + const _11: rt.u8 = rt.u8Rem(b, 5); + if (_11 === 0) { + listing = undefined; + } else if (_11 === 1) { + list(rt.place(() => listing, (value4) => listing = value4), b); + } else if (_11 === 2) { + const _16: rt.Place = rt.place(() => listing, (value3) => listing = value3); + if (_16.v === undefined) { + _16.v = Listing.default$Default(); + } + const _17: rt.u8 | undefined = unwrapOr$Option_u8((_16.v as Listing.Listing).source, b) ^ b; + (_16.v as Listing.Listing).source = _17; + } else if (_11 === 3) { + const _22: rt.Place = rt.place(() => listing, (value2) => listing = value2); + const relist: (a0: rt.u8) => void = (b2: rt.u8): void => { + if (_22.v === undefined) { + _22.v = Listing.default$Default(); + } + rt.byteVecPush((_22.v as Listing.Listing).listed, b2); + }; + relist(b); + relist(b ^ 1); + } else { + const _31: rt.Place = rt.place(() => listing, (value) => listing = value); + if (_31.v === undefined) { + _31.v = Listing.default$Default(); + } + (_31.v as Listing.Listing).source = undefined; + rt.byteVecPop((_31.v as Listing.Listing).listed); + } + } + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(listing, f, (value: Listing.Listing, f: rt.Formatter) => Listing.fmt$Debug(value, f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +export function list(listing: rt.Place, b: rt.u8): void { + if (listing.v === undefined) { + listing.v = Listing.default$Default(); + } + (listing.v as Listing.Listing).source = b; + const _5: rt.ByteVec = rt.byteVecFrom(rt.byteVecView((listing.v as Listing.Listing).listed)); + (listing.v as Listing.Listing).stale = _5; + rt.byteVecPush((listing.v as Listing.Listing).listed, b); +} + +/** moq-net's ingest: a field of what a `&mut` parameter points at, taken by a closure. */ +export function restock(listing: Listing.Listing, b: rt.u8): rt.ByteVec | undefined { + return then$bool_Vec_u8_restock_closure0(rt.u8Rem(b, 2) === 0, (): rt.ByteVec => { + const _2: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(b)); + const old = listing.listed; + listing.listed = _2; + return old; + }); +} + +/** + * moq-net's front: a `Vec` a closure captured by reference, taken, replaced, and + * refilled on each call, read after by the caller. + */ +export function taken(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + let held: rt.ByteVec = rt.byteSliceToByteVec(data); + let wide: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { + return rt.u32Mul(_2 as rt.u32, 1000); + })); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(poll$taken_closure1(data.data, data.start, data.length, (b4: rt.u8): boolean => { + const taken_ = held; + held = new rt.ByteVec(); + for (const x of rt.byteVecView(taken_)) { + if (rt.u8Rem(x, 3) !== rt.u8Rem(b4, 3)) { + rt.byteVecPush(held, rt.u8Div(x, 2)); + } + } + ((): void => { + const _34: rt.u32[] = []; + const old2 = wide; + wide = _34; + wide = rt.iterToArray(rt.iterMap(rt.iterFilter(rt.iterSlice(old2), (_25: rt.u32): boolean => { + return _25 > ((b4 as rt.u32)); + }), (x3: rt.u32): rt.u32 => { + return rt.u32Div(x3, 2); + })); + })(); + return held.length === 0; + }) as rt.u32))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(held)); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(wide, f, rt.u32Debug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); + const pair: [rt.ByteVec, Listing.Listing] = [rt.byteSliceToByteVec(data), Listing.default$Default()]; + const swap: (a0: rt.u8) => rt.ByteVec = (b5: rt.u8): rt.ByteVec => { + const _36: rt.ByteVec = rt.byteVecOf(b5, rt.u8Rem(b5, 4) as rt.usize); + const old3 = pair[0]; + pair[0] = _36; + return old3; + }; + const swapped: rt.ByteVec = new rt.ByteVec(); + for (const _39 of rt.byteSliceView(data)) { + const _45: rt.ByteVec = swap(_39); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45))); + } + const list_: (a0: rt.u8) => void = (b6: rt.u8): void => { + const taken2 = pair[1].listed; + pair[1].listed = new rt.ByteVec(); + pair[1].stale = taken2; + rt.byteVecPush(pair[1].listed, b6); + }; + rt.iterForEach(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): void => { + list_(_26); + }); + for (const _57 of rt.byteSliceView(data)) { + const _63: rt.ByteVec = unwrapOrDefault$Option_Vec_u8(restock(pair[1], _57)); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63))); + } + const taken3 = pair[1].stale; + pair[1].stale = new rt.ByteVec(); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(taken3)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(swapped)); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteVecView(pair[0]), f, rt.u8Debug), (f: rt.Formatter) => Listing.fmt$Debug(pair[1], f)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); +} + +export function poll$taken_closure1(dataData: Uint8Array, dataStart: number, dataLen: number, f: (a0: rt.u8) => boolean): rt.usize { + return rt.iterCount(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): boolean => { + return !f(_2); + })); +} + /** * What std lends of the elements and values of slices and collections, which JS copies: * one, each in turn, or each to a closure. diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts index 346f9ef5a..1b2b226a0 100644 --- a/ts/fixtures/lang/expected/returns.ts +++ b/ts/fixtures/lang/expected/returns.ts @@ -178,7 +178,7 @@ export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - rt.drop(new Guard.Guard(new rt.ByteSlice(otherData, otherStart, otherLen), dataLen & 0xff)); + new Guard.Guard(new rt.ByteSlice(otherData, otherStart, otherLen), dataLen & 0xff)[Symbol.dispose](); if (err !== undefined) { return err as Error.Error; } From 3b9cc55dcad947ac469aee15b8803f394ff66090 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Thu, 29 Oct 2026 13:05:52 -0700 Subject: [PATCH 10/26] quest: record #160's deciding bench, inconclusive Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/returns.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index e874532ac..3b954dc52 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -39,11 +39,13 @@ most. One out slot per payload type, which a forwarded result already fills, avo already. A slot sits beside the first function in source order that writes it, so its place doesn't depend on the order translation reaches them. `?`'s `Err` assigns a result held as its parts, so a function with early returns writes the slot at each. -- Chrome's `time/` convert workloads, 7-12% slower than `main` in single runs, are V8's - variance between realms, not parts: the same code differed as much between two workers - of one run (`time/u64` 60 against 55, `btree/256` 113 against 152), and over 12 launches - each the medians matched (`time/` 58.2 on `main`, 58.0 here), with the same instruction - counts and inlining. One realm's A/A route doesn't capture this, so compare those - workloads over repeated runs. +- Measured from the translator's own output on 2026-10-29, four `just ts bench` runs against + `main` at ccd52a0e. Chrome took 0.79-0.81 of `main`'s time on varint decode and 0.79-0.81 + on frame decode, and Node 0.68-0.78 and 0.71-0.72. No run's Chrome A/A came under 5% at the + max: 5.5%, 61%, 16%, and 5.1%, with medians of 0.6-2.0%. It doesn't land on those runs. +- Open: Chrome's `time/u64` conversions took 1.11-1.17x `main`'s time in all four runs, with + that workload's A/A within 4%, and `btree/` 1.08-1.28x in three of them. That is the bundle, + not V8's variance between realms, as an earlier note here had it. Leading-ones varints of + 8 bytes took 1.06-1.20x. Find out why before landing. Public API: the translator's output for byte slices. From a4b559ae2eb9567104d30d147fe60344c70b6d36 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Thu, 29 Oct 2026 13:57:37 -0700 Subject: [PATCH 11/26] quest: record why #160's 8-byte varints are slower, and what time/ and btree/ aren't Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/returns.md | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index 3b954dc52..04cd022f2 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -22,11 +22,14 @@ most. One out slot per payload type, which a forwarded result already fills, avo value is wrapped in an arrow that rebuilds the `Result`. - The callee writes its slot at the JS `return`, after its MIR drops ran; the caller reads it at once, before any other call. -- Start the slot's number fields as `undefined`, not `0`, so V8 keeps them tagged. A field - that starts as a small integer turns into a boxed double once a value past 2^31 is - stored, and a function too big for V8 to inline (over 460 bytes of bytecode, as - `read_leading_ones` is) then boxes every write and the caller unboxes every read. This - is why the first hand edit was slower than `main` on leading-ones varints. +- Start the slot's number fields as `undefined`, not `0`. Such a field holds any value once + a small integer is written (V8's `--trace-generalization`), so a write of a number that is + no small integer, as an 8-byte varint is, boxes a new one into an old object. A field + that starts as `0` stays a double written in place, but a slot that held one such number + converts every small one read after: on Chrome, `p_0` starting at `0` took QUIC and + leading-ones 8-byte varints from 1.13x and 1.24x `main`'s time to 0.88x and 1.06x, and + frame decode from 0.83x and 0.67x to 0.90x and 0.76x (2026-10-29, interleaved, a busy + host). Starting the starts and lengths at `0` changed nothing. - Measured by hand edits of the codec's translation against `main`, Chrome first (2026-10-28, on a busy host, so confirm on a quiet one): with the slot's fields tagged, Chrome's varint and frame decode were each about 1.25x faster and group decode 1.06x, Node 1.33x and @@ -44,8 +47,13 @@ most. One out slot per payload type, which a forwarded result already fills, avo on frame decode, and Node 0.68-0.78 and 0.71-0.72. No run's Chrome A/A came under 5% at the max: 5.5%, 61%, 16%, and 5.1%, with medians of 0.6-2.0%. It doesn't land on those runs. - Open: Chrome's `time/u64` conversions took 1.11-1.17x `main`'s time in all four runs, with - that workload's A/A within 4%, and `btree/` 1.08-1.28x in three of them. That is the bundle, - not V8's variance between realms, as an earlier note here had it. Leading-ones varints of - 8 bytes took 1.06-1.20x. Find out why before landing. + that workload's A/A within 4%, and `btree/` 1.08-1.28x in three of them. Swapping which + route is `translated` kept `main` faster, so it isn't the route's place in the run. Their + functions translate to the same text on both, and a harness of their own, running every + workload in a fixed or shuffled order, timed them within 3% of `main`. So the gap is in + how the bench drives them, not in their translation. Find which before landing. +- Leading-ones varints of 8 bytes took 1.06-1.24x `main`'s time: `read_leading_ones` is too + big to inline, so each call boxes its value into the slot (above), where `main` returned + a new array. Public API: the translator's output for byte slices. From 465ac86a12c3667c5a59a8d8295e16d041455c86 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Thu, 29 Oct 2026 14:44:19 -0700 Subject: [PATCH 12/26] quest: park #160 until the host is quiet, with its next steps Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/returns.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index 04cd022f2..b23436a51 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -54,6 +54,12 @@ most. One out slot per payload type, which a forwarded result already fills, avo how the bench drives them, not in their translation. Find which before landing. - Leading-ones varints of 8 bytes took 1.06-1.24x `main`'s time: `read_leading_ones` is too big to inline, so each call boxes its value into the slot (above), where `main` returned - a new array. + a new array. Returning the `Ok`'s first number, rather than writing it to the slot, would + avoid both the box and the conversion: an ABI change for the maintainer to weigh. +- Parked as a draft on 2026-10-29 until the host is quiet, with moq.pro's dev servers + stopped. Then: time `time/` and `btree/` alone on the bench, to see whether the other + workloads cause their gap; trace V8's inlining of `rescale` in the bench itself, where + Turbofan took 3-4x longer to compile it and `ordered` here than on `main`; and run the + deciding bench, judged on family geomeans. Public API: the translator's output for byte slices. From aa3fe79ff794e0a3c1e61c82692e1c9590e6fabc Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Thu, 29 Oct 2026 18:26:28 -0700 Subject: [PATCH 13/26] quest: record #160's evening bench and rescale's deopts Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-byte-views/returns.md | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index b23436a51..1b4c6d784 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -56,10 +56,26 @@ most. One out slot per payload type, which a forwarded result already fills, avo big to inline, so each call boxes its value into the slot (above), where `main` returned a new array. Returning the `Ok`'s first number, rather than writing it to the slot, would avoid both the box and the conversion: an ABI change for the maintainer to weigh. -- Parked as a draft on 2026-10-29 until the host is quiet, with moq.pro's dev servers - stopped. Then: time `time/` and `btree/` alone on the bench, to see whether the other - workloads cause their gap; trace V8's inlining of `rescale` in the bench itself, where - Turbofan took 3-4x longer to compile it and `ordered` here than on `main`; and run the - deciding bench, judged on family geomeans. +- Measured again on 2026-10-29 evening, other agents held, against `main` at ccd52a0e. CI + jobs on the host's runners started during both deciding runs, and neither met the A/A + rule: Chrome's was 4.0% at the median and 28% at the max, then 0.9% and 7.0%. Chrome took + 0.81x and 0.79x `main`'s time on varint decode, 1.01x and 0.81x on frame decode, 1.02x and + 1.03x on group decode, 1.18x and 0.84x on `btree/`, and 1.08x on `time/` conversions in + both. Node took 0.68-0.74x on varint and 0.71x on frame decode. +- Timed alone, `time/` and `btree/` on the bench still put `time/u64` at 1.12-1.18x `main`, + with the A/A within 6%, so the other workloads don't cause it. `btree/` swung from + 1.12-1.26x to 0.85-0.94x. One bench run under `--trace-turbo-inlining` showed this + branch's `rescale` deopting 1,892 times, from Turbofan code compiled on stack replacement + before the `put_u64` calls after its loop had run, where `main`'s deopted 28 times; but + under `--trace-deopt` alone it deopted 4 and 7 times, so that loop came from the tracing. +- `rescale`'s only change from `main` is its `take_u64` calls: `take_u64` takes its slice + as parts but makes it an `rt.ByteSlice` on entry, so each caller holding one splits it + for the callee to make it again. That breaks this file's rule that nothing is made more + often than before, but at 5 objects per 1024 conversions it can't be 8%. Not passing as + parts a parameter its body makes on entry needs each callee's analysis before its + callers are lowered. A hand edit of that (all outputs equal) deopted 0 and 1 times. +- Parked as a draft until the host is quiet, with its runners frozen. Then run the + deciding bench, judged on family geomeans, and time the `take_u64` hand edit beside + this branch, to see whether the call's shape is `time/`'s gap. Public API: the translator's output for byte slices. From c1092d29de0c6c1ec1b62c0413a3cf7eb6fef74e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 10:14:52 -0700 Subject: [PATCH 14/26] style(ts): format the merge's resolutions Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/src/harness.rs | 8 ++++---- ts/src/lower/body.rs | 6 ++++-- ts/src/lower/names.rs | 3 ++- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 3a1e57782..469f02bb5 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,10 +2,10 @@ //! case and the rest is its input. use crate::{ - args, arrays, ascii, atomics, borrows, bounds, boxes, captures, cells, chars, chunks, clones, collections, combinators, - counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, hints, holds, - ints, iters, joins, keys, locals, locks, methods, nested, objects, orders, pointers, refs, returns, saturates, separated, - shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, + args, arrays, ascii, atomics, borrows, bounds, boxes, captures, cells, chars, chunks, clones, collections, + combinators, counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, + hints, holds, ints, iters, joins, keys, locals, locks, methods, nested, objects, orders, pointers, refs, returns, + saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index ddcf95319..a829fd701 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -355,8 +355,10 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { Some(sym) => Some(sym), // One that takes byte slices as their parts, or hands back its `Ok`'s, is wrapped // to take and return them whole. - None => (self.t.lowers(instance) && self.t.parted(instance).is_empty() && self.t.slotted(instance).is_none()) - .then(|| self.t.callee(instance, span)), + None => (self.t.lowers(instance) + && self.t.parted(instance).is_empty() + && self.t.slotted(instance).is_none()) + .then(|| self.t.callee(instance, span)), }; if let Some(sym) = sym { return match sig.output().is_unit() { diff --git a/ts/src/lower/names.rs b/ts/src/lower/names.rs index be201a154..32692b453 100644 --- a/ts/src/lower/names.rs +++ b/ts/src/lower/names.rs @@ -165,7 +165,8 @@ impl<'tcx> Translator<'_, 'tcx> { /// The slot of `Ok` parts beside the function `def_id`, if it returns a `Result`. fn slot_names(&self, def_id: DefId, names: &mut Names) { let output = self.tcx.fn_sig(def_id).skip_binder().output().skip_binder(); - if matches!(output.kind(), ty::Adt(adt, _) if library::Std::of(self.tcx, adt.did()) == Some(library::Std::Result)) { + if matches!(output.kind(), ty::Adt(adt, _) if library::Std::of(self.tcx, adt.did()) == Some(library::Std::Result)) + { importable(names, &slot_base(self.tcx, def_id), self.module_of(def_id)); } } From 5e9e64f9b03ebbeec43dec1151491e1840c0ff51 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 14:52:50 -0700 Subject: [PATCH 15/26] chore(ts): regenerate snapshots after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/arrays.ts | 122 +++--- ts/fixtures/lang/expected/harness.ts | 550 ++++++++++++++++++++------ ts/fixtures/lang/expected/iters.ts | 342 ++++++++-------- ts/fixtures/lang/expected/orders.ts | 3 +- ts/fixtures/lang/expected/pointers.ts | 29 +- ts/fixtures/lang/expected/slices.ts | 399 ++++++++++++------- ts/fixtures/stock/expected/harness.ts | 58 ++- 7 files changed, 985 insertions(+), 518 deletions(-) diff --git a/ts/fixtures/lang/expected/arrays.ts b/ts/fixtures/lang/expected/arrays.ts index 8141f747a..1dc725927 100644 --- a/ts/fixtures/lang/expected/arrays.ts +++ b/ts/fixtures/lang/expected/arrays.ts @@ -439,56 +439,61 @@ export function written(bytes: rt.ByteSlice, wide: rt.u16[], op: rt.u8): void { * fields, and parts of a longer slice. Writes through each land in the array, and a copy shares nothing with * it. Of no bytes, one, three, and many. */ -export function given(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function given(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { - givenN$0(data, out); - taken$0(data, out); + givenN$0(dataData, dataStart, dataLen, out); + taken$0(dataData, dataStart, dataLen, out); } else if (_4 === 1) { - givenN$1(data, out); - taken$1(data, out); + givenN$1(dataData, dataStart, dataLen, out); + taken$1(dataData, dataStart, dataLen, out); } else if (_4 === 2) { - givenN$3(data, out); - taken$3(data, out); - fields(data, out); + givenN$3(dataData, dataStart, dataLen, out); + taken$3(dataData, dataStart, dataLen, out); + fields(dataData, dataStart, dataLen, out); } else { - givenN$40(data, out); - taken$32(data, out); + givenN$40(dataData, dataStart, dataLen, out); + taken$32(dataData, dataStart, dataLen, out); } } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$0(data: rt.ByteSlice, at: rt.usize): Uint8Array { +export function bytesAt$0(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$1(data: rt.ByteSlice, at: rt.usize): Uint8Array { +export function bytesAt$1(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$3(data: rt.ByteSlice, at: rt.usize): Uint8Array { +export function bytesAt$3(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$32(data: rt.ByteSlice, at: rt.usize): Uint8Array { +export function bytesAt$32(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); return rt.bytesFromFn(32, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$40(data: rt.ByteSlice, at: rt.usize): Uint8Array { +export function bytesAt$40(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); return rt.bytesFromFn(40, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } @@ -589,9 +594,10 @@ export function putSome$40(out: rt.ByteVec, a: Uint8Array | undefined): void { } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$0(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$0(data, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$0(data, 0)); +export function givenN$0(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const a: Uint8Array = copy$array_u8(bytesAt$0(data.data, data.start, data.length, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$0(data.data, data.start, data.length, 0)); const copied: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -613,7 +619,7 @@ export function givenN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } put$0(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$0(data, rt.usizeMul(k, 2)); + return bytesAt$0(data.data, data.start, data.length, rt.usizeMul(k, 2)); }), undefined, 0, true); rt.byteSliceFrom(v[rt.idx(v, 0)]); rt.byteSliceFrom(a); @@ -686,9 +692,10 @@ export function givenN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$1(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$1(data, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$1(data, 1)); +export function givenN$1(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const a: Uint8Array = copy$array_u8(bytesAt$1(data.data, data.start, data.length, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$1(data.data, data.start, data.length, 1)); const copied: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -713,7 +720,7 @@ export function givenN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } put$1(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$1(data, rt.usizeMul(k, 2)); + return bytesAt$1(data.data, data.start, data.length, rt.usizeMul(k, 2)); }), undefined, 1, true); const _50: rt.ByteSlice = rt.byteSliceFrom(v[rt.idx(v, 0)]); const _52: rt.ByteSlice = rt.byteSliceFrom(a); @@ -804,9 +811,10 @@ export function givenN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$3(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$3(data, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$3(data, 3)); +export function givenN$3(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const a: Uint8Array = copy$array_u8(bytesAt$3(data.data, data.start, data.length, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$3(data.data, data.start, data.length, 3)); const copied: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -831,7 +839,7 @@ export function givenN$3(data: rt.ByteSlice, out: rt.ByteVec): void { } put$3(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$3(data, rt.usizeMul(k, 2)); + return bytesAt$3(data.data, data.start, data.length, rt.usizeMul(k, 2)); }), undefined, 3, true); const _50: rt.ByteSlice = rt.byteSliceFrom(v[rt.idx(v, 0)]); const _52: rt.ByteSlice = rt.byteSliceFrom(a); @@ -922,9 +930,10 @@ export function givenN$3(data: rt.ByteSlice, out: rt.ByteVec): void { } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$40(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$40(data, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$40(data, 40)); +export function givenN$40(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const a: Uint8Array = copy$array_u8(bytesAt$40(data.data, data.start, data.length, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$40(data.data, data.start, data.length, 40)); const copied: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -949,7 +958,7 @@ export function givenN$40(data: rt.ByteSlice, out: rt.ByteVec): void { } put$40(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$40(data, rt.usizeMul(k, 2)); + return bytesAt$40(data.data, data.start, data.length, rt.usizeMul(k, 2)); }), undefined, 40, true); const _50: rt.ByteSlice = rt.byteSliceFrom(v[rt.idx(v, 0)]); const _52: rt.ByteSlice = rt.byteSliceFrom(a); @@ -1043,9 +1052,9 @@ export function givenN$40(data: rt.ByteSlice, out: rt.ByteVec): void { * [`given`] of a field's `[u8; 3]`, swapped, replaced, taken, and formatted through its * own `Debug`. */ -export function fields(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$3(data, 2)); - const held: Framed.Framed = { bytes: copy$array_u8(bytesAt$3(data, 0)) }; +export function fields(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$3(dataData, dataStart, dataLen, 2)); + const held: Framed.Framed = { bytes: copy$array_u8(bytesAt$3(dataData, dataStart, dataLen, 0)) }; const _7: rt.ByteSlice = rt.byteSliceFrom(held.bytes); const _8: rt.ByteSlice = rt.byteSliceFrom(a); const swapped = rt.byteSliceToArray(_7); @@ -1066,28 +1075,27 @@ export function fields(data: rt.ByteSlice, out: rt.ByteVec): void { _41.data.set(rt.bytes(3), _41.start); put$3(out, [taken2, copy$array_u8(held.bytes)]); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(shown)); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d: rt.u8): boolean => { + if (isSomeAnd$09tpccf(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), (d: rt.u8): boolean => { return rt.u8Rem(d, 3) === 1; })) { [rt.byteSliceFrom(old), rt.byteSliceFrom(a)] as [rt.ByteSlice, rt.ByteSlice]; if (rt.eqBytes(rt.byteSliceFrom(old), rt.byteSliceFrom(a))) { - const arg = data.length; const kind: string = "!="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(dataLen, f)]; const _60: rt.Arguments | undefined = ["fields of ", args4[0]]; - const arg2 = rt.byteSliceView(rt.byteSliceFrom(old)); - const arg3 = rt.byteSliceView(rt.byteSliceFrom(a)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _60); + const arg = rt.byteSliceView(rt.byteSliceFrom(old)); + const arg2 = rt.byteSliceView(rt.byteSliceFrom(a)); + rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), _60); } } } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$0(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$0(data, 1)); +export function taken$0(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$0(dataData, dataStart, dataLen, 1)); rt.byteSliceFrom(a); put$0(out, [rt.bytes(0), copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(0).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(0).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 0); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); @@ -1097,13 +1105,13 @@ export function taken$0(data: rt.ByteSlice, out: rt.ByteVec): void { } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$1(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$1(data, 1)); +export function taken$1(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$1(dataData, dataStart, dataLen, 1)); const _5: rt.ByteSlice = rt.byteSliceFrom(a); const taken = rt.byteSliceToArray(_5); _5.data.set(rt.bytes(1), _5.start); put$1(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(1).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(1).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 1); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); @@ -1115,13 +1123,13 @@ export function taken$1(data: rt.ByteSlice, out: rt.ByteVec): void { } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$3(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$3(data, 1)); +export function taken$3(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$3(dataData, dataStart, dataLen, 1)); const _5: rt.ByteSlice = rt.byteSliceFrom(a); const taken = rt.byteSliceToArray(_5); _5.data.set(rt.bytes(3), _5.start); put$3(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(3).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(3).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 3); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); @@ -1133,13 +1141,13 @@ export function taken$3(data: rt.ByteSlice, out: rt.ByteVec): void { } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$32(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$32(data, 1)); +export function taken$32(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$32(dataData, dataStart, dataLen, 1)); const _5: rt.ByteSlice = rt.byteSliceFrom(a); const taken = rt.byteSliceToArray(_5); _5.data.set(rt.bytes(32), _5.start); put$32(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(32).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(32).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 32); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 72f5aa5cb..b531f13d7 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { args } from "./args.ts"; import { fromFns, maps, lent as arrays_lent, asSlices, given } from "./arrays.ts"; import { bytes as ascii_bytes, chars as ascii_chars, slices as ascii_slices } from "./ascii.ts"; import { atomics } from "./atomics.ts"; @@ -41,6 +42,7 @@ import { objects } from "./objects.ts"; import { orders, bytes as orders_bytes, tuples as orders_tuples, held as orders_held, btrees } from "./orders.ts"; import { lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded } from "./pointers.ts"; import { refs, toRefs } from "./refs.ts"; +import { returns } from "./returns.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -60,177 +62,463 @@ import { zeros, impls, keys as zeros_keys, unread, writes as zeros_writes } from * case added at the end moves no other. */ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] { - return [["ints::u8_op", u8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", u16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", u32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", u64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", u128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", usizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", i8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", i16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", i32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", i64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", i128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", isizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", neg as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", cast as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_2100: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { - convert(data, out); + return [["ints::u8_op", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { + u8Op(a0, a1.data, a1.start, a1.length, a2); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", (a02: rt.u8, a12: rt.ByteSlice, a22: rt.ByteVec): undefined => { + u16Op(a02, a12.data, a12.start, a12.length, a22); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", (a03: rt.u8, a13: rt.ByteSlice, a23: rt.ByteVec): undefined => { + u32Op(a03, a13.data, a13.start, a13.length, a23); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", (a04: rt.u8, a14: rt.ByteSlice, a24: rt.ByteVec): undefined => { + u64Op(a04, a14.data, a14.start, a14.length, a24); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", (a05: rt.u8, a15: rt.ByteSlice, a25: rt.ByteVec): undefined => { + u128Op(a05, a15.data, a15.start, a15.length, a25); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", (a06: rt.u8, a16: rt.ByteSlice, a26: rt.ByteVec): undefined => { + usizeOp(a06, a16.data, a16.start, a16.length, a26); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", (a07: rt.u8, a17: rt.ByteSlice, a27: rt.ByteVec): undefined => { + i8Op(a07, a17.data, a17.start, a17.length, a27); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", (a08: rt.u8, a18: rt.ByteSlice, a28: rt.ByteVec): undefined => { + i16Op(a08, a18.data, a18.start, a18.length, a28); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", (a09: rt.u8, a19: rt.ByteSlice, a29: rt.ByteVec): undefined => { + i32Op(a09, a19.data, a19.start, a19.length, a29); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", (a010: rt.u8, a110: rt.ByteSlice, a210: rt.ByteVec): undefined => { + i64Op(a010, a110.data, a110.start, a110.length, a210); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", (a011: rt.u8, a111: rt.ByteSlice, a211: rt.ByteVec): undefined => { + i128Op(a011, a111.data, a111.start, a111.length, a211); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", (a012: rt.u8, a112: rt.ByteSlice, a212: rt.ByteVec): undefined => { + isizeOp(a012, a112.data, a112.start, a112.length, a212); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", (a013: rt.u8, a113: rt.ByteSlice, a213: rt.ByteVec): undefined => { + neg(a013, a113.data, a113.start, a113.length, a213); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", (a014: rt.u8, a114: rt.ByteSlice, a214: rt.ByteVec): undefined => { + cast(a014, a114.data, a114.start, a114.length, a214); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_2100: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { + convert(data.data, data.start, data.length, out); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::copies", (_2101: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { - shapes_copies(data2, out2); + shapes_copies(data2.data, data2.start, data2.length, out2); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::loops", (_2102: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { - loops(data3, out3); + loops(data3.data, data3.start, data3.length, out3); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::patterns", (_2103: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { - patterns(data4, out4); + patterns(data4.data, data4.start, data4.length, out4); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::closures", (_2104: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { - shapes_closures(data5, out5); + shapes_closures(data5.data, data5.start, data5.length, out5); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::discriminants", (_2105: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { - discriminants(data6, out6); + discriminants(data6.data, data6.start, data6.length, out6); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::library", (_2106: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { - library(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::ints", ints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_2107: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { - strings(data8, out8); + library(data7.data, data7.start, data7.length, out7); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::ints", (a015: rt.u8, a115: rt.ByteSlice, a215: rt.ByteVec): undefined => { + ints(a015, a115.data, a115.start, a115.length, a215); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_2107: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + strings(data8.data, data8.start, data8.length, out8); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::derived", (_2108: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { - derived(data9, out9); + derived(data9.data, data9.start, data9.length, out9); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::written", (_2109: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): undefined => { - fmt_written(data10, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", fmt_panics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_2110: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { - methods(data11, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::adaptors", adaptors as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", iters_consumers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_2111: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { - iters_ranges(data12, out12); + fmt_written(data10.data, data10.start, data10.length, out10); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", (a016: rt.u8, a116: rt.ByteSlice, a216: rt.ByteVec): undefined => { + fmt_panics(a016, a116.data, a116.start, a116.length, a216); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_2110: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { + methods(data11.data, data11.start, data11.length, out11); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::adaptors", (a017: rt.u8, a117: rt.ByteSlice, a217: rt.ByteVec): undefined => { + adaptors(a017, a117.data, a117.start, a117.length, a217); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", (a018: rt.u8, a118: rt.ByteSlice, a218: rt.ByteVec): undefined => { + iters_consumers(a018, a118.data, a118.start, a118.length, a218); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_2111: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { + iters_ranges(data12.data, data12.start, data12.length, out12); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::options", (_2112: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): undefined => { - iters_options(data13, out13); + iters_options(data13.data, data13.start, data13.length, out13); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::own", (_2113: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): undefined => { - own(data14, out14); + own(data14.data, data14.start, data14.length, out14); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::values", (_2114: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): undefined => { - iters_values(data15, out15); + iters_values(data15.data, data15.start, data15.length, out15); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::order", (_2115: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): undefined => { - shapes_order(data16, out16); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", hashMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", sets as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", btreeMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { - deques(data17, out17); + shapes_order(data16.data, data16.start, data16.length, out16); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", (a019: rt.u8, a119: rt.ByteSlice, a219: rt.ByteVec): undefined => { + hashMaps(a019, a119.data, a119.start, a119.length, a219); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", (a020: rt.u8, a120: rt.ByteSlice, a220: rt.ByteVec): undefined => { + sets(a020, a120.data, a120.start, a120.length, a220); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", (a021: rt.u8, a121: rt.ByteSlice, a221: rt.ByteVec): undefined => { + btreeMaps(a021, a121.data, a121.start, a121.length, a221); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { + deques(data17.data, data17.start, data17.length, out17); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::flows", (_2117: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): undefined => { - flows(data18, out18); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", keys_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", chars_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", strs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { - vecs(data19, out19); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", strs_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { - stores(data20, out20); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", chunks as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", cows as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", durations as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", combinators as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", splits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", nested_nested as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { - refs(data21, out21); + flows(data18.data, data18.start, data18.length, out18); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", (a022: rt.u8, a122: rt.ByteSlice, a222: rt.ByteVec): undefined => { + keys_keys(a022, a122.data, a122.start, a122.length, a222); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", (a023: rt.u8, a123: rt.ByteSlice, a223: rt.ByteVec): undefined => { + chars_chars(a023, a123.data, a123.start, a123.length, a223); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", (a024: rt.u8, a124: rt.ByteSlice, a224: rt.ByteVec): undefined => { + strs(a024, a124.data, a124.start, a124.length, a224); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { + vecs(data19.data, data19.start, data19.length, out19); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", (a025: rt.u8, a125: rt.ByteSlice, a225: rt.ByteVec): undefined => { + strs_slices(a025, a125.data, a125.start, a125.length, a225); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { + stores(data20.data, data20.start, data20.length, out20); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", (a026: rt.u8, a126: rt.ByteSlice, a226: rt.ByteVec): undefined => { + chunks(a026, a126.data, a126.start, a126.length, a226); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", (a027: rt.u8, a127: rt.ByteSlice, a227: rt.ByteVec): undefined => { + cows(a027, a127.data, a127.start, a127.length, a227); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", (a028: rt.u8, a128: rt.ByteSlice, a228: rt.ByteVec): undefined => { + durations(a028, a128.data, a128.start, a128.length, a228); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", (a029: rt.u8, a129: rt.ByteSlice, a229: rt.ByteVec): undefined => { + combinators(a029, a129.data, a129.start, a129.length, a229); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", (a030: rt.u8, a130: rt.ByteSlice, a230: rt.ByteVec): undefined => { + splits(a030, a130.data, a130.start, a130.length, a230); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", (a031: rt.u8, a131: rt.ByteSlice, a231: rt.ByteVec): undefined => { + nested_nested(a031, a131.data, a131.start, a131.length, a231); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { + refs(data21.data, data21.start, data21.length, out21); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::counts", (_2121: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): undefined => { - fmt_counts(data22, out22); + fmt_counts(data22.data, data22.start, data22.length, out22); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::rounding", (_2122: rt.u8, _3100: rt.ByteSlice, out23: rt.ByteVec): undefined => { rounding(out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", skips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", wrappers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", edits_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", floats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", atomics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { - dyns(data23, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", cells_cells as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { - dyns_shared(data24, out25); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", iters_ranked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", captures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { - locks(data25, out26); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", (a032: rt.u8, a132: rt.ByteSlice, a232: rt.ByteVec): undefined => { + skips(a032, a132.data, a132.start, a132.length, a232); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", (a033: rt.u8, a133: rt.ByteSlice, a233: rt.ByteVec): undefined => { + wrappers(a033, a133.data, a133.start, a133.length, a233); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", (a034: rt.u8, a134: rt.ByteSlice, a234: rt.ByteVec): undefined => { + edits_edits(a034, a134.data, a134.start, a134.length, a234); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", (a035: rt.u8, a135: rt.ByteSlice, a235: rt.ByteVec): undefined => { + decodes(a035, a135.data, a135.start, a135.length, a235); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", (a036: rt.u8, a136: rt.ByteSlice, a236: rt.ByteVec): undefined => { + floats(a036, a136.data, a136.start, a136.length, a236); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", (a037: rt.u8, a137: rt.ByteSlice, a237: rt.ByteVec): undefined => { + atomics(a037, a137.data, a137.start, a137.length, a237); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", (a038: rt.u8, a138: rt.ByteSlice, a238: rt.ByteVec): undefined => { + overrides(a038, a138.data, a138.start, a138.length, a238); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { + dyns(data23.data, data23.start, data23.length, out24); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", (a039: rt.u8, a139: rt.ByteSlice, a239: rt.ByteVec): undefined => { + cells_cells(a039, a139.data, a139.start, a139.length, a239); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { + dyns_shared(data24.data, data24.start, data24.length, out25); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", (a040: rt.u8, a140: rt.ByteSlice, a240: rt.ByteVec): undefined => { + iters_ranked(a040, a140.data, a140.start, a140.length, a240); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", (a041: rt.u8, a141: rt.ByteSlice, a241: rt.ByteVec): undefined => { + captures(a041, a141.data, a141.start, a141.length, a241); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { + locks(data25.data, data25.start, data25.length, out26); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::relock", (_2126: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): undefined => { - relock(data26, out27); + relock(data26.data, data26.start, data26.length, out27); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locals::locals", (_2127: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): undefined => { - locals(data27, out28); + locals(data27.data, data27.start, data27.length, out28); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::statics", (_2128: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): undefined => { - statics(data28, out29); + statics(data28.data, data28.start, data28.length, out29); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::rwlocks", (_2129: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): undefined => { - rwlocks(data29, out30); + rwlocks(data29.data, data29.start, data29.length, out30); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::borrows", (_2130: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): undefined => { - borrows_borrows(data30, out31); + borrows_borrows(data30.data, data30.start, data30.length, out31); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["defaults::defaults", (_2131: rt.u8, data31: rt.ByteSlice, out32: rt.ByteVec): undefined => { - defaults_defaults(data31, out32); + defaults_defaults(data31.data, data31.start, data31.length, out32); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::arcs", (_2132: rt.u8, data32: rt.ByteSlice, out33: rt.ByteVec): undefined => { - counts_arcs(data32, out33); + counts_arcs(data32.data, data32.start, data32.length, out33); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::rcs", (_2133: rt.u8, data33: rt.ByteSlice, out34: rt.ByteVec): undefined => { - rcs(data33, out34); + rcs(data33.data, data33.start, data33.length, out34); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_arcs", (_2134: rt.u8, data34: rt.ByteSlice, out35: rt.ByteVec): undefined => { - cyclicArcs(data34, out35); + cyclicArcs(data34.data, data34.start, data34.length, out35); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_rcs", (_2135: rt.u8, data35: rt.ByteSlice, out36: rt.ByteVec): undefined => { - cyclicRcs(data35, out36); + cyclicRcs(data35.data, data35.start, data35.length, out36); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_arcs", (_2136: rt.u8, data36: rt.ByteSlice, out37: rt.ByteVec): undefined => { - uniqueArcs(data36, out37); + uniqueArcs(data36.data, data36.start, data36.length, out37); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_rcs", (_2137: rt.u8, data37: rt.ByteSlice, out38: rt.ByteVec): undefined => { - uniqueRcs(data37, out38); + uniqueRcs(data37.data, data37.start, data37.length, out38); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::anys", (_2138: rt.u8, data38: rt.ByteSlice, out39: rt.ByteVec): undefined => { - anys(data38, out39); + anys(data38.data, data38.start, data38.length, out39); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::fns", (_2139: rt.u8, data39: rt.ByteSlice, out40: rt.ByteVec): undefined => { - fns(data39, out40); + fns(data39.data, data39.start, data39.length, out40); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::copies", (_2140: rt.u8, data40: rt.ByteSlice, out41: rt.ByteVec): undefined => { - pointers_copies(data40, out41); + pointers_copies(data40.data, data40.start, data40.length, out41); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lists", (_2141: rt.u8, data41: rt.ByteSlice, out42: rt.ByteVec): undefined => { - lists(data41, out42); + lists(data41.data, data41.start, data41.length, out42); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::nested", (_2142: rt.u8, data42: rt.ByteSlice, out43: rt.ByteVec): undefined => { - pointers_nested(data42, out43); + pointers_nested(data42.data, data42.start, data42.length, out43); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::places", (_2143: rt.u8, data43: rt.ByteSlice, out44: rt.ByteVec): undefined => { - pointers_places(data43, out44); + pointers_places(data43.data, data43.start, data43.length, out44); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::sentinels", (_2144: rt.u8, data44: rt.ByteSlice, out45: rt.ByteVec): undefined => { - sentinels(data44, out45); + sentinels(data44.data, data44.start, data44.length, out45); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::shared", (_2145: rt.u8, data45: rt.ByteSlice, out46: rt.ByteVec): undefined => { - pointers_shared(data45, out46); + pointers_shared(data45.data, data45.start, data45.length, out46); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::unchecked", (_2146: rt.u8, data46: rt.ByteSlice, out47: rt.ByteVec): undefined => { - unchecked(data46, out47); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", edits_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { - fromFns(data47, out48); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["objects::objects", (_2148: rt.u8, data48: rt.ByteSlice, out49: rt.ByteVec): undefined => { - objects(data48, out49); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["holds::holds", holds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_2149: rt.u8, data49: rt.ByteSlice, out50: rt.ByteVec): undefined => { - fmt_wrapped(data49, out50); + unchecked(data46.data, data46.start, data46.length, out47); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", (a042: rt.u8, a142: rt.ByteSlice, a242: rt.ByteVec): undefined => { + edits_bytes(a042, a142.data, a142.start, a142.length, a242); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { + fromFns(data47.data, data47.start, data47.length, out48); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", (a043: rt.u8, a143: rt.ByteSlice, a243: rt.ByteVec): undefined => { + optionals(a043, a143.data, a143.start, a143.length, a243); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["objects::objects", (_2148: rt.u8, data48: rt.ByteSlice, out49: rt.ByteVec): undefined => { + objects(data48.data, data48.start, data48.length, out49); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["holds::holds", (a044: rt.u8, a144: rt.ByteSlice, a244: rt.ByteVec): undefined => { + holds(a044, a144.data, a144.start, a144.length, a244); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_2149: rt.u8, data49: rt.ByteSlice, out50: rt.ByteVec): undefined => { + fmt_wrapped(data49.data, data49.start, data49.length, out50); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::to_refs", (_2150: rt.u8, data50: rt.ByteSlice, out51: rt.ByteVec): undefined => { - toRefs(data50, out51); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::orders", orders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_2151: rt.u8, data51: rt.ByteSlice, out52: rt.ByteVec): undefined => { - clonedArcs(data51, out52); + toRefs(data50.data, data50.start, data50.length, out51); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::orders", (a045: rt.u8, a145: rt.ByteSlice, a245: rt.ByteVec): undefined => { + orders(a045, a145.data, a145.start, a145.length, a245); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_2151: rt.u8, data51: rt.ByteSlice, out52: rt.ByteVec): undefined => { + clonedArcs(data51.data, data51.start, data51.length, out52); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_rcs", (_2152: rt.u8, data52: rt.ByteSlice, out53: rt.ByteVec): undefined => { - clonedRcs(data52, out53); + clonedRcs(data52.data, data52.start, data52.length, out53); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::copies", (_2153: rt.u8, data53: rt.ByteSlice, out54: rt.ByteVec): undefined => { - counts_copies(data53, out54); + counts_copies(data53.data, data53.start, data53.length, out54); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::cells", (_2154: rt.u8, data54: rt.ByteSlice, out55: rt.ByteVec): undefined => { - statics_cells(data54, out55); + statics_cells(data54.data, data54.start, data54.length, out55); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::returned", (_2155: rt.u8, data55: rt.ByteSlice, out56: rt.ByteVec): undefined => { - returned(data55, out56); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::values", hashes_values as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_2156: rt.u8, data56: rt.ByteSlice, out57: rt.ByteVec): undefined => { - random(data56, out57); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", floats_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", floats_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_2157: rt.u8, data57: rt.ByteSlice, out58: rt.ByteVec): undefined => { - orders_bytes(data57, out58); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::parts", slices_parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", slices_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_2158: rt.u8, data58: rt.ByteSlice, out59: rt.ByteVec): undefined => { - onces(data58, out59); + returned(data55.data, data55.start, data55.length, out56); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::values", (a046: rt.u8, a146: rt.ByteSlice, a246: rt.ByteVec): undefined => { + hashes_values(a046, a146.data, a146.start, a146.length, a246); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_2156: rt.u8, data56: rt.ByteSlice, out57: rt.ByteVec): undefined => { + random(data56.data, data56.start, data56.length, out57); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", (a047: rt.u8, a147: rt.ByteSlice, a247: rt.ByteVec): undefined => { + floats_formats(a047, a147.data, a147.start, a147.length, a247); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", (a048: rt.u8, a148: rt.ByteSlice, a248: rt.ByteVec): undefined => { + floats_parses(a048, a148.data, a148.start, a148.length, a248); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_2157: rt.u8, data57: rt.ByteSlice, out58: rt.ByteVec): undefined => { + orders_bytes(data57.data, data57.start, data57.length, out58); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::parts", (a049: rt.u8, a149: rt.ByteSlice, a249: rt.ByteVec): undefined => { + slices_parts(a049, a149.data, a149.start, a149.length, a249); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", (a050: rt.u8, a150: rt.ByteSlice, a250: rt.ByteVec): undefined => { + slices_drains(a050, a150.data, a150.start, a150.length, a250); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", (a051: rt.u8, a151: rt.ByteSlice, a251: rt.ByteVec): undefined => { + chunked(a051, a151.data, a151.start, a151.length, a251); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_2158: rt.u8, data58: rt.ByteSlice, out59: rt.ByteVec): undefined => { + onces(data58.data, data58.start, data58.length, out59); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::writes", (_2159: rt.u8, data59: rt.ByteSlice, out60: rt.ByteVec): undefined => { - fmt_writes(data59, out60); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", bounds_bounds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { - pointers_cells(data60, out61); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", ints_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", strs_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { - hashes_bytes(data61, out62); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", keys_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", strs_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { - pointers_rebound(data62, out63); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", slices_ranges as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_2163: rt.u8, data63: rt.ByteSlice, out64: rt.ByteVec): undefined => { - reducers(data63, out64); + fmt_writes(data59.data, data59.start, data59.length, out60); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", (a052: rt.u8, a152: rt.ByteSlice, a252: rt.ByteVec): undefined => { + bounds_bounds(a052, a152.data, a152.start, a152.length, a252); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { + pointers_cells(data60.data, data60.start, data60.length, out61); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", (a053: rt.u8, a153: rt.ByteSlice, a253: rt.ByteVec): undefined => { + ints_parses(a053, a153.data, a153.start, a153.length, a253); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", (a054: rt.u8, a154: rt.ByteSlice, a254: rt.ByteVec): undefined => { + strs_edits(a054, a154.data, a154.start, a154.length, a254); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", (a055: rt.u8, a155: rt.ByteSlice, a255: rt.ByteVec): undefined => { + subslices(a055, a155.data, a155.start, a155.length, a255); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { + hashes_bytes(data61.data, data61.start, data61.length, out62); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", (a056: rt.u8, a156: rt.ByteSlice, a256: rt.ByteVec): undefined => { + keys_bytes(a056, a156.data, a156.start, a156.length, a256); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", (a057: rt.u8, a157: rt.ByteSlice, a257: rt.ByteVec): undefined => { + strs_parses(a057, a157.data, a157.start, a157.length, a257); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { + pointers_rebound(data62.data, data62.start, data62.length, out63); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", (a058: rt.u8, a158: rt.ByteSlice, a258: rt.ByteVec): undefined => { + slices_ranges(a058, a158.data, a158.start, a158.length, a258); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_2163: rt.u8, data63: rt.ByteSlice, out64: rt.ByteVec): undefined => { + reducers(data63.data, data63.start, data63.length, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): undefined => { - writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { - pointers_made(data65, out66); + writers(data64.data, data64.start, data64.length, out65); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", (a059: rt.u8, a159: rt.ByteSlice, a259: rt.ByteVec): undefined => { + eqs(a059, a159.data, a159.start, a159.length, a259); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", (a060: rt.u8, a160: rt.ByteSlice, a260: rt.ByteVec): undefined => { + slices_edits(a060, a160.data, a160.start, a160.length, a260); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", (a061: rt.u8, a161: rt.ByteSlice, a261: rt.ByteVec): undefined => { + strs_iters(a061, a161.data, a161.start, a161.length, a261); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", (a062: rt.u8, a162: rt.ByteSlice, a262: rt.ByteVec): undefined => { + strs_drains(a062, a162.data, a162.start, a162.length, a262); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", (a063: rt.u8, a163: rt.ByteSlice, a263: rt.ByteVec): undefined => { + hinted(a063, a163.data, a163.start, a163.length, a263); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { + pointers_made(data65.data, data65.start, data65.length, out66); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_2166: rt.u8, data66: rt.ByteSlice, out67: rt.ByteVec): undefined => { - asSlices(data66, out67); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", widenings as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): undefined => { - uninhabited(data67, out68); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", lentKeys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", lentValues as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", singles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", singles_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", singles_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { - peekedOthers(data68, out69); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", hints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", folds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::zeros", zeros as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_2169: rt.u8, data69: rt.ByteSlice, out70: rt.ByteVec): undefined => { - maps(data69, out70); + asSlices(data66.data, data66.start, data66.length, out67); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", (a064: rt.u8, a164: rt.ByteSlice, a264: rt.ByteVec): undefined => { + widenings(a064, a164.data, a164.start, a164.length, a264); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): undefined => { + uninhabited(data67.data, data67.start, data67.length, out68); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", (a065: rt.u8, a165: rt.ByteSlice, a265: rt.ByteVec): undefined => { + lentKeys(a065, a165.data, a165.start, a165.length, a265); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", (a066: rt.u8, a166: rt.ByteSlice, a266: rt.ByteVec): undefined => { + lentValues(a066, a166.data, a166.start, a166.length, a266); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", (a067: rt.u8, a167: rt.ByteSlice, a267: rt.ByteVec): undefined => { + singles(a067, a167.data, a167.start, a167.length, a267); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", (a068: rt.u8, a168: rt.ByteSlice, a268: rt.ByteVec): undefined => { + singles_formats(a068, a168.data, a168.start, a168.length, a268); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", (a069: rt.u8, a169: rt.ByteSlice, a269: rt.ByteVec): undefined => { + singles_parses(a069, a169.data, a169.start, a169.length, a269); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { + peekedOthers(data68.data, data68.start, data68.length, out69); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", (a070: rt.u8, a170: rt.ByteSlice, a270: rt.ByteVec): undefined => { + hints(a070, a170.data, a170.start, a170.length, a270); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", (a071: rt.u8, a171: rt.ByteSlice, a271: rt.ByteVec): undefined => { + reserves(a071, a171.data, a171.start, a171.length, a271); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", (a072: rt.u8, a172: rt.ByteSlice, a272: rt.ByteVec): undefined => { + setOps(a072, a172.data, a172.start, a172.length, a272); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", (a073: rt.u8, a173: rt.ByteSlice, a273: rt.ByteVec): undefined => { + folds(a073, a173.data, a173.start, a173.length, a273); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::zeros", (a074: rt.u8, a174: rt.ByteSlice, a274: rt.ByteVec): undefined => { + zeros(a074, a174.data, a174.start, a174.length, a274); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_2169: rt.u8, data69: rt.ByteSlice, out70: rt.ByteVec): undefined => { + maps(data69.data, data69.start, data69.length, out70); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::lent", (_2170: rt.u8, data70: rt.ByteSlice, out71: rt.ByteVec): undefined => { - arrays_lent(data70, out71); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", floats_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", singles_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { - collections(data71, out72); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", zeros_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", zips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", zipsBack as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { - fmt_iters(data72, out73); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", unread as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", rangeFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", rangeMethods as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::iters", clones_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", compares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cycles::cycles", cycles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_2173: rt.u8, data73: rt.ByteSlice, out74: rt.ByteVec): undefined => { - lapsed(data73, out74); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", cows_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", cows_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u8s", wraps_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", wraps_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", wraps_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", wraps_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", wraps_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", wraps_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", wraps_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", wraps_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", wraps_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", wraps_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", wraps_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", wraps_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_2174: rt.u8, data74: rt.ByteSlice, out75: rt.ByteVec): undefined => { - enums(data74, out75); + arrays_lent(data70.data, data70.start, data70.length, out71); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", (a075: rt.u8, a175: rt.ByteSlice, a275: rt.ByteVec): undefined => { + floats_mulAdds(a075, a175.data, a175.start, a175.length, a275); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", (a076: rt.u8, a176: rt.ByteSlice, a276: rt.ByteVec): undefined => { + singles_mulAdds(a076, a176.data, a176.start, a176.length, a276); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { + collections(data71.data, data71.start, data71.length, out72); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", (a077: rt.u8, a177: rt.ByteSlice, a277: rt.ByteVec): undefined => { + unlikeEqs(a077, a177.data, a177.start, a177.length, a277); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", (a078: rt.u8, a178: rt.ByteSlice, a278: rt.ByteVec): undefined => { + impls(a078, a178.data, a178.start, a178.length, a278); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", (a079: rt.u8, a179: rt.ByteSlice, a279: rt.ByteVec): undefined => { + zeros_keys(a079, a179.data, a179.start, a179.length, a279); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", (a080: rt.u8, a180: rt.ByteSlice, a280: rt.ByteVec): undefined => { + arrays(a080, a180.data, a180.start, a180.length, a280); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", (a081: rt.u8, a181: rt.ByteSlice, a281: rt.ByteVec): undefined => { + zips(a081, a181.data, a181.start, a181.length, a281); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", (a082: rt.u8, a182: rt.ByteSlice, a282: rt.ByteVec): undefined => { + zipsBack(a082, a182.data, a182.start, a182.length, a282); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", (a083: rt.u8, a183: rt.ByteSlice, a283: rt.ByteVec): undefined => { + ownNes(a083, a183.data, a183.start, a183.length, a283); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { + fmt_iters(data72.data, data72.start, data72.length, out73); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", (a084: rt.u8, a184: rt.ByteSlice, a284: rt.ByteVec): undefined => { + unread(a084, a184.data, a184.start, a184.length, a284); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", (a085: rt.u8, a185: rt.ByteSlice, a285: rt.ByteVec): undefined => { + rangeFroms(a085, a185.data, a185.start, a185.length, a285); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", (a086: rt.u8, a186: rt.ByteSlice, a286: rt.ByteVec): undefined => { + rangeMethods(a086, a186.data, a186.start, a186.length, a286); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::iters", (a087: rt.u8, a187: rt.ByteSlice, a287: rt.ByteVec): undefined => { + clones_iters(a087, a187.data, a187.start, a187.length, a287); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", (a088: rt.u8, a188: rt.ByteSlice, a288: rt.ByteVec): undefined => { + cellEqs(a088, a188.data, a188.start, a188.length, a288); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", (a089: rt.u8, a189: rt.ByteSlice, a289: rt.ByteVec): undefined => { + compares(a089, a189.data, a189.start, a189.length, a289); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", (a090: rt.u8, a190: rt.ByteSlice, a290: rt.ByteVec): undefined => { + unlikeCompares(a090, a190.data, a190.start, a190.length, a290); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", (a091: rt.u8, a191: rt.ByteSlice, a291: rt.ByteVec): undefined => { + refOrders(a091, a191.data, a191.start, a191.length, a291); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cycles::cycles", (a092: rt.u8, a192: rt.ByteSlice, a292: rt.ByteVec): undefined => { + cycles(a092, a192.data, a192.start, a192.length, a292); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_2173: rt.u8, data73: rt.ByteSlice, out74: rt.ByteVec): undefined => { + lapsed(data73.data, data73.start, data73.length, out74); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", (a093: rt.u8, a193: rt.ByteSlice, a293: rt.ByteVec): undefined => { + cows_slices(a093, a193.data, a193.start, a193.length, a293); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", (a094: rt.u8, a194: rt.ByteSlice, a294: rt.ByteVec): undefined => { + cows_bytes(a094, a194.data, a194.start, a194.length, a294); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u8s", (a095: rt.u8, a195: rt.ByteSlice, a295: rt.ByteVec): undefined => { + wraps_u8s(a095, a195.data, a195.start, a195.length, a295); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", (a096: rt.u8, a196: rt.ByteSlice, a296: rt.ByteVec): undefined => { + wraps_u16s(a096, a196.data, a196.start, a196.length, a296); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", (a097: rt.u8, a197: rt.ByteSlice, a297: rt.ByteVec): undefined => { + wraps_u32s(a097, a197.data, a197.start, a197.length, a297); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", (a098: rt.u8, a198: rt.ByteSlice, a298: rt.ByteVec): undefined => { + wraps_u64s(a098, a198.data, a198.start, a198.length, a298); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", (a099: rt.u8, a199: rt.ByteSlice, a299: rt.ByteVec): undefined => { + wraps_u128s(a099, a199.data, a199.start, a199.length, a299); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", (a0100: rt.u8, a1100: rt.ByteSlice, a2100: rt.ByteVec): undefined => { + wraps_usizes(a0100, a1100.data, a1100.start, a1100.length, a2100); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", (a0101: rt.u8, a1101: rt.ByteSlice, a2101: rt.ByteVec): undefined => { + wraps_i8s(a0101, a1101.data, a1101.start, a1101.length, a2101); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", (a0102: rt.u8, a1102: rt.ByteSlice, a2102: rt.ByteVec): undefined => { + wraps_i16s(a0102, a1102.data, a1102.start, a1102.length, a2102); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", (a0103: rt.u8, a1103: rt.ByteSlice, a2103: rt.ByteVec): undefined => { + wraps_i32s(a0103, a1103.data, a1103.start, a1103.length, a2103); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", (a0104: rt.u8, a1104: rt.ByteSlice, a2104: rt.ByteVec): undefined => { + wraps_i64s(a0104, a1104.data, a1104.start, a1104.length, a2104); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", (a0105: rt.u8, a1105: rt.ByteSlice, a2105: rt.ByteVec): undefined => { + wraps_i128s(a0105, a1105.data, a1105.start, a1105.length, a2105); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", (a0106: rt.u8, a1106: rt.ByteSlice, a2106: rt.ByteVec): undefined => { + wraps_isizes(a0106, a1106.data, a1106.start, a1106.length, a2106); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_2174: rt.u8, data74: rt.ByteSlice, out75: rt.ByteVec): undefined => { + enums(data74.data, data74.start, data74.length, out75); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::segments", (_2175: rt.u8, data75: rt.ByteSlice, out76: rt.ByteVec): undefined => { - segments(data75, out76); + segments(data75.data, data75.start, data75.length, out76); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::uninit_runs", (_2176: rt.u8, data76: rt.ByteSlice, out77: rt.ByteVec): undefined => { - uninitRuns(data76, out77); + uninitRuns(data76.data, data76.start, data76.length, out77); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::beside_written", (_2177: rt.u8, data77: rt.ByteSlice, out78: rt.ByteVec): undefined => { - besideWritten(data77, out78); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", byteRefs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_2178: rt.u8, data78: rt.ByteSlice, out79: rt.ByteVec): undefined => { - orders_held(data78, out79); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", joins as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { - iteratedRuns(data79, out80); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", zeros_writes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { - orders_tuples(data80, out81); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", tuples_tuples as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", saturates_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", saturates_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", saturates_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", saturates_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", saturates_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", saturates_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", saturates_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", saturates_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", saturates_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", saturates_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", saturates_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", saturates_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", methods_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", methods_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", methods_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", methods_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", methods_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", methods_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", methods_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", methods_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", methods_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", methods_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", methods_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", methods_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", separated as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { - waiters(data81, out82); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::boxes", boxes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::bytes", ascii_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", ascii_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", ascii_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", given as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_2182: rt.u8, data82: rt.ByteSlice, out83: rt.ByteVec): undefined => { - pointers_taken(data82, out83); + besideWritten(data77.data, data77.start, data77.length, out78); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", (a0107: rt.u8, a1107: rt.ByteSlice, a2107: rt.ByteVec): undefined => { + byteRefs(a0107, a1107.data, a1107.start, a1107.length, a2107); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_2178: rt.u8, data78: rt.ByteSlice, out79: rt.ByteVec): undefined => { + orders_held(data78.data, data78.start, data78.length, out79); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", (a0108: rt.u8, a1108: rt.ByteSlice, a2108: rt.ByteVec): undefined => { + joins(a0108, a1108.data, a1108.start, a1108.length, a2108); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { + iteratedRuns(data79.data, data79.start, data79.length, out80); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", (a0109: rt.u8, a1109: rt.ByteSlice, a2109: rt.ByteVec): undefined => { + zeros_writes(a0109, a1109.data, a1109.start, a1109.length, a2109); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { + orders_tuples(data80.data, data80.start, data80.length, out81); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", (a0110: rt.u8, a1110: rt.ByteSlice, a2110: rt.ByteVec): undefined => { + tuples_tuples(a0110, a1110.data, a1110.start, a1110.length, a2110); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", (a0111: rt.u8, a1111: rt.ByteSlice, a2111: rt.ByteVec): undefined => { + saturates_u8s(a0111, a1111.data, a1111.start, a1111.length, a2111); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", (a0112: rt.u8, a1112: rt.ByteSlice, a2112: rt.ByteVec): undefined => { + saturates_u16s(a0112, a1112.data, a1112.start, a1112.length, a2112); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", (a0113: rt.u8, a1113: rt.ByteSlice, a2113: rt.ByteVec): undefined => { + saturates_u32s(a0113, a1113.data, a1113.start, a1113.length, a2113); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", (a0114: rt.u8, a1114: rt.ByteSlice, a2114: rt.ByteVec): undefined => { + saturates_u64s(a0114, a1114.data, a1114.start, a1114.length, a2114); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", (a0115: rt.u8, a1115: rt.ByteSlice, a2115: rt.ByteVec): undefined => { + saturates_u128s(a0115, a1115.data, a1115.start, a1115.length, a2115); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", (a0116: rt.u8, a1116: rt.ByteSlice, a2116: rt.ByteVec): undefined => { + saturates_usizes(a0116, a1116.data, a1116.start, a1116.length, a2116); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", (a0117: rt.u8, a1117: rt.ByteSlice, a2117: rt.ByteVec): undefined => { + saturates_i8s(a0117, a1117.data, a1117.start, a1117.length, a2117); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", (a0118: rt.u8, a1118: rt.ByteSlice, a2118: rt.ByteVec): undefined => { + saturates_i16s(a0118, a1118.data, a1118.start, a1118.length, a2118); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", (a0119: rt.u8, a1119: rt.ByteSlice, a2119: rt.ByteVec): undefined => { + saturates_i32s(a0119, a1119.data, a1119.start, a1119.length, a2119); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", (a0120: rt.u8, a1120: rt.ByteSlice, a2120: rt.ByteVec): undefined => { + saturates_i64s(a0120, a1120.data, a1120.start, a1120.length, a2120); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", (a0121: rt.u8, a1121: rt.ByteSlice, a2121: rt.ByteVec): undefined => { + saturates_i128s(a0121, a1121.data, a1121.start, a1121.length, a2121); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", (a0122: rt.u8, a1122: rt.ByteSlice, a2122: rt.ByteVec): undefined => { + saturates_isizes(a0122, a1122.data, a1122.start, a1122.length, a2122); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", (a0123: rt.u8, a1123: rt.ByteSlice, a2123: rt.ByteVec): undefined => { + methods_u8s(a0123, a1123.data, a1123.start, a1123.length, a2123); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", (a0124: rt.u8, a1124: rt.ByteSlice, a2124: rt.ByteVec): undefined => { + methods_u16s(a0124, a1124.data, a1124.start, a1124.length, a2124); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", (a0125: rt.u8, a1125: rt.ByteSlice, a2125: rt.ByteVec): undefined => { + methods_u32s(a0125, a1125.data, a1125.start, a1125.length, a2125); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", (a0126: rt.u8, a1126: rt.ByteSlice, a2126: rt.ByteVec): undefined => { + methods_u64s(a0126, a1126.data, a1126.start, a1126.length, a2126); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", (a0127: rt.u8, a1127: rt.ByteSlice, a2127: rt.ByteVec): undefined => { + methods_u128s(a0127, a1127.data, a1127.start, a1127.length, a2127); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", (a0128: rt.u8, a1128: rt.ByteSlice, a2128: rt.ByteVec): undefined => { + methods_usizes(a0128, a1128.data, a1128.start, a1128.length, a2128); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", (a0129: rt.u8, a1129: rt.ByteSlice, a2129: rt.ByteVec): undefined => { + methods_i8s(a0129, a1129.data, a1129.start, a1129.length, a2129); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", (a0130: rt.u8, a1130: rt.ByteSlice, a2130: rt.ByteVec): undefined => { + methods_i16s(a0130, a1130.data, a1130.start, a1130.length, a2130); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", (a0131: rt.u8, a1131: rt.ByteSlice, a2131: rt.ByteVec): undefined => { + methods_i32s(a0131, a1131.data, a1131.start, a1131.length, a2131); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", (a0132: rt.u8, a1132: rt.ByteSlice, a2132: rt.ByteVec): undefined => { + methods_i64s(a0132, a1132.data, a1132.start, a1132.length, a2132); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", (a0133: rt.u8, a1133: rt.ByteSlice, a2133: rt.ByteVec): undefined => { + methods_i128s(a0133, a1133.data, a1133.start, a1133.length, a2133); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", (a0134: rt.u8, a1134: rt.ByteSlice, a2134: rt.ByteVec): undefined => { + methods_isizes(a0134, a1134.data, a1134.start, a1134.length, a2134); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", (a0135: rt.u8, a1135: rt.ByteSlice, a2135: rt.ByteVec): undefined => { + separated(a0135, a1135.data, a1135.start, a1135.length, a2135); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { + waiters(data81.data, data81.start, data81.length, out82); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::boxes", (a0136: rt.u8, a1136: rt.ByteSlice, a2136: rt.ByteVec): undefined => { + boxes(a0136, a1136.data, a1136.start, a1136.length, a2136); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::bytes", (a0137: rt.u8, a1137: rt.ByteSlice, a2137: rt.ByteVec): undefined => { + ascii_bytes(a0137, a1137.data, a1137.start, a1137.length, a2137); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", (a0138: rt.u8, a1138: rt.ByteSlice, a2138: rt.ByteVec): undefined => { + ascii_chars(a0138, a1138.data, a1138.start, a1138.length, a2138); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", (a0139: rt.u8, a1139: rt.ByteSlice, a2139: rt.ByteVec): undefined => { + ascii_slices(a0139, a1139.data, a1139.start, a1139.length, a2139); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", (a0140: rt.u8, a1140: rt.ByteSlice, a2140: rt.ByteVec): undefined => { + given(a0140, a1140.data, a1140.start, a1140.length, a2140); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_2182: rt.u8, data82: rt.ByteSlice, out83: rt.ByteVec): undefined => { + pointers_taken(data82.data, data82.start, data82.length, out83); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::bytes", (_2183: rt.u8, data83: rt.ByteSlice, out84: rt.ByteVec): undefined => { - pointers_bytes(data83, out84); + pointers_bytes(data83.data, data83.start, data83.length, out84); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::loaded", (_2184: rt.u8, data84: rt.ByteSlice, out85: rt.ByteVec): undefined => { - loaded(data84, out85); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", btrees as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + loaded(data84.data, data84.start, data84.length, out85); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", (a0141: rt.u8, a1141: rt.ByteSlice, a2141: rt.ByteVec): undefined => { + btrees(a0141, a1141.data, a1141.start, a1141.length, a2141); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", (a0142: rt.u8, a1142: rt.ByteSlice, a2142: rt.ByteVec): undefined => { + args(a0142, a1142.data, a1142.start, a1142.length, a2142); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", (a0143: rt.u8, a1143: rt.ByteSlice, a2143: rt.ByteVec): undefined => { + returns(a0143, a1143.data, a1143.start, a1143.length, a2143); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ @@ -258,20 +546,20 @@ export function op(name: string): rt.u8 { } /** Negate the signed type `kind` picks. */ -export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function neg(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - i8Neg(data, out); + i8Neg(dataData, dataStart, dataLen, out); } else if (_4 === 1) { - i16Neg(data, out); + i16Neg(dataData, dataStart, dataLen, out); } else if (_4 === 2) { - i32Neg(data, out); + i32Neg(dataData, dataStart, dataLen, out); } else if (_4 === 3) { - i64Neg(data, out); + i64Neg(dataData, dataStart, dataLen, out); } else if (_4 === 4) { - i128Neg(data, out); + i128Neg(dataData, dataStart, dataLen, out); } else { - isizeNeg(data, out); + isizeNeg(dataData, dataStart, dataLen, out); } } @@ -279,11 +567,11 @@ export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Cast from the type `kind` picks to the one the next byte does, or without one, to * a type `kind` also picks. */ -export function cast(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length === 0) { - ints_cast(kind, rt.u8Div(kind, 12), data, out); +export function cast(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen === 0) { + ints_cast(kind, rt.u8Div(kind, 12), dataData, dataStart, dataLen, out); } else { - ints_cast(kind, data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1), out); + ints_cast(kind, dataData[dataStart], dataData, dataStart + 1, dataLen - 1, out); } } diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 893e58554..938b66a6e 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -18,7 +18,8 @@ import * as Tilt from "./iters.Tilt.ts"; import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ -export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function adaptors(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); b0: { const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { @@ -80,7 +81,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, skipped.length & 0xff); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(mapped)); } else if (_4 === 4) { - const words: rt.ByteVec[] = chunksByZero$iters_ChunksByZero_slice_u8(data); + const words: rt.ByteVec[] = chunksByZero$iters_ChunksByZero_slice_u8(data.data, data.start, data.length); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); }), "next"))); @@ -158,10 +159,10 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** The runs between zero bytes. */ -export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt.ByteVec[] { +export function chunksByZero$iters_ChunksByZero_slice_u8(selfData: Uint8Array, selfStart: number, selfLen: number): rt.ByteVec[] { const words: rt.ByteVec[] = []; let word: rt.ByteVec = new rt.ByteVec(); - for (const b of rt.byteSliceView(self)) { + for (const b of rt.byteSliceView(new rt.ByteSlice(selfData, selfStart, selfLen))) { if (!(b === 0)) { rt.byteVecPush(word, b); } else { @@ -175,7 +176,8 @@ export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt } /** Consumers, and how far each reads: `log` records every item a closure sees. */ -export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function consumers(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const log: rt.ByteVec = new rt.ByteVec(); const _5: rt.u8 = rt.u8Rem(kind, 6); if (_5 === 0) { @@ -314,7 +316,8 @@ export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi * `reduce`, `max_by`, and `min_by`, whose comparators log each pair they see, and * `Peekable`'s `peek_mut` and `next_if_eq`. */ -export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { +export function reducers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const log: rt.ByteVec = new rt.ByteVec(); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMaxBy(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8, _3: rt.u8): rt.Ordering => { const a: rt.u8 = _2; @@ -387,9 +390,9 @@ export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Qu return rt.u8Rem(self, 4) === rt.u8Rem(other._0, 4); } -export function eq$cmp_PartialEq_iters_Quarter_array2_u8(self: rt.ByteSlice, other: Quarter.Quarter): boolean { +export function eq$cmp_PartialEq_iters_Quarter_array2_u8(selfData: Uint8Array, selfStart: number, selfLen: number, other: Quarter.Quarter): boolean { rt.cellSet(other._1, rt.u8WrappingAdd(other._1.v, 64)); - return rt.iterSum(rt.iterSlice(rt.byteSliceView(self)), rt.u8Add, 0) === other._0; + return rt.iterSum(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(selfData, selfStart, selfLen))), rt.u8Add, 0) === other._0; } export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quarter.Quarter): boolean { @@ -402,7 +405,8 @@ export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quart * `PartialEq`: std's across strings and slices, and the crate's own. Each matches the * first item, and a mismatch keeps the item for the next `next`. */ -export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { +export function peekedOthers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.u8) => string = (b: rt.u8): string => { const _42: rt.char = rt.u8Add(97, rt.u8Rem(b, 3)) as rt.char; return rt.fmtToString((f: rt.Formatter) => rt.fmtCharDisplay(_42, f)); @@ -544,7 +548,9 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { return p2[0]; })); rt.byteVecPush(out, option_mapOr$0sl5app(rt.peekableNextIfEq(it9, { _0: 1, _1: calls }, (a2: Uint8Array, b8: Quarter.Quarter): boolean => { - return eq$cmp_PartialEq_iters_Quarter_array2_u8(rt.byteSliceFrom(a2), b8); + return ((a018: rt.ByteSlice, a114: Quarter.Quarter): boolean => { + return eq$cmp_PartialEq_iters_Quarter_array2_u8(a018.data, a018.start, a018.length, a114); + })(rt.byteSliceFrom(a2), b8); }), 170, (p3: Uint8Array): rt.u8 => { return p3[0]; })); @@ -605,7 +611,7 @@ export function rotateFree$iters_RotateFree_u8(self: rt.u8): rt.u8 { * `nth` and `nth_back` through each adaptor, of a source whose reads `by_ref` or * `inspect` shows: each reads on past a `take`'s limit, or stops at it, as std's does. */ -export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function skips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let item!: rt.u8 | undefined; let item2!: rt.u8 | undefined; let item3!: rt.u8 | undefined; @@ -634,6 +640,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let item26!: rt.u8 | undefined; let item27!: [rt.u8, rt.u8] | undefined; let item28!: Uint8Array | undefined; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { return rt.usizeRem(_2 as rt.usize, 4); }); @@ -1017,7 +1024,8 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `min_by_key` and `max_by_key` by keys that are tuples, `Reverse`s, `Option`s, and the * crate's own orders, `min` and `max` of such items, and `rposition` and `rfind`. */ -export function ranked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function ranked(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _4: (a0: rt.ByteVec, a1: [rt.usize, rt.u8] | undefined) => undefined = (out2: rt.ByteVec, found2: [rt.usize, rt.u8] | undefined): undefined => { rt.byteVecPush(out2, option_mapOr$06gg5x7(found2, 255, (_2: [rt.usize, rt.u8]): rt.u8 => { return _2[0] & 0xff; @@ -1145,7 +1153,8 @@ export function ranked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Ranges as values and as iterators. */ -export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ranges(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const range: rt.Range = new rt.Range(a, b); @@ -1231,15 +1240,16 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { for (const _295 of rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)), undefined, 4, true)) { rt.byteVecPush(out, _295 & 0xff); } - updates(a, b, data, out); + updates(a, b, data.data, data.start, data.length, out); } /** * Struct update syntax on std's ranges: the fields written run before the base, and * the rest are read from it. */ -export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function updates(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _29!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const base: rt.Range = new rt.Range(a, b); rt.byteVecPush(out, 208); const _7: rt.u8 = rt.u8Div(b, 2); @@ -1284,7 +1294,8 @@ export function fullRange(out: rt.ByteVec): undefined { } /** Iterators of `Option`, which keep each `None` apart from their end. */ -export function options(data: rt.ByteSlice, out: rt.ByteVec): void { +export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _83: (a0: rt.u8, a1: rt.ByteVec) => rt.u8 | undefined = (b2: rt.u8, calls2: rt.ByteVec): rt.u8 | undefined => { rt.byteVecPush(calls2, b2); return option_map$0cs071d(rt.u8CheckedSub(b2, 1), (b3: rt.u8): rt.u8 => { @@ -1392,7 +1403,8 @@ export function second$iter_Map_slice_Iter_u8_iters_options_closure0(items: rt.I } /** The crate's own iterators, through `for`, adaptors, and `next`. */ -export function own(data: rt.ByteSlice, out: rt.ByteVec): void { +export function own(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const left: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const step: rt.u8 = rt.max(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 1), 1); const iter: iters_Countdown.Countdown = { left, step }; @@ -1443,20 +1455,22 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { * The last two bytes of `data`, as a `slice::Iter` made from the second argument: a * `for` must iterate it, not the first. */ -export function tail(_head: rt.ByteSlice, data: rt.ByteSlice): rt.Iter { - return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.usizeSaturatingSub(data.length, 2)))); +export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, dataData: Uint8Array, dataStart: number, dataLen: number): rt.Iter { + return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.usizeSaturatingSub(dataLen, 2)))); } /** The odd bytes, from a function returning `impl Iterator`. */ -export function odds(data: rt.ByteSlice): rt.Iter { - return rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): boolean => { +export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Iter { + return rt.iterFilter(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (b: rt.u8): boolean => { return rt.u8Rem(b, 2) === 1; }); } /** Iterators as values: returned, stored, and printed. */ -export function values(data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = tail(rt.byteSliceFrom(Uint8Array.of(1, 2, 3)), data); +export function values(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + const _5: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); + const iter: rt.Iter = tail(_5.data, _5.start, _5.length, data.data, data.start, data.length); while (true) { const _8: rt.u8 | rt.Done = iter.next(); if (_8 === rt.DONE) { @@ -1466,7 +1480,7 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { } const held: iters_Held.Held = { it: rt.iterSlice(rt.byteSliceView(data)) }; rt.byteVecPush(out, iters_Held.skipOne(held)); - const iter2: rt.Iter = odds(data); + const iter2: rt.Iter = odds(data.data, data.start, data.length); while (true) { const _21: rt.u8 | rt.Done = iter2.next(); if (_21 === rt.DONE) { @@ -1519,7 +1533,8 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { * What std's `Option`-returning calls give, returned as is: an `Option`, whose `None` * stays apart from an item's own. */ -export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { +export function returned(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.u8 | undefined, a1: rt.ByteVec) => undefined = (b: rt.u8 | undefined, out2: rt.ByteVec): undefined => { rt.byteVecPush(out2, option_mapOr$1surhce(b, 170, (b2: rt.u8): rt.u8 => { return b2; @@ -1578,13 +1593,13 @@ export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { _3(part12, out); const part13 = borrowed(it); _3(part13, out); - const part14 = secondOf(data); + const part14 = secondOf(data.data, data.start, data.length); _3(part14, out); const part15 = fromOne(n & 0xff); _3(part15, out); const part16 = peeked$iter_Copied_slice_Iter_u8(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data)))); _3(part16, out); - const part17 = at$u8(data, n); + const part17 = at$u8(data.data, data.start, data.length, n); _3(part17, out); const part18 = at$Option_u8(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b8: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b8, 3) === 0)) { @@ -1647,8 +1662,8 @@ export function borrowed(it: rt.Iter): rt.u8 | undefined { } /** Of a slice's iterator the function makes. */ -export function secondOf(data: rt.ByteSlice): rt.u8 | undefined { - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); +export function secondOf(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + const it: rt.Iter = rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))); it.next(); return rt.iterToOption(it.next()); } @@ -1667,8 +1682,8 @@ export function at$Option_u8(items: Array, i: rt.usize): rt.u return rt.sliceGet(items, i, rt.None); } -export function at$u8(items: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { - return rt.byteSliceGet(items, i); +export function at$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: number, i: rt.usize): rt.u8 | undefined { + return rt.byteSliceGet(new rt.ByteSlice(itemsData, itemsStart, itemsLen), i); } /** @@ -1677,7 +1692,7 @@ export function at$u8(items: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { * (`TrustedLen`, or only `TrustedRandomAccessNoCoerce`), and by `next` (neither), read by * each of std's consumers, and through adaptors that fold it or read it by `try_fold`. */ -export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _18!: [rt.ByteSlice, rt.ByteSlice]; const _40: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2: [rt.u8, rt.u8]): rt.u8 => { return _2[0] ^ _2[1]; @@ -1700,19 +1715,19 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _1101: (a0: [rt.u8, rt.u8]) => rt.u8 = (_221: [rt.u8, rt.u8]): rt.u8 => { return _221[0] ^ _221[1]; }; - const mid: number = rt.usizeRem(kind >> 5 as rt.usize, rt.usizeAdd(data.length, 1)); - if (mid > data.length) { + const mid: number = rt.usizeRem(kind >> 5 as rt.usize, rt.usizeAdd(dataLen, 1)); + if (mid > dataLen) { rt.panic("mid > len"); } if (!((kind & 8) === 0)) { - _18 = [new rt.ByteSlice(data.data, data.start + mid, data.length - mid), new rt.ByteSlice(data.data, data.start, mid)] as [rt.ByteSlice, rt.ByteSlice]; + _18 = [new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), new rt.ByteSlice(dataData, dataStart, mid)] as [rt.ByteSlice, rt.ByteSlice]; } else { - _18 = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rt.ByteSlice, rt.ByteSlice]; + _18 = [new rt.ByteSlice(dataData, dataStart, mid), new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid)] as [rt.ByteSlice, rt.ByteSlice]; } const a2: rt.ByteSlice = _18[0]; const b2: rt.ByteSlice = _18[1]; const other: boolean = (kind & 4) !== 0; - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_223: rt.u8): rt.usize => { + const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0, (_223: rt.u8): rt.usize => { return rt.usizeRem(_223 as rt.usize, 4); }); const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); @@ -1732,7 +1747,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.refMutRelease(_6239); return x232; }), [true, true]); - const _41: rt.usize = rt.usizeRem(data.length, 8); + const _41: rt.usize = rt.usizeRem(dataLen, 8); if (_41 === 0) { rt.byteVecPush(out, rt.iterCount(z) & 0xff); } else if (_41 === 1) { @@ -1781,7 +1796,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _79: rt.usize = rt.usizeRem(data.length, 8); + const _79: rt.usize = rt.usizeRem(dataLen, 8); if (_79 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2287: rt.u8): rt.u8 => { const x228: rt.u8 = _2287; @@ -1921,7 +1936,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.refMutRelease(_6219); return x201; }), "len"); - const _202: rt.usize = rt.usizeRem(data.length, 8); + const _202: rt.usize = rt.usizeRem(dataLen, 8); if (_202 === 0) { rt.byteVecPush(out, rt.iterCount(z3) & 0xff); } else if (_202 === 1) { @@ -1970,7 +1985,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _240: rt.usize = rt.usizeRem(data.length, 8); + const _240: rt.usize = rt.usizeRem(dataLen, 8); if (_240 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2256: rt.u8): rt.u8 => { const x197: rt.u8 = _2256; @@ -2108,7 +2123,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.refMutRelease(_6199); return x170; }), "len"); - const _381: rt.usize = rt.usizeRem(data.length, 8); + const _381: rt.usize = rt.usizeRem(dataLen, 8); if (_381 === 0) { rt.byteVecPush(out, rt.iterCount(z5) & 0xff); } else if (_381 === 1) { @@ -2157,7 +2172,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _419: rt.usize = rt.usizeRem(data.length, 8); + const _419: rt.usize = rt.usizeRem(dataLen, 8); if (_419 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2225: rt.u8): rt.u8 => { const x166: rt.u8 = _2225; @@ -2295,7 +2310,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.refMutRelease(_6179); return x139; }), "len"); - const _574: rt.usize = rt.usizeRem(data.length, 8); + const _574: rt.usize = rt.usizeRem(dataLen, 8); if (_574 === 0) { rt.byteVecPush(out, rt.iterCount(z7) & 0xff); } else if (_574 === 1) { @@ -2344,7 +2359,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _612: rt.usize = rt.usizeRem(data.length, 8); + const _612: rt.usize = rt.usizeRem(dataLen, 8); if (_612 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x135: rt.u8): rt.u8 => { const _6176: rt.RefCell = rt.refCellBorrowMut(log); @@ -2465,7 +2480,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.refMutRelease(_6159); return x108; }), "len"); - const _751: rt.usize = rt.usizeRem(data.length, 8); + const _751: rt.usize = rt.usizeRem(dataLen, 8); if (_751 === 0) { rt.byteVecPush(out, rt.iterCount(z9) & 0xff); } else if (_751 === 1) { @@ -2514,7 +2529,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _789: rt.usize = rt.usizeRem(data.length, 8); + const _789: rt.usize = rt.usizeRem(dataLen, 8); if (_789 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x104: rt.u8): rt.u8 => { const _6156: rt.RefCell = rt.refCellBorrowMut(log); @@ -2647,7 +2662,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.refMutRelease(_6139); return x77; })); - const _927: rt.usize = rt.usizeRem(data.length, 8); + const _927: rt.usize = rt.usizeRem(dataLen, 8); if (_927 === 0) { rt.byteVecPush(out, rt.iterCount(z11) & 0xff); } else if (_927 === 1) { @@ -2696,7 +2711,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _965: rt.usize = rt.usizeRem(data.length, 8); + const _965: rt.usize = rt.usizeRem(dataLen, 8); if (_965 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2157: rt.u8): rt.u8 => { const x73: rt.u8 = _2157; @@ -2858,7 +2873,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), "len"), (_2123: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { return [_2123[0][0] ^ _2123[1], _2123[0][1]] as [rt.u8, rt.u8]; }); - const _1102: rt.usize = rt.usizeRem(data.length, 8); + const _1102: rt.usize = rt.usizeRem(dataLen, 8); if (_1102 === 0) { rt.byteVecPush(out, rt.iterCount(z13) & 0xff); } else if (_1102 === 1) { @@ -2907,7 +2922,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })); } } else { - const _1140: rt.usize = rt.usizeRem(data.length, 8); + const _1140: rt.usize = rt.usizeRem(dataLen, 8); if (_1140 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2115: rt.u8): rt.u8 => { const x38: rt.u8 = _2115; @@ -3106,7 +3121,8 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * std trims the longer side on the first pair it reads from the back, and a by-index zip * reads no item it never yields from a side that does not log, nor through `nth` it skips. */ -export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function zipsBack(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _20: (a0: rt.ByteSlice) => rt.u8 = (c: rt.ByteSlice): rt.u8 => { return c.length & 0xff; }; @@ -3435,73 +3451,73 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * takes and as its own, stepping up to its type's last value, past which std's debug * build panics, and ranges of `char` across the surrogates, which they skip. */ -export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); +export function rangeFroms(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0); const near: rt.u8 = rt.u8Rem(a, 4); const how: rt.u8 = kind >> 6; const _12: rt.u8 = rt.u8Rem(kind, 16); if (_12 === 0) { - fromTop$u8_iters_range_froms_closure0(rt.u8Sub(255, near), data, how, out, (x14: rt.u8, out15: rt.ByteVec): undefined => { + fromTop$u8_iters_range_froms_closure0(rt.u8Sub(255, near), dataData, dataStart, dataLen, how, out, (x14: rt.u8, out15: rt.ByteVec): undefined => { rt.byteVecPush(out15, x14); }); } else if (_12 === 1) { - fromTop$u16_iters_range_froms_closure1(rt.u16Sub(65535, near as rt.u16), data, how, out, (x13: rt.u16, out14: rt.ByteVec): undefined => { + fromTop$u16_iters_range_froms_closure1(rt.u16Sub(65535, near as rt.u16), dataData, dataStart, dataLen, how, out, (x13: rt.u16, out14: rt.ByteVec): undefined => { rt.iterExtendBytes(out14, rt.iterSlice(rt.u16ToBeBytes(x13).reverse()), undefined, true); }); } else if (_12 === 2) { - fromTop$u32_iters_range_froms_closure2(rt.u32Sub(4294967295, near as rt.u32), data, how, out, (x12: rt.u32, out13: rt.ByteVec): undefined => { + fromTop$u32_iters_range_froms_closure2(rt.u32Sub(4294967295, near as rt.u32), dataData, dataStart, dataLen, how, out, (x12: rt.u32, out13: rt.ByteVec): undefined => { rt.iterExtendBytes(out13, rt.iterSlice(rt.u32ToBeBytes(x12).reverse()), undefined, true); }); } else if (_12 === 3) { - fromTop$u64_iters_range_froms_closure3(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, near as rt.u64), data, how, out, (x11: rt.u64, out12: rt.ByteVec): undefined => { + fromTop$u64_iters_range_froms_closure3(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, near as rt.u64), dataData, dataStart, dataLen, how, out, (x11: rt.u64, out12: rt.ByteVec): undefined => { rt.iterExtendBytes(out12, rt.iterSlice(rt.u64ToBeBytes(x11).reverse()), undefined, true); }); } else if (_12 === 4) { - fromTop$u128_iters_range_froms_closure4(rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, near as rt.u128), data, how, out, (x10: rt.u128, out11: rt.ByteVec): undefined => { + fromTop$u128_iters_range_froms_closure4(rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, near as rt.u128), dataData, dataStart, dataLen, how, out, (x10: rt.u128, out11: rt.ByteVec): undefined => { rt.iterExtendBytes(out11, rt.iterSlice(rt.u128ToBeBytes(x10).reverse()), undefined, true); }); } else if (_12 === 5) { - fromTop$usize_iters_range_froms_closure5(rt.usizeSub(4294967295, near as rt.usize), data, how, out, (x9: rt.usize, out10: rt.ByteVec): undefined => { + fromTop$usize_iters_range_froms_closure5(rt.usizeSub(4294967295, near as rt.usize), dataData, dataStart, dataLen, how, out, (x9: rt.usize, out10: rt.ByteVec): undefined => { rt.iterExtendBytes(out10, rt.iterSlice(rt.usizeToBeBytes(x9).reverse()), undefined, true); }); } else if (_12 === 6) { - fromTop$i8_iters_range_froms_closure6(rt.i8Sub(127, (near << 24) >> 24), data, how, out, (x8: rt.i8, out9: rt.ByteVec): undefined => { + fromTop$i8_iters_range_froms_closure6(rt.i8Sub(127, (near << 24) >> 24), dataData, dataStart, dataLen, how, out, (x8: rt.i8, out9: rt.ByteVec): undefined => { rt.iterExtendBytes(out9, rt.iterSlice(rt.i8ToBeBytes(x8).reverse()), undefined, true); }); } else if (_12 === 7) { - fromTop$i16_iters_range_froms_closure7(rt.i16Sub(32767, near as rt.i16), data, how, out, (x7: rt.i16, out8: rt.ByteVec): undefined => { + fromTop$i16_iters_range_froms_closure7(rt.i16Sub(32767, near as rt.i16), dataData, dataStart, dataLen, how, out, (x7: rt.i16, out8: rt.ByteVec): undefined => { rt.iterExtendBytes(out8, rt.iterSlice(rt.i16ToBeBytes(x7).reverse()), undefined, true); }); } else if (_12 === 8) { - fromTop$i32_iters_range_froms_closure8(rt.i32Sub(2147483647, near as rt.i32), data, how, out, (x6: rt.i32, out7: rt.ByteVec): undefined => { + fromTop$i32_iters_range_froms_closure8(rt.i32Sub(2147483647, near as rt.i32), dataData, dataStart, dataLen, how, out, (x6: rt.i32, out7: rt.ByteVec): undefined => { rt.iterExtendBytes(out7, rt.iterSlice(rt.i32ToBeBytes(x6).reverse()), undefined, true); }); } else if (_12 === 9) { - fromTop$i64_iters_range_froms_closure9(rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, near as rt.i64), data, how, out, (x5: rt.i64, out6: rt.ByteVec): undefined => { + fromTop$i64_iters_range_froms_closure9(rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, near as rt.i64), dataData, dataStart, dataLen, how, out, (x5: rt.i64, out6: rt.ByteVec): undefined => { rt.iterExtendBytes(out6, rt.iterSlice(rt.i64ToBeBytes(x5).reverse()), undefined, true); }); } else if (_12 === 10) { - fromTop$i128_iters_range_froms_closure10(rt.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, near as rt.i128), data, how, out, (x4: rt.i128, out5: rt.ByteVec): undefined => { + fromTop$i128_iters_range_froms_closure10(rt.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, near as rt.i128), dataData, dataStart, dataLen, how, out, (x4: rt.i128, out5: rt.ByteVec): undefined => { rt.iterExtendBytes(out5, rt.iterSlice(rt.i128ToBeBytes(x4).reverse()), undefined, true); }); } else if (_12 === 11) { - fromTop$isize_iters_range_froms_closure11(rt.isizeSub(2147483647, near as rt.isize), data, how, out, (x3: rt.isize, out4: rt.ByteVec): undefined => { + fromTop$isize_iters_range_froms_closure11(rt.isizeSub(2147483647, near as rt.isize), dataData, dataStart, dataLen, how, out, (x3: rt.isize, out4: rt.ByteVec): undefined => { rt.iterExtendBytes(out4, rt.iterSlice(rt.isizeToBeBytes(x3).reverse()), undefined, true); }); } else if (_12 === 12) { - fromTop$u64_iters_range_froms_closure12(rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), near as rt.u64), data, how, out, (x: rt.u64, out2: rt.ByteVec): undefined => { + fromTop$u64_iters_range_froms_closure12(rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), near as rt.u64), dataData, dataStart, dataLen, how, out, (x: rt.u64, out2: rt.ByteVec): undefined => { rt.iterExtendBytes(out2, rt.iterSlice(rt.u64ToBeBytes(x).reverse()), undefined, true); }); - fromTop$u128_iters_range_froms_closure13(rt.u128Add(rt.u128Sub(rt.u128Shl(1, 64), 2), near as rt.u128), data, how ^ 2, out, (x2: rt.u128, out3: rt.ByteVec): undefined => { + fromTop$u128_iters_range_froms_closure13(rt.u128Add(rt.u128Sub(rt.u128Shl(1, 64), 2), near as rt.u128), dataData, dataStart, dataLen, how ^ 2, out, (x2: rt.u128, out3: rt.ByteVec): undefined => { rt.iterExtendBytes(out3, rt.iterSlice(rt.u128ToBeBytes(x2).reverse()), undefined, true); }); rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(option_unwrapOr$00uis1j(rt.iterNth(new rt.RangeFrom(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 2), rt.i64Step), a as rt.usize), 0)).reverse()), undefined, true); } else if (_12 === 13) { - chars(a, data, how, out); + chars(a, dataData, dataStart, dataLen, how, out); } else if (_12 === 14) { - adapted(a, data, out); + adapted(a, dataData, dataStart, dataLen, out); } else { - overflowed(a, data, out); + overflowed(a, dataData, dataStart, dataLen, out); } } @@ -3511,11 +3527,11 @@ export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.char, a1: rt.ByteVec) => undefined): void { +export function fromTop$char_iters_chars_closure0(start: rt.char, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.char, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.char]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"); + const iter: rt.Iter<[rt.u8, rt.char]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.charStep), "len"); while (true) { const _13: [rt.u8, rt.char] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3528,7 +3544,7 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteS } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"), (_26: [rt.u8, rt.char]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.charStep), "len"), (_26: [rt.u8, rt.char]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.char = _26[1]; rt.byteVecPush(out, b4); @@ -3536,7 +3552,7 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteS }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.char, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3548,7 +3564,7 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteS rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.char, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.char, rt.u8]): undefined => { const x3: rt.char = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3564,11 +3580,11 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteS * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i128, a1: rt.ByteVec) => undefined): void { +export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i128, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i128Step), "len"); while (true) { const _13: [rt.u8, rt.i128] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3581,7 +3597,7 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: r } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"), (_26: [rt.u8, rt.i128]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i128Step), "len"), (_26: [rt.u8, rt.i128]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i128 = _26[1]; rt.byteVecPush(out, b4); @@ -3589,7 +3605,7 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: r }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.i128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.i128, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3601,7 +3617,7 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: r rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i128, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i128, rt.u8]): undefined => { const x3: rt.i128 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3617,11 +3633,11 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: r * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i16, a1: rt.ByteVec) => undefined): void { +export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i16, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i16Step), "len"); while (true) { const _13: [rt.u8, rt.i16] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3634,7 +3650,7 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.B } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"), (_26: [rt.u8, rt.i16]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i16Step), "len"), (_26: [rt.u8, rt.i16]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i16 = _26[1]; rt.byteVecPush(out, b4); @@ -3642,7 +3658,7 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.B }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.i16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.i16, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3654,7 +3670,7 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.B rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i16, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i16, rt.u8]): undefined => { const x3: rt.i16 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3670,11 +3686,11 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i32, a1: rt.ByteVec) => undefined): void { +export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i32, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i32Step), "len"); while (true) { const _13: [rt.u8, rt.i32] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3687,7 +3703,7 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.B } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"), (_26: [rt.u8, rt.i32]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i32Step), "len"), (_26: [rt.u8, rt.i32]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i32 = _26[1]; rt.byteVecPush(out, b4); @@ -3695,7 +3711,7 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.B }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.i32, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3707,7 +3723,7 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.B rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i32, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i32, rt.u8]): undefined => { const x3: rt.i32 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3723,11 +3739,11 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i64, a1: rt.ByteVec) => undefined): void { +export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i64, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i64Step), "len"); while (true) { const _13: [rt.u8, rt.i64] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3740,7 +3756,7 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.B } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"), (_26: [rt.u8, rt.i64]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i64Step), "len"), (_26: [rt.u8, rt.i64]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i64 = _26[1]; rt.byteVecPush(out, b4); @@ -3748,7 +3764,7 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.B }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.i64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.i64, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3760,7 +3776,7 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.B rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i64, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i64, rt.u8]): undefined => { const x3: rt.i64 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3776,11 +3792,11 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i8, a1: rt.ByteVec) => undefined): void { +export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i8, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i8Step), "len"); while (true) { const _13: [rt.u8, rt.i8] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3793,7 +3809,7 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.Byt } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"), (_26: [rt.u8, rt.i8]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i8Step), "len"), (_26: [rt.u8, rt.i8]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i8 = _26[1]; rt.byteVecPush(out, b4); @@ -3801,7 +3817,7 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.Byt }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.i8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.i8, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3813,7 +3829,7 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.Byt rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i8, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i8, rt.u8]): undefined => { const x3: rt.i8 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3829,11 +3845,11 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.Byt * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.isize, a1: rt.ByteVec) => undefined): void { +export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.isize, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.isize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"); + const iter: rt.Iter<[rt.u8, rt.isize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.isizeStep), "len"); while (true) { const _13: [rt.u8, rt.isize] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3846,7 +3862,7 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"), (_26: [rt.u8, rt.isize]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.isizeStep), "len"), (_26: [rt.u8, rt.isize]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.isize = _26[1]; rt.byteVecPush(out, b4); @@ -3854,7 +3870,7 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.isize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.isize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.isize, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3866,7 +3882,7 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.isize, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.isize, rt.u8]): undefined => { const x3: rt.isize = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3882,11 +3898,11 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { +export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"); while (true) { const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3899,7 +3915,7 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: r } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u128 = _26[1]; rt.byteVecPush(out, b4); @@ -3907,7 +3923,7 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: r }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3919,7 +3935,7 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: r rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u128, rt.u8]): undefined => { const x3: rt.u128 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3935,11 +3951,11 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: r * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { +export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"); while (true) { const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3952,7 +3968,7 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u128 = _26[1]; rt.byteVecPush(out, b4); @@ -3960,7 +3976,7 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3972,7 +3988,7 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u128, rt.u8]): undefined => { const x3: rt.u128 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3988,11 +4004,11 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u16, a1: rt.ByteVec) => undefined): void { +export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u16, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u16Step), "len"); while (true) { const _13: [rt.u8, rt.u16] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4005,7 +4021,7 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.B } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"), (_26: [rt.u8, rt.u16]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u16Step), "len"), (_26: [rt.u8, rt.u16]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u16 = _26[1]; rt.byteVecPush(out, b4); @@ -4013,7 +4029,7 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.B }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u16, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4025,7 +4041,7 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.B rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u16, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u16, rt.u8]): undefined => { const x3: rt.u16 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4041,11 +4057,11 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u32, a1: rt.ByteVec) => undefined): void { +export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u32, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u32Step), "len"); while (true) { const _13: [rt.u8, rt.u32] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4058,7 +4074,7 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.B } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"), (_26: [rt.u8, rt.u32]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u32Step), "len"), (_26: [rt.u8, rt.u32]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u32 = _26[1]; rt.byteVecPush(out, b4); @@ -4066,7 +4082,7 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.B }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u32, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4078,7 +4094,7 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.B rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u32, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u32, rt.u8]): undefined => { const x3: rt.u32 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4094,11 +4110,11 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { +export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"); while (true) { const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4111,7 +4127,7 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt. } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u64 = _26[1]; rt.byteVecPush(out, b4); @@ -4119,7 +4135,7 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt. }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4131,7 +4147,7 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt. rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u64, rt.u8]): undefined => { const x3: rt.u64 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4147,11 +4163,11 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt. * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { +export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"); while (true) { const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4164,7 +4180,7 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.B } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u64 = _26[1]; rt.byteVecPush(out, b4); @@ -4172,7 +4188,7 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.B }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4184,7 +4200,7 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.B rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u64, rt.u8]): undefined => { const x3: rt.u64 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4200,11 +4216,11 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u8, a1: rt.ByteVec) => undefined): void { +export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u8, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u8Step), "len"); while (true) { const _13: [rt.u8, rt.u8] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4217,7 +4233,7 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.Byt } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"), (_26: [rt.u8, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u8Step), "len"), (_26: [rt.u8, rt.u8]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u8 = _26[1]; rt.byteVecPush(out, b4); @@ -4225,7 +4241,7 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.Byt }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.u8, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4237,7 +4253,7 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.Byt rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u8, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u8, rt.u8]): undefined => { const x3: rt.u8 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4253,11 +4269,11 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.Byt * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.usize, a1: rt.ByteVec) => undefined): void { +export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.usize, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"); + const iter: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.usizeStep), "len"); while (true) { const _13: [rt.u8, rt.usize] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4270,7 +4286,7 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"), (_26: [rt.u8, rt.usize]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.usizeStep), "len"), (_26: [rt.u8, rt.usize]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.usize = _26[1]; rt.byteVecPush(out, b4); @@ -4278,7 +4294,7 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); while (true) { const _31: [rt.usize, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4290,7 +4306,7 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.usize, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.usize, rt.u8]): undefined => { const x3: rt.usize = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4304,20 +4320,20 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: * `char` ranges of each kind across the surrogates, which std's `Step` skips, and up to * `char::MAX`, past which `start..` panics. */ -export function chars(a: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec): void { +export function chars(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec): void { const _8: (a0: rt.char, a1: rt.ByteVec) => undefined = (c2: rt.char, out2: rt.ByteVec): undefined => { rt.iterExtendBytes(out2, rt.iterSlice(rt.u32ToBeBytes(c2 as rt.u32).reverse()), undefined, true); }; const near: rt.u32 = rt.u8Rem(a, 4) as rt.u32; const gap: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(55293, near))); - fromTop$char_iters_chars_closure0(gap, data, how, out, (c3: rt.char, out3: rt.ByteVec): undefined => { + fromTop$char_iters_chars_closure0(gap, dataData, dataStart, dataLen, how, out, (c3: rt.char, out3: rt.ByteVec): undefined => { rt.iterExtendBytes(out3, rt.iterSlice(rt.u32ToBeBytes(c3 as rt.u32).reverse()), undefined, true); }); const top: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Sub(1114111 as rt.u32, near))); - fromTop$char_iters_chars_closure0(top, data, how, out, (c4: rt.char, out4: rt.ByteVec): undefined => { + fromTop$char_iters_chars_closure0(top, dataData, dataStart, dataLen, how, out, (c4: rt.char, out4: rt.ByteVec): undefined => { rt.iterExtendBytes(out4, rt.iterSlice(rt.u32ToBeBytes(c4 as rt.u32).reverse()), undefined, true); }); - const n: rt.usize = data.length; + const n: rt.usize = dataLen; const end: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(57344, near))); const iter: rt.Iter = rt.iterStepBy(rt.iterRev(new rt.Range(gap, end, rt.charStep)), 2); while (true) { @@ -4357,7 +4373,8 @@ export function chars(a: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec) * `start..` as what each adaptor and consumer taking an `IntoIterator` takes, and as its * own receiver. */ -export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function adapted(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const lo: rt.u8 = rt.u8Rem(a, 64); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const it: () => rt.Iter = (): rt.Iter => { @@ -4429,9 +4446,9 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Consumers that step `start..` past its type's last value, which panics in std's * debug build, as the fixture is built. */ -export function overflowed(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { const top: rt.u8 = rt.max(a, 250); - const _5: rt.usize = rt.usizeRem(data.length, 8); + const _5: rt.usize = rt.usizeRem(dataLen, 8); if (_5 === 0) { rt.iterExtendBytes(out, new rt.RangeFrom(top, rt.u8Step), undefined, true); } else if (_5 === 1) { @@ -4459,15 +4476,17 @@ export function overflowed(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * width at their ends and past 2^53 and 2^64, `char`s at either side of the surrogates, * floats with NaN and the zeros, and unsigned `NonZero`s. */ -export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function rangeMethods(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: rt.usize[] = rt.arrayMap([0, 1], (i: rt.usize): rt.usize => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.usize; + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0) as rt.usize; }); const past53: rt.u64 = rt.u64Add({ hi: 0x200000, lo: 0 } as rt.u64, 1); const past64: rt.u128 = rt.u128Add(rt.u128Shl(1, 64), 1); const _17: rt.u8 = rt.u8Rem(kind, 19); if (_17 === 0) { - stepped$u8(rt.byteSliceFrom(Uint8Array.of(0, 1, 2, 254, 255)), at, out); + const _19: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(0, 1, 2, 254, 255)); + stepped$u8(_19.data, _19.start, _19.length, at, out); } else if (_17 === 1) { 65535 - 1; stepped$u16([0, 1, 32767, 65534, 65535], at, out); @@ -5718,7 +5737,8 @@ export function bounded$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): [ * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec): [rt.u8, rt.u8] { +export function bounded$u8(tableData: Uint8Array, tableStart: number, tableLen: number, at: rt.usize[], out: rt.ByteVec): [rt.u8, rt.u8] { + const table: rt.ByteSlice = new rt.ByteSlice(tableData, tableStart, tableLen); const _6: Uint8Array = rt.bytesMap(at, (i: rt.usize): rt.u8 => { const _3: rt.usize = rt.usizeRem(i, table.length); rt.idx(table, _3); @@ -7839,15 +7859,16 @@ export function stepped$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec): void { +export function stepped$u8(tableData: Uint8Array, tableStart: number, tableLen: number, at: rt.usize[], out: rt.ByteVec): void { let _20!: rt.i32; let read!: rt.u8 | undefined; + const table: rt.ByteSlice = new rt.ByteSlice(tableData, tableStart, tableLen); const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { const h: rt.Hasher = rt.hasher(); value(h); return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); }; - const _6: [rt.u8, rt.u8] = bounded$u8(table, at, out); + const _6: [rt.u8, rt.u8] = bounded$u8(table.data, table.start, table.length, at, out); const a: rt.u8 = _6[0]; const b: rt.u8 = _6[1]; const part2 = (h2: rt.Hasher): undefined => { @@ -8030,7 +8051,7 @@ export function stepped$usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec * on after; of floats with NaN for 0xff, against a `Vec` by value; and of `start..`, which * never ends, and panics past its type's last value. */ -export function compares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function compares(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let r!: rt.u8; let r2!: rt.u8; let r3!: rt.u8; @@ -8038,6 +8059,7 @@ export function compares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void let r5!: rt.u8; let r6!: rt.u8; let r7!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _23: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { return o2 & 0xff; diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 71f8e0a9e..ad62af82d 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -1123,7 +1123,8 @@ export function torn(tag: rt.usize, key: rt.u8, mode: rt.u8): Torn.Torn { * the set operators, which build as `collect` does from what they yield, of sets that * `insert` built. Then zero-sized keys, which std's sort leaves as they are. */ -export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function btrees(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const mode: rt.u8 = rt.u8Rem(kind, 5); const keys: (a0: rt.ByteSlice) => Torn.Torn[] = (bytes: rt.ByteSlice): Torn.Torn[] => { return rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(bytes))), (_2: [rt.usize, rt.u8]): Torn.Torn => { diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index 4cc94dc26..32ec164ce 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -1037,8 +1037,8 @@ export function waiters(dataData: Uint8Array, dataStart: number, dataLen: number * points at another variable, whose first is assigned after, and ones a callee gives back * only as a reference, through a borrow a closure keeps. */ -export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { +export function taken(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _10: rt.u8 = rt.u8Rem(n, 4); if (_10 === 0) { rt.iterExtendBytes(out, rt.iterSlice(readBefore(n)), undefined, true); @@ -1121,13 +1121,24 @@ export function viewed(n: rt.u8): Uint8Array { * `UnsafeCell`, and `AtomicPtr` make and take them. Pointers to one array are equal however they were made, and to arrays of equal * bytes, or to parts at other offsets, are not. */ -export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { +export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const a: Uint8Array = Uint8Array.of(n, n ^ 1, n ^ 2, n ^ 3); const b: Uint8Array = copy$array_u8(a); const fromRef: rt.ByteSlice = rt.byteSliceFrom(a); const fromRaw: rt.ByteSlice = rt.byteSliceFrom(a); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.byteSliceSame(fromRef, rt.byteSliceFrom(a)) ? 1 : 0, rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0, rt.byteSliceSame(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0, rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0, !rt.byteSliceSame(fromRef, rt.byteSliceFrom(b)) ? 1 : 0, rt.byteSliceSame(fromRef, rt.NULL) ? 1 : 0, sameBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(a)) ? 1 : 0, sameBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0)), undefined, true); + const _19: rt.u8 = rt.byteSliceSame(fromRef, rt.byteSliceFrom(a)) ? 1 : 0; + const _23: rt.u8 = rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0; + const _25: rt.u8 = rt.byteSliceSame(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0; + const _31: rt.u8 = rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0; + const _33: rt.u8 = !rt.byteSliceSame(fromRef, rt.byteSliceFrom(b)) ? 1 : 0; + const _36: rt.u8 = rt.byteSliceSame(fromRef, rt.NULL) ? 1 : 0; + const _41: rt.ByteSlice = rt.byteSliceFrom(a); + const _43: rt.ByteSlice = rt.byteSliceFrom(a); + const _39: rt.u8 = sameBytes(_41, _43.data, _43.start, _43.length) ? 1 : 0; + const _46: rt.ByteSlice = rt.byteSliceFrom(a); + const _48: rt.ByteSlice = rt.byteSliceFrom(b); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_19, _23, _25, _31, _33, _36, _39, sameBytes(_46, _48.data, _48.start, _48.length) ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(held(n)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(parts(rt.byteSliceFrom(a))), undefined, true); const _55: rt.u8 = rt.u8Rem(n, 4); @@ -1144,8 +1155,8 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { } } -export function sameBytes(p: rt.ByteSlice, q: rt.ByteSlice): boolean { - return rt.byteSliceSame(p, q); +export function sameBytes(p: rt.ByteSlice, qData: Uint8Array, qStart: number, qLen: number): boolean { + return rt.byteSliceSame(p, new rt.ByteSlice(qData, qStart, qLen)); } /** @@ -1282,8 +1293,8 @@ export function exchanged(n: rt.u8): Uint8Array { * none of those pointers: each read out over a type parameter, as smallvec's `Drain` * reads its items, and kept past its array's next value. */ -export function loaded(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { +export function loaded(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { let pair: Loaded.Loaded[] = [{ _0: n, _1: 1 }, { _0: 2, _1: ~n & 0xff }]; const first: Loaded.Loaded = option_unwrapOr$0mkoact(nextRead$pointers_Loaded(rt.iterSlice(pair)), { _0: 0, _1: 0 }); pair = [{ _0: first._1, _1: n ^ 90 }, { _0: first._0, _1: n }]; diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index c1505a94d..e5ff7bf28 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import { copy$slices_Pair } from "./lib.ts"; -import { map$1wqzuhy as option_map$1wqzuhy, map$0c2keyb as option_map$0c2keyb, map$11y9s7r as option_map$11y9s7r, map$0qyyft9 as option_map$0qyyft9, map$1xk4yz1 as option_map$1xk4yz1, map$003seos as option_map$003seos, map$0a57co2 as option_map$0a57co2, mapOr$189goit as option_mapOr$189goit, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; +import { map$1wqzuhy as option_map$1wqzuhy, map$0c2keyb as option_map$0c2keyb, map$11y9s7r as option_map$11y9s7r, map$0qyyft9 as option_map$0qyyft9, map$1uvq0gl as option_map$1uvq0gl, map$003seos as option_map$003seos, map$0a57co2 as option_map$0a57co2, mapOr$189goit as option_mapOr$189goit, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; import * as slices_Counted from "./slices.Counted.ts"; import * as slices_Item from "./slices.Item.ts"; import * as slices_Noisy from "./slices.Noisy.ts"; @@ -23,8 +23,8 @@ export function flush(out: rt.ByteVec): void { } /** A digest of a part, which tells parts of different lengths or contents apart. */ -export function digest(part: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(part)), part.length & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { +export function digest(partData: Uint8Array, partStart: number, partLen: number): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(partData, partStart, partLen))), partLen & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { return rt.u8WrappingAdd(rt.u8WrappingMul(acc, 31), _32); }); } @@ -39,25 +39,44 @@ export function digestWords(part: rt.u16[]): rt.u8 { * `windows` or `chunks`, as `kind` picks, of a size it picks too, which is 0 one time in * six, which panics. */ -export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function parts(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 2), 6) as rt.usize; const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); if (rt.u8Rem(kind, 2) === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), (a019: rt.ByteSlice): rt.u8 => { + return digest(a019.data, a019.start, a019.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), (a020: rt.ByteSlice): rt.u8 => { + return digest(a020.data, a020.start, a020.length); + }), undefined, true); const it: rt.Iter = rt.byteSliceWindows(data, size); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.next()), (a021: rt.ByteSlice): rt.u8 => { + return digest(a021.data, a021.start, a021.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.nextBack()), (a022: rt.ByteSlice): rt.u8 => { + return digest(a022.data, a022.start, a022.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it, 1), (a023: rt.ByteSlice): rt.u8 => { + return digest(a023.data, a023.start, a023.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it, 1), (a024: rt.ByteSlice): rt.u8 => { + return digest(a024.data, a024.start, a024.length); + })), undefined, true); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceWindows(data, size)), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it, (a025: rt.ByteSlice): rt.u8 => { + return digest(a025.data, a025.start, a025.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceWindows(data, size)), (a026: rt.ByteSlice): rt.u8 => { + return digest(a026.data, a026.start, a026.length); + })), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceWindows(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), (a027: rt.ByteSlice): rt.u8 => { + return digest(a027.data, a027.start, a027.length); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceWindows(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceWindows(words, size)), digestWords), undefined, true); const it2: rt.Iter = rt.sliceWindows(words, size); @@ -86,19 +105,37 @@ export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), (a0: rt.ByteSlice): rt.u8 => { + return digest(a0.data, a0.start, a0.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), (a02: rt.ByteSlice): rt.u8 => { + return digest(a02.data, a02.start, a02.length); + }), undefined, true); const it3: rt.Iter = rt.byteSliceChunks(data, size); rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it3.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it3.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it3, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it3, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it3.next()), (a03: rt.ByteSlice): rt.u8 => { + return digest(a03.data, a03.start, a03.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it3.nextBack()), (a04: rt.ByteSlice): rt.u8 => { + return digest(a04.data, a04.start, a04.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it3, 1), (a05: rt.ByteSlice): rt.u8 => { + return digest(a05.data, a05.start, a05.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it3, 1), (a06: rt.ByteSlice): rt.u8 => { + return digest(a06.data, a06.start, a06.length); + })), undefined, true); rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it3, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceChunks(data, size)), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it3, (a07: rt.ByteSlice): rt.u8 => { + return digest(a07.data, a07.start, a07.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceChunks(data, size)), (a08: rt.ByteSlice): rt.u8 => { + return digest(a08.data, a08.start, a08.length); + })), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), (a09: rt.ByteSlice): rt.u8 => { + return digest(a09.data, a09.start, a09.length); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunks(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunks(words, size)), digestWords), undefined, true); const it4: rt.Iter = rt.sliceChunks(words, size); @@ -203,7 +240,8 @@ export function digestPairs(part: slices_Pair.Pair[]): rt.u8 { * `chunks`, as `kind` picks, of a size it picks too, which is 0 one time in six, which * panics. */ -export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 8), 6) as rt.usize; const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { @@ -216,19 +254,37 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void b0: { const _16: rt.u8 = rt.u8Rem(kind, 8); if (_16 === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), (a037: rt.ByteSlice): rt.u8 => { + return digest(a037.data, a037.start, a037.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), (a038: rt.ByteSlice): rt.u8 => { + return digest(a038.data, a038.start, a038.length); + }), undefined, true); const it: rt.Iter = rt.byteSliceChunksExact(data, size); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.next()), (a039: rt.ByteSlice): rt.u8 => { + return digest(a039.data, a039.start, a039.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.nextBack()), (a040: rt.ByteSlice): rt.u8 => { + return digest(a040.data, a040.start, a040.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it, 1), (a041: rt.ByteSlice): rt.u8 => { + return digest(a041.data, a041.start, a041.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it, 1), (a042: rt.ByteSlice): rt.u8 => { + return digest(a042.data, a042.start, a042.length); + })), undefined, true); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceChunksExact(data, size)), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it, (a043: rt.ByteSlice): rt.u8 => { + return digest(a043.data, a043.start, a043.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceChunksExact(data, size)), (a044: rt.ByteSlice): rt.u8 => { + return digest(a044.data, a044.start, a044.length); + })), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), (a045: rt.ByteSlice): rt.u8 => { + return digest(a045.data, a045.start, a045.length); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunksExact(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunksExact(words, size)), digestWords), undefined, true); const it2: rt.Iter = rt.sliceChunksExact(words, size); @@ -243,25 +299,45 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.iterCount(rt.sliceChunksExact(words, size)) & 0xff); rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunksExact(words, size), 2), 2), digestWords), undefined, true); const it3: rt.Iter = rt.byteSliceChunksExact(data, size); - rt.byteVecPush(out, digest(rt.partsRemainder(it3))); + const _129: rt.ByteSlice = rt.partsRemainder(it3); + rt.byteVecPush(out, digest(_129.data, _129.start, _129.length)); it3.next(); rt.iterToOption(it3.nextBack()); - rt.byteVecPush(out, digest(rt.partsRemainder(it3))); + const _137: rt.ByteSlice = rt.partsRemainder(it3); + rt.byteVecPush(out, digest(_137.data, _137.start, _137.length)); rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceChunksExact(words, size)))); } else if (_16 === 1) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), (a019: rt.ByteSlice): rt.u8 => { + return digest(a019.data, a019.start, a019.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), (a020: rt.ByteSlice): rt.u8 => { + return digest(a020.data, a020.start, a020.length); + }), undefined, true); const it4: rt.Iter = rt.byteSliceRchunks(data, size); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it4.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it4.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it4, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it4, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it4.next()), (a021: rt.ByteSlice): rt.u8 => { + return digest(a021.data, a021.start, a021.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it4.nextBack()), (a022: rt.ByteSlice): rt.u8 => { + return digest(a022.data, a022.start, a022.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it4, 1), (a023: rt.ByteSlice): rt.u8 => { + return digest(a023.data, a023.start, a023.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it4, 1), (a024: rt.ByteSlice): rt.u8 => { + return digest(a024.data, a024.start, a024.length); + })), undefined, true); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it4, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceRchunks(data, size)), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it4, (a025: rt.ByteSlice): rt.u8 => { + return digest(a025.data, a025.start, a025.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceRchunks(data, size)), (a026: rt.ByteSlice): rt.u8 => { + return digest(a026.data, a026.start, a026.length); + })), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), (a027: rt.ByteSlice): rt.u8 => { + return digest(a027.data, a027.start, a027.length); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunks(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunks(words, size)), digestWords), undefined, true); const it5: rt.Iter = rt.sliceRchunks(words, size); @@ -279,19 +355,37 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return c13.length & 0xff; })), undefined, true); } else if (_16 === 2) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), (a0: rt.ByteSlice): rt.u8 => { + return digest(a0.data, a0.start, a0.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), (a02: rt.ByteSlice): rt.u8 => { + return digest(a02.data, a02.start, a02.length); + }), undefined, true); const it6: rt.Iter = rt.byteSliceRchunksExact(data, size); rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it6.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it6.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it6, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it6, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it6.next()), (a03: rt.ByteSlice): rt.u8 => { + return digest(a03.data, a03.start, a03.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it6.nextBack()), (a04: rt.ByteSlice): rt.u8 => { + return digest(a04.data, a04.start, a04.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it6, 1), (a05: rt.ByteSlice): rt.u8 => { + return digest(a05.data, a05.start, a05.length); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it6, 1), (a06: rt.ByteSlice): rt.u8 => { + return digest(a06.data, a06.start, a06.length); + })), undefined, true); rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it6, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceRchunksExact(data, size)), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it6, (a07: rt.ByteSlice): rt.u8 => { + return digest(a07.data, a07.start, a07.length); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceRchunksExact(data, size)), (a08: rt.ByteSlice): rt.u8 => { + return digest(a08.data, a08.start, a08.length); + })), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), (a09: rt.ByteSlice): rt.u8 => { + return digest(a09.data, a09.start, a09.length); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunksExact(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunksExact(words, size)), digestWords), undefined, true); const it7: rt.Iter = rt.sliceRchunksExact(words, size); @@ -306,9 +400,11 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksExact(words, size)) & 0xff); rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunksExact(words, size), 2), 2), digestWords), undefined, true); const it8: rt.Iter = rt.byteSliceRchunksExact(data, size); - rt.byteVecPush(out, digest(rt.partsRemainder(it8))); + const _370: rt.ByteSlice = rt.partsRemainder(it8); + rt.byteVecPush(out, digest(_370.data, _370.start, _370.length)); rt.iterNth(it8, 1); - rt.byteVecPush(out, digest(rt.partsRemainder(it8))); + const _376: rt.ByteSlice = rt.partsRemainder(it8); + rt.byteVecPush(out, digest(_376.data, _376.start, _376.length)); rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceRchunksExact(words, size)))); } else if (_16 === 3) { const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)); @@ -319,7 +415,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } scribble(_391[0], _391[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _399: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_399.data, _399.start, _399.length)); const held: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter2: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held))); while (true) { @@ -330,7 +427,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(rt.usizeAdd(_412[0], 7), _412[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held), (c10: rt.ByteSlice): rt.u8 => { - return digest(c10); + const _417: rt.ByteSlice = c10; + return digest(_417.data, _417.start, _417.length); }), undefined, true); const it9: rt.Iter = rt.byteSliceChunks(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it9.len() & 0xff); @@ -352,7 +450,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(4, _451); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _464: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_464.data, _464.start, _464.length)); const iter3: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksMut(words, size)); while (true) { const _472: [rt.usize, rt.u16[]] | rt.Done = iter3.next(); @@ -446,7 +545,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } scribble(_634[0], _634[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _642: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_642.data, _642.start, _642.length)); const held4: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter8: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held4))); while (true) { @@ -457,7 +557,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(rt.usizeAdd(_655[0], 7), _655[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held4), (c7: rt.ByteSlice): rt.u8 => { - return digest(c7); + const _414: rt.ByteSlice = c7; + return digest(_414.data, _414.start, _414.length); }), undefined, true); const it12: rt.Iter = rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it12.len() & 0xff); @@ -479,7 +580,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(4, _694); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _707: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_707.data, _707.start, _707.length)); const iter9: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksExactMut(words, size)); while (true) { const _715: [rt.usize, rt.u16[]] | rt.Done = iter9.next(); @@ -590,7 +692,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } scribble(_908[0], _908[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _916: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_916.data, _916.start, _916.length)); const held7: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter15: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held7))); while (true) { @@ -601,7 +704,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(rt.usizeAdd(_929[0], 7), _929[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held7), (c4: rt.ByteSlice): rt.u8 => { - return digest(c4); + const _410: rt.ByteSlice = c4; + return digest(_410.data, _410.start, _410.length); }), undefined, true); const it17: rt.Iter = rt.byteSliceRchunks(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it17.len() & 0xff); @@ -623,7 +727,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(4, _968); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _981: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_981.data, _981.start, _981.length)); const iter16: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRchunksMut(words, size)); while (true) { const _989: [rt.usize, rt.u16[]] | rt.Done = iter16.next(); @@ -717,7 +822,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } scribble(_1151[0], _1151[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _1159: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_1159.data, _1159.start, _1159.length)); const held10: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter21: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held10))); while (true) { @@ -728,7 +834,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(rt.usizeAdd(_1172[0], 7), _1172[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held10), (c: rt.ByteSlice): rt.u8 => { - return digest(c); + const _45: rt.ByteSlice = c; + return digest(_45.data, _45.start, _45.length); }), undefined, true); const it20: rt.Iter = rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it20.len() & 0xff); @@ -750,7 +857,8 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(4, _1211); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); + const _1224: rt.ByteSlice = rt.byteVecSlice(bytes); + rt.byteVecPush(out, digest(_1224.data, _1224.start, _1224.length)); const iter22: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRchunksExactMut(words, size)); while (true) { const _1232: [rt.usize, rt.u16[]] | rt.Done = iter22.next(); @@ -948,24 +1056,25 @@ export function pokeArray(s: rt.u32[]): void { * bounds from the first two bytes, which may be out of bounds or backwards, which * panics; with what is written through each part landing in what it came from. */ -export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length >= 2) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); - const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach)]; +export function subslices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen >= 2) { + const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); + const reach: rt.usize = rt.usizeAdd(data2.length, 2); + const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 1] as rt.usize, reach)]; const a: rt.usize = _14[0]; const b: rt.usize = _14[1]; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); - const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); + const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); - const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): slices_Pair.Pair => { + const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): slices_Pair.Pair => { const b4: rt.u8 = _23; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; }), undefined, 4, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), [false, false]); + const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(data2)), [false, false]); while (true) { const _37: [rt.Place, rt.u8] | rt.Done = iter.next(); if (_37 === rt.DONE) { @@ -1145,17 +1254,18 @@ export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi * backwards, which panics, of the rest as items, bytes, and integers: what it yields, and * what each drops and keeps as the drain drops, or as it is forgotten. */ -export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length >= 2) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); - const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach)]; +export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen >= 2) { + const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); + const reach: rt.usize = rt.usizeAdd(data2.length, 2); + const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 1] as rt.usize, reach)]; const a: rt.usize = _14[0]; const b: rt.usize = _14[1]; - const items: slices_Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): slices_Item.Item => { + const items: slices_Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): slices_Item.Item => { return new slices_Item.Item(_2); }), undefined, 1, true); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); - const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): rt.u32 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); + const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): rt.u32 => { return rt.u32Add(_23 as rt.u32, 1000); }), undefined, 4, true); const _31: rt.u8 = rt.u8Rem(kind, 8); @@ -1288,7 +1398,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * backwards, which panics or gives `None`; with what is written through each mutable * part landing in what it came from. */ -export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _104!: rt.u8; let _112!: rt.u8; let _120!: rt.u8; @@ -1323,29 +1433,30 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } return { tag: "Unbounded" } as rt.RangeBound; }; - if (data.length >= 2) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); + if (dataLen >= 2) { + const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); + const reach: rt.usize = rt.usizeAdd(data2.length, 2); const at: (a0: rt.u8) => rt.usize = (x3: rt.u8): rt.usize => { if (!(x3 === 255)) { return rt.usizeRem(x3 as rt.usize, reach); } return 4294967295; }; - const _16: [rt.usize, rt.usize] = [at(data.data[data.start]), at(data.data[data.start + 1])]; + const _16: [rt.usize, rt.usize] = [at(dataData[dataStart]), at(dataData[dataStart + 1])]; const a: rt.usize = _16[0]; const b: rt.usize = _16[1]; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); - const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); + const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); - const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_22: rt.u8): slices_Pair.Pair => { + const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): slices_Pair.Pair => { const b4: rt.u8 = _22; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; }), undefined, 4, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), [false, false]); + const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(data2)), [false, false]); while (true) { const _39: [rt.Place, rt.u8] | rt.Done = iter.next(); if (_39 === rt.DONE) { @@ -1356,24 +1467,25 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _47: rt.u8 = rt.u8Rem(kind, 8); if (_47 === 0) { const _53: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const slice7 = rt.byteVecSlice(bytes); - const bounds26 = rt.sliceIndexBounds(_53, slice7.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice7, bounds26[0], bounds26[1]))); + const slice5 = rt.byteVecSlice(bytes); + const bounds26 = rt.sliceIndexBounds(_53, slice5.length); + const _51: rt.ByteSlice = rt.byteSliceRange(slice5, bounds26[0], bounds26[1]); + rt.byteVecPush(out, digest(_51.data, _51.start, _51.length)); const bounds27 = rt.sliceIndexBounds(new rt.RangeInclusive(a, b, rt.usizeStep), words.length); rt.byteVecPush(out, digestWords(rt.sliceRange(words, bounds27[0], bounds27[1]))); const bounds28 = rt.sliceIndexBounds({ end: b, inclusive: true }, pairs.length); rt.byteVecPush(out, digestPairs(rt.sliceRange(pairs, bounds28[0], bounds28[1]))); const bounds29 = rt.sliceIndexBounds(new rt.RangeInclusive(rt.min(a, 4), rt.min(b, 4), rt.usizeStep), array.length); - const part6 = rt.sliceRange(array, bounds29[0], bounds29[1]); - rt.byteVecPush(out, _46(part6)); - const slice8 = rt.byteSliceRange(data, 2); - const bounds30 = rt.sliceIndexBounds({ end: b, inclusive: true }, slice8.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice8, bounds30[0], bounds30[1]))); + const part5 = rt.sliceRange(array, bounds29[0], bounds29[1]); + rt.byteVecPush(out, _46(part5)); + const bounds30 = rt.sliceIndexBounds({ end: b, inclusive: true }, data2.length); + const _75: rt.ByteSlice = rt.byteSliceRange(data2, bounds30[0], bounds30[1]); + rt.byteVecPush(out, digest(_75.data, _75.start, _75.length)); } else if (_47 === 1) { const _79: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const slice6 = rt.byteVecSlice(bytes); - const bounds21 = rt.sliceIndexBounds(_79, slice6.length); - const part: rt.ByteSlice = rt.byteSliceRange(slice6, bounds21[0], bounds21[1]); + const slice4 = rt.byteVecSlice(bytes); + const bounds21 = rt.sliceIndexBounds(_79, slice4.length); + const part: rt.ByteSlice = rt.byteSliceRange(slice4, bounds21[0], bounds21[1]); rt.byteSliceView(part).reverse(); rt.idx(part, 0); part.data[part.start] = part.data[part.start] ^ 90; @@ -1391,7 +1503,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_105 === undefined) { _104 = 238; } else { - _104 = digest(_105); + _104 = digest(_105.data, _105.start, _105.length); } rt.byteVecPush(out, _104); const _114: rt.ByteSlice = rt.byteVecSlice(bytes); @@ -1400,14 +1512,14 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_113 === undefined) { _112 = 238; } else { - _112 = digest(_113); + _112 = digest(_113.data, _113.start, _113.length); } rt.byteVecPush(out, _112); const _121: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, b); if (_121 === undefined) { _120 = 238; } else { - _120 = digest(_121); + _120 = digest(_121.data, _121.start, _121.length); } rt.byteVecPush(out, _120); const _130: rt.ByteSlice = rt.byteVecSlice(bytes); @@ -1416,28 +1528,28 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_129 === undefined) { _128 = 238; } else { - _128 = digest(_129); + _128 = digest(_129.data, _129.start, _129.length); } rt.byteVecPush(out, _128); const _137: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), a); if (_137 === undefined) { _136 = 238; } else { - _136 = digest(_137); + _136 = digest(_137.data, _137.start, _137.length); } rt.byteVecPush(out, _136); const _145: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0); if (_145 === undefined) { _144 = 238; } else { - _144 = digest(_145); + _144 = digest(_145.data, _145.start, _145.length); } rt.byteVecPush(out, _144); - const _152: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceRange(data, 2), a, b); + const _152: rt.ByteSlice | undefined = rt.byteSliceGetRange(data2, a, b); if (_152 === undefined) { _151 = 238; } else { - _151 = digest(_152); + _151 = digest(_152.data, _152.start, _152.length); } rt.byteVecPush(out, _151); const _158: rt.u16[] | undefined = rt.sliceGetRange(words, a, b); @@ -1561,7 +1673,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_297 === undefined) { _296 = 238; } else { - _296 = digest(_297); + _296 = digest(_297.data, _297.start, _297.length); } rt.byteVecPush(out, _296); const _307: slices_Pair.Pair[] = pairs; @@ -1580,14 +1692,13 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _324: rt.RangeInclusive = stepped; const slice3 = rt.byteVecSlice(bytes); const bounds10 = rt.sliceIndexBounds(_324, slice3.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice3, bounds10[0], bounds10[1]))); - const _328: rt.RangeInclusive = folded; - const slice4 = rt.byteSliceRange(data, 2); - const bounds11 = rt.sliceIndexBounds(_328, slice4.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice4, bounds11[0], bounds11[1]))); + const _322: rt.ByteSlice = rt.byteSliceRange(slice3, bounds10[0], bounds10[1]); + rt.byteVecPush(out, digest(_322.data, _322.start, _322.length)); + const bounds11 = rt.sliceIndexBounds(folded, data2.length); + const _327: rt.ByteSlice = rt.byteSliceRange(data2, bounds11[0], bounds11[1]); + rt.byteVecPush(out, digest(_327.data, _327.start, _327.length)); } else if (_47 === 5) { - const part4 = rt.byteSliceRange(data, 2).length & 0xff; - const _333: rt.RangeBound = _329(a, part4); + const _333: rt.RangeBound = _329(a, data2.length & 0xff); const _332: [rt.RangeBound, rt.RangeBound] = [_333, _329(b, rt.u8Div(kind, 8))]; const lo: rt.RangeBound = _333; const hi: rt.RangeBound = _332[1]; @@ -1597,7 +1708,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_345 === undefined) { _344 = 238; } else { - _344 = digest(_345); + _344 = digest(_345.data, _345.start, _345.length); } rt.byteVecPush(out, _344); const _354: slices_Pair.Pair[] = pairs; @@ -1619,19 +1730,24 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { pokePairs(9, rt.sliceRangeMut(pairs, bounds4[0], bounds4[1])); const slice2 = rt.byteVecSlice(bytes); const bounds5 = rt.sliceIndexBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], slice2.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice2, bounds5[0], bounds5[1]))); + const _372: rt.ByteSlice = rt.byteSliceRange(slice2, bounds5[0], bounds5[1]); + rt.byteVecPush(out, digest(_372.data, _372.start, _372.length)); } else if (_47 === 6) { rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 0), (c2: rt.ByteSlice): rt.u8 => { - return digest(c2); + const _38: rt.ByteSlice = c2; + return digest(_38.data, _38.start, _38.length); })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 3), (c3: rt.ByteSlice): rt.u8 => { - return digest(c3); + const _310: rt.ByteSlice = c3; + return digest(_310.data, _310.start, _310.length); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 1), (c4: rt.ByteSlice): rt.u8 => { - return digest(c4); + rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(data2, 1), (c4: rt.ByteSlice): rt.u8 => { + const _311: rt.ByteSlice = c4; + return digest(_311.data, _311.start, _311.length); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 4), (c5: rt.ByteSlice): rt.u8 => { - return digest(c5); + rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(data2, 4), (c5: rt.ByteSlice): rt.u8 => { + const _312: rt.ByteSlice = c5; + return digest(_312.data, _312.start, _312.length); })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$1wqzuhy(rt.sliceGetRange(words, 0, 4), (c6: rt.u16[]): rt.u8 => { return digestWords(c6); @@ -1644,11 +1760,13 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })), undefined, true); const slice: rt.ByteSlice = rt.byteVecSlice(bytes); if (slice.length >= 1) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(new rt.ByteSlice(slice.data, slice.start, 1)), digest(new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1)))), undefined, true); + const _415: rt.ByteSlice = new rt.ByteSlice(slice.data, slice.start, 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_415.data, _415.start, _415.length), digest(slice.data, slice.start + 1, slice.length - 1))), undefined, true); } const _417: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitLastChunk(rt.byteVecSlice(bytes), 4); if (_417 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1]))), undefined, true); + const _427: rt.ByteSlice = _417[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0].data, _417[0].start, _417[0].length), digest(_427.data, _427.start, _427.length))), undefined, true); } const _428: [rt.u16[], rt.u16[]] | undefined = rt.sliceSplitAtChecked(words, 0); if (_428 !== undefined) { @@ -1736,32 +1854,33 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * options of them, on the whole slice and on mutable parts and chunks of it, at bounds * from the first three bytes, which may be out of bounds or backwards, which panics. */ -export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length >= 3) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 3).length, 2); - const _16: [rt.usize, rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach), rt.usizeRem(data.data[data.start + 2] as rt.usize, reach)]; +export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen >= 3) { + const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3); + const reach: rt.usize = rt.usizeAdd(data2.length, 2); + const _16: [rt.usize, rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 1] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 2] as rt.usize, reach)]; const a: rt.usize = _16[0]; const b: rt.usize = _16[1]; const c: rt.usize = _16[2]; const size: rt.usize = rt.usizeAdd(rt.usizeRem(c, 3), 1); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 3)); - const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_2: rt.u8): rt.u16 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); + const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); - const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_29: rt.u8): slices_Pair.Pair => { + const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_29: rt.u8): slices_Pair.Pair => { const b4: rt.u8 = _29; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; }), undefined, 4, true); - const counted: slices_Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_211: rt.u8): slices_Counted.Counted => { + const counted: slices_Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_211: rt.u8): slices_Counted.Counted => { return { n: _211 }; }), undefined, 1, true); - const items: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_212: rt.u8): slices_Noisy.Noisy => { + const items: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_212: rt.u8): slices_Noisy.Noisy => { return new slices_Noisy.Noisy(_212); }), undefined, 1, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), [false, false]); + const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(data2)), [false, false]); while (true) { const _53: [rt.Place, rt.u8] | rt.Done = iter.next(); if (_53 === rt.DONE) { @@ -1796,7 +1915,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.sliceFill(items, new slices_Noisy.Noisy(c & 0xff), slices_Noisy.clone$Clone, rt.drop); flush(out); rt.sliceRangeMut(array, rt.min(a, 5)).fill(c as rt.u32); - const opts: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_224: rt.u8): slices_Noisy.Noisy | undefined => { + const opts: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_224: rt.u8): slices_Noisy.Noisy | undefined => { return new slices_Noisy.Noisy(_224); }), undefined, 2, true); rt.sliceFill(rt.sliceRangeMut(opts, a), undefined as slices_Noisy.Noisy | undefined, option_clone$1omlcob, rt.drop); @@ -1882,7 +2001,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.sliceRotateLeft(_246[1], n2); rt.sliceRotateRight(_246[1], rt.min(b, n2)); flush(out); - const _258: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(rt.byteVecSlice(bytes), rt.min(b, rt.byteSliceRange(data, 3).length)); + const _258: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(rt.byteVecSlice(bytes), rt.min(b, data2.length)); rt.byteSliceRotateLeft(_258[0], _258[0].length); rt.byteSliceRotateRight(_258[1], rt.usizeDiv(_258[1].length, 2)); rt.sliceRotateLeft(rt.sliceRangeMut(array, 1), c); @@ -1924,7 +2043,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { _350.b = 48879; } const _357: slices_Counted.Counted[] = rt.sliceRangeMut(counted, a); - const part8 = rt.usizeSub(rt.byteSliceRange(data, 3).length, a); + const part8 = rt.usizeSub(data2.length, a); rt.sliceCopyFromSlice(_357, rt.sliceRange(rt.iterToArray(rt.iterMap(new rt.Range(0, c), (n9: rt.usize): slices_Counted.Counted => { return { n: n9 & 0xff }; }), undefined, 1, true), 0, part8)); @@ -1940,7 +2059,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const source2: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(new rt.Range(0, c), (tag3: rt.usize): slices_Noisy.Noisy => { return new slices_Noisy.Noisy((tag3 & 0xff) | 80); }), undefined, 1, true); - const n5: rt.usize = rt.min(rt.byteSliceRange(data, 3).length, c); + const n5: rt.usize = rt.min(data2.length, c); rt.sliceCloneFromSlice(rt.sliceRangeMut(items, 0, n5), rt.sliceRange(source2, 0, n5), slices_Noisy.clone$Clone, rt.drop); flush(out); const _403: [slices_Counted.Counted[], slices_Counted.Counted[]] = rt.sliceSplitAtMut(counted, a); diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 793b1d401..52cc8dafa 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -9,7 +9,25 @@ import * as Owner from "./harness.Owner.ts"; * case added at the end moves no other. */ export function cases(): [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined][] { - return [["slices", slices as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["made", made as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", events as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", random as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", bytesMut as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", reads as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::writes", writes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::edits", edits as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reserves", reserves as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]]; + return [["slices", (a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { + slices(a0.data, a0.start, a0.length, a1); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["made", (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + made(a02.data, a02.start, a02.length, a12); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { + events(a03.data, a03.start, a03.length, a13); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + random(a04.data, a04.start, a04.length, a14); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + bytesMut(a05.data, a05.start, a05.length, a15); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + reads(a06.data, a06.start, a06.length, a16); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::writes", (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + writes(a07.data, a07.start, a07.length, a17); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::edits", (a08: rt.ByteSlice, a18: rt.ByteVec): undefined => { + edits(a08.data, a08.start, a08.length, a18); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reserves", (a09: rt.ByteSlice, a19: rt.ByteVec): undefined => { + reserves(a09.data, a09.start, a09.length, a19); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]]; } /** Run one case. */ @@ -41,19 +59,19 @@ export function op(name: string): rt.u8 { * `Bytes`'s slices by every kind of range, out of bounds included, which panic as * `bytes` does, and what they compare equal to. */ -export function slices(data: rt.ByteSlice, out: rt.ByteVec): void { +export function slices(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let part!: rt.ByteSlice; let range!: rt.RangeInclusive; - if (data.length >= 3) { - const bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(data.data, data.start + 3, data.length - 3)); - const past: boolean = data.data[data.start + 2] === 255; - const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start + 1] as rt.usize, rt.usizeAdd(data.length - 3, 2)), rt.usizeRem(data.data[data.start + 2] as rt.usize, rt.usizeAdd(data.length - 3, 2))]; + if (dataLen >= 3) { + const bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)); + const past: boolean = dataData[dataStart + 2] === 255; + const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(dataLen - 3, 2)), rt.usizeRem(dataData[dataStart + 2] as rt.usize, rt.usizeAdd(dataLen - 3, 2))]; const a: rt.usize = _14[0]; const b: rt.usize = _14[1]; - if ((data.data[data.start] & 128) !== 0) { + if ((dataData[dataStart] & 128) !== 0) { rt.bytesSlice(bytes, b); } - const _35: rt.u8 = rt.u8Rem(data.data[data.start], 7); + const _35: rt.u8 = rt.u8Rem(dataData[dataStart], 7); if (_35 === 0) { part = rt.bytesSlice(bytes, a, b); } else if (_35 === 1) { @@ -91,16 +109,16 @@ export function slices(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, part); rt.byteVecPush(out, rt.byteSliceEq(part, bytes) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(part, rt.byteSliceRange(part, 0)) ? 1 : 0); - rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, data.length - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); + rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, dataLen - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToByteVec(part))); } } /** `Bytes` made each way, printed with `Debug`. */ -export function made(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const skip: rt.u8 = data.data[data.start]; - const rest: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); +export function made(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const skip: rt.u8 = dataData[dataStart]; + const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const made: rt.ByteSlice[] = [rt.byteVecSlice(rt.byteSliceToByteVec(rest)), rt.byteSliceFrom(Uint8Array.of(0, 9, 13, 10, 92, 34, 39, 126, 127, 128, 255)), rt.stringAsBytes("string"), rt.stringAsBytes("text"), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(115, 116, 97, 116, 105, 99)), 0), rt.bytesNew(), Owner.asRef$convert_AsRef_slice_u8({ data: rt.byteSliceToByteVec(rest), skip: skip as rt.usize })]; const source: rt.ByteVec = rt.byteSliceToByteVec(rest); const copied: rt.ByteSlice = rt.bytesCopyFromSlice(rt.byteVecSlice(source)); @@ -126,20 +144,20 @@ export function made(data: rt.ByteSlice, out: rt.ByteVec): void { * `tracing`'s events, which evaluate nothing without a subscriber: no field marks `out`, * one in a branch included. */ -export function events(data: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecPush(out, data.length & 0xff); +export function events(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { + rt.byteVecPush(out, dataLen & 0xff); } /** * `rand::rng()`'s values: each in its range, an empty range panicking as `rand`'s does, * and every value of a small range drawn. */ -export function random(data: rt.ByteSlice, out: rt.ByteVec): void { +export function random(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let inRange!: boolean; - if (data.length >= 3) { - const kind: rt.u8 = data.data[data.start]; - const a: rt.u8 = data.data[data.start + 1]; - const b: rt.u8 = data.data[data.start + 2]; + if (dataLen >= 3) { + const kind: rt.u8 = dataData[dataStart]; + const a: rt.u8 = dataData[dataStart + 1]; + const b: rt.u8 = dataData[dataStart + 2]; rt.randRng(); b1: { const _10: rt.u8 = rt.u8Rem(kind, 10); From eccd5c3144ee8a53a6b30c241d0f49815a385e88 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 15:33:58 -0700 Subject: [PATCH 16/26] chore(ts): regenerate snapshots after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/harness.ts | 552 ++++++++++++++++++++------- ts/fixtures/lang/expected/iters.ts | 3 +- 2 files changed, 422 insertions(+), 133 deletions(-) diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 40749c0fd..a0ec78e85 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { args } from "./args.ts"; import { fromFns, maps, lent as arrays_lent, asSlices, given } from "./arrays.ts"; import { bytes as ascii_bytes, chars as ascii_chars, slices as ascii_slices } from "./ascii.ts"; import { atomics } from "./atomics.ts"; @@ -41,6 +42,7 @@ import { objects } from "./objects.ts"; import { orders, bytes as orders_bytes, tuples as orders_tuples, held as orders_held, btrees } from "./orders.ts"; import { lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded } from "./pointers.ts"; import { refs, toRefs } from "./refs.ts"; +import { returns } from "./returns.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -60,178 +62,464 @@ import { zeros, impls, keys as zeros_keys, unread, writes as zeros_writes } from * case added at the end moves no other. */ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] { - return [["ints::u8_op", u8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", u16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", u32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", u64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", u128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", usizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", i8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", i16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", i32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", i64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", i128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", isizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", neg as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", cast as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_2100: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { - convert(data, out); + return [["ints::u8_op", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { + u8Op(a0, a1.data, a1.start, a1.length, a2); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", (a02: rt.u8, a12: rt.ByteSlice, a22: rt.ByteVec): undefined => { + u16Op(a02, a12.data, a12.start, a12.length, a22); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", (a03: rt.u8, a13: rt.ByteSlice, a23: rt.ByteVec): undefined => { + u32Op(a03, a13.data, a13.start, a13.length, a23); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", (a04: rt.u8, a14: rt.ByteSlice, a24: rt.ByteVec): undefined => { + u64Op(a04, a14.data, a14.start, a14.length, a24); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", (a05: rt.u8, a15: rt.ByteSlice, a25: rt.ByteVec): undefined => { + u128Op(a05, a15.data, a15.start, a15.length, a25); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", (a06: rt.u8, a16: rt.ByteSlice, a26: rt.ByteVec): undefined => { + usizeOp(a06, a16.data, a16.start, a16.length, a26); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", (a07: rt.u8, a17: rt.ByteSlice, a27: rt.ByteVec): undefined => { + i8Op(a07, a17.data, a17.start, a17.length, a27); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", (a08: rt.u8, a18: rt.ByteSlice, a28: rt.ByteVec): undefined => { + i16Op(a08, a18.data, a18.start, a18.length, a28); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", (a09: rt.u8, a19: rt.ByteSlice, a29: rt.ByteVec): undefined => { + i32Op(a09, a19.data, a19.start, a19.length, a29); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", (a010: rt.u8, a110: rt.ByteSlice, a210: rt.ByteVec): undefined => { + i64Op(a010, a110.data, a110.start, a110.length, a210); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", (a011: rt.u8, a111: rt.ByteSlice, a211: rt.ByteVec): undefined => { + i128Op(a011, a111.data, a111.start, a111.length, a211); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", (a012: rt.u8, a112: rt.ByteSlice, a212: rt.ByteVec): undefined => { + isizeOp(a012, a112.data, a112.start, a112.length, a212); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", (a013: rt.u8, a113: rt.ByteSlice, a213: rt.ByteVec): undefined => { + neg(a013, a113.data, a113.start, a113.length, a213); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", (a014: rt.u8, a114: rt.ByteSlice, a214: rt.ByteVec): undefined => { + cast(a014, a114.data, a114.start, a114.length, a214); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_2100: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { + convert(data.data, data.start, data.length, out); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::copies", (_2101: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { - shapes_copies(data2, out2); + shapes_copies(data2.data, data2.start, data2.length, out2); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::loops", (_2102: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { - loops(data3, out3); + loops(data3.data, data3.start, data3.length, out3); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::patterns", (_2103: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { - patterns(data4, out4); + patterns(data4.data, data4.start, data4.length, out4); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::closures", (_2104: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { - shapes_closures(data5, out5); + shapes_closures(data5.data, data5.start, data5.length, out5); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::discriminants", (_2105: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { - discriminants(data6, out6); + discriminants(data6.data, data6.start, data6.length, out6); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::library", (_2106: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { - library(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::ints", ints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_2107: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { - strings(data8, out8); + library(data7.data, data7.start, data7.length, out7); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::ints", (a015: rt.u8, a115: rt.ByteSlice, a215: rt.ByteVec): undefined => { + ints(a015, a115.data, a115.start, a115.length, a215); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_2107: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + strings(data8.data, data8.start, data8.length, out8); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::derived", (_2108: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { - derived(data9, out9); + derived(data9.data, data9.start, data9.length, out9); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::written", (_2109: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): undefined => { - fmt_written(data10, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", fmt_panics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_2110: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { - methods(data11, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::adaptors", adaptors as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", iters_consumers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_2111: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { - iters_ranges(data12, out12); + fmt_written(data10.data, data10.start, data10.length, out10); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", (a016: rt.u8, a116: rt.ByteSlice, a216: rt.ByteVec): undefined => { + fmt_panics(a016, a116.data, a116.start, a116.length, a216); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_2110: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { + methods(data11.data, data11.start, data11.length, out11); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::adaptors", (a017: rt.u8, a117: rt.ByteSlice, a217: rt.ByteVec): undefined => { + adaptors(a017, a117.data, a117.start, a117.length, a217); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", (a018: rt.u8, a118: rt.ByteSlice, a218: rt.ByteVec): undefined => { + iters_consumers(a018, a118.data, a118.start, a118.length, a218); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_2111: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { + iters_ranges(data12.data, data12.start, data12.length, out12); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::options", (_2112: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): undefined => { - iters_options(data13, out13); + iters_options(data13.data, data13.start, data13.length, out13); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::own", (_2113: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): undefined => { - own(data14, out14); + own(data14.data, data14.start, data14.length, out14); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::values", (_2114: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): undefined => { - iters_values(data15, out15); + iters_values(data15.data, data15.start, data15.length, out15); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::order", (_2115: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): undefined => { - shapes_order(data16, out16); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", hashMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", sets as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", btreeMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { - deques(data17, out17); + shapes_order(data16.data, data16.start, data16.length, out16); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", (a019: rt.u8, a119: rt.ByteSlice, a219: rt.ByteVec): undefined => { + hashMaps(a019, a119.data, a119.start, a119.length, a219); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", (a020: rt.u8, a120: rt.ByteSlice, a220: rt.ByteVec): undefined => { + sets(a020, a120.data, a120.start, a120.length, a220); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", (a021: rt.u8, a121: rt.ByteSlice, a221: rt.ByteVec): undefined => { + btreeMaps(a021, a121.data, a121.start, a121.length, a221); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { + deques(data17.data, data17.start, data17.length, out17); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::flows", (_2117: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): undefined => { - flows(data18, out18); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", keys_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", chars_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", strs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { - vecs(data19, out19); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", strs_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { - stores(data20, out20); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", chunks as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", cows as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", durations as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", combinators as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", splits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", nested_nested as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { - refs(data21, out21); + flows(data18.data, data18.start, data18.length, out18); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", (a022: rt.u8, a122: rt.ByteSlice, a222: rt.ByteVec): undefined => { + keys_keys(a022, a122.data, a122.start, a122.length, a222); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", (a023: rt.u8, a123: rt.ByteSlice, a223: rt.ByteVec): undefined => { + chars_chars(a023, a123.data, a123.start, a123.length, a223); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", (a024: rt.u8, a124: rt.ByteSlice, a224: rt.ByteVec): undefined => { + strs(a024, a124.data, a124.start, a124.length, a224); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { + vecs(data19.data, data19.start, data19.length, out19); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", (a025: rt.u8, a125: rt.ByteSlice, a225: rt.ByteVec): undefined => { + strs_slices(a025, a125.data, a125.start, a125.length, a225); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { + stores(data20.data, data20.start, data20.length, out20); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", (a026: rt.u8, a126: rt.ByteSlice, a226: rt.ByteVec): undefined => { + chunks(a026, a126.data, a126.start, a126.length, a226); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", (a027: rt.u8, a127: rt.ByteSlice, a227: rt.ByteVec): undefined => { + cows(a027, a127.data, a127.start, a127.length, a227); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", (a028: rt.u8, a128: rt.ByteSlice, a228: rt.ByteVec): undefined => { + durations(a028, a128.data, a128.start, a128.length, a228); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", (a029: rt.u8, a129: rt.ByteSlice, a229: rt.ByteVec): undefined => { + combinators(a029, a129.data, a129.start, a129.length, a229); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", (a030: rt.u8, a130: rt.ByteSlice, a230: rt.ByteVec): undefined => { + splits(a030, a130.data, a130.start, a130.length, a230); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", (a031: rt.u8, a131: rt.ByteSlice, a231: rt.ByteVec): undefined => { + nested_nested(a031, a131.data, a131.start, a131.length, a231); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { + refs(data21.data, data21.start, data21.length, out21); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::counts", (_2121: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): undefined => { - fmt_counts(data22, out22); + fmt_counts(data22.data, data22.start, data22.length, out22); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::rounding", (_2122: rt.u8, _3100: rt.ByteSlice, out23: rt.ByteVec): undefined => { rounding(out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", skips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", wrappers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", edits_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", floats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", atomics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { - dyns(data23, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", cells_cells as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { - dyns_shared(data24, out25); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", iters_ranked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", captures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { - locks(data25, out26); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", (a032: rt.u8, a132: rt.ByteSlice, a232: rt.ByteVec): undefined => { + skips(a032, a132.data, a132.start, a132.length, a232); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", (a033: rt.u8, a133: rt.ByteSlice, a233: rt.ByteVec): undefined => { + wrappers(a033, a133.data, a133.start, a133.length, a233); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", (a034: rt.u8, a134: rt.ByteSlice, a234: rt.ByteVec): undefined => { + edits_edits(a034, a134.data, a134.start, a134.length, a234); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", (a035: rt.u8, a135: rt.ByteSlice, a235: rt.ByteVec): undefined => { + decodes(a035, a135.data, a135.start, a135.length, a235); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", (a036: rt.u8, a136: rt.ByteSlice, a236: rt.ByteVec): undefined => { + floats(a036, a136.data, a136.start, a136.length, a236); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", (a037: rt.u8, a137: rt.ByteSlice, a237: rt.ByteVec): undefined => { + atomics(a037, a137.data, a137.start, a137.length, a237); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", (a038: rt.u8, a138: rt.ByteSlice, a238: rt.ByteVec): undefined => { + overrides(a038, a138.data, a138.start, a138.length, a238); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { + dyns(data23.data, data23.start, data23.length, out24); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", (a039: rt.u8, a139: rt.ByteSlice, a239: rt.ByteVec): undefined => { + cells_cells(a039, a139.data, a139.start, a139.length, a239); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { + dyns_shared(data24.data, data24.start, data24.length, out25); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", (a040: rt.u8, a140: rt.ByteSlice, a240: rt.ByteVec): undefined => { + iters_ranked(a040, a140.data, a140.start, a140.length, a240); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", (a041: rt.u8, a141: rt.ByteSlice, a241: rt.ByteVec): undefined => { + captures(a041, a141.data, a141.start, a141.length, a241); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { + locks(data25.data, data25.start, data25.length, out26); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::relock", (_2126: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): undefined => { - relock(data26, out27); + relock(data26.data, data26.start, data26.length, out27); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locals::locals", (_2127: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): undefined => { - locals(data27, out28); + locals(data27.data, data27.start, data27.length, out28); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::statics", (_2128: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): undefined => { - statics(data28, out29); + statics(data28.data, data28.start, data28.length, out29); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::rwlocks", (_2129: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): undefined => { - rwlocks(data29, out30); + rwlocks(data29.data, data29.start, data29.length, out30); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::borrows", (_2130: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): undefined => { - borrows_borrows(data30, out31); + borrows_borrows(data30.data, data30.start, data30.length, out31); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["defaults::defaults", (_2131: rt.u8, data31: rt.ByteSlice, out32: rt.ByteVec): undefined => { - defaults_defaults(data31, out32); + defaults_defaults(data31.data, data31.start, data31.length, out32); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::arcs", (_2132: rt.u8, data32: rt.ByteSlice, out33: rt.ByteVec): undefined => { - counts_arcs(data32, out33); + counts_arcs(data32.data, data32.start, data32.length, out33); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::rcs", (_2133: rt.u8, data33: rt.ByteSlice, out34: rt.ByteVec): undefined => { - rcs(data33, out34); + rcs(data33.data, data33.start, data33.length, out34); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_arcs", (_2134: rt.u8, data34: rt.ByteSlice, out35: rt.ByteVec): undefined => { - cyclicArcs(data34, out35); + cyclicArcs(data34.data, data34.start, data34.length, out35); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_rcs", (_2135: rt.u8, data35: rt.ByteSlice, out36: rt.ByteVec): undefined => { - cyclicRcs(data35, out36); + cyclicRcs(data35.data, data35.start, data35.length, out36); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_arcs", (_2136: rt.u8, data36: rt.ByteSlice, out37: rt.ByteVec): undefined => { - uniqueArcs(data36, out37); + uniqueArcs(data36.data, data36.start, data36.length, out37); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_rcs", (_2137: rt.u8, data37: rt.ByteSlice, out38: rt.ByteVec): undefined => { - uniqueRcs(data37, out38); + uniqueRcs(data37.data, data37.start, data37.length, out38); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::anys", (_2138: rt.u8, data38: rt.ByteSlice, out39: rt.ByteVec): undefined => { - anys(data38, out39); + anys(data38.data, data38.start, data38.length, out39); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::fns", (_2139: rt.u8, data39: rt.ByteSlice, out40: rt.ByteVec): undefined => { - fns(data39, out40); + fns(data39.data, data39.start, data39.length, out40); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::copies", (_2140: rt.u8, data40: rt.ByteSlice, out41: rt.ByteVec): undefined => { - pointers_copies(data40, out41); + pointers_copies(data40.data, data40.start, data40.length, out41); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lists", (_2141: rt.u8, data41: rt.ByteSlice, out42: rt.ByteVec): undefined => { - lists(data41, out42); + lists(data41.data, data41.start, data41.length, out42); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::nested", (_2142: rt.u8, data42: rt.ByteSlice, out43: rt.ByteVec): undefined => { - pointers_nested(data42, out43); + pointers_nested(data42.data, data42.start, data42.length, out43); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::places", (_2143: rt.u8, data43: rt.ByteSlice, out44: rt.ByteVec): undefined => { - pointers_places(data43, out44); + pointers_places(data43.data, data43.start, data43.length, out44); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::sentinels", (_2144: rt.u8, data44: rt.ByteSlice, out45: rt.ByteVec): undefined => { - sentinels(data44, out45); + sentinels(data44.data, data44.start, data44.length, out45); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::shared", (_2145: rt.u8, data45: rt.ByteSlice, out46: rt.ByteVec): undefined => { - pointers_shared(data45, out46); + pointers_shared(data45.data, data45.start, data45.length, out46); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::unchecked", (_2146: rt.u8, data46: rt.ByteSlice, out47: rt.ByteVec): undefined => { - unchecked(data46, out47); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", edits_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { - fromFns(data47, out48); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["objects::objects", (_2148: rt.u8, data48: rt.ByteSlice, out49: rt.ByteVec): undefined => { - objects(data48, out49); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["holds::holds", holds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_2149: rt.u8, data49: rt.ByteSlice, out50: rt.ByteVec): undefined => { - fmt_wrapped(data49, out50); + unchecked(data46.data, data46.start, data46.length, out47); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", (a042: rt.u8, a142: rt.ByteSlice, a242: rt.ByteVec): undefined => { + edits_bytes(a042, a142.data, a142.start, a142.length, a242); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { + fromFns(data47.data, data47.start, data47.length, out48); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", (a043: rt.u8, a143: rt.ByteSlice, a243: rt.ByteVec): undefined => { + optionals(a043, a143.data, a143.start, a143.length, a243); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["objects::objects", (_2148: rt.u8, data48: rt.ByteSlice, out49: rt.ByteVec): undefined => { + objects(data48.data, data48.start, data48.length, out49); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["holds::holds", (a044: rt.u8, a144: rt.ByteSlice, a244: rt.ByteVec): undefined => { + holds(a044, a144.data, a144.start, a144.length, a244); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_2149: rt.u8, data49: rt.ByteSlice, out50: rt.ByteVec): undefined => { + fmt_wrapped(data49.data, data49.start, data49.length, out50); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::to_refs", (_2150: rt.u8, data50: rt.ByteSlice, out51: rt.ByteVec): undefined => { - toRefs(data50, out51); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::orders", orders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_2151: rt.u8, data51: rt.ByteSlice, out52: rt.ByteVec): undefined => { - clonedArcs(data51, out52); + toRefs(data50.data, data50.start, data50.length, out51); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::orders", (a045: rt.u8, a145: rt.ByteSlice, a245: rt.ByteVec): undefined => { + orders(a045, a145.data, a145.start, a145.length, a245); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_2151: rt.u8, data51: rt.ByteSlice, out52: rt.ByteVec): undefined => { + clonedArcs(data51.data, data51.start, data51.length, out52); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_rcs", (_2152: rt.u8, data52: rt.ByteSlice, out53: rt.ByteVec): undefined => { - clonedRcs(data52, out53); + clonedRcs(data52.data, data52.start, data52.length, out53); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::copies", (_2153: rt.u8, data53: rt.ByteSlice, out54: rt.ByteVec): undefined => { - counts_copies(data53, out54); + counts_copies(data53.data, data53.start, data53.length, out54); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::cells", (_2154: rt.u8, data54: rt.ByteSlice, out55: rt.ByteVec): undefined => { - statics_cells(data54, out55); + statics_cells(data54.data, data54.start, data54.length, out55); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::returned", (_2155: rt.u8, data55: rt.ByteSlice, out56: rt.ByteVec): undefined => { - returned(data55, out56); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::values", hashes_values as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_2156: rt.u8, data56: rt.ByteSlice, out57: rt.ByteVec): undefined => { - random(data56, out57); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", floats_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", floats_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_2157: rt.u8, data57: rt.ByteSlice, out58: rt.ByteVec): undefined => { - orders_bytes(data57, out58); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::parts", slices_parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", slices_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_2158: rt.u8, data58: rt.ByteSlice, out59: rt.ByteVec): undefined => { - onces(data58, out59); + returned(data55.data, data55.start, data55.length, out56); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::values", (a046: rt.u8, a146: rt.ByteSlice, a246: rt.ByteVec): undefined => { + hashes_values(a046, a146.data, a146.start, a146.length, a246); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_2156: rt.u8, data56: rt.ByteSlice, out57: rt.ByteVec): undefined => { + random(data56.data, data56.start, data56.length, out57); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", (a047: rt.u8, a147: rt.ByteSlice, a247: rt.ByteVec): undefined => { + floats_formats(a047, a147.data, a147.start, a147.length, a247); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", (a048: rt.u8, a148: rt.ByteSlice, a248: rt.ByteVec): undefined => { + floats_parses(a048, a148.data, a148.start, a148.length, a248); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_2157: rt.u8, data57: rt.ByteSlice, out58: rt.ByteVec): undefined => { + orders_bytes(data57.data, data57.start, data57.length, out58); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::parts", (a049: rt.u8, a149: rt.ByteSlice, a249: rt.ByteVec): undefined => { + slices_parts(a049, a149.data, a149.start, a149.length, a249); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", (a050: rt.u8, a150: rt.ByteSlice, a250: rt.ByteVec): undefined => { + slices_drains(a050, a150.data, a150.start, a150.length, a250); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", (a051: rt.u8, a151: rt.ByteSlice, a251: rt.ByteVec): undefined => { + chunked(a051, a151.data, a151.start, a151.length, a251); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_2158: rt.u8, data58: rt.ByteSlice, out59: rt.ByteVec): undefined => { + onces(data58.data, data58.start, data58.length, out59); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::writes", (_2159: rt.u8, data59: rt.ByteSlice, out60: rt.ByteVec): undefined => { - fmt_writes(data59, out60); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", bounds_bounds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { - pointers_cells(data60, out61); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", ints_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", strs_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { - hashes_bytes(data61, out62); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", keys_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", strs_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { - pointers_rebound(data62, out63); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", slices_ranges as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_2163: rt.u8, data63: rt.ByteSlice, out64: rt.ByteVec): undefined => { - reducers(data63, out64); + fmt_writes(data59.data, data59.start, data59.length, out60); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", (a052: rt.u8, a152: rt.ByteSlice, a252: rt.ByteVec): undefined => { + bounds_bounds(a052, a152.data, a152.start, a152.length, a252); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { + pointers_cells(data60.data, data60.start, data60.length, out61); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", (a053: rt.u8, a153: rt.ByteSlice, a253: rt.ByteVec): undefined => { + ints_parses(a053, a153.data, a153.start, a153.length, a253); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", (a054: rt.u8, a154: rt.ByteSlice, a254: rt.ByteVec): undefined => { + strs_edits(a054, a154.data, a154.start, a154.length, a254); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", (a055: rt.u8, a155: rt.ByteSlice, a255: rt.ByteVec): undefined => { + subslices(a055, a155.data, a155.start, a155.length, a255); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { + hashes_bytes(data61.data, data61.start, data61.length, out62); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", (a056: rt.u8, a156: rt.ByteSlice, a256: rt.ByteVec): undefined => { + keys_bytes(a056, a156.data, a156.start, a156.length, a256); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", (a057: rt.u8, a157: rt.ByteSlice, a257: rt.ByteVec): undefined => { + strs_parses(a057, a157.data, a157.start, a157.length, a257); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { + pointers_rebound(data62.data, data62.start, data62.length, out63); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", (a058: rt.u8, a158: rt.ByteSlice, a258: rt.ByteVec): undefined => { + slices_ranges(a058, a158.data, a158.start, a158.length, a258); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_2163: rt.u8, data63: rt.ByteSlice, out64: rt.ByteVec): undefined => { + reducers(data63.data, data63.start, data63.length, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): undefined => { - writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { - pointers_made(data65, out66); + writers(data64.data, data64.start, data64.length, out65); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", (a059: rt.u8, a159: rt.ByteSlice, a259: rt.ByteVec): undefined => { + eqs(a059, a159.data, a159.start, a159.length, a259); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", (a060: rt.u8, a160: rt.ByteSlice, a260: rt.ByteVec): undefined => { + slices_edits(a060, a160.data, a160.start, a160.length, a260); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", (a061: rt.u8, a161: rt.ByteSlice, a261: rt.ByteVec): undefined => { + strs_iters(a061, a161.data, a161.start, a161.length, a261); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", (a062: rt.u8, a162: rt.ByteSlice, a262: rt.ByteVec): undefined => { + strs_drains(a062, a162.data, a162.start, a162.length, a262); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", (a063: rt.u8, a163: rt.ByteSlice, a263: rt.ByteVec): undefined => { + hinted(a063, a163.data, a163.start, a163.length, a263); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { + pointers_made(data65.data, data65.start, data65.length, out66); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_2166: rt.u8, data66: rt.ByteSlice, out67: rt.ByteVec): undefined => { - asSlices(data66, out67); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", widenings as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): undefined => { - uninhabited(data67, out68); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", lentKeys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", lentValues as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", singles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", singles_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", singles_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { - peekedOthers(data68, out69); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", hints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", folds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::zeros", zeros as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_2169: rt.u8, data69: rt.ByteSlice, out70: rt.ByteVec): undefined => { - maps(data69, out70); + asSlices(data66.data, data66.start, data66.length, out67); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", (a064: rt.u8, a164: rt.ByteSlice, a264: rt.ByteVec): undefined => { + widenings(a064, a164.data, a164.start, a164.length, a264); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): undefined => { + uninhabited(data67.data, data67.start, data67.length, out68); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", (a065: rt.u8, a165: rt.ByteSlice, a265: rt.ByteVec): undefined => { + lentKeys(a065, a165.data, a165.start, a165.length, a265); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", (a066: rt.u8, a166: rt.ByteSlice, a266: rt.ByteVec): undefined => { + lentValues(a066, a166.data, a166.start, a166.length, a266); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", (a067: rt.u8, a167: rt.ByteSlice, a267: rt.ByteVec): undefined => { + singles(a067, a167.data, a167.start, a167.length, a267); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", (a068: rt.u8, a168: rt.ByteSlice, a268: rt.ByteVec): undefined => { + singles_formats(a068, a168.data, a168.start, a168.length, a268); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", (a069: rt.u8, a169: rt.ByteSlice, a269: rt.ByteVec): undefined => { + singles_parses(a069, a169.data, a169.start, a169.length, a269); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { + peekedOthers(data68.data, data68.start, data68.length, out69); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", (a070: rt.u8, a170: rt.ByteSlice, a270: rt.ByteVec): undefined => { + hints(a070, a170.data, a170.start, a170.length, a270); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", (a071: rt.u8, a171: rt.ByteSlice, a271: rt.ByteVec): undefined => { + reserves(a071, a171.data, a171.start, a171.length, a271); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", (a072: rt.u8, a172: rt.ByteSlice, a272: rt.ByteVec): undefined => { + setOps(a072, a172.data, a172.start, a172.length, a272); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", (a073: rt.u8, a173: rt.ByteSlice, a273: rt.ByteVec): undefined => { + folds(a073, a173.data, a173.start, a173.length, a273); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::zeros", (a074: rt.u8, a174: rt.ByteSlice, a274: rt.ByteVec): undefined => { + zeros(a074, a174.data, a174.start, a174.length, a274); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_2169: rt.u8, data69: rt.ByteSlice, out70: rt.ByteVec): undefined => { + maps(data69.data, data69.start, data69.length, out70); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::lent", (_2170: rt.u8, data70: rt.ByteSlice, out71: rt.ByteVec): undefined => { - arrays_lent(data70, out71); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", floats_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", singles_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { - collections(data71, out72); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", zeros_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", zips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", zipsBack as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { - fmt_iters(data72, out73); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", unread as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", rangeFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", rangeMethods as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::iters", clones_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", compares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cycles::cycles", cycles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_2173: rt.u8, data73: rt.ByteSlice, out74: rt.ByteVec): undefined => { - lapsed(data73, out74); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", cows_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", cows_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u8s", wraps_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", wraps_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", wraps_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", wraps_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", wraps_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", wraps_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", wraps_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", wraps_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", wraps_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", wraps_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", wraps_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", wraps_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_2174: rt.u8, data74: rt.ByteSlice, out75: rt.ByteVec): undefined => { - enums(data74, out75); + arrays_lent(data70.data, data70.start, data70.length, out71); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", (a075: rt.u8, a175: rt.ByteSlice, a275: rt.ByteVec): undefined => { + floats_mulAdds(a075, a175.data, a175.start, a175.length, a275); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", (a076: rt.u8, a176: rt.ByteSlice, a276: rt.ByteVec): undefined => { + singles_mulAdds(a076, a176.data, a176.start, a176.length, a276); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { + collections(data71.data, data71.start, data71.length, out72); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", (a077: rt.u8, a177: rt.ByteSlice, a277: rt.ByteVec): undefined => { + unlikeEqs(a077, a177.data, a177.start, a177.length, a277); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", (a078: rt.u8, a178: rt.ByteSlice, a278: rt.ByteVec): undefined => { + impls(a078, a178.data, a178.start, a178.length, a278); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", (a079: rt.u8, a179: rt.ByteSlice, a279: rt.ByteVec): undefined => { + zeros_keys(a079, a179.data, a179.start, a179.length, a279); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", (a080: rt.u8, a180: rt.ByteSlice, a280: rt.ByteVec): undefined => { + arrays(a080, a180.data, a180.start, a180.length, a280); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", (a081: rt.u8, a181: rt.ByteSlice, a281: rt.ByteVec): undefined => { + zips(a081, a181.data, a181.start, a181.length, a281); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", (a082: rt.u8, a182: rt.ByteSlice, a282: rt.ByteVec): undefined => { + zipsBack(a082, a182.data, a182.start, a182.length, a282); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", (a083: rt.u8, a183: rt.ByteSlice, a283: rt.ByteVec): undefined => { + ownNes(a083, a183.data, a183.start, a183.length, a283); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { + fmt_iters(data72.data, data72.start, data72.length, out73); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", (a084: rt.u8, a184: rt.ByteSlice, a284: rt.ByteVec): undefined => { + unread(a084, a184.data, a184.start, a184.length, a284); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", (a085: rt.u8, a185: rt.ByteSlice, a285: rt.ByteVec): undefined => { + rangeFroms(a085, a185.data, a185.start, a185.length, a285); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", (a086: rt.u8, a186: rt.ByteSlice, a286: rt.ByteVec): undefined => { + rangeMethods(a086, a186.data, a186.start, a186.length, a286); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::iters", (a087: rt.u8, a187: rt.ByteSlice, a287: rt.ByteVec): undefined => { + clones_iters(a087, a187.data, a187.start, a187.length, a287); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", (a088: rt.u8, a188: rt.ByteSlice, a288: rt.ByteVec): undefined => { + cellEqs(a088, a188.data, a188.start, a188.length, a288); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", (a089: rt.u8, a189: rt.ByteSlice, a289: rt.ByteVec): undefined => { + compares(a089, a189.data, a189.start, a189.length, a289); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", (a090: rt.u8, a190: rt.ByteSlice, a290: rt.ByteVec): undefined => { + unlikeCompares(a090, a190.data, a190.start, a190.length, a290); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", (a091: rt.u8, a191: rt.ByteSlice, a291: rt.ByteVec): undefined => { + refOrders(a091, a191.data, a191.start, a191.length, a291); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cycles::cycles", (a092: rt.u8, a192: rt.ByteSlice, a292: rt.ByteVec): undefined => { + cycles(a092, a192.data, a192.start, a192.length, a292); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_2173: rt.u8, data73: rt.ByteSlice, out74: rt.ByteVec): undefined => { + lapsed(data73.data, data73.start, data73.length, out74); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", (a093: rt.u8, a193: rt.ByteSlice, a293: rt.ByteVec): undefined => { + cows_slices(a093, a193.data, a193.start, a193.length, a293); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", (a094: rt.u8, a194: rt.ByteSlice, a294: rt.ByteVec): undefined => { + cows_bytes(a094, a194.data, a194.start, a194.length, a294); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u8s", (a095: rt.u8, a195: rt.ByteSlice, a295: rt.ByteVec): undefined => { + wraps_u8s(a095, a195.data, a195.start, a195.length, a295); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", (a096: rt.u8, a196: rt.ByteSlice, a296: rt.ByteVec): undefined => { + wraps_u16s(a096, a196.data, a196.start, a196.length, a296); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", (a097: rt.u8, a197: rt.ByteSlice, a297: rt.ByteVec): undefined => { + wraps_u32s(a097, a197.data, a197.start, a197.length, a297); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", (a098: rt.u8, a198: rt.ByteSlice, a298: rt.ByteVec): undefined => { + wraps_u64s(a098, a198.data, a198.start, a198.length, a298); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", (a099: rt.u8, a199: rt.ByteSlice, a299: rt.ByteVec): undefined => { + wraps_u128s(a099, a199.data, a199.start, a199.length, a299); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", (a0100: rt.u8, a1100: rt.ByteSlice, a2100: rt.ByteVec): undefined => { + wraps_usizes(a0100, a1100.data, a1100.start, a1100.length, a2100); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", (a0101: rt.u8, a1101: rt.ByteSlice, a2101: rt.ByteVec): undefined => { + wraps_i8s(a0101, a1101.data, a1101.start, a1101.length, a2101); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", (a0102: rt.u8, a1102: rt.ByteSlice, a2102: rt.ByteVec): undefined => { + wraps_i16s(a0102, a1102.data, a1102.start, a1102.length, a2102); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", (a0103: rt.u8, a1103: rt.ByteSlice, a2103: rt.ByteVec): undefined => { + wraps_i32s(a0103, a1103.data, a1103.start, a1103.length, a2103); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", (a0104: rt.u8, a1104: rt.ByteSlice, a2104: rt.ByteVec): undefined => { + wraps_i64s(a0104, a1104.data, a1104.start, a1104.length, a2104); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", (a0105: rt.u8, a1105: rt.ByteSlice, a2105: rt.ByteVec): undefined => { + wraps_i128s(a0105, a1105.data, a1105.start, a1105.length, a2105); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", (a0106: rt.u8, a1106: rt.ByteSlice, a2106: rt.ByteVec): undefined => { + wraps_isizes(a0106, a1106.data, a1106.start, a1106.length, a2106); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_2174: rt.u8, data74: rt.ByteSlice, out75: rt.ByteVec): undefined => { + enums(data74.data, data74.start, data74.length, out75); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::segments", (_2175: rt.u8, data75: rt.ByteSlice, out76: rt.ByteVec): undefined => { - segments(data75, out76); + segments(data75.data, data75.start, data75.length, out76); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::uninit_runs", (_2176: rt.u8, data76: rt.ByteSlice, out77: rt.ByteVec): undefined => { - uninitRuns(data76, out77); + uninitRuns(data76.data, data76.start, data76.length, out77); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::beside_written", (_2177: rt.u8, data77: rt.ByteSlice, out78: rt.ByteVec): undefined => { - besideWritten(data77, out78); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", byteRefs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_2178: rt.u8, data78: rt.ByteSlice, out79: rt.ByteVec): undefined => { - orders_held(data78, out79); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", joins as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { - iteratedRuns(data79, out80); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", zeros_writes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { - orders_tuples(data80, out81); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", tuples_tuples as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", saturates_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", saturates_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", saturates_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", saturates_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", saturates_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", saturates_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", saturates_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", saturates_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", saturates_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", saturates_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", saturates_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", saturates_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", methods_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", methods_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", methods_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", methods_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", methods_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", methods_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", methods_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", methods_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", methods_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", methods_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", methods_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", methods_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", separated as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { - waiters(data81, out82); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::boxes", boxes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::bytes", ascii_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", ascii_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", ascii_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", given as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_2182: rt.u8, data82: rt.ByteSlice, out83: rt.ByteVec): undefined => { - pointers_taken(data82, out83); + besideWritten(data77.data, data77.start, data77.length, out78); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", (a0107: rt.u8, a1107: rt.ByteSlice, a2107: rt.ByteVec): undefined => { + byteRefs(a0107, a1107.data, a1107.start, a1107.length, a2107); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_2178: rt.u8, data78: rt.ByteSlice, out79: rt.ByteVec): undefined => { + orders_held(data78.data, data78.start, data78.length, out79); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", (a0108: rt.u8, a1108: rt.ByteSlice, a2108: rt.ByteVec): undefined => { + joins(a0108, a1108.data, a1108.start, a1108.length, a2108); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { + iteratedRuns(data79.data, data79.start, data79.length, out80); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", (a0109: rt.u8, a1109: rt.ByteSlice, a2109: rt.ByteVec): undefined => { + zeros_writes(a0109, a1109.data, a1109.start, a1109.length, a2109); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { + orders_tuples(data80.data, data80.start, data80.length, out81); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", (a0110: rt.u8, a1110: rt.ByteSlice, a2110: rt.ByteVec): undefined => { + tuples_tuples(a0110, a1110.data, a1110.start, a1110.length, a2110); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", (a0111: rt.u8, a1111: rt.ByteSlice, a2111: rt.ByteVec): undefined => { + saturates_u8s(a0111, a1111.data, a1111.start, a1111.length, a2111); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", (a0112: rt.u8, a1112: rt.ByteSlice, a2112: rt.ByteVec): undefined => { + saturates_u16s(a0112, a1112.data, a1112.start, a1112.length, a2112); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", (a0113: rt.u8, a1113: rt.ByteSlice, a2113: rt.ByteVec): undefined => { + saturates_u32s(a0113, a1113.data, a1113.start, a1113.length, a2113); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", (a0114: rt.u8, a1114: rt.ByteSlice, a2114: rt.ByteVec): undefined => { + saturates_u64s(a0114, a1114.data, a1114.start, a1114.length, a2114); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", (a0115: rt.u8, a1115: rt.ByteSlice, a2115: rt.ByteVec): undefined => { + saturates_u128s(a0115, a1115.data, a1115.start, a1115.length, a2115); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", (a0116: rt.u8, a1116: rt.ByteSlice, a2116: rt.ByteVec): undefined => { + saturates_usizes(a0116, a1116.data, a1116.start, a1116.length, a2116); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", (a0117: rt.u8, a1117: rt.ByteSlice, a2117: rt.ByteVec): undefined => { + saturates_i8s(a0117, a1117.data, a1117.start, a1117.length, a2117); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", (a0118: rt.u8, a1118: rt.ByteSlice, a2118: rt.ByteVec): undefined => { + saturates_i16s(a0118, a1118.data, a1118.start, a1118.length, a2118); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", (a0119: rt.u8, a1119: rt.ByteSlice, a2119: rt.ByteVec): undefined => { + saturates_i32s(a0119, a1119.data, a1119.start, a1119.length, a2119); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", (a0120: rt.u8, a1120: rt.ByteSlice, a2120: rt.ByteVec): undefined => { + saturates_i64s(a0120, a1120.data, a1120.start, a1120.length, a2120); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", (a0121: rt.u8, a1121: rt.ByteSlice, a2121: rt.ByteVec): undefined => { + saturates_i128s(a0121, a1121.data, a1121.start, a1121.length, a2121); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", (a0122: rt.u8, a1122: rt.ByteSlice, a2122: rt.ByteVec): undefined => { + saturates_isizes(a0122, a1122.data, a1122.start, a1122.length, a2122); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", (a0123: rt.u8, a1123: rt.ByteSlice, a2123: rt.ByteVec): undefined => { + methods_u8s(a0123, a1123.data, a1123.start, a1123.length, a2123); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", (a0124: rt.u8, a1124: rt.ByteSlice, a2124: rt.ByteVec): undefined => { + methods_u16s(a0124, a1124.data, a1124.start, a1124.length, a2124); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", (a0125: rt.u8, a1125: rt.ByteSlice, a2125: rt.ByteVec): undefined => { + methods_u32s(a0125, a1125.data, a1125.start, a1125.length, a2125); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", (a0126: rt.u8, a1126: rt.ByteSlice, a2126: rt.ByteVec): undefined => { + methods_u64s(a0126, a1126.data, a1126.start, a1126.length, a2126); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", (a0127: rt.u8, a1127: rt.ByteSlice, a2127: rt.ByteVec): undefined => { + methods_u128s(a0127, a1127.data, a1127.start, a1127.length, a2127); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", (a0128: rt.u8, a1128: rt.ByteSlice, a2128: rt.ByteVec): undefined => { + methods_usizes(a0128, a1128.data, a1128.start, a1128.length, a2128); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", (a0129: rt.u8, a1129: rt.ByteSlice, a2129: rt.ByteVec): undefined => { + methods_i8s(a0129, a1129.data, a1129.start, a1129.length, a2129); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", (a0130: rt.u8, a1130: rt.ByteSlice, a2130: rt.ByteVec): undefined => { + methods_i16s(a0130, a1130.data, a1130.start, a1130.length, a2130); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", (a0131: rt.u8, a1131: rt.ByteSlice, a2131: rt.ByteVec): undefined => { + methods_i32s(a0131, a1131.data, a1131.start, a1131.length, a2131); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", (a0132: rt.u8, a1132: rt.ByteSlice, a2132: rt.ByteVec): undefined => { + methods_i64s(a0132, a1132.data, a1132.start, a1132.length, a2132); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", (a0133: rt.u8, a1133: rt.ByteSlice, a2133: rt.ByteVec): undefined => { + methods_i128s(a0133, a1133.data, a1133.start, a1133.length, a2133); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", (a0134: rt.u8, a1134: rt.ByteSlice, a2134: rt.ByteVec): undefined => { + methods_isizes(a0134, a1134.data, a1134.start, a1134.length, a2134); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", (a0135: rt.u8, a1135: rt.ByteSlice, a2135: rt.ByteVec): undefined => { + separated(a0135, a1135.data, a1135.start, a1135.length, a2135); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { + waiters(data81.data, data81.start, data81.length, out82); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::boxes", (a0136: rt.u8, a1136: rt.ByteSlice, a2136: rt.ByteVec): undefined => { + boxes(a0136, a1136.data, a1136.start, a1136.length, a2136); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::bytes", (a0137: rt.u8, a1137: rt.ByteSlice, a2137: rt.ByteVec): undefined => { + ascii_bytes(a0137, a1137.data, a1137.start, a1137.length, a2137); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", (a0138: rt.u8, a1138: rt.ByteSlice, a2138: rt.ByteVec): undefined => { + ascii_chars(a0138, a1138.data, a1138.start, a1138.length, a2138); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", (a0139: rt.u8, a1139: rt.ByteSlice, a2139: rt.ByteVec): undefined => { + ascii_slices(a0139, a1139.data, a1139.start, a1139.length, a2139); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", (a0140: rt.u8, a1140: rt.ByteSlice, a2140: rt.ByteVec): undefined => { + given(a0140, a1140.data, a1140.start, a1140.length, a2140); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_2182: rt.u8, data82: rt.ByteSlice, out83: rt.ByteVec): undefined => { + pointers_taken(data82.data, data82.start, data82.length, out83); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::bytes", (_2183: rt.u8, data83: rt.ByteSlice, out84: rt.ByteVec): undefined => { - pointers_bytes(data83, out84); + pointers_bytes(data83.data, data83.start, data83.length, out84); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::loaded", (_2184: rt.u8, data84: rt.ByteSlice, out85: rt.ByteVec): undefined => { - loaded(data84, out85); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", btrees as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::option_items", (_2185: rt.u8, data85: rt.ByteSlice, out86: rt.ByteVec): undefined => { - optionItems(data85, out86); + loaded(data84.data, data84.start, data84.length, out85); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", (a0141: rt.u8, a1141: rt.ByteSlice, a2141: rt.ByteVec): undefined => { + btrees(a0141, a1141.data, a1141.start, a1141.length, a2141); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::option_items", (_2185: rt.u8, data85: rt.ByteSlice, out86: rt.ByteVec): undefined => { + optionItems(data85.data, data85.start, data85.length, out86); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", (a0142: rt.u8, a1142: rt.ByteSlice, a2142: rt.ByteVec): undefined => { + args(a0142, a1142.data, a1142.start, a1142.length, a2142); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", (a0143: rt.u8, a1143: rt.ByteSlice, a2143: rt.ByteVec): undefined => { + returns(a0143, a1143.data, a1143.start, a1143.length, a2143); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } @@ -260,20 +548,20 @@ export function op(name: string): rt.u8 { } /** Negate the signed type `kind` picks. */ -export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function neg(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - i8Neg(data, out); + i8Neg(dataData, dataStart, dataLen, out); } else if (_4 === 1) { - i16Neg(data, out); + i16Neg(dataData, dataStart, dataLen, out); } else if (_4 === 2) { - i32Neg(data, out); + i32Neg(dataData, dataStart, dataLen, out); } else if (_4 === 3) { - i64Neg(data, out); + i64Neg(dataData, dataStart, dataLen, out); } else if (_4 === 4) { - i128Neg(data, out); + i128Neg(dataData, dataStart, dataLen, out); } else { - isizeNeg(data, out); + isizeNeg(dataData, dataStart, dataLen, out); } } @@ -281,11 +569,11 @@ export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Cast from the type `kind` picks to the one the next byte does, or without one, to * a type `kind` also picks. */ -export function cast(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length === 0) { - ints_cast(kind, rt.u8Div(kind, 12), data, out); +export function cast(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen === 0) { + ints_cast(kind, rt.u8Div(kind, 12), dataData, dataStart, dataLen, out); } else { - ints_cast(kind, data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1), out); + ints_cast(kind, dataData[dataStart], dataData, dataStart + 1, dataLen - 1, out); } } diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 098c23fee..302e1afc7 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -1397,11 +1397,12 @@ export function options(dataData: Uint8Array, dataStart: number, dataLen: number * each way JS holds `None`: `undefined`, `rt.None` where `Some` can be `undefined`, and * nested. */ -export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { +export function optionItems(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _44!: rt.u8; let _67!: boolean; let _87!: undefined | rt.None; let _138!: rt.u8; + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.u8) => rt.u8 | undefined = (b4: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b4, 3) === 0)) { return b4; From 13f264c74fb29f2dc692ab977dd8d16527d74220 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 15:54:39 -0700 Subject: [PATCH 17/26] perf(ts): return a slotted function's first Ok part, and its error in the slot Co-Authored-By: Claude Opus 5.5 --- ts/MIGRATE.md | 5 +- ts/README.md | 18 ++- .../codec/expected/coding/decode.Decoder.ts | 66 ++++---- ts/fixtures/codec/expected/coding/varint.ts | 68 ++++---- ts/fixtures/codec/expected/harness.ts | 16 +- ts/src/lower/body.rs | 6 +- ts/src/lower/mir/mod.rs | 5 +- ts/src/lower/mir/scalar.rs | 153 +++++++++++------- 8 files changed, 197 insertions(+), 140 deletions(-) diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index addf93d83..862868457 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -5,8 +5,9 @@ - A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter as its `data`, `start`, and `length`: `read(buf, form)` is `read(buf.data, buf.start, buf.length, form)`. One that returns a `Result` of byte slices - and scalars returns its error or `undefined`, and leaves the `Ok`'s parts in a - module-level slot, such as `readOut`. A root still takes an `rt.ByteSlice` and returns + and scalars returns the `Ok`'s first part, or `undefined` for an error, and leaves the + rest of the `Ok`'s parts, or the error as `err`, in a module-level slot, such as + `readOut`. A root still takes an `rt.ByteSlice` and returns the `Result`. - `rt.btreeCollect` takes whether it sorts and the keys' `!ne` after the entries, and `rt.btreeCollectKeys` the keys' `PartialOrd::lt` and `!ne`, as in diff --git a/ts/README.md b/ts/README.md index b36c5f212..7ea39b1a7 100644 --- a/ts/README.md +++ b/ts/README.md @@ -687,14 +687,16 @@ they need. noise, and Node's varint decode at 1.11-1.15. - A function of the crate's that only translated code calls and that returns a `Result` of byte slices and scalars, such as `Result<(u64, &[u8]), E>`, whose error is one JS - value that is never `undefined`, returns the error or `undefined`. It writes the `Ok`'s - parts into a module-level slot, which every function returning that payload type - shares, named for the first of them in source order with its suffix, as `readOut` or - `leadOut$u16`, at its JS `return`, after its drops, and its caller reads them at once, so one - that returns another's result as is returns the call. The slot's fields start as - `undefined`, so V8 keeps them tagged: one that starts as a small integer would box - every `u64` past 2^31 that a function too big to inline writes. The function as a value - is an arrow that rebuilds the `Result`. + value, returns the `Ok`'s first part, or `undefined` for an error. It writes the rest of + the `Ok`'s parts, or the error, into a module-level slot, which every function returning + that payload type shares, named for the first of them in source order with its suffix, + as `readOut` or `leadOut$u16`, at its JS `return`, after its drops, and its caller + reads them at once, so one that returns another's result as is returns the call. + Returning the first part keeps a `u64` past 2^31, which a function too big to inline + boxes, out of the long-lived slot: Chrome's 8-byte leading-ones varints took 1.06-1.09x + `main`'s time writing it there, and 0.87-0.92x this way. The slot's fields start as + `undefined`, so V8 keeps them tagged. The function as a value is an arrow that rebuilds + the `Result`. - A `BTreeMap` is a B+ tree of up to 64 keys a node, O(log n) as std's B-tree is: its leaves hold the keys and values and link to their neighbors, which iterators walk from either end, and its branches hold each child's lower bound. A node's slots shift in a diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 04b230e66..89ced15b0 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -61,19 +61,19 @@ export function isEmpty(self: Decoder): boolean { } /** Read `len` raw bytes. */ -export function slice(self: Decoder, len: rt.usize): DecodeError.DecodeError | undefined { +export function slice(self: Decoder, len: rt.usize): Uint8Array | undefined { const slice: rt.ByteSlice = self.buf; if (len <= slice.length) { self.buf = new rt.ByteSlice(slice.data, slice.start + len, slice.length - len); - sliceOut.pData = slice.data; sliceOut.pStart = slice.start; sliceOut.pLen = len; - return undefined; + return slice.data; } - return short(self, len); + sliceOut.err = short(self, len); + return undefined; } -export const sliceOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; +export const sliceOut: { err: unknown; pStart: number; pLen: number } = { err: undefined, pStart: undefined as never, pLen: undefined as never }; /** Read every remaining byte. */ export function rest(self: Decoder): rt.ByteSlice { @@ -84,46 +84,46 @@ export function rest(self: Decoder): rt.ByteSlice { /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ export function sub(self: Decoder, len: rt.usize): rt.Result { - const err: DecodeError.DecodeError | undefined = slice(self, len); - const part: Uint8Array = sliceOut.pData; + const part: Uint8Array | undefined = slice(self, len); const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - if (err === undefined) { - return rt.Ok(new_(part, part2, part3, self.form)); + const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; + if (part !== undefined) { + return rt.Ok(new_(part as Uint8Array, part2, part3, self.form)); } return rt.Err(err as DecodeError.DecodeError); } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - const err: DecodeError.DecodeError | undefined = slice(self, 1); - const part: Uint8Array = sliceOut.pData; + const part: Uint8Array | undefined = slice(self, 1); const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - if (err === undefined) { + const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; + if (part !== undefined) { if (0 >= part3) { rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); } - return rt.Ok(part[part2]); + return rt.Ok((part as Uint8Array)[part2]); } return rt.Err(err as DecodeError.DecodeError); } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const err: DecodeError.DecodeError | undefined = slice(self, 2); - const part: Uint8Array = sliceOut.pData; + const part: Uint8Array | undefined = slice(self, 2); const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - if (err === undefined) { + const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; + if (part !== undefined) { if (0 >= part3) { rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); } - const _9: rt.u8 = part[part2]; + const _9: rt.u8 = (part as Uint8Array)[part2]; if (1 >= part3) { rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 1); } - return rt.Ok((_9 << 8) | part[part2 + 1]); + return rt.Ok((_9 << 8) | (part as Uint8Array)[part2 + 1]); } return rt.Err(err as DecodeError.DecodeError); } @@ -148,13 +148,13 @@ export function bool(self: Decoder): rt.Result export function varint(self: Decoder): rt.Result { let _0!: rt.Result; const _13: rt.ByteSlice = self.buf; - const err2: DecodeError.DecodeError | undefined = read(_13.data, _13.start, _13.length, self.form); - const part: rt.u64 = readOut.p_0; + const part: rt.u64 | undefined = read(_13.data, _13.start, _13.length, self.form); const part2: Uint8Array = readOut.p_1Data; const part3: number = readOut.p_1Start; const part4: number = readOut.p_1Len; - if (err2 === undefined) { - const value: rt.u64 = part; + const err2: DecodeError.DecodeError | undefined = part === undefined ? readOut.err as DecodeError.DecodeError : undefined; + if (part !== undefined) { + const value: rt.u64 = part as rt.u64; self.buf = new rt.ByteSlice(part2, part3, part4); _0 = rt.Ok(value); } else if ((err2 as DecodeError.DecodeError).tag === "Short") { @@ -175,7 +175,7 @@ export function varintOpt(self: Decoder): rt.Result; const start: rt.ByteSlice = self.buf; const _6: rt.Result = varint(self); @@ -184,14 +184,14 @@ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { return { tag: "BoundsExceeded" } as DecodeError.DecodeError; }); if (_3.ok) { - const err: DecodeError.DecodeError | undefined = slice(self, _3.value); - const part: Uint8Array = sliceOut.pData; + const part: Uint8Array | undefined = slice(self, _3.value); const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; + const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; const _15: (a0: DecodeError.DecodeError) => undefined = (_22: DecodeError.DecodeError): undefined => { self.buf = start; }; - _0 = inspectErr$156koiv((err !== undefined ? rt.Err(err as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part, part2, part3))) as rt.Result, _15); + _0 = inspectErr$156koiv((part === undefined ? rt.Err(err as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part as Uint8Array, part2, part3))) as rt.Result, _15); } else { _0 = _3; } @@ -200,23 +200,23 @@ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { } const result: rt.Result = _0; if (!result.ok) { - return result.error; + sliceOut.err = result.error; + return undefined; } const slice_: rt.ByteSlice = result.value; - sliceOut.pData = slice_.data; sliceOut.pStart = slice_.start; sliceOut.pLen = slice_.length; - return undefined; + return slice_.data; } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - const err: DecodeError.DecodeError | undefined = bytes(self); - const part: Uint8Array = sliceOut.pData; + const part: Uint8Array | undefined = bytes(self); const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - if (err === undefined) { - const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part, part2, part3))); + const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; + if (part !== undefined) { + const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part as Uint8Array, part2, part3))); if (_2.ok) { return rt.Ok(_2.value); } diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 996be3650..0149bc5d3 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -191,58 +191,61 @@ export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ -export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): DecodeError.DecodeError | undefined { +export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): rt.u64 | undefined { if (form.tag === "Quic") { return readQuic(bufData, bufStart, bufLen); } return readLeadingOnes(bufData, bufStart, bufLen, form.seven); } -export const readOut: { p_0: rt.u64; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const readOut: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): DecodeError.DecodeError | undefined { +export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): rt.u64 | undefined { if (bufLen !== 0) { const first: rt.u8 = bufData[bufStart]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { if (bufLen >= 8) { - readOut.p_0 = fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); + const _61_0: rt.u64 = fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); readOut.p_1Data = bufData; readOut.p_1Start = bufStart + 8; readOut.p_1Len = bufLen - 8; - return undefined; + return _61_0; } - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } if (bufLen >= 4) { - readOut.p_0 = (((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + const _40_0: rt.u64 = (((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; readOut.p_1Data = bufData; readOut.p_1Start = bufStart + 4; readOut.p_1Len = bufLen - 4; - return undefined; + return _40_0; } - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } if (bufLen >= 2) { - readOut.p_0 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + const _21_0: rt.u64 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; readOut.p_1Data = bufData; readOut.p_1Start = bufStart + 2; readOut.p_1Len = bufLen - 2; - return undefined; + return _21_0; } - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - readOut.p_0 = first as rt.u64; readOut.p_1Data = bufData; readOut.p_1Start = bufStart + 1; readOut.p_1Len = bufLen - 1; - return undefined; + return first as rt.u64; } - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } -export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): DecodeError.DecodeError | undefined { +export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): rt.u64 | undefined { let _8_0!: rt.u64; let _8_1Data!: Uint8Array; let _8_1Start!: number; @@ -262,7 +265,8 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 2; _8_1Len = bufLen - 2; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 2) { if (bufLen >= 3) { @@ -271,7 +275,8 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 3; _8_1Len = bufLen - 3; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 3) { if (bufLen >= 4) { @@ -280,7 +285,8 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 4; _8_1Len = bufLen - 4; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 4) { if (bufLen >= 5) { @@ -289,7 +295,8 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 5; _8_1Len = bufLen - 5; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 5) { if (bufLen >= 6) { @@ -298,11 +305,13 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 6; _8_1Len = bufLen - 6; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 6) { if (!seven) { - return { tag: "InvalidValue" } as DecodeError.DecodeError; + readOut.err = { tag: "InvalidValue" } as DecodeError.DecodeError; + return undefined; } if (bufLen >= 7) { _8_0 = fromHalves(((bufData[bufStart] & 1) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2], ((bufData[bufStart + 3] << 24) | (bufData[bufStart + 4] << 16) | (bufData[bufStart + 5] << 8) | bufData[bufStart + 6]) >>> 0); @@ -310,7 +319,8 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 7; _8_1Len = bufLen - 7; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 7) { if (bufLen >= 8) { @@ -319,7 +329,8 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 8; _8_1Len = bufLen - 8; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (bufLen >= 9) { _8_0 = fromHalves(((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0, ((bufData[bufStart + 5] << 24) | (bufData[bufStart + 6] << 16) | (bufData[bufStart + 7] << 8) | bufData[bufStart + 8]) >>> 0); @@ -327,15 +338,16 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n _8_1Start = bufStart + 9; _8_1Len = bufLen - 9; } else { - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - readOut.p_0 = _8_0; readOut.p_1Data = _8_1Data; readOut.p_1Start = _8_1Start; readOut.p_1Len = _8_1Len; - return undefined; + return _8_0; } - return { tag: "Short" } as DecodeError.DecodeError; + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } /** diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index ed8310918..a17920e04 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -270,13 +270,13 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _31; } } else if (_5 === 5) { - const err2: DecodeError.DecodeError | undefined = Decoder.bytes(r); - const part4: Uint8Array = Decoder.sliceOut.pData; + const part4: Uint8Array | undefined = Decoder.bytes(r); const part5: number = Decoder.sliceOut.pStart; const part6: number = Decoder.sliceOut.pLen; - if (err2 === undefined) { + const err2: DecodeError.DecodeError | undefined = part4 === undefined ? Decoder.sliceOut.err as DecodeError.DecodeError : undefined; + if (part4 !== undefined) { putUsize(out, part6); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part4, part5, part6)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part4 as Uint8Array, part5, part6)); } else { return rt.Err(err2 as DecodeError.DecodeError); } @@ -288,12 +288,12 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _49; } } else if (_5 === 7) { - const err: DecodeError.DecodeError | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); - const part: Uint8Array = Decoder.sliceOut.pData; + const part: Uint8Array | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); const part2: number = Decoder.sliceOut.pStart; const part3: number = Decoder.sliceOut.pLen; - if (err === undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part, part2, part3)); + const err: DecodeError.DecodeError | undefined = part === undefined ? Decoder.sliceOut.err as DecodeError.DecodeError : undefined; + if (part !== undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part as Uint8Array, part2, part3)); } else { return rt.Err(err as DecodeError.DecodeError); } diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index a829fd701..99f7f68db 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -134,9 +134,9 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { // One that hands back its `Ok`'s parts, made whole here, before anything else can // write its slot. if let Some(slotted) = self.t.slotted(instance) { - let err = self.fresh("err"); - out.push(StmtKind::decl(false, err.clone(), None, Some(call)).at(None)); - let value = slotted.rebuild(self.t, &err, span); + let first = self.fresh("part"); + out.push(StmtKind::decl(false, first.clone(), None, Some(call)).at(None)); + let value = slotted.rebuild(self.t, &first, span); let result = self.fresh("result"); let ty = self.t.ty(slotted.ret, span); out.push(StmtKind::decl(false, result.clone(), Some(ty), Some(value)).at(None)); diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 59b72f369..1bba2d9a9 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -64,10 +64,7 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> (true, ty::Adt(_, args)) => { Type::Union(vec![fx.b.t.ty(args.type_at(0), ret_span), Type::Rt("Done", Vec::new())]) } - // The error, or `undefined` once the `Ok`'s parts are in the slot. - (_, ty::Adt(_, args)) if slotted.is_some() => { - Type::Union(vec![fx.b.t.ty(args.type_at(1), ret_span), Type::Builtin("undefined")]) - } + (_, ty::Adt(..)) if let Some(slotted) = &slotted => fx.b.t.slot_ret_ty(slotted, ret_span), _ => fx.b.t.ret_ty(ret_ty, ret_span), }; Some(ts::Function { diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index b9c94565c..bf775c6fd 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -8,7 +8,7 @@ //! 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. A function that hands back a `Result` in a slot holds its -//! result so, to write the `Ok`'s parts there, and its callers read them back as parts. +//! result so, to hand back the `Ok`'s parts, and its callers read them back as parts. use rustc_abi::VariantIdx; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -233,10 +233,10 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } /// Where `instance` hands back its `Ok`'s parts, if it does: a function of the crate's - /// that only translated code calls directly, and that returns a `Result` of byte slices and scalars, such as - /// `Result<(u64, &[u8]), E>`, returns its error or `undefined`, and writes the `Ok`'s - /// parts into a module-level slot its caller reads at once. Its error must be one value - /// that is never `undefined`. + /// that only translated code calls directly, and that returns a `Result` of byte slices + /// and scalars, such as `Result<(u64, &[u8]), E>`, returns the `Ok`'s first part, which + /// is never `undefined`, or `undefined` for an error. It writes the rest, or the error, + /// which must be one value, into a module-level slot its caller reads at once. pub(crate) fn slotted(&mut self, instance: ty::Instance<'tcx>) -> Option> { if let Some(slotted) = self.slotted.get(&instance) { return slotted.clone(); @@ -264,20 +264,18 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { return None; } let shape = self.shape(ok)?; - let erased = self.erases_to(err); - if !shape.has_slice() - || shape.has_enum() - || !matches!(self.shape(err), Some(Shape::Leaf(_))) - || erased.undefined - || erased.none - || erased.param - || erased.pending - || erased.outer_pending - { + if !shape.has_slice() || shape.has_enum() || !matches!(self.shape(err), Some(Shape::Leaf(_))) { return None; } let mut parts = Vec::new(); shape.parts("", &mut parts); + // The first part is returned, so `undefined` must mean an error. + if let Part::Value(first) = parts[0].1 { + let erased = self.erases_to(first); + if erased.undefined || erased.none || erased.param || erased.pending || erased.outer_pending { + return None; + } + } let fields: Vec = parts.iter().map(|(suffix, _)| format!("p{suffix}")).collect(); let sym = match self.slots.get(&ok) { Some(&sym) => sym, @@ -294,8 +292,9 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } /// The slot of `Ok` payloads of type `ok`, which every function returning one shares: - /// each of `fields` starts `undefined`, so V8 keeps it tagged rather than boxing every - /// number past 2^31 that a function too big to inline writes. + /// the error, of any of their error types, then each of `fields` but the first part's, + /// which the function returns. Each starts `undefined`, so V8 keeps it tagged rather + /// than boxing every number past 2^31 that a function too big to inline writes. fn slot( &mut self, ok: Ty<'tcx>, @@ -318,14 +317,18 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { }); let tys: Vec = parts.iter().map(|(_, part)| self.part_ty(*part, span)).collect(); let never = Expr::As(Box::new(Expr::undefined()), Type::Builtin("never")); + let held = std::iter::zip(&fields[1..], tys.into_iter().skip(1)); self.program.items.push(crate::ts::Item::Value { sym, - ty: Type::Object(fields.iter().cloned().zip(tys).collect()), + ty: Type::Object( + std::iter::once((ERR.to_string(), Type::Builtin("unknown"))) + .chain(held.map(|(field, ty)| (field.clone(), ty))) + .collect(), + ), doc: None, value: Expr::Object( - fields - .iter() - .map(|field| (Key::Name(field.clone()), never.clone())) + std::iter::once((Key::Name(ERR.into()), Expr::undefined())) + .chain(fields[1..].iter().map(|field| (Key::Name(field.clone()), never.clone()))) .collect(), ), }); @@ -349,6 +352,14 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { (slot.order, slot.module, slot.base, slot.suffix) = (order, module, base, suffix); } + /// What a function that hands back its `Ok`'s parts in `slotted` returns: the first + /// part, or `undefined` for an error. + pub(crate) fn slot_ret_ty(&mut self, slotted: &Slotted<'tcx>, span: Span) -> Type { + let mut parts = Vec::new(); + slotted.ok.parts("", &mut parts); + Type::Union(vec![self.part_ty(parts[0].1, span), Type::Builtin("undefined")]) + } + /// The type of a variable or field that holds `part`. fn part_ty(&mut self, part: Part<'tcx>, span: Span) -> Type { match part { @@ -398,8 +409,11 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } } -/// Where a function hands back its `Ok`'s parts: the module-level slot it writes them -/// into, and their layout. +/// The slot's field that holds an error. +const ERR: &str = "err"; + +/// Where a function hands back its `Ok`'s parts: it returns the first, or `undefined` for +/// an error, and writes the rest, or the error, into a module-level slot. #[derive(Clone, Debug)] pub struct Slotted<'tcx> { pub sym: crate::ts::SymId, @@ -409,26 +423,34 @@ pub struct Slotted<'tcx> { pub err: Ty<'tcx>, /// The `Ok` payload's layout, which has no enum. pub ok: Shape<'tcx>, - /// Each part's field in the slot, in order. + /// Each part's field in the slot, in order, but the first's, which is returned. pub fields: Vec, } impl<'tcx> Slotted<'tcx> { - /// The slot's field `i`, read or written. + /// The slot's field of part `i`, after the first, read or written. pub fn field(&self, i: usize) -> Expr { + assert!(i > 0, "the first part is returned"); Expr::Sym(self.sym).member(self.fields[i].clone()) } - /// What a caller that keeps the result whole makes of what the call returned, `err` - /// (a name), read at once: the `Ok` of the slot's parts, or the `Err`. - pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, err: &str, span: Span) -> Expr { - let parts: Vec = (0..self.fields.len()).map(|i| self.field(i)).collect(); + /// The slot's field of the error. + pub fn err_field(&self) -> Expr { + Expr::Sym(self.sym).member(ERR) + } + + /// What a caller that keeps the result whole makes of what the call returned, `first` + /// (a name), read at once: the `Ok` of it and the slot's parts, or the `Err`. + pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, first: &str, span: Span) -> Expr { + let parts: Vec = std::iter::once(Expr::ident(first)) + .chain((1..self.fields.len()).map(|i| self.field(i))) + .collect(); let ok = build_plain(t, &self.ok, &parts, span); let err_ty = t.ty(self.err, span); Expr::Cond( - Box::new(Expr::ident(err).binary("===", Expr::undefined())), + Box::new(Expr::ident(first).binary("===", Expr::undefined())), + Box::new(Expr::rt("Err", vec![Expr::As(Box::new(self.err_field()), err_ty)])), Box::new(Expr::rt("Ok", vec![ok])), - Box::new(Expr::rt("Err", vec![Expr::As(Box::new(Expr::ident(err)), err_ty)])), ) } } @@ -457,6 +479,15 @@ fn build_plain<'tcx>( } } +/// Return `undefined` from a function that hands back its `Ok`'s parts, with its error +/// `err` in the slot. +fn slot_fail(slot: &Slotted<'_>, err: Expr, loc: Option) -> Vec { + vec![ + StmtKind::Expr(slot.err_field().assign(err)).at(None), + StmtKind::Return(Some(Expr::undefined())).at(loc), + ] +} + /// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rt.ByteSlice`. fn slice_ref(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Ref(_, inner, rustc_ast::Mutability::Not) @@ -1581,8 +1612,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } /// The parts of what a function that hands back its `Ok`'s parts returns into `local`: - /// whether it is an error, then the slot's fields, read now before anything else can - /// write them, then the error. + /// whether it is an error, then what it returned and the slot's fields, read now before + /// anything else can write them, then the error. fn slotted_call( &mut self, local: Local, @@ -1592,28 +1623,39 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) -> Vec> { let slotted = self.slotted_calls[&self.at.block].1.clone(); let call = self.slotted_raw(local, args, span, out); - let err = self.b.fresh("err"); - let err_ty = self.b.t.ty(slotted.err, span); - self.steady.insert(err.clone()); + let mut kinds = Vec::new(); + slotted.ok.parts("", &mut kinds); + let first = self.b.fresh("part"); + let first_ty = self.b.t.part_ty(kinds[0].1, span); + self.steady.insert(first.clone()); self.scalar_binds.push(( - err.clone(), - Type::Union(vec![err_ty.clone(), Type::Builtin("undefined")]), + first.clone(), + Type::Union(vec![first_ty.clone(), Type::Builtin("undefined")]), )); - let stmt = StmtKind::Expr(Expr::ident(&err).assign(call)).at(None); + let stmt = StmtKind::Expr(Expr::ident(&first).assign(call)).at(None); self.emit(vec![stmt], false, out); - let mut parts = vec![Some((Expr::ident(&err).binary("!==", Expr::undefined()), true))]; - let mut kinds = Vec::new(); - slotted.ok.parts("", &mut kinds); - for (i, (_, part)) in kinds.into_iter().enumerate() { + let failed = Expr::ident(&first).binary("===", Expr::undefined()); + let mut parts = vec![ + Some((failed.clone(), true)), + Some((Expr::As(Box::new(Expr::ident(&first)), first_ty), true)), + ]; + for (i, (_, part)) in kinds.into_iter().enumerate().skip(1) { let ty = self.b.t.part_ty(part, span); parts.push(Some(self.steady_value(slotted.field(i), "part", ty, out))); } - parts.push(Some((Expr::As(Box::new(Expr::ident(&err)), err_ty), true))); + let err_ty = self.b.t.ty(slotted.err, span); + let err = Expr::Cond( + Box::new(failed), + Box::new(Expr::As(Box::new(slotted.err_field()), err_ty.clone())), + Box::new(Expr::undefined()), + ); + let (err, _) = self.steady_value(err, "err", Type::Union(vec![err_ty.clone(), Type::Builtin("undefined")]), out); + parts.push(Some((Expr::As(Box::new(err), err_ty), true))); parts } /// The call, ending the block being lowered, of a function that hands back its `Ok`'s - /// parts, into `local`: what it returns, its error or `undefined`. + /// parts, into `local`: what it returns, its `Ok`'s first part or `undefined`. fn slotted_raw(&mut self, local: Local, args: &[Spanned>], span: Span, out: &mut Vec) -> Expr { let instance = self.slotted_calls[&self.at.block].0; let result = self.mir.local_decls[local].ty; @@ -1733,7 +1775,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let (result, _) = self.steady_value(value, "result", ty, out); let check = StmtKind::If { cond: result.clone().member("ok").not(), - then: vec![StmtKind::Return(Some(result.clone().member("error"))).at(loc)], + then: slot_fail(slot, result.clone().member("error"), loc), els: Vec::new(), }; self.emit(vec![check.at(None)], false, out); @@ -1741,8 +1783,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.slot_write(slot, parts.into_iter().map(|(e, _)| Some(e)).collect(), span, out); } - /// Return the result's `parts`: its error, if the flag says it is one, or else - /// `undefined` once the `Ok`'s parts are in the slot. + /// Return the result's `parts`: `undefined` once its error is in the slot, if the flag + /// says it is one, or else the `Ok`'s first part once the rest are. fn slot_return_parts(&mut self, parts: Vec>, span: Span, out: &mut Vec) { let slot = self.slot.clone().expect("a function with a slot"); let loc = self.b.t.loc(span); @@ -1752,13 +1794,13 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { match &flag { Expr::Lit(t) if t == "false" => {} Expr::Lit(t) if t == "true" => { - self.emit(vec![StmtKind::Return(Some(err)).at(loc)], false, out); + self.emit(slot_fail(&slot, err, loc), false, out); return; } _ => { let check = StmtKind::If { cond: flag, - then: vec![StmtKind::Return(Some(err)).at(loc)], + then: slot_fail(&slot, err, loc), els: Vec::new(), }; self.emit(vec![check.at(None)], false, out); @@ -1767,13 +1809,16 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.slot_write(&slot, parts[1..=n].to_vec(), span, out); } - /// Write the `Ok`'s parts `ok` into the slot, and return `undefined`. + /// Write the `Ok`'s parts `ok` but the first into the slot, and return the first. fn slot_write(&mut self, slot: &Slotted<'tcx>, ok: Vec>, span: Span, out: &mut Vec) { let loc = self.b.t.loc(span); - let mut stmts: Vec = (ok.into_iter().enumerate()) - .map(|(i, part)| StmtKind::Expr(slot.field(i).assign(part.unwrap_or_else(Expr::undefined))).at(None)) + let mut ok = ok.into_iter(); + let first = ok.next().flatten().unwrap_or_else(Expr::undefined); + let mut stmts: Vec = ok + .enumerate() + .map(|(i, part)| StmtKind::Expr(slot.field(i + 1).assign(part.unwrap_or_else(Expr::undefined))).at(None)) .collect(); - stmts.push(StmtKind::Return(Some(Expr::undefined())).at(loc)); + stmts.push(StmtKind::Return(Some(first)).at(loc)); self.emit(stmts, false, out); } From 0700f7295ddc334fbe4b0c420ea65ee06b34527f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:04:06 -0700 Subject: [PATCH 18/26] chore(ts): regenerate the lang fixture's slots Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/chunks.ts | 22 +- ts/fixtures/lang/expected/returns.At.ts | 10 +- ts/fixtures/lang/expected/returns.Guard.ts | 5 +- ts/fixtures/lang/expected/returns.Split.ts | 4 +- ts/fixtures/lang/expected/returns.ts | 391 +++++++++++---------- ts/fixtures/lang/expected/splits.ts | 40 +-- 6 files changed, 242 insertions(+), 230 deletions(-) diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index 7d1d7284a..c301f629a 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -11,20 +11,20 @@ export function header(dataData: Uint8Array, dataStart: number, dataLen: number) return undefined; } -export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { +export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { if (!(dataLen >= 4)) { - return dataLen & 0xff; + take4Out.err = dataLen & 0xff; + return undefined; } - take4Out.p_0Data = dataData; take4Out.p_0Start = dataStart; take4Out.p_0Len = 4; take4Out.p_1Data = dataData; take4Out.p_1Start = dataStart + 4; take4Out.p_1Len = dataLen - 4; - return undefined; + return dataData; } -export const take4Out: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const take4Out: { err: unknown; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; export function word(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): rt.u32 { return ((chunkData[chunkStart] << 24) | (chunkData[chunkStart + 1] << 16) | (chunkData[chunkStart + 2] << 8) | chunkData[chunkStart + 3]) >>> 0; @@ -69,17 +69,17 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, h.tag.data[h.tag.start + 1]); rt.byteVecPush(out, h.rest.length & 0xff); } - const err: rt.u8 | undefined = take4(dataData, dataStart, dataLen); - const part2: Uint8Array = take4Out.p_0Data; + const part2: Uint8Array | undefined = take4(dataData, dataStart, dataLen); const part3: number = take4Out.p_0Start; const part4: number = take4Out.p_0Len; const part5: Uint8Array = take4Out.p_1Data; const part6: number = take4Out.p_1Start; const part7: number = take4Out.p_1Len; - if (err === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(part2, part3, part4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part2[part3 + 1] << 8) | part2[part3 + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part2, part3, part4); + const err: rt.u8 | undefined = part2 === undefined ? take4Out.err as rt.u8 : undefined; + if (part2 !== undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(part2 as Uint8Array, part3, part4)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(((((part2 as Uint8Array)[part3 + 1] << 8) | (part2 as Uint8Array)[part3 + 2]) << 16) >> 16))); + const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part2 as Uint8Array, part3, part4); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part5, part6, part7)); } else { diff --git a/ts/fixtures/lang/expected/returns.At.ts b/ts/fixtures/lang/expected/returns.At.ts index d58cc8d8e..4cd088060 100644 --- a/ts/fixtures/lang/expected/returns.At.ts +++ b/ts/fixtures/lang/expected/returns.At.ts @@ -7,21 +7,21 @@ export interface At { _0: rt.usize; } -export function split$returns_Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function split$returns_Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { const mid: number = self._0; const _5 = { tag: "Short", _0: self._0 } as returns_Error.Error; if (!(mid <= dataLen)) { - return _5; + splitOut$returns_Split.err = _5; + return undefined; } - splitOut$returns_Split.p_0Data = dataData; splitOut$returns_Split.p_0Start = dataStart; splitOut$returns_Split.p_0Len = mid; splitOut$returns_Split.p_1Data = dataData; splitOut$returns_Split.p_1Start = dataStart + mid; splitOut$returns_Split.p_1Len = dataLen - mid; - return undefined; + return dataData; } -export const splitOut$returns_Split: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const splitOut$returns_Split: { err: unknown; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; //# sourceMappingURL=returns.At.ts.map diff --git a/ts/fixtures/lang/expected/returns.Guard.ts b/ts/fixtures/lang/expected/returns.Guard.ts index 6e52932c7..a9303ba4a 100644 --- a/ts/fixtures/lang/expected/returns.Guard.ts +++ b/ts/fixtures/lang/expected/returns.Guard.ts @@ -1,7 +1,8 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { narrow } from "./returns.ts"; +import { wideOut, narrow } from "./returns.ts"; +import type * as returns_Error from "./returns.Error.ts"; /** A guard whose drop writes the slot after its function's call did. */ export class Guard { @@ -20,7 +21,7 @@ export class Guard { export function drop$ops_Drop(self: Guard): void { const _3: rt.ByteSlice = rt.byteSliceRange(self._0, rt.usizeRem(self._1 as rt.usize, 2)); - narrow(_3.data, _3.start, _3.length); + narrow(_3.data, _3.start, _3.length) === undefined ? wideOut.err as returns_Error.Error : undefined; } //# sourceMappingURL=returns.Guard.ts.map diff --git a/ts/fixtures/lang/expected/returns.Split.ts b/ts/fixtures/lang/expected/returns.Split.ts index 107938235..36ee33c31 100644 --- a/ts/fixtures/lang/expected/returns.Split.ts +++ b/ts/fixtures/lang/expected/returns.Split.ts @@ -15,8 +15,8 @@ export class of$returns_At { } split$Split(a: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> { - const err = At.split$returns_Split(this.v, a.data, a.start, a.length); - const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = err === undefined ? rt.Ok([new rt.ByteSlice(At.splitOut$returns_Split.p_0Data, At.splitOut$returns_Split.p_0Start, At.splitOut$returns_Split.p_0Len), new rt.ByteSlice(At.splitOut$returns_Split.p_1Data, At.splitOut$returns_Split.p_1Start, At.splitOut$returns_Split.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]) : rt.Err(err as returns_Error.Error); + const part = At.split$returns_Split(this.v, a.data, a.start, a.length); + const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = part === undefined ? rt.Err(At.splitOut$returns_Split.err as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part, At.splitOut$returns_Split.p_0Start, At.splitOut$returns_Split.p_0Len), new rt.ByteSlice(At.splitOut$returns_Split.p_1Data, At.splitOut$returns_Split.p_1Start, At.splitOut$returns_Split.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]); return result; } } diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts index f28567ebc..aaa188a63 100644 --- a/ts/fixtures/lang/expected/returns.ts +++ b/ts/fixtures/lang/expected/returns.ts @@ -10,69 +10,72 @@ import * as Guard from "./returns.Guard.ts"; import * as Split from "./returns.Split.ts"; /** A slice alone, with returns from several places. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Uint8Array | undefined { if (!(n > 200)) { if (!(n <= dataLen)) { - return { tag: "Short", _0: rt.usizeSub(n, dataLen) } as returns_Error.Error; + takeOut.err = { tag: "Short", _0: rt.usizeSub(n, dataLen) } as returns_Error.Error; + return undefined; } - takeOut.pData = dataData; takeOut.pStart = dataStart; takeOut.pLen = n; - return undefined; + return dataData; } - return { tag: "Bad" } as returns_Error.Error; + takeOut.err = { tag: "Bad" } as returns_Error.Error; + return undefined; } -export const takeOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; +export const takeOut: { err: unknown; pStart: number; pLen: number } = { err: undefined, pStart: undefined as never, pLen: undefined as never }; /** The same slice type through another function, which shares its slot. */ -export function tail(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { +export function tail(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Uint8Array | undefined { const _4: boolean = n <= dataLen; const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const _0: rt.Result = option_okOr$12p77jh(then$0w2ymju(_4, (): rt.ByteSlice => { return rt.byteSliceRange(captured, n); }), { tag: "Short", _0: n } as returns_Error.Error); if (!_0.ok) { - return _0.error; + takeOut.err = _0.error; + return undefined; } const slice: rt.ByteSlice = _0.value; - takeOut.pData = slice.data; takeOut.pStart = slice.start; takeOut.pLen = slice.length; - return undefined; + return slice.data; } /** A number past 2^31 and the rest. */ -export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { if (dataLen >= 8) { - wideOut.p_0 = rt.u64FromBeBytes(rt.byteSliceToArray(new rt.ByteSlice(dataData, dataStart, 8))); + const _11_0: rt.u64 = rt.u64FromBeBytes(rt.byteSliceToArray(new rt.ByteSlice(dataData, dataStart, 8))); wideOut.p_1Data = dataData; wideOut.p_1Start = dataStart + 8; wideOut.p_1Len = dataLen - 8; - return undefined; + return _11_0; } - return { tag: "Short", _0: 8 } as returns_Error.Error; + wideOut.err = { tag: "Short", _0: 8 } as returns_Error.Error; + return undefined; } -export const wideOut: { p_0: rt.u64; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const wideOut: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { if (dataLen !== 0) { const b: rt.u8 = dataData[dataStart]; if (b === 255) { - return { tag: "Bad" } as returns_Error.Error; + wideOut.err = { tag: "Bad" } as returns_Error.Error; + return undefined; } - wideOut.p_0 = b as rt.u64; wideOut.p_1Data = dataData; wideOut.p_1Start = dataStart + 1; wideOut.p_1Len = dataLen - 1; - return undefined; + return b as rt.u64; } - return { tag: "Short", _0: 1 } as returns_Error.Error; + wideOut.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; } /** What either returns, returned as is. */ -export function number(dataData: Uint8Array, dataStart: number, dataLen: number, wide_: boolean): returns_Error.Error | undefined { +export function number(dataData: Uint8Array, dataStart: number, dataLen: number, wide_: boolean): rt.u64 | undefined { if (!wide_) { return narrow(dataData, dataStart, dataLen); } @@ -80,40 +83,40 @@ export function number(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Each byte before a zero counted, recursively. */ -export function count(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function count(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { if (dataLen === 0) { - return { tag: "Short", _0: 1 } as returns_Error.Error; + wideOut.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; } if (dataData[dataStart] === 0) { - wideOut.p_0 = 0; wideOut.p_1Data = dataData; wideOut.p_1Start = dataStart + 1; wideOut.p_1Len = dataLen - 1; - return undefined; + return 0; } - const err: returns_Error.Error | undefined = count(dataData, dataStart + 1, dataLen - 1); - const part: rt.u64 = wideOut.p_0; + const part: rt.u64 | undefined = count(dataData, dataStart + 1, dataLen - 1); const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - if (err === undefined) { - wideOut.p_0 = rt.u64Add(part, 1); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; + if (part !== undefined) { + const _14_0: rt.u64 = rt.u64Add(part as rt.u64, 1); wideOut.p_1Data = part2; wideOut.p_1Start = part3; wideOut.p_1Len = part4; - return undefined; + return _14_0; } - return err as returns_Error.Error; + wideOut.err = err as returns_Error.Error; + return undefined; } /** Two slices, and a reference to an array. */ -export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { +export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { if (dataLen >= 2) { const mid: number = rt.usizeDiv(dataLen - 2, 2); if (mid > dataLen - 2) { rt.panic("mid > len"); } - halvesOut.p_0Data = dataData; halvesOut.p_0Start = dataStart + 2; halvesOut.p_0Len = mid; halvesOut.p_1Data = dataData; @@ -122,71 +125,75 @@ export function halves(dataData: Uint8Array, dataStart: number, dataLen: number) halvesOut.p_2Data = dataData; halvesOut.p_2Start = dataStart + 2 + mid; halvesOut.p_2Len = dataLen - 2 - mid; - return undefined; + return dataData; } - return dataLen & 0xff; + halvesOut.err = dataLen & 0xff; + return undefined; } -export const halvesOut: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; +export const halvesOut: { err: unknown; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; /** Calls whose results are both held while the slot is written again between them. */ -export function both(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { - const err: returns_Error.Error | undefined = narrow(dataData, dataStart, dataLen); - const part: rt.u64 = wideOut.p_0; +export function both(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { + const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - if (err === undefined) { - const a: rt.u64 = part; - const err2: returns_Error.Error | undefined = number(part2, part3, part4, rt.u64Rem(a, 2) === 1); - const part5: rt.u64 = wideOut.p_0; + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; + if (part !== undefined) { + const a: rt.u64 = part as rt.u64; + const part5: rt.u64 | undefined = number(part2, part3, part4, rt.u64Rem(a, 2) === 1); const part6: Uint8Array = wideOut.p_1Data; const part7: number = wideOut.p_1Start; const part8: number = wideOut.p_1Len; - if (err2 === undefined) { - const b: rt.u64 = part5; - const err3: returns_Error.Error | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); - const part9: Uint8Array = takeOut.pData; + const err2: returns_Error.Error | undefined = part5 === undefined ? wideOut.err as returns_Error.Error : undefined; + if (part5 !== undefined) { + const b: rt.u64 = part5 as rt.u64; + const part9: Uint8Array | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); const part10: number = takeOut.pStart; const part11: number = takeOut.pLen; - if (err3 === undefined) { - const err4: returns_Error.Error | undefined = take(part9, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); + const err3: returns_Error.Error | undefined = part9 === undefined ? takeOut.err as returns_Error.Error : undefined; + if (part9 !== undefined) { + const part12: Uint8Array | undefined = take(part9 as Uint8Array, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); const part14: number = takeOut.pLen; - if (err4 === undefined) { - const _35_1: rt.u64 = rt.u64Xor(b, part14 as rt.u64); - bothOut.p_0 = a; - bothOut.p_1 = _35_1; - bothOut.p_2Data = part9; + const err4: returns_Error.Error | undefined = part12 === undefined ? takeOut.err as returns_Error.Error : undefined; + if (part12 !== undefined) { + bothOut.p_1 = rt.u64Xor(b, part14 as rt.u64); + bothOut.p_2Data = part9 as Uint8Array; bothOut.p_2Start = part10; bothOut.p_2Len = part11; - return undefined; + return a; } - return err4 as returns_Error.Error; + bothOut.err = err4 as returns_Error.Error; + return undefined; } - return err3 as returns_Error.Error; + bothOut.err = err3 as returns_Error.Error; + return undefined; } - return err2 as returns_Error.Error; + bothOut.err = err2 as returns_Error.Error; + return undefined; } - return err as returns_Error.Error; + bothOut.err = err as returns_Error.Error; + return undefined; } -export const bothOut: { p_0: rt.u64; p_1: rt.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0: undefined as never, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; +export const bothOut: { err: unknown; p_1: rt.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; -export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, otherData: Uint8Array, otherStart: number, otherLen: number): returns_Error.Error | undefined { - const err: returns_Error.Error | undefined = narrow(dataData, dataStart, dataLen); - const part: rt.u64 = wideOut.p_0; +export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, otherData: Uint8Array, otherStart: number, otherLen: number): rt.u64 | undefined { + const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; new Guard.Guard(new rt.ByteSlice(otherData, otherStart, otherLen), dataLen & 0xff)[Symbol.dispose](); - if (err !== undefined) { - return err as returns_Error.Error; + if (part === undefined) { + wideOut.err = err as returns_Error.Error; + return undefined; } - wideOut.p_0 = part; wideOut.p_1Data = part2; wideOut.p_1Start = part3; wideOut.p_1Len = part4; - return undefined; + return part as rt.u64; } /** Errors that are no single value: `()`, and an `Option`. */ @@ -211,33 +218,35 @@ export function noneErr(dataData: Uint8Array, dataStart: number, dataLen: number }), undefined as rt.u8 | undefined); } -export function lead$u16(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function lead$u16(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u16 | undefined { if (dataLen !== 0) { - leadOut$u16.p_0 = dataData[dataStart] as rt.u16; + const _11_0: rt.u16 = dataData[dataStart] as rt.u16; leadOut$u16.p_1Data = dataData; leadOut$u16.p_1Start = dataStart + 1; leadOut$u16.p_1Len = dataLen - 1; - return undefined; + return _11_0; } - return { tag: "Short", _0: 1 } as returns_Error.Error; + leadOut$u16.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; } -export function lead$u32(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function lead$u32(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 | undefined { if (dataLen !== 0) { - leadOut$u32.p_0 = dataData[dataStart] as rt.u32; + const _11_0: rt.u32 = dataData[dataStart] as rt.u32; leadOut$u32.p_1Data = dataData; leadOut$u32.p_1Start = dataStart + 1; leadOut$u32.p_1Len = dataLen - 1; - return undefined; + return _11_0; } - return { tag: "Short", _0: 1 } as returns_Error.Error; + leadOut$u32.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; } -export const leadOut$u16: { p_0: rt.u16; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const leadOut$u16: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export const leadOut$u32: { p_0: rt.u32; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const leadOut$u32: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export function splitWith$returns_At(s: At.At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { +export function splitWith$returns_At(s: At.At, dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { return At.split$returns_Split(s, dataData, dataStart, dataLen); } @@ -265,77 +274,77 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da b0: { const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - const err17: returns_Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); - const part55: Uint8Array = takeOut.pData; - const part56: number = takeOut.pStart; - const part57: number = takeOut.pLen; - push(out, (err17 !== undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part55, part56, part57))) as rt.Result); - const err18: returns_Error.Error | undefined = take(data.data, data.start, data.length, 201); - const part58: Uint8Array = takeOut.pData; - const part59: number = takeOut.pStart; - const part60: number = takeOut.pLen; - push(out, (err18 !== undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part58, part59, part60))) as rt.Result); - const err19: returns_Error.Error | undefined = tail(data.data, data.start, data.length, 3); - const part61: Uint8Array = takeOut.pData; - const part62: number = takeOut.pStart; - const part63: number = takeOut.pLen; - push(out, (err19 !== undefined ? rt.Err(err19 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part61, part62, part63))) as rt.Result); - const err20: returns_Error.Error | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); - const part64: rt.u64 = wideOut.p_0; - const part65: Uint8Array = wideOut.p_1Data; - const part66: number = wideOut.p_1Start; - const part67: number = wideOut.p_1Len; - pushNumber(out, (err20 !== undefined ? rt.Err(err20 as returns_Error.Error) : rt.Ok([part64, new rt.ByteSlice(part65, part66, part67)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); - const err21: returns_Error.Error | undefined = count(data.data, data.start, data.length); - const part68: rt.u64 = wideOut.p_0; - const part69: Uint8Array = wideOut.p_1Data; - const part70: number = wideOut.p_1Start; - const part71: number = wideOut.p_1Len; - pushNumber(out, (err21 !== undefined ? rt.Err(err21 as returns_Error.Error) : rt.Ok([part68, new rt.ByteSlice(part69, part70, part71)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part60: Uint8Array | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); + const part61: number = takeOut.pStart; + const part62: number = takeOut.pLen; + const err12: returns_Error.Error | undefined = part60 === undefined ? takeOut.err as returns_Error.Error : undefined; + push(out, (part60 === undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part60 as Uint8Array, part61, part62))) as rt.Result); + const part63: Uint8Array | undefined = take(data.data, data.start, data.length, 201); + const part64: number = takeOut.pStart; + const part65: number = takeOut.pLen; + const err13: returns_Error.Error | undefined = part63 === undefined ? takeOut.err as returns_Error.Error : undefined; + push(out, (part63 === undefined ? rt.Err(err13 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part63 as Uint8Array, part64, part65))) as rt.Result); + const part66: Uint8Array | undefined = tail(data.data, data.start, data.length, 3); + const part67: number = takeOut.pStart; + const part68: number = takeOut.pLen; + const err14: returns_Error.Error | undefined = part66 === undefined ? takeOut.err as returns_Error.Error : undefined; + push(out, (part66 === undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part66 as Uint8Array, part67, part68))) as rt.Result); + const part69: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + const part70: Uint8Array = wideOut.p_1Data; + const part71: number = wideOut.p_1Start; + const part72: number = wideOut.p_1Len; + const err15: returns_Error.Error | undefined = part69 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part69 === undefined ? rt.Err(err15 as returns_Error.Error) : rt.Ok([part69 as rt.u64, new rt.ByteSlice(part70, part71, part72)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part73: rt.u64 | undefined = count(data.data, data.start, data.length); + const part74: Uint8Array = wideOut.p_1Data; + const part75: number = wideOut.p_1Start; + const part76: number = wideOut.p_1Len; + const err16: returns_Error.Error | undefined = part73 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part73 === undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok([part73 as rt.u64, new rt.ByteSlice(part74, part75, part76)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 1) { const kept: rt.Result[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { - const err14 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); - return err14 === undefined ? rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)) : rt.Err(err14 as returns_Error.Error); + const part51 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); + return part51 === undefined ? rt.Err(takeOut.err as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part51, takeOut.pStart, takeOut.pLen)); }), undefined, 12, true); - const err15: returns_Error.Error | undefined = tail(data.data, data.start, data.length, 1); - const part47: Uint8Array = takeOut.pData; - const part48: number = takeOut.pStart; - const part49: number = takeOut.pLen; + const part52: Uint8Array | undefined = tail(data.data, data.start, data.length, 1); + const part53: number = takeOut.pStart; + const part54: number = takeOut.pLen; + const err10: returns_Error.Error | undefined = part52 === undefined ? takeOut.err as returns_Error.Error : undefined; for (const _29 of kept) { push(out, _29); } - push(out, (err15 !== undefined ? rt.Err(err15 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part47, part48, part49))) as rt.Result); - const err16: returns_Error.Error | undefined = both(data.data, data.start, data.length); - const part50: rt.u64 = bothOut.p_0; - const part51: rt.u64 = bothOut.p_1; - const part54: number = bothOut.p_2Len; - if (err16 === undefined) { - const a: rt.u64 = part50; - const b: rt.u64 = part51; + push(out, (part52 === undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part52 as Uint8Array, part53, part54))) as rt.Result); + const part55: rt.u64 | undefined = both(data.data, data.start, data.length); + const part56: rt.u64 = bothOut.p_1; + const part59: number = bothOut.p_2Len; + const err11: returns_Error.Error | undefined = part55 === undefined ? bothOut.err as returns_Error.Error : undefined; + if (part55 !== undefined) { + const a: rt.u64 = part55 as rt.u64; + const b: rt.u64 = part56; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); - rt.byteVecPush(out, part54 & 0xff); + rt.byteVecPush(out, part59 & 0xff); } else { - rt.byteVecPush(out, returns_Error.code(err16 as returns_Error.Error)); + rt.byteVecPush(out, returns_Error.code(err11 as returns_Error.Error)); } } else if (_4 === 2) { if (!(rt.usizeRem(data.length, 2) === 0)) { f = (a02: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const err11 = narrow(a02.data, a02.start, a02.length); - const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = err11 === undefined ? rt.Ok([wideOut.p_0, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]) : rt.Err(err11 as returns_Error.Error); + const part45 = narrow(a02.data, a02.start, a02.length); + const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part45 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part45, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result3; }; } else { f = (a0: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const err10 = wide(a0.data, a0.start, a0.length); - const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = err10 === undefined ? rt.Ok([wideOut.p_0, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]) : rt.Err(err10 as returns_Error.Error); + const part44 = wide(a0.data, a0.start, a0.length); + const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part44 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part44, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result2; }; } pushNumber(out, f(data)); for (const _71 of rt.iterToArray(rt.iterMap(rt.iterSlice([data, rt.byteSliceRange(data, rt.min(data.length, 3))]), (a03: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const err12 = count(a03.data, a03.start, a03.length); - const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = err12 === undefined ? rt.Ok([wideOut.p_0, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]) : rt.Err(err12 as returns_Error.Error); + const part47 = count(a03.data, a03.start, a03.length); + const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part47 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part47, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result4; }), undefined, 16, true)) { pushNumber(out, _71); @@ -343,45 +352,46 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { return _22[1]; }), (s: rt.ByteSlice): rt.u8 => { - const err13: returns_Error.Error | undefined = tail(s.data, s.start, s.length, 2); - const part44: Uint8Array = takeOut.pData; - const part45: number = takeOut.pStart; - const part46: number = takeOut.pLen; - return result_mapOr$0fbyajt((err13 !== undefined ? rt.Err(err13 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part44, part45, part46))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { + const part48: Uint8Array | undefined = tail(s.data, s.start, s.length, 2); + const part49: number = takeOut.pStart; + const part50: number = takeOut.pLen; + const err9: returns_Error.Error | undefined = part48 === undefined ? takeOut.err as returns_Error.Error : undefined; + return result_mapOr$0fbyajt((part48 === undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part48 as Uint8Array, part49, part50))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { return a04.length; }) & 0xff; })), undefined, true); } else if (_4 === 3) { - const err7: rt.u8 | undefined = halves(data.data, data.start, data.length); - const part28: number = halvesOut.p_0Len; - const part29: Uint8Array = halvesOut.p_1Data; - const part30: number = halvesOut.p_1Start; - const part31: number = halvesOut.p_1Len; - const part32: Uint8Array = halvesOut.p_2Data; - const part33: number = halvesOut.p_2Start; - const part34: number = halvesOut.p_2Len; - if (err7 === undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part29, part30, part31)); - rt.byteVecPush(out, part28 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part32, part33, part34)); + const part27: Uint8Array | undefined = halves(data.data, data.start, data.length); + const part29: number = halvesOut.p_0Len; + const part30: Uint8Array = halvesOut.p_1Data; + const part31: number = halvesOut.p_1Start; + const part32: number = halvesOut.p_1Len; + const part33: Uint8Array = halvesOut.p_2Data; + const part34: number = halvesOut.p_2Start; + const part35: number = halvesOut.p_2Len; + const err6: rt.u8 | undefined = part27 === undefined ? halvesOut.err as rt.u8 : undefined; + if (part27 !== undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part30, part31, part32)); + rt.byteVecPush(out, part29 & 0xff); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part33, part34, part35)); } else { - rt.byteVecPush(out, err7 as rt.u8); + rt.byteVecPush(out, err6 as rt.u8); } const other: Uint8Array = Uint8Array.of(255, 1, 2); const _96: rt.ByteSlice = rt.byteSliceFrom(other); - const err8: returns_Error.Error | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); - const part35: rt.u64 = wideOut.p_0; - const part36: Uint8Array = wideOut.p_1Data; - const part37: number = wideOut.p_1Start; - const part38: number = wideOut.p_1Len; - pushNumber(out, (err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part35, new rt.ByteSlice(part36, part37, part38)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part36: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); + const part37: Uint8Array = wideOut.p_1Data; + const part38: number = wideOut.p_1Start; + const part39: number = wideOut.p_1Len; + const err7: returns_Error.Error | undefined = part36 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part36 === undefined ? rt.Err(err7 as returns_Error.Error) : rt.Ok([part36 as rt.u64, new rt.ByteSlice(part37, part38, part39)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); - const err9: returns_Error.Error | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); - const part39: rt.u64 = wideOut.p_0; - const part40: Uint8Array = wideOut.p_1Data; - const part41: number = wideOut.p_1Start; - const part42: number = wideOut.p_1Len; - pushNumber(out, (err9 !== undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok([part39, new rt.ByteSlice(part40, part41, part42)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part40: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); + const part41: Uint8Array = wideOut.p_1Data; + const part42: number = wideOut.p_1Start; + const part43: number = wideOut.p_1Len; + const err8: returns_Error.Error | undefined = part40 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part40 === undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part40 as rt.u64, new rt.ByteSlice(part41, part42, part43)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 4) { const _104: rt.Result = unitErr(data.data, data.start, data.length); if (_104.ok) { @@ -395,34 +405,35 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } else { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$0r2bmpr(_110.error, 0)))); } - const err5: returns_Error.Error | undefined = lead$u16(data.data, data.start, data.length); - const part17: rt.u16 = leadOut$u16.p_0; - const part18: Uint8Array = leadOut$u16.p_1Data; - const part19: number = leadOut$u16.p_1Start; - const part20: number = leadOut$u16.p_1Len; + const part18: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); + const part19: Uint8Array = leadOut$u16.p_1Data; + const part20: number = leadOut$u16.p_1Start; + const part21: number = leadOut$u16.p_1Len; + const err4: returns_Error.Error | undefined = part18 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; const _123: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); - const err6: returns_Error.Error | undefined = lead$u32(_123.data, _123.start, _123.length); - const part22: rt.u32 = leadOut$u32.p_0; - const part23: Uint8Array = leadOut$u32.p_1Data; - const part24: number = leadOut$u32.p_1Start; - const part25: number = leadOut$u32.p_1Len; - if (err5 === undefined) { - if (err6 === undefined) { - const a3: rt.u16 = part17; - const b3: rt.u32 = part22; + const part23: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); + const part24: Uint8Array = leadOut$u32.p_1Data; + const part25: number = leadOut$u32.p_1Start; + const part26: number = leadOut$u32.p_1Len; + const err5: returns_Error.Error | undefined = part23 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; + if (part18 !== undefined) { + if (part23 !== undefined) { + const a3: rt.u16 = part18 as rt.u16; + const b3: rt.u32 = part23 as rt.u32; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a3))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(b3))); - rt.byteVecPush(out, part25 & 0xff); + rt.byteVecPush(out, part26 & 0xff); break b0; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err5 !== undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part17, new rt.ByteSlice(part18, part19, part20)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err6 !== undefined ? rt.Err(err6 as returns_Error.Error) : rt.Ok([part22, new rt.ByteSlice(part23, part24, part25)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((part18 === undefined ? rt.Err(err4 as returns_Error.Error) : rt.Ok([part18 as rt.u16, new rt.ByteSlice(part19, part20, part21)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((part23 === undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part23 as rt.u32, new rt.ByteSlice(part24, part25, part26)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); } else { const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; - const err: returns_Error.Error | undefined = splitWith$returns_At(at, data.data, data.start, data.length); + const part: Uint8Array | undefined = splitWith$returns_At(at, data.data, data.start, data.length); const part3: number = At.splitOut$returns_Split.p_0Len; const part6: number = At.splitOut$returns_Split.p_1Len; - if (err === undefined) { + const err: returns_Error.Error | undefined = part === undefined ? At.splitOut$returns_Split.err as returns_Error.Error : undefined; + if (part !== undefined) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part3 & 0xff, part6 & 0xff))); } else { rt.byteVecPush(out, returns_Error.code(err as returns_Error.Error)); @@ -433,16 +444,16 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } else { rt.byteVecPush(out, returns_Error.code(_176.error)); } - const err2: returns_Error.Error | undefined = At.split$returns_Split(at, data.data, data.start, data.length); - const part7: Uint8Array = At.splitOut$returns_Split.p_0Data; + const part7: Uint8Array | undefined = At.split$returns_Split(at, data.data, data.start, data.length); const part8: number = At.splitOut$returns_Split.p_0Start; const part9: number = At.splitOut$returns_Split.p_0Len; const part10: Uint8Array = At.splitOut$returns_Split.p_1Data; const part11: number = At.splitOut$returns_Split.p_1Start; const part12: number = At.splitOut$returns_Split.p_1Len; - const _190: rt.Result = result_andThen$1yropo4((err2 !== undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { - const err3 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); - return err3 === undefined ? rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)) : rt.Err(err3 as returns_Error.Error); + const err2: returns_Error.Error | undefined = part7 === undefined ? At.splitOut$returns_Split.err as returns_Error.Error : undefined; + const _190: rt.Result = result_andThen$1yropo4((part7 === undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7 as Uint8Array, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { + const part13 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); + return part13 === undefined ? rt.Err(takeOut.err as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part13, takeOut.pStart, takeOut.pLen)); }); if (_190.ok) { rt.byteVecPush(out, _190.value.length & 0xff); @@ -454,16 +465,16 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da let restLen3: number = data.length; let sum: rt.u64 = 0; while (true) { - const err4: returns_Error.Error | undefined = narrow(restData3, restStart3, restLen3); - const part13: rt.u64 = wideOut.p_0; - const part14: Uint8Array = wideOut.p_1Data; - const part15: number = wideOut.p_1Start; - const part16: number = wideOut.p_1Len; - if (err4 === undefined) { - sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13); - restData3 = part14; - restStart3 = part15; - restLen3 = part16; + const part14: rt.u64 | undefined = narrow(restData3, restStart3, restLen3); + const part15: Uint8Array = wideOut.p_1Data; + const part16: number = wideOut.p_1Start; + const part17: number = wideOut.p_1Len; + part14 === undefined ? wideOut.err as returns_Error.Error : undefined; + if (part14 !== undefined) { + sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part14 as rt.u64); + restData3 = part15; + restStart3 = part16; + restLen3 = part17; } else { break; } diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index 43f2dc277..35376cb1b 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -6,24 +6,24 @@ import * as At from "./returns.At.ts"; import type * as Short from "./splits.Short.ts"; /** The first byte, then a big-endian `u16`, by `?` on `ok_or`. */ -export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Short.Short | undefined { +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { if (dataLen !== 0) { const a: rt.u8 = dataData[dataStart]; if (dataLen - 1 >= 2) { - const _20_1: rt.u16 = (dataData[dataStart + 1] << 8) | dataData[dataStart + 2]; - headerOut.p_0 = a; - headerOut.p_1 = _20_1; + headerOut.p_1 = (dataData[dataStart + 1] << 8) | dataData[dataStart + 2]; headerOut.p_2Data = dataData; headerOut.p_2Start = dataStart + 3; headerOut.p_2Len = dataLen - 3; - return undefined; + return a; } - return { tag: "Need", _0: 2 } as Short.Short; + headerOut.err = { tag: "Need", _0: 2 } as Short.Short; + return undefined; } - return { tag: "Empty" } as Short.Short; + headerOut.err = { tag: "Empty" } as Short.Short; + return undefined; } -export const headerOut: { p_0: rt.u8; p_1: rt.u16; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0: undefined as never, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; +export const headerOut: { err: unknown; p_1: rt.u16; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; /** Two bytes, by `?` on an `Option`. */ export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u8, rt.u8, rt.ByteSlice] | undefined { @@ -38,17 +38,17 @@ export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [ } /** `n` bytes, or how many it needed. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Short.Short | undefined { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Uint8Array | undefined { if (!(n <= dataLen)) { - return { tag: "Need", _0: n } as Short.Short; + At.splitOut$returns_Split.err = { tag: "Need", _0: n } as Short.Short; + return undefined; } - At.splitOut$returns_Split.p_0Data = dataData; At.splitOut$returns_Split.p_0Start = dataStart; At.splitOut$returns_Split.p_0Len = n; At.splitOut$returns_Split.p_1Data = dataData; At.splitOut$returns_Split.p_1Start = dataStart + n; At.splitOut$returns_Split.p_1Len = dataLen - n; - return undefined; + return dataData; } /** The byte after the first, or an error that is itself an enum, held whole. */ @@ -110,14 +110,14 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, mid4 & 0xff); rt.byteVecExtendFromSlice(out, new rt.ByteSlice(dataData, dataStart + mid4, dataLen - mid4)); } else if (_4 === 2) { - const err3: Short.Short | undefined = header(dataData, dataStart, dataLen); - const part7: rt.u8 = headerOut.p_0; + const part7: rt.u8 | undefined = header(dataData, dataStart, dataLen); const part8: rt.u16 = headerOut.p_1; const part9: Uint8Array = headerOut.p_2Data; const part10: number = headerOut.p_2Start; const part11: number = headerOut.p_2Len; - if (err3 === undefined) { - const a2: rt.u8 = part7; + const err3: Short.Short | undefined = part7 === undefined ? headerOut.err as Short.Short : undefined; + if (part7 !== undefined) { + const a2: rt.u8 = part7 as rt.u8; const b3: rt.u16 = part8; rt.byteVecPush(out, a2); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(b3))); @@ -237,13 +237,13 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } - const err2: Short.Short | undefined = take(dataData, dataStart, dataLen, 3); - const part: Uint8Array = At.splitOut$returns_Split.p_0Data; + const part: Uint8Array | undefined = take(dataData, dataStart, dataLen, 3); const part2: number = At.splitOut$returns_Split.p_0Start; const part3: number = At.splitOut$returns_Split.p_0Len; const part6: number = At.splitOut$returns_Split.p_1Len; - if (err2 === undefined) { - rt.byteVecPush(out, opaque(part, part2, part3)); + const err2: Short.Short | undefined = part === undefined ? At.splitOut$returns_Split.err as Short.Short : undefined; + if (part !== undefined) { + rt.byteVecPush(out, opaque(part as Uint8Array, part2, part3)); rt.byteVecPush(out, part6 & 0xff); } else { const e: Short.Short = err2 as Short.Short; From 6a07b19d1bed656ac9e5e0faac70a10bc7bbefb1 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:22:38 -0700 Subject: [PATCH 19/26] perf(ts): return only a number as a slotted function's first part A slice's bytes stay in the slot: returning them gave back frame decode. Co-Authored-By: Claude Opus 5.5 --- .../codec/expected/coding/decode.Decoder.ts | 58 +++--- ts/fixtures/codec/expected/harness.ts | 16 +- ts/src/lower/body.rs | 6 +- ts/src/lower/mir/scalar.rs | 185 +++++++++++------- 4 files changed, 151 insertions(+), 114 deletions(-) diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 89ced15b0..724c225ac 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -61,19 +61,19 @@ export function isEmpty(self: Decoder): boolean { } /** Read `len` raw bytes. */ -export function slice(self: Decoder, len: rt.usize): Uint8Array | undefined { +export function slice(self: Decoder, len: rt.usize): DecodeError.DecodeError | undefined { const slice: rt.ByteSlice = self.buf; if (len <= slice.length) { self.buf = new rt.ByteSlice(slice.data, slice.start + len, slice.length - len); + sliceOut.pData = slice.data; sliceOut.pStart = slice.start; sliceOut.pLen = len; - return slice.data; + return undefined; } - sliceOut.err = short(self, len); - return undefined; + return short(self, len); } -export const sliceOut: { err: unknown; pStart: number; pLen: number } = { err: undefined, pStart: undefined as never, pLen: undefined as never }; +export const sliceOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; /** Read every remaining byte. */ export function rest(self: Decoder): rt.ByteSlice { @@ -84,46 +84,46 @@ export function rest(self: Decoder): rt.ByteSlice { /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ export function sub(self: Decoder, len: rt.usize): rt.Result { - const part: Uint8Array | undefined = slice(self, len); + const err: DecodeError.DecodeError | undefined = slice(self, len); + const part: Uint8Array = sliceOut.pData; const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; - if (part !== undefined) { - return rt.Ok(new_(part as Uint8Array, part2, part3, self.form)); + if (err === undefined) { + return rt.Ok(new_(part, part2, part3, self.form)); } return rt.Err(err as DecodeError.DecodeError); } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - const part: Uint8Array | undefined = slice(self, 1); + const err: DecodeError.DecodeError | undefined = slice(self, 1); + const part: Uint8Array = sliceOut.pData; const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; - if (part !== undefined) { + if (err === undefined) { if (0 >= part3) { rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); } - return rt.Ok((part as Uint8Array)[part2]); + return rt.Ok(part[part2]); } return rt.Err(err as DecodeError.DecodeError); } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const part: Uint8Array | undefined = slice(self, 2); + const err: DecodeError.DecodeError | undefined = slice(self, 2); + const part: Uint8Array = sliceOut.pData; const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; - if (part !== undefined) { + if (err === undefined) { if (0 >= part3) { rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); } - const _9: rt.u8 = (part as Uint8Array)[part2]; + const _9: rt.u8 = part[part2]; if (1 >= part3) { rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 1); } - return rt.Ok((_9 << 8) | (part as Uint8Array)[part2 + 1]); + return rt.Ok((_9 << 8) | part[part2 + 1]); } return rt.Err(err as DecodeError.DecodeError); } @@ -175,7 +175,7 @@ export function varintOpt(self: Decoder): rt.Result; const start: rt.ByteSlice = self.buf; const _6: rt.Result = varint(self); @@ -184,14 +184,14 @@ export function bytes(self: Decoder): Uint8Array | undefined { return { tag: "BoundsExceeded" } as DecodeError.DecodeError; }); if (_3.ok) { - const part: Uint8Array | undefined = slice(self, _3.value); + const err: DecodeError.DecodeError | undefined = slice(self, _3.value); + const part: Uint8Array = sliceOut.pData; const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; const _15: (a0: DecodeError.DecodeError) => undefined = (_22: DecodeError.DecodeError): undefined => { self.buf = start; }; - _0 = inspectErr$156koiv((part === undefined ? rt.Err(err as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part as Uint8Array, part2, part3))) as rt.Result, _15); + _0 = inspectErr$156koiv((err !== undefined ? rt.Err(err as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part, part2, part3))) as rt.Result, _15); } else { _0 = _3; } @@ -200,23 +200,23 @@ export function bytes(self: Decoder): Uint8Array | undefined { } const result: rt.Result = _0; if (!result.ok) { - sliceOut.err = result.error; - return undefined; + return result.error; } const slice_: rt.ByteSlice = result.value; + sliceOut.pData = slice_.data; sliceOut.pStart = slice_.start; sliceOut.pLen = slice_.length; - return slice_.data; + return undefined; } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - const part: Uint8Array | undefined = bytes(self); + const err: DecodeError.DecodeError | undefined = bytes(self); + const part: Uint8Array = sliceOut.pData; const part2: number = sliceOut.pStart; const part3: number = sliceOut.pLen; - const err: DecodeError.DecodeError | undefined = part === undefined ? sliceOut.err as DecodeError.DecodeError : undefined; - if (part !== undefined) { - const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part as Uint8Array, part2, part3))); + if (err === undefined) { + const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part, part2, part3))); if (_2.ok) { return rt.Ok(_2.value); } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index a17920e04..ed8310918 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -270,13 +270,13 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _31; } } else if (_5 === 5) { - const part4: Uint8Array | undefined = Decoder.bytes(r); + const err2: DecodeError.DecodeError | undefined = Decoder.bytes(r); + const part4: Uint8Array = Decoder.sliceOut.pData; const part5: number = Decoder.sliceOut.pStart; const part6: number = Decoder.sliceOut.pLen; - const err2: DecodeError.DecodeError | undefined = part4 === undefined ? Decoder.sliceOut.err as DecodeError.DecodeError : undefined; - if (part4 !== undefined) { + if (err2 === undefined) { putUsize(out, part6); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part4 as Uint8Array, part5, part6)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part4, part5, part6)); } else { return rt.Err(err2 as DecodeError.DecodeError); } @@ -288,12 +288,12 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _49; } } else if (_5 === 7) { - const part: Uint8Array | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + const err: DecodeError.DecodeError | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + const part: Uint8Array = Decoder.sliceOut.pData; const part2: number = Decoder.sliceOut.pStart; const part3: number = Decoder.sliceOut.pLen; - const err: DecodeError.DecodeError | undefined = part === undefined ? Decoder.sliceOut.err as DecodeError.DecodeError : undefined; - if (part !== undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part as Uint8Array, part2, part3)); + if (err === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part, part2, part3)); } else { return rt.Err(err as DecodeError.DecodeError); } diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 99f7f68db..3260cc8fb 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -134,9 +134,9 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { // One that hands back its `Ok`'s parts, made whole here, before anything else can // write its slot. if let Some(slotted) = self.t.slotted(instance) { - let first = self.fresh("part"); - out.push(StmtKind::decl(false, first.clone(), None, Some(call)).at(None)); - let value = slotted.rebuild(self.t, &first, span); + let ret = self.fresh(if slotted.returned { "part" } else { "err" }); + out.push(StmtKind::decl(false, ret.clone(), None, Some(call)).at(None)); + let value = slotted.rebuild(self.t, &ret, span); let result = self.fresh("result"); let ty = self.t.ty(slotted.ret, span); out.push(StmtKind::decl(false, result.clone(), Some(ty), Some(value)).at(None)); diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index bf775c6fd..e3582d37f 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -234,9 +234,10 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { /// Where `instance` hands back its `Ok`'s parts, if it does: a function of the crate's /// that only translated code calls directly, and that returns a `Result` of byte slices - /// and scalars, such as `Result<(u64, &[u8]), E>`, returns the `Ok`'s first part, which - /// is never `undefined`, or `undefined` for an error. It writes the rest, or the error, - /// which must be one value, into a module-level slot its caller reads at once. + /// and scalars whose error is one value, such as `Result<(u64, &[u8]), E>`, writes the + /// `Ok`'s parts into a module-level slot its caller reads at once, and returns its error + /// or `undefined`. One whose first part is a number returns that, or `undefined` for an + /// error, and writes the error into the slot instead. pub(crate) fn slotted(&mut self, instance: ty::Instance<'tcx>) -> Option> { if let Some(slotted) = self.slotted.get(&instance) { return slotted.clone(); @@ -269,17 +270,18 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } let mut parts = Vec::new(); shape.parts("", &mut parts); - // The first part is returned, so `undefined` must mean an error. - if let Part::Value(first) = parts[0].1 { - let erased = self.erases_to(first); - if erased.undefined || erased.none || erased.param || erased.pending || erased.outer_pending { - return None; - } + // A number is returned rather than written to the long-lived slot, where V8 boxes + // one past 2^31 that a function too big to inline writes; the error then goes in + // the slot. Else the error is returned, so it must never be `undefined`. + let returned = matches!(parts[0].1, Part::Value(first) if first.is_numeric()); + let erased = self.erases_to(err); + if !returned && (erased.undefined || erased.none || erased.param || erased.pending || erased.outer_pending) { + return None; } let fields: Vec = parts.iter().map(|(suffix, _)| format!("p{suffix}")).collect(); let sym = match self.slots.get(&ok) { Some(&sym) => sym, - None => self.slot(ok, instance, &parts, &fields), + None => self.slot(ok, instance, &parts, &fields, returned), }; self.place_slot(sym, instance); Some(Slotted { @@ -288,19 +290,20 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { err, ok: shape, fields, + returned, }) } /// The slot of `Ok` payloads of type `ok`, which every function returning one shares: - /// the error, of any of their error types, then each of `fields` but the first part's, - /// which the function returns. Each starts `undefined`, so V8 keeps it tagged rather - /// than boxing every number past 2^31 that a function too big to inline writes. + /// each of `fields`, or if the first part is `returned`, the error, of any of their + /// error types, and the rest. Each starts `undefined`, so V8 keeps it tagged. fn slot( &mut self, ok: Ty<'tcx>, instance: ty::Instance<'tcx>, parts: &[(String, Part<'tcx>)], fields: &[String], + returned: bool, ) -> crate::ts::SymId { let span = self.tcx.def_span(instance.def_id()); let sym = self.program.sym(crate::program::Symbol { @@ -317,18 +320,18 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { }); let tys: Vec = parts.iter().map(|(_, part)| self.part_ty(*part, span)).collect(); let never = Expr::As(Box::new(Expr::undefined()), Type::Builtin("never")); - let held = std::iter::zip(&fields[1..], tys.into_iter().skip(1)); + let held = usize::from(returned); + let err = returned.then(|| (ERR.to_string(), Type::Builtin("unknown"), Expr::undefined())); + let held = std::iter::zip(&fields[held..], tys.into_iter().skip(held)) + .map(|(field, ty)| (field.clone(), ty, never.clone())); + let fields: Vec<(String, Type, Expr)> = err.into_iter().chain(held).collect(); self.program.items.push(crate::ts::Item::Value { sym, - ty: Type::Object( - std::iter::once((ERR.to_string(), Type::Builtin("unknown"))) - .chain(held.map(|(field, ty)| (field.clone(), ty))) - .collect(), - ), + ty: Type::Object(fields.iter().map(|(field, ty, _)| (field.clone(), ty.clone())).collect()), doc: None, value: Expr::Object( - std::iter::once((Key::Name(ERR.into()), Expr::undefined())) - .chain(fields[1..].iter().map(|field| (Key::Name(field.clone()), never.clone()))) + (fields.into_iter()) + .map(|(field, _, value)| (Key::Name(field), value)) .collect(), ), }); @@ -353,11 +356,17 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } /// What a function that hands back its `Ok`'s parts in `slotted` returns: the first - /// part, or `undefined` for an error. + /// part, if it does, or its error, or else `undefined`. pub(crate) fn slot_ret_ty(&mut self, slotted: &Slotted<'tcx>, span: Span) -> Type { - let mut parts = Vec::new(); - slotted.ok.parts("", &mut parts); - Type::Union(vec![self.part_ty(parts[0].1, span), Type::Builtin("undefined")]) + let ty = match slotted.returned { + true => { + let mut parts = Vec::new(); + slotted.ok.parts("", &mut parts); + self.part_ty(parts[0].1, span) + } + false => self.ty(slotted.err, span), + }; + Type::Union(vec![ty, Type::Builtin("undefined")]) } /// The type of a variable or field that holds `part`. @@ -412,8 +421,9 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { /// The slot's field that holds an error. const ERR: &str = "err"; -/// Where a function hands back its `Ok`'s parts: it returns the first, or `undefined` for -/// an error, and writes the rest, or the error, into a module-level slot. +/// Where a function hands back its `Ok`'s parts: it writes them into a module-level slot +/// and returns its error or `undefined`, or, if the first part is `returned`, it returns +/// that or `undefined` for an error, and writes the rest, or the error, into the slot. #[derive(Clone, Debug)] pub struct Slotted<'tcx> { pub sym: crate::ts::SymId, @@ -423,33 +433,43 @@ pub struct Slotted<'tcx> { pub err: Ty<'tcx>, /// The `Ok` payload's layout, which has no enum. pub ok: Shape<'tcx>, - /// Each part's field in the slot, in order, but the first's, which is returned. + /// Each part's field in the slot, in order. pub fields: Vec, + /// Whether the first part, a number, is returned rather than written. + pub returned: bool, } impl<'tcx> Slotted<'tcx> { - /// The slot's field of part `i`, after the first, read or written. + /// The slot's field of part `i`, read or written. pub fn field(&self, i: usize) -> Expr { - assert!(i > 0, "the first part is returned"); + assert!(i > 0 || !self.returned, "the first part is returned"); Expr::Sym(self.sym).member(self.fields[i].clone()) } + /// Where the parts the slot holds start. + fn held(&self) -> usize { + usize::from(self.returned) + } + /// The slot's field of the error. pub fn err_field(&self) -> Expr { Expr::Sym(self.sym).member(ERR) } - /// What a caller that keeps the result whole makes of what the call returned, `first` - /// (a name), read at once: the `Ok` of it and the slot's parts, or the `Err`. - pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, first: &str, span: Span) -> Expr { - let parts: Vec = std::iter::once(Expr::ident(first)) - .chain((1..self.fields.len()).map(|i| self.field(i))) - .collect(); + /// What a caller that keeps the result whole makes of what the call returned, `ret` + /// (a name), read at once: the `Ok` of the slot's parts, or the `Err`. + pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, ret: &str, span: Span) -> Expr { + let first = self.returned.then(|| Expr::ident(ret)); + let parts: Vec = first.into_iter().chain((self.held()..self.fields.len()).map(|i| self.field(i))).collect(); let ok = build_plain(t, &self.ok, &parts, span); let err_ty = t.ty(self.err, span); + let (failed, err) = match self.returned { + true => (Expr::ident(ret).binary("===", Expr::undefined()), self.err_field()), + false => (Expr::ident(ret).binary("!==", Expr::undefined()), Expr::ident(ret)), + }; Expr::Cond( - Box::new(Expr::ident(first).binary("===", Expr::undefined())), - Box::new(Expr::rt("Err", vec![Expr::As(Box::new(self.err_field()), err_ty)])), + Box::new(failed), + Box::new(Expr::rt("Err", vec![Expr::As(Box::new(err), err_ty)])), Box::new(Expr::rt("Ok", vec![ok])), ) } @@ -479,13 +499,16 @@ fn build_plain<'tcx>( } } -/// Return `undefined` from a function that hands back its `Ok`'s parts, with its error -/// `err` in the slot. +/// Return the error `err` from a function that hands back its `Ok`'s parts, or +/// `undefined` with `err` in the slot, if it returns its first part. fn slot_fail(slot: &Slotted<'_>, err: Expr, loc: Option) -> Vec { - vec![ - StmtKind::Expr(slot.err_field().assign(err)).at(None), - StmtKind::Return(Some(Expr::undefined())).at(loc), - ] + match slot.returned { + true => vec![ + StmtKind::Expr(slot.err_field().assign(err)).at(None), + StmtKind::Return(Some(Expr::undefined())).at(loc), + ], + false => vec![StmtKind::Return(Some(err)).at(loc)], + } } /// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rt.ByteSlice`. @@ -1612,8 +1635,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } /// The parts of what a function that hands back its `Ok`'s parts returns into `local`: - /// whether it is an error, then what it returned and the slot's fields, read now before - /// anything else can write them, then the error. + /// whether it is an error, then the first part it returned, if it does, and the slot's + /// fields, read now before anything else can write them, then the error. fn slotted_call( &mut self, local: Local, @@ -1625,37 +1648,44 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let call = self.slotted_raw(local, args, span, out); let mut kinds = Vec::new(); slotted.ok.parts("", &mut kinds); - let first = self.b.fresh("part"); - let first_ty = self.b.t.part_ty(kinds[0].1, span); - self.steady.insert(first.clone()); - self.scalar_binds.push(( - first.clone(), - Type::Union(vec![first_ty.clone(), Type::Builtin("undefined")]), - )); - let stmt = StmtKind::Expr(Expr::ident(&first).assign(call)).at(None); + let err_ty = self.b.t.ty(slotted.err, span); + let ret_ty = self.b.t.slot_ret_ty(&slotted, span); + let ret = self.b.fresh(if slotted.returned { "part" } else { "err" }); + self.steady.insert(ret.clone()); + self.scalar_binds.push((ret.clone(), ret_ty)); + let stmt = StmtKind::Expr(Expr::ident(&ret).assign(call)).at(None); self.emit(vec![stmt], false, out); - let failed = Expr::ident(&first).binary("===", Expr::undefined()); - let mut parts = vec![ - Some((failed.clone(), true)), - Some((Expr::As(Box::new(Expr::ident(&first)), first_ty), true)), - ]; - for (i, (_, part)) in kinds.into_iter().enumerate().skip(1) { + let failed = match slotted.returned { + true => Expr::ident(&ret).binary("===", Expr::undefined()), + false => Expr::ident(&ret).binary("!==", Expr::undefined()), + }; + let mut parts = vec![Some((failed.clone(), true))]; + if slotted.returned { + let first_ty = self.b.t.part_ty(kinds[0].1, span); + parts.push(Some((Expr::As(Box::new(Expr::ident(&ret)), first_ty), true))); + } + for (i, (_, part)) in kinds.into_iter().enumerate().skip(slotted.held()) { let ty = self.b.t.part_ty(part, span); parts.push(Some(self.steady_value(slotted.field(i), "part", ty, out))); } - let err_ty = self.b.t.ty(slotted.err, span); - let err = Expr::Cond( - Box::new(failed), - Box::new(Expr::As(Box::new(slotted.err_field()), err_ty.clone())), - Box::new(Expr::undefined()), - ); - let (err, _) = self.steady_value(err, "err", Type::Union(vec![err_ty.clone(), Type::Builtin("undefined")]), out); + let err = match slotted.returned { + true => { + let err = Expr::Cond( + Box::new(failed), + Box::new(Expr::As(Box::new(slotted.err_field()), err_ty.clone())), + Box::new(Expr::undefined()), + ); + let ty = Type::Union(vec![err_ty.clone(), Type::Builtin("undefined")]); + self.steady_value(err, "err", ty, out).0 + } + false => Expr::ident(&ret), + }; parts.push(Some((Expr::As(Box::new(err), err_ty), true))); parts } /// The call, ending the block being lowered, of a function that hands back its `Ok`'s - /// parts, into `local`: what it returns, its `Ok`'s first part or `undefined`. + /// parts, into `local`: what it returns, its `Ok`'s first part or its error, or `undefined`. fn slotted_raw(&mut self, local: Local, args: &[Spanned>], span: Span, out: &mut Vec) -> Expr { let instance = self.slotted_calls[&self.at.block].0; let result = self.mir.local_decls[local].ty; @@ -1783,8 +1813,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.slot_write(slot, parts.into_iter().map(|(e, _)| Some(e)).collect(), span, out); } - /// Return the result's `parts`: `undefined` once its error is in the slot, if the flag - /// says it is one, or else the `Ok`'s first part once the rest are. + /// Return the result's `parts`: its error, if the flag says it is one, or else what the + /// slot doesn't hold, once it holds the rest. fn slot_return_parts(&mut self, parts: Vec>, span: Span, out: &mut Vec) { let slot = self.slot.clone().expect("a function with a slot"); let loc = self.b.t.loc(span); @@ -1809,16 +1839,23 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.slot_write(&slot, parts[1..=n].to_vec(), span, out); } - /// Write the `Ok`'s parts `ok` but the first into the slot, and return the first. + /// Write the `Ok`'s parts `ok` the slot holds into it, and return the first part, if the + /// slot doesn't hold it, or else `undefined`. fn slot_write(&mut self, slot: &Slotted<'tcx>, ok: Vec>, span: Span, out: &mut Vec) { let loc = self.b.t.loc(span); let mut ok = ok.into_iter(); - let first = ok.next().flatten().unwrap_or_else(Expr::undefined); + let ret = match slot.returned { + true => ok.next().flatten(), + false => None, + }; let mut stmts: Vec = ok .enumerate() - .map(|(i, part)| StmtKind::Expr(slot.field(i + 1).assign(part.unwrap_or_else(Expr::undefined))).at(None)) + .map(|(i, part)| { + let field = slot.field(i + slot.held()); + StmtKind::Expr(field.assign(part.unwrap_or_else(Expr::undefined))).at(None) + }) .collect(); - stmts.push(StmtKind::Return(Some(first)).at(loc)); + stmts.push(StmtKind::Return(Some(ret.unwrap_or_else(Expr::undefined))).at(loc)); self.emit(stmts, false, out); } From 1aea30e2b7e781c3938b3b1e96962a9ec904fae8 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:43:12 -0700 Subject: [PATCH 20/26] fix(ts): keep the slot's error rule for returned numbers too Co-Authored-By: Claude Opus 5.5 --- ts/MIGRATE.md | 7 +- ts/README.md | 21 +- ts/fixtures/lang/expected/chunks.ts | 22 +- ts/fixtures/lang/expected/returns.At.ts | 10 +- ts/fixtures/lang/expected/returns.Split.ts | 4 +- ts/fixtures/lang/expected/returns.ts | 272 ++++++++++----------- ts/fixtures/lang/expected/splits.ts | 16 +- ts/src/lower/mir/scalar.rs | 19 +- 8 files changed, 185 insertions(+), 186 deletions(-) diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index 862868457..e2936b60a 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -5,9 +5,10 @@ - A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter as its `data`, `start`, and `length`: `read(buf, form)` is `read(buf.data, buf.start, buf.length, form)`. One that returns a `Result` of byte slices - and scalars returns the `Ok`'s first part, or `undefined` for an error, and leaves the - rest of the `Ok`'s parts, or the error as `err`, in a module-level slot, such as - `readOut`. A root still takes an `rt.ByteSlice` and returns + and scalars returns its error or `undefined`, and leaves the `Ok`'s parts in a + module-level slot, such as `sliceOut`. If the `Ok`'s first part is a number, it returns + that, or `undefined` for an error, and leaves the rest, or the error as `err`, in the + slot, such as `readOut`. A root still takes an `rt.ByteSlice` and returns the `Result`. - `rt.btreeCollect` takes whether it sorts and the keys' `!ne` after the entries, and `rt.btreeCollectKeys` the keys' `PartialOrd::lt` and `!ne`, as in diff --git a/ts/README.md b/ts/README.md index 7ea39b1a7..3999869fd 100644 --- a/ts/README.md +++ b/ts/README.md @@ -687,16 +687,17 @@ they need. noise, and Node's varint decode at 1.11-1.15. - A function of the crate's that only translated code calls and that returns a `Result` of byte slices and scalars, such as `Result<(u64, &[u8]), E>`, whose error is one JS - value, returns the `Ok`'s first part, or `undefined` for an error. It writes the rest of - the `Ok`'s parts, or the error, into a module-level slot, which every function returning - that payload type shares, named for the first of them in source order with its suffix, - as `readOut` or `leadOut$u16`, at its JS `return`, after its drops, and its caller - reads them at once, so one that returns another's result as is returns the call. - Returning the first part keeps a `u64` past 2^31, which a function too big to inline - boxes, out of the long-lived slot: Chrome's 8-byte leading-ones varints took 1.06-1.09x - `main`'s time writing it there, and 0.87-0.92x this way. The slot's fields start as - `undefined`, so V8 keeps them tagged. The function as a value is an arrow that rebuilds - the `Result`. + value that is never `undefined`, writes the `Ok`'s parts into a module-level slot and returns the error or + `undefined`. The slot is shared by every function returning that payload type, named + for the first of them in source order with its suffix, as `readOut` or `leadOut$u16`. + The function writes it at its JS `return`, after its drops, and its caller reads it at + once, so one that returns another's result as is returns the call. The slot's fields + start as `undefined`, so V8 keeps them tagged. When the `Ok`'s first part is a number, + the function returns that, or `undefined` for an error, and writes the error into the + slot instead: V8 boxes a number past 2^31 that a function too big to inline writes into + the long-lived slot, which made Chrome's 8-byte leading-ones varints 1.06-1.09x `main`'s + time. A slice's bytes stay in the slot, since returning them gave back frame decode. The + function as a value is an arrow that rebuilds the `Result`. - A `BTreeMap` is a B+ tree of up to 64 keys a node, O(log n) as std's B-tree is: its leaves hold the keys and values and link to their neighbors, which iterators walk from either end, and its branches hold each child's lower bound. A node's slots shift in a diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index c301f629a..7d1d7284a 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -11,20 +11,20 @@ export function header(dataData: Uint8Array, dataStart: number, dataLen: number) return undefined; } -export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { +export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { if (!(dataLen >= 4)) { - take4Out.err = dataLen & 0xff; - return undefined; + return dataLen & 0xff; } + take4Out.p_0Data = dataData; take4Out.p_0Start = dataStart; take4Out.p_0Len = 4; take4Out.p_1Data = dataData; take4Out.p_1Start = dataStart + 4; take4Out.p_1Len = dataLen - 4; - return dataData; + return undefined; } -export const take4Out: { err: unknown; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const take4Out: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; export function word(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): rt.u32 { return ((chunkData[chunkStart] << 24) | (chunkData[chunkStart + 1] << 16) | (chunkData[chunkStart + 2] << 8) | chunkData[chunkStart + 3]) >>> 0; @@ -69,17 +69,17 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, h.tag.data[h.tag.start + 1]); rt.byteVecPush(out, h.rest.length & 0xff); } - const part2: Uint8Array | undefined = take4(dataData, dataStart, dataLen); + const err: rt.u8 | undefined = take4(dataData, dataStart, dataLen); + const part2: Uint8Array = take4Out.p_0Data; const part3: number = take4Out.p_0Start; const part4: number = take4Out.p_0Len; const part5: Uint8Array = take4Out.p_1Data; const part6: number = take4Out.p_1Start; const part7: number = take4Out.p_1Len; - const err: rt.u8 | undefined = part2 === undefined ? take4Out.err as rt.u8 : undefined; - if (part2 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(part2 as Uint8Array, part3, part4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(((((part2 as Uint8Array)[part3 + 1] << 8) | (part2 as Uint8Array)[part3 + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part2 as Uint8Array, part3, part4); + if (err === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(part2, part3, part4)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part2[part3 + 1] << 8) | part2[part3 + 2]) << 16) >> 16))); + const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part2, part3, part4); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part5, part6, part7)); } else { diff --git a/ts/fixtures/lang/expected/returns.At.ts b/ts/fixtures/lang/expected/returns.At.ts index 4cd088060..d58cc8d8e 100644 --- a/ts/fixtures/lang/expected/returns.At.ts +++ b/ts/fixtures/lang/expected/returns.At.ts @@ -7,21 +7,21 @@ export interface At { _0: rt.usize; } -export function split$returns_Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { +export function split$returns_Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { const mid: number = self._0; const _5 = { tag: "Short", _0: self._0 } as returns_Error.Error; if (!(mid <= dataLen)) { - splitOut$returns_Split.err = _5; - return undefined; + return _5; } + splitOut$returns_Split.p_0Data = dataData; splitOut$returns_Split.p_0Start = dataStart; splitOut$returns_Split.p_0Len = mid; splitOut$returns_Split.p_1Data = dataData; splitOut$returns_Split.p_1Start = dataStart + mid; splitOut$returns_Split.p_1Len = dataLen - mid; - return dataData; + return undefined; } -export const splitOut$returns_Split: { err: unknown; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const splitOut$returns_Split: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; //# sourceMappingURL=returns.At.ts.map diff --git a/ts/fixtures/lang/expected/returns.Split.ts b/ts/fixtures/lang/expected/returns.Split.ts index 36ee33c31..cb32fc30e 100644 --- a/ts/fixtures/lang/expected/returns.Split.ts +++ b/ts/fixtures/lang/expected/returns.Split.ts @@ -15,8 +15,8 @@ export class of$returns_At { } split$Split(a: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> { - const part = At.split$returns_Split(this.v, a.data, a.start, a.length); - const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = part === undefined ? rt.Err(At.splitOut$returns_Split.err as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part, At.splitOut$returns_Split.p_0Start, At.splitOut$returns_Split.p_0Len), new rt.ByteSlice(At.splitOut$returns_Split.p_1Data, At.splitOut$returns_Split.p_1Start, At.splitOut$returns_Split.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]); + const err = At.split$returns_Split(this.v, a.data, a.start, a.length); + const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = err !== undefined ? rt.Err(err as returns_Error.Error) : rt.Ok([new rt.ByteSlice(At.splitOut$returns_Split.p_0Data, At.splitOut$returns_Split.p_0Start, At.splitOut$returns_Split.p_0Len), new rt.ByteSlice(At.splitOut$returns_Split.p_1Data, At.splitOut$returns_Split.p_1Start, At.splitOut$returns_Split.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]); return result; } } diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts index aaa188a63..cb745483b 100644 --- a/ts/fixtures/lang/expected/returns.ts +++ b/ts/fixtures/lang/expected/returns.ts @@ -10,37 +10,36 @@ import * as Guard from "./returns.Guard.ts"; import * as Split from "./returns.Split.ts"; /** A slice alone, with returns from several places. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Uint8Array | undefined { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { if (!(n > 200)) { if (!(n <= dataLen)) { - takeOut.err = { tag: "Short", _0: rt.usizeSub(n, dataLen) } as returns_Error.Error; - return undefined; + return { tag: "Short", _0: rt.usizeSub(n, dataLen) } as returns_Error.Error; } + takeOut.pData = dataData; takeOut.pStart = dataStart; takeOut.pLen = n; - return dataData; + return undefined; } - takeOut.err = { tag: "Bad" } as returns_Error.Error; - return undefined; + return { tag: "Bad" } as returns_Error.Error; } -export const takeOut: { err: unknown; pStart: number; pLen: number } = { err: undefined, pStart: undefined as never, pLen: undefined as never }; +export const takeOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; /** The same slice type through another function, which shares its slot. */ -export function tail(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Uint8Array | undefined { +export function tail(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { const _4: boolean = n <= dataLen; const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const _0: rt.Result = option_okOr$12p77jh(then$0w2ymju(_4, (): rt.ByteSlice => { return rt.byteSliceRange(captured, n); }), { tag: "Short", _0: n } as returns_Error.Error); if (!_0.ok) { - takeOut.err = _0.error; - return undefined; + return _0.error; } const slice: rt.ByteSlice = _0.value; + takeOut.pData = slice.data; takeOut.pStart = slice.start; takeOut.pLen = slice.length; - return slice.data; + return undefined; } /** A number past 2^31 and the rest. */ @@ -111,12 +110,13 @@ export function count(dataData: Uint8Array, dataStart: number, dataLen: number): } /** Two slices, and a reference to an array. */ -export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { +export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { if (dataLen >= 2) { const mid: number = rt.usizeDiv(dataLen - 2, 2); if (mid > dataLen - 2) { rt.panic("mid > len"); } + halvesOut.p_0Data = dataData; halvesOut.p_0Start = dataStart + 2; halvesOut.p_0Len = mid; halvesOut.p_1Data = dataData; @@ -125,13 +125,12 @@ export function halves(dataData: Uint8Array, dataStart: number, dataLen: number) halvesOut.p_2Data = dataData; halvesOut.p_2Start = dataStart + 2 + mid; halvesOut.p_2Len = dataLen - 2 - mid; - return dataData; + return undefined; } - halvesOut.err = dataLen & 0xff; - return undefined; + return dataLen & 0xff; } -export const halvesOut: { err: unknown; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; +export const halvesOut: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; /** Calls whose results are both held while the slot is written again between them. */ export function both(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { @@ -149,17 +148,16 @@ export function both(dataData: Uint8Array, dataStart: number, dataLen: number): const err2: returns_Error.Error | undefined = part5 === undefined ? wideOut.err as returns_Error.Error : undefined; if (part5 !== undefined) { const b: rt.u64 = part5 as rt.u64; - const part9: Uint8Array | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); + const err3: returns_Error.Error | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); + const part9: Uint8Array = takeOut.pData; const part10: number = takeOut.pStart; const part11: number = takeOut.pLen; - const err3: returns_Error.Error | undefined = part9 === undefined ? takeOut.err as returns_Error.Error : undefined; - if (part9 !== undefined) { - const part12: Uint8Array | undefined = take(part9 as Uint8Array, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); + if (err3 === undefined) { + const err4: returns_Error.Error | undefined = take(part9, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); const part14: number = takeOut.pLen; - const err4: returns_Error.Error | undefined = part12 === undefined ? takeOut.err as returns_Error.Error : undefined; - if (part12 !== undefined) { + if (err4 === undefined) { bothOut.p_1 = rt.u64Xor(b, part14 as rt.u64); - bothOut.p_2Data = part9 as Uint8Array; + bothOut.p_2Data = part9; bothOut.p_2Start = part10; bothOut.p_2Len = part11; return a; @@ -246,7 +244,7 @@ export const leadOut$u16: { err: unknown; p_1Data: Uint8Array; p_1Start: number; export const leadOut$u32: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export function splitWith$returns_At(s: At.At, dataData: Uint8Array, dataStart: number, dataLen: number): Uint8Array | undefined { +export function splitWith$returns_At(s: At.At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { return At.split$returns_Split(s, dataData, dataStart, dataLen); } @@ -274,77 +272,77 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da b0: { const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - const part60: Uint8Array | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); - const part61: number = takeOut.pStart; - const part62: number = takeOut.pLen; - const err12: returns_Error.Error | undefined = part60 === undefined ? takeOut.err as returns_Error.Error : undefined; - push(out, (part60 === undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part60 as Uint8Array, part61, part62))) as rt.Result); - const part63: Uint8Array | undefined = take(data.data, data.start, data.length, 201); - const part64: number = takeOut.pStart; - const part65: number = takeOut.pLen; - const err13: returns_Error.Error | undefined = part63 === undefined ? takeOut.err as returns_Error.Error : undefined; - push(out, (part63 === undefined ? rt.Err(err13 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part63 as Uint8Array, part64, part65))) as rt.Result); - const part66: Uint8Array | undefined = tail(data.data, data.start, data.length, 3); - const part67: number = takeOut.pStart; - const part68: number = takeOut.pLen; - const err14: returns_Error.Error | undefined = part66 === undefined ? takeOut.err as returns_Error.Error : undefined; - push(out, (part66 === undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part66 as Uint8Array, part67, part68))) as rt.Result); - const part69: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); - const part70: Uint8Array = wideOut.p_1Data; - const part71: number = wideOut.p_1Start; - const part72: number = wideOut.p_1Len; - const err15: returns_Error.Error | undefined = part69 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part69 === undefined ? rt.Err(err15 as returns_Error.Error) : rt.Ok([part69 as rt.u64, new rt.ByteSlice(part70, part71, part72)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); - const part73: rt.u64 | undefined = count(data.data, data.start, data.length); - const part74: Uint8Array = wideOut.p_1Data; - const part75: number = wideOut.p_1Start; - const part76: number = wideOut.p_1Len; - const err16: returns_Error.Error | undefined = part73 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part73 === undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok([part73 as rt.u64, new rt.ByteSlice(part74, part75, part76)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const err14: returns_Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); + const part58: Uint8Array = takeOut.pData; + const part59: number = takeOut.pStart; + const part60: number = takeOut.pLen; + push(out, (err14 !== undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part58, part59, part60))) as rt.Result); + const err15: returns_Error.Error | undefined = take(data.data, data.start, data.length, 201); + const part61: Uint8Array = takeOut.pData; + const part62: number = takeOut.pStart; + const part63: number = takeOut.pLen; + push(out, (err15 !== undefined ? rt.Err(err15 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part61, part62, part63))) as rt.Result); + const err16: returns_Error.Error | undefined = tail(data.data, data.start, data.length, 3); + const part64: Uint8Array = takeOut.pData; + const part65: number = takeOut.pStart; + const part66: number = takeOut.pLen; + push(out, (err16 !== undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part64, part65, part66))) as rt.Result); + const part67: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + const part68: Uint8Array = wideOut.p_1Data; + const part69: number = wideOut.p_1Start; + const part70: number = wideOut.p_1Len; + const err17: returns_Error.Error | undefined = part67 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part67 === undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok([part67 as rt.u64, new rt.ByteSlice(part68, part69, part70)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part71: rt.u64 | undefined = count(data.data, data.start, data.length); + const part72: Uint8Array = wideOut.p_1Data; + const part73: number = wideOut.p_1Start; + const part74: number = wideOut.p_1Len; + const err18: returns_Error.Error | undefined = part71 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part71 === undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok([part71 as rt.u64, new rt.ByteSlice(part72, part73, part74)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 1) { const kept: rt.Result[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { - const part51 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); - return part51 === undefined ? rt.Err(takeOut.err as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part51, takeOut.pStart, takeOut.pLen)); + const err11 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); + return err11 !== undefined ? rt.Err(err11 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); }), undefined, 12, true); - const part52: Uint8Array | undefined = tail(data.data, data.start, data.length, 1); - const part53: number = takeOut.pStart; - const part54: number = takeOut.pLen; - const err10: returns_Error.Error | undefined = part52 === undefined ? takeOut.err as returns_Error.Error : undefined; + const err12: returns_Error.Error | undefined = tail(data.data, data.start, data.length, 1); + const part50: Uint8Array = takeOut.pData; + const part51: number = takeOut.pStart; + const part52: number = takeOut.pLen; for (const _29 of kept) { push(out, _29); } - push(out, (part52 === undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part52 as Uint8Array, part53, part54))) as rt.Result); - const part55: rt.u64 | undefined = both(data.data, data.start, data.length); - const part56: rt.u64 = bothOut.p_1; - const part59: number = bothOut.p_2Len; - const err11: returns_Error.Error | undefined = part55 === undefined ? bothOut.err as returns_Error.Error : undefined; - if (part55 !== undefined) { - const a: rt.u64 = part55 as rt.u64; - const b: rt.u64 = part56; + push(out, (err12 !== undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part50, part51, part52))) as rt.Result); + const part53: rt.u64 | undefined = both(data.data, data.start, data.length); + const part54: rt.u64 = bothOut.p_1; + const part57: number = bothOut.p_2Len; + const err13: returns_Error.Error | undefined = part53 === undefined ? bothOut.err as returns_Error.Error : undefined; + if (part53 !== undefined) { + const a: rt.u64 = part53 as rt.u64; + const b: rt.u64 = part54; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); - rt.byteVecPush(out, part59 & 0xff); + rt.byteVecPush(out, part57 & 0xff); } else { - rt.byteVecPush(out, returns_Error.code(err11 as returns_Error.Error)); + rt.byteVecPush(out, returns_Error.code(err13 as returns_Error.Error)); } } else if (_4 === 2) { if (!(rt.usizeRem(data.length, 2) === 0)) { f = (a02: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const part45 = narrow(a02.data, a02.start, a02.length); - const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part45 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part45, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + const part44 = narrow(a02.data, a02.start, a02.length); + const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part44 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part44, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result3; }; } else { f = (a0: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const part44 = wide(a0.data, a0.start, a0.length); - const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part44 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part44, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + const part43 = wide(a0.data, a0.start, a0.length); + const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part43 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part43, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result2; }; } pushNumber(out, f(data)); for (const _71 of rt.iterToArray(rt.iterMap(rt.iterSlice([data, rt.byteSliceRange(data, rt.min(data.length, 3))]), (a03: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const part47 = count(a03.data, a03.start, a03.length); - const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part47 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part47, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + const part46 = count(a03.data, a03.start, a03.length); + const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part46 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part46, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result4; }), undefined, 16, true)) { pushNumber(out, _71); @@ -352,46 +350,45 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { return _22[1]; }), (s: rt.ByteSlice): rt.u8 => { - const part48: Uint8Array | undefined = tail(s.data, s.start, s.length, 2); - const part49: number = takeOut.pStart; - const part50: number = takeOut.pLen; - const err9: returns_Error.Error | undefined = part48 === undefined ? takeOut.err as returns_Error.Error : undefined; - return result_mapOr$0fbyajt((part48 === undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part48 as Uint8Array, part49, part50))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { + const err10: returns_Error.Error | undefined = tail(s.data, s.start, s.length, 2); + const part47: Uint8Array = takeOut.pData; + const part48: number = takeOut.pStart; + const part49: number = takeOut.pLen; + return result_mapOr$0fbyajt((err10 !== undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part47, part48, part49))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { return a04.length; }) & 0xff; })), undefined, true); } else if (_4 === 3) { - const part27: Uint8Array | undefined = halves(data.data, data.start, data.length); - const part29: number = halvesOut.p_0Len; - const part30: Uint8Array = halvesOut.p_1Data; - const part31: number = halvesOut.p_1Start; - const part32: number = halvesOut.p_1Len; - const part33: Uint8Array = halvesOut.p_2Data; - const part34: number = halvesOut.p_2Start; - const part35: number = halvesOut.p_2Len; - const err6: rt.u8 | undefined = part27 === undefined ? halvesOut.err as rt.u8 : undefined; - if (part27 !== undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part30, part31, part32)); - rt.byteVecPush(out, part29 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part33, part34, part35)); + const err7: rt.u8 | undefined = halves(data.data, data.start, data.length); + const part28: number = halvesOut.p_0Len; + const part29: Uint8Array = halvesOut.p_1Data; + const part30: number = halvesOut.p_1Start; + const part31: number = halvesOut.p_1Len; + const part32: Uint8Array = halvesOut.p_2Data; + const part33: number = halvesOut.p_2Start; + const part34: number = halvesOut.p_2Len; + if (err7 === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part29, part30, part31)); + rt.byteVecPush(out, part28 & 0xff); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part32, part33, part34)); } else { - rt.byteVecPush(out, err6 as rt.u8); + rt.byteVecPush(out, err7 as rt.u8); } const other: Uint8Array = Uint8Array.of(255, 1, 2); const _96: rt.ByteSlice = rt.byteSliceFrom(other); - const part36: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); - const part37: Uint8Array = wideOut.p_1Data; - const part38: number = wideOut.p_1Start; - const part39: number = wideOut.p_1Len; - const err7: returns_Error.Error | undefined = part36 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part36 === undefined ? rt.Err(err7 as returns_Error.Error) : rt.Ok([part36 as rt.u64, new rt.ByteSlice(part37, part38, part39)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part35: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); + const part36: Uint8Array = wideOut.p_1Data; + const part37: number = wideOut.p_1Start; + const part38: number = wideOut.p_1Len; + const err8: returns_Error.Error | undefined = part35 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part35 === undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part35 as rt.u64, new rt.ByteSlice(part36, part37, part38)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); - const part40: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); - const part41: Uint8Array = wideOut.p_1Data; - const part42: number = wideOut.p_1Start; - const part43: number = wideOut.p_1Len; - const err8: returns_Error.Error | undefined = part40 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part40 === undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part40 as rt.u64, new rt.ByteSlice(part41, part42, part43)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part39: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); + const part40: Uint8Array = wideOut.p_1Data; + const part41: number = wideOut.p_1Start; + const part42: number = wideOut.p_1Len; + const err9: returns_Error.Error | undefined = part39 === undefined ? wideOut.err as returns_Error.Error : undefined; + pushNumber(out, (part39 === undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok([part39 as rt.u64, new rt.ByteSlice(part40, part41, part42)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 4) { const _104: rt.Result = unitErr(data.data, data.start, data.length); if (_104.ok) { @@ -405,35 +402,34 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } else { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$0r2bmpr(_110.error, 0)))); } - const part18: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); - const part19: Uint8Array = leadOut$u16.p_1Data; - const part20: number = leadOut$u16.p_1Start; - const part21: number = leadOut$u16.p_1Len; - const err4: returns_Error.Error | undefined = part18 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; + const part17: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); + const part18: Uint8Array = leadOut$u16.p_1Data; + const part19: number = leadOut$u16.p_1Start; + const part20: number = leadOut$u16.p_1Len; + const err5: returns_Error.Error | undefined = part17 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; const _123: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); - const part23: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); - const part24: Uint8Array = leadOut$u32.p_1Data; - const part25: number = leadOut$u32.p_1Start; - const part26: number = leadOut$u32.p_1Len; - const err5: returns_Error.Error | undefined = part23 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; - if (part18 !== undefined) { - if (part23 !== undefined) { - const a3: rt.u16 = part18 as rt.u16; - const b3: rt.u32 = part23 as rt.u32; + const part22: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); + const part23: Uint8Array = leadOut$u32.p_1Data; + const part24: number = leadOut$u32.p_1Start; + const part25: number = leadOut$u32.p_1Len; + const err6: returns_Error.Error | undefined = part22 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; + if (part17 !== undefined) { + if (part22 !== undefined) { + const a3: rt.u16 = part17 as rt.u16; + const b3: rt.u32 = part22 as rt.u32; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a3))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(b3))); - rt.byteVecPush(out, part26 & 0xff); + rt.byteVecPush(out, part25 & 0xff); break b0; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((part18 === undefined ? rt.Err(err4 as returns_Error.Error) : rt.Ok([part18 as rt.u16, new rt.ByteSlice(part19, part20, part21)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((part23 === undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part23 as rt.u32, new rt.ByteSlice(part24, part25, part26)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((part17 === undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part17 as rt.u16, new rt.ByteSlice(part18, part19, part20)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((part22 === undefined ? rt.Err(err6 as returns_Error.Error) : rt.Ok([part22 as rt.u32, new rt.ByteSlice(part23, part24, part25)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); } else { const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; - const part: Uint8Array | undefined = splitWith$returns_At(at, data.data, data.start, data.length); + const err: returns_Error.Error | undefined = splitWith$returns_At(at, data.data, data.start, data.length); const part3: number = At.splitOut$returns_Split.p_0Len; const part6: number = At.splitOut$returns_Split.p_1Len; - const err: returns_Error.Error | undefined = part === undefined ? At.splitOut$returns_Split.err as returns_Error.Error : undefined; - if (part !== undefined) { + if (err === undefined) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part3 & 0xff, part6 & 0xff))); } else { rt.byteVecPush(out, returns_Error.code(err as returns_Error.Error)); @@ -444,16 +440,16 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } else { rt.byteVecPush(out, returns_Error.code(_176.error)); } - const part7: Uint8Array | undefined = At.split$returns_Split(at, data.data, data.start, data.length); + const err2: returns_Error.Error | undefined = At.split$returns_Split(at, data.data, data.start, data.length); + const part7: Uint8Array = At.splitOut$returns_Split.p_0Data; const part8: number = At.splitOut$returns_Split.p_0Start; const part9: number = At.splitOut$returns_Split.p_0Len; const part10: Uint8Array = At.splitOut$returns_Split.p_1Data; const part11: number = At.splitOut$returns_Split.p_1Start; const part12: number = At.splitOut$returns_Split.p_1Len; - const err2: returns_Error.Error | undefined = part7 === undefined ? At.splitOut$returns_Split.err as returns_Error.Error : undefined; - const _190: rt.Result = result_andThen$1yropo4((part7 === undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7 as Uint8Array, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { - const part13 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); - return part13 === undefined ? rt.Err(takeOut.err as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part13, takeOut.pStart, takeOut.pLen)); + const _190: rt.Result = result_andThen$1yropo4((err2 !== undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { + const err3 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); + return err3 !== undefined ? rt.Err(err3 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); }); if (_190.ok) { rt.byteVecPush(out, _190.value.length & 0xff); @@ -465,16 +461,16 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da let restLen3: number = data.length; let sum: rt.u64 = 0; while (true) { - const part14: rt.u64 | undefined = narrow(restData3, restStart3, restLen3); - const part15: Uint8Array = wideOut.p_1Data; - const part16: number = wideOut.p_1Start; - const part17: number = wideOut.p_1Len; - part14 === undefined ? wideOut.err as returns_Error.Error : undefined; - if (part14 !== undefined) { - sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part14 as rt.u64); - restData3 = part15; - restStart3 = part16; - restLen3 = part17; + const part13: rt.u64 | undefined = narrow(restData3, restStart3, restLen3); + const part14: Uint8Array = wideOut.p_1Data; + const part15: number = wideOut.p_1Start; + const part16: number = wideOut.p_1Len; + part13 === undefined ? wideOut.err as returns_Error.Error : undefined; + if (part13 !== undefined) { + sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13 as rt.u64); + restData3 = part14; + restStart3 = part15; + restLen3 = part16; } else { break; } diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index 35376cb1b..02b37622d 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -38,17 +38,17 @@ export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [ } /** `n` bytes, or how many it needed. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Uint8Array | undefined { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Short.Short | undefined { if (!(n <= dataLen)) { - At.splitOut$returns_Split.err = { tag: "Need", _0: n } as Short.Short; - return undefined; + return { tag: "Need", _0: n } as Short.Short; } + At.splitOut$returns_Split.p_0Data = dataData; At.splitOut$returns_Split.p_0Start = dataStart; At.splitOut$returns_Split.p_0Len = n; At.splitOut$returns_Split.p_1Data = dataData; At.splitOut$returns_Split.p_1Start = dataStart + n; At.splitOut$returns_Split.p_1Len = dataLen - n; - return dataData; + return undefined; } /** The byte after the first, or an error that is itself an enum, held whole. */ @@ -237,13 +237,13 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } - const part: Uint8Array | undefined = take(dataData, dataStart, dataLen, 3); + const err2: Short.Short | undefined = take(dataData, dataStart, dataLen, 3); + const part: Uint8Array = At.splitOut$returns_Split.p_0Data; const part2: number = At.splitOut$returns_Split.p_0Start; const part3: number = At.splitOut$returns_Split.p_0Len; const part6: number = At.splitOut$returns_Split.p_1Len; - const err2: Short.Short | undefined = part === undefined ? At.splitOut$returns_Split.err as Short.Short : undefined; - if (part !== undefined) { - rt.byteVecPush(out, opaque(part as Uint8Array, part2, part3)); + if (err2 === undefined) { + rt.byteVecPush(out, opaque(part, part2, part3)); rt.byteVecPush(out, part6 & 0xff); } else { const e: Short.Short = err2 as Short.Short; diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index e3582d37f..200cf6e74 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -234,10 +234,11 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { /// Where `instance` hands back its `Ok`'s parts, if it does: a function of the crate's /// that only translated code calls directly, and that returns a `Result` of byte slices - /// and scalars whose error is one value, such as `Result<(u64, &[u8]), E>`, writes the - /// `Ok`'s parts into a module-level slot its caller reads at once, and returns its error - /// or `undefined`. One whose first part is a number returns that, or `undefined` for an - /// error, and writes the error into the slot instead. + /// and scalars whose error is one value that is never `undefined`, such as + /// `Result<(u64, &[u8]), E>`, writes the `Ok`'s parts into a module-level slot its + /// caller reads at once, and returns its error or `undefined`. One whose first part is + /// a number returns that, or `undefined` for an error, and writes the error into the + /// slot instead. pub(crate) fn slotted(&mut self, instance: ty::Instance<'tcx>) -> Option> { if let Some(slotted) = self.slotted.get(&instance) { return slotted.clone(); @@ -270,14 +271,14 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } let mut parts = Vec::new(); shape.parts("", &mut parts); - // A number is returned rather than written to the long-lived slot, where V8 boxes - // one past 2^31 that a function too big to inline writes; the error then goes in - // the slot. Else the error is returned, so it must never be `undefined`. - let returned = matches!(parts[0].1, Part::Value(first) if first.is_numeric()); let erased = self.erases_to(err); - if !returned && (erased.undefined || erased.none || erased.param || erased.pending || erased.outer_pending) { + if erased.undefined || erased.none || erased.param || erased.pending || erased.outer_pending { return None; } + // A number is returned rather than written to the long-lived slot, where V8 boxes + // one past 2^31 that a function too big to inline writes; the error then goes in + // the slot. + let returned = matches!(parts[0].1, Part::Value(first) if first.is_numeric()); let fields: Vec = parts.iter().map(|(suffix, _)| format!("p{suffix}")).collect(); let sym = match self.slots.get(&ok) { Some(&sym) => sym, From a30214d5e35a78fae09a9f042dd077037b24e791 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 17:18:31 -0700 Subject: [PATCH 21/26] perf(ts): read a slotted call's error before its other parts Co-Authored-By: Claude Opus 5.5 --- .../codec/expected/coding/decode.Decoder.ts | 4 +-- ts/src/lower/mir/scalar.rs | 25 ++++++++----------- 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 724c225ac..3570fa92d 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -149,11 +149,11 @@ export function varint(self: Decoder): rt.Result; const _13: rt.ByteSlice = self.buf; const part: rt.u64 | undefined = read(_13.data, _13.start, _13.length, self.form); + const err2: DecodeError.DecodeError | undefined = part === undefined ? readOut.err as DecodeError.DecodeError : undefined; const part2: Uint8Array = readOut.p_1Data; const part3: number = readOut.p_1Start; const part4: number = readOut.p_1Len; - const err2: DecodeError.DecodeError | undefined = part === undefined ? readOut.err as DecodeError.DecodeError : undefined; - if (part !== undefined) { + if (err2 === undefined) { const value: rt.u64 = part as rt.u64; self.buf = new rt.ByteSlice(part2, part3, part4); _0 = rt.Ok(value); diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 200cf6e74..223263acb 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -1656,23 +1656,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.scalar_binds.push((ret.clone(), ret_ty)); let stmt = StmtKind::Expr(Expr::ident(&ret).assign(call)).at(None); self.emit(vec![stmt], false, out); - let failed = match slotted.returned { - true => Expr::ident(&ret).binary("===", Expr::undefined()), - false => Expr::ident(&ret).binary("!==", Expr::undefined()), - }; - let mut parts = vec![Some((failed.clone(), true))]; - if slotted.returned { - let first_ty = self.b.t.part_ty(kinds[0].1, span); - parts.push(Some((Expr::As(Box::new(Expr::ident(&ret)), first_ty), true))); - } - for (i, (_, part)) in kinds.into_iter().enumerate().skip(slotted.held()) { - let ty = self.b.t.part_ty(part, span); - parts.push(Some(self.steady_value(slotted.field(i), "part", ty, out))); - } + // The error, read before the rest: V8 runs frame decode about 7% faster so. let err = match slotted.returned { true => { let err = Expr::Cond( - Box::new(failed), + Box::new(Expr::ident(&ret).binary("===", Expr::undefined())), Box::new(Expr::As(Box::new(slotted.err_field()), err_ty.clone())), Box::new(Expr::undefined()), ); @@ -1681,6 +1669,15 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } false => Expr::ident(&ret), }; + let mut parts = vec![Some((err.clone().binary("!==", Expr::undefined()), true))]; + if slotted.returned { + let first_ty = self.b.t.part_ty(kinds[0].1, span); + parts.push(Some((Expr::As(Box::new(Expr::ident(&ret)), first_ty), true))); + } + for (i, (_, part)) in kinds.into_iter().enumerate().skip(slotted.held()) { + let ty = self.b.t.part_ty(part, span); + parts.push(Some(self.steady_value(slotted.field(i), "part", ty, out))); + } parts.push(Some((Expr::As(Box::new(err), err_ty), true))); parts } From 30cb047e883c5f0d4abe18a08d64934138793902 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 17:38:28 -0700 Subject: [PATCH 22/26] chore(ts): regenerate the lang fixture's slotted calls Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/returns.ts | 50 ++++++++++++++-------------- ts/fixtures/lang/expected/splits.ts | 4 +-- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts index cb745483b..0003d8ff8 100644 --- a/ts/fixtures/lang/expected/returns.ts +++ b/ts/fixtures/lang/expected/returns.ts @@ -94,11 +94,11 @@ export function count(dataData: Uint8Array, dataStart: number, dataLen: number): return 0; } const part: rt.u64 | undefined = count(dataData, dataStart + 1, dataLen - 1); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; - if (part !== undefined) { + if (err === undefined) { const _14_0: rt.u64 = rt.u64Add(part as rt.u64, 1); wideOut.p_1Data = part2; wideOut.p_1Start = part3; @@ -135,18 +135,18 @@ export const halvesOut: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; /** Calls whose results are both held while the slot is written again between them. */ export function both(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; - if (part !== undefined) { + if (err === undefined) { const a: rt.u64 = part as rt.u64; const part5: rt.u64 | undefined = number(part2, part3, part4, rt.u64Rem(a, 2) === 1); + const err2: returns_Error.Error | undefined = part5 === undefined ? wideOut.err as returns_Error.Error : undefined; const part6: Uint8Array = wideOut.p_1Data; const part7: number = wideOut.p_1Start; const part8: number = wideOut.p_1Len; - const err2: returns_Error.Error | undefined = part5 === undefined ? wideOut.err as returns_Error.Error : undefined; - if (part5 !== undefined) { + if (err2 === undefined) { const b: rt.u64 = part5 as rt.u64; const err3: returns_Error.Error | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); const part9: Uint8Array = takeOut.pData; @@ -179,12 +179,12 @@ export const bothOut: { err: unknown; p_1: rt.u64; p_2Data: Uint8Array; p_2Start export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, otherData: Uint8Array, otherStart: number, otherLen: number): rt.u64 | undefined { const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; new Guard.Guard(new rt.ByteSlice(otherData, otherStart, otherLen), dataLen & 0xff)[Symbol.dispose](); - if (part === undefined) { + if (err !== undefined) { wideOut.err = err as returns_Error.Error; return undefined; } @@ -288,17 +288,17 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const part66: number = takeOut.pLen; push(out, (err16 !== undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part64, part65, part66))) as rt.Result); const part67: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + const err17: returns_Error.Error | undefined = part67 === undefined ? wideOut.err as returns_Error.Error : undefined; const part68: Uint8Array = wideOut.p_1Data; const part69: number = wideOut.p_1Start; const part70: number = wideOut.p_1Len; - const err17: returns_Error.Error | undefined = part67 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part67 === undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok([part67 as rt.u64, new rt.ByteSlice(part68, part69, part70)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + pushNumber(out, (err17 !== undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok([part67 as rt.u64, new rt.ByteSlice(part68, part69, part70)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); const part71: rt.u64 | undefined = count(data.data, data.start, data.length); + const err18: returns_Error.Error | undefined = part71 === undefined ? wideOut.err as returns_Error.Error : undefined; const part72: Uint8Array = wideOut.p_1Data; const part73: number = wideOut.p_1Start; const part74: number = wideOut.p_1Len; - const err18: returns_Error.Error | undefined = part71 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part71 === undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok([part71 as rt.u64, new rt.ByteSlice(part72, part73, part74)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + pushNumber(out, (err18 !== undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok([part71 as rt.u64, new rt.ByteSlice(part72, part73, part74)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 1) { const kept: rt.Result[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { const err11 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); @@ -313,10 +313,10 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } push(out, (err12 !== undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part50, part51, part52))) as rt.Result); const part53: rt.u64 | undefined = both(data.data, data.start, data.length); + const err13: returns_Error.Error | undefined = part53 === undefined ? bothOut.err as returns_Error.Error : undefined; const part54: rt.u64 = bothOut.p_1; const part57: number = bothOut.p_2Len; - const err13: returns_Error.Error | undefined = part53 === undefined ? bothOut.err as returns_Error.Error : undefined; - if (part53 !== undefined) { + if (err13 === undefined) { const a: rt.u64 = part53 as rt.u64; const b: rt.u64 = part54; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); @@ -377,18 +377,18 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const other: Uint8Array = Uint8Array.of(255, 1, 2); const _96: rt.ByteSlice = rt.byteSliceFrom(other); const part35: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); + const err8: returns_Error.Error | undefined = part35 === undefined ? wideOut.err as returns_Error.Error : undefined; const part36: Uint8Array = wideOut.p_1Data; const part37: number = wideOut.p_1Start; const part38: number = wideOut.p_1Len; - const err8: returns_Error.Error | undefined = part35 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part35 === undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part35 as rt.u64, new rt.ByteSlice(part36, part37, part38)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + pushNumber(out, (err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part35 as rt.u64, new rt.ByteSlice(part36, part37, part38)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); const part39: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); + const err9: returns_Error.Error | undefined = part39 === undefined ? wideOut.err as returns_Error.Error : undefined; const part40: Uint8Array = wideOut.p_1Data; const part41: number = wideOut.p_1Start; const part42: number = wideOut.p_1Len; - const err9: returns_Error.Error | undefined = part39 === undefined ? wideOut.err as returns_Error.Error : undefined; - pushNumber(out, (part39 === undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok([part39 as rt.u64, new rt.ByteSlice(part40, part41, part42)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + pushNumber(out, (err9 !== undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok([part39 as rt.u64, new rt.ByteSlice(part40, part41, part42)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 4) { const _104: rt.Result = unitErr(data.data, data.start, data.length); if (_104.ok) { @@ -403,18 +403,18 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$0r2bmpr(_110.error, 0)))); } const part17: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); + const err5: returns_Error.Error | undefined = part17 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; const part18: Uint8Array = leadOut$u16.p_1Data; const part19: number = leadOut$u16.p_1Start; const part20: number = leadOut$u16.p_1Len; - const err5: returns_Error.Error | undefined = part17 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; const _123: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); const part22: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); + const err6: returns_Error.Error | undefined = part22 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; const part23: Uint8Array = leadOut$u32.p_1Data; const part24: number = leadOut$u32.p_1Start; const part25: number = leadOut$u32.p_1Len; - const err6: returns_Error.Error | undefined = part22 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; - if (part17 !== undefined) { - if (part22 !== undefined) { + if (err5 === undefined) { + if (err6 === undefined) { const a3: rt.u16 = part17 as rt.u16; const b3: rt.u32 = part22 as rt.u32; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a3))); @@ -423,7 +423,7 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da break b0; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((part17 === undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part17 as rt.u16, new rt.ByteSlice(part18, part19, part20)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((part22 === undefined ? rt.Err(err6 as returns_Error.Error) : rt.Ok([part22 as rt.u32, new rt.ByteSlice(part23, part24, part25)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err5 !== undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part17 as rt.u16, new rt.ByteSlice(part18, part19, part20)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err6 !== undefined ? rt.Err(err6 as returns_Error.Error) : rt.Ok([part22 as rt.u32, new rt.ByteSlice(part23, part24, part25)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); } else { const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; const err: returns_Error.Error | undefined = splitWith$returns_At(at, data.data, data.start, data.length); @@ -462,11 +462,11 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da let sum: rt.u64 = 0; while (true) { const part13: rt.u64 | undefined = narrow(restData3, restStart3, restLen3); + const err4: returns_Error.Error | undefined = part13 === undefined ? wideOut.err as returns_Error.Error : undefined; const part14: Uint8Array = wideOut.p_1Data; const part15: number = wideOut.p_1Start; const part16: number = wideOut.p_1Len; - part13 === undefined ? wideOut.err as returns_Error.Error : undefined; - if (part13 !== undefined) { + if (err4 === undefined) { sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13 as rt.u64); restData3 = part14; restStart3 = part15; diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index 02b37622d..756bc8a6f 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -111,12 +111,12 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, new rt.ByteSlice(dataData, dataStart + mid4, dataLen - mid4)); } else if (_4 === 2) { const part7: rt.u8 | undefined = header(dataData, dataStart, dataLen); + const err3: Short.Short | undefined = part7 === undefined ? headerOut.err as Short.Short : undefined; const part8: rt.u16 = headerOut.p_1; const part9: Uint8Array = headerOut.p_2Data; const part10: number = headerOut.p_2Start; const part11: number = headerOut.p_2Len; - const err3: Short.Short | undefined = part7 === undefined ? headerOut.err as Short.Short : undefined; - if (part7 !== undefined) { + if (err3 === undefined) { const a2: rt.u8 = part7 as rt.u8; const b3: rt.u16 = part8; rt.byteVecPush(out, a2); From 32355f137bf999914397303f6b7d8fada33ce977 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 17:51:53 -0700 Subject: [PATCH 23/26] style(ts): format the slot's declaration Co-Authored-By: Claude Opus 5.5 --- ts/src/lower/mir/scalar.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 223263acb..64f43b535 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -328,7 +328,12 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { let fields: Vec<(String, Type, Expr)> = err.into_iter().chain(held).collect(); self.program.items.push(crate::ts::Item::Value { sym, - ty: Type::Object(fields.iter().map(|(field, ty, _)| (field.clone(), ty.clone())).collect()), + ty: Type::Object( + fields + .iter() + .map(|(field, ty, _)| (field.clone(), ty.clone())) + .collect(), + ), doc: None, value: Expr::Object( (fields.into_iter()) @@ -461,7 +466,10 @@ impl<'tcx> Slotted<'tcx> { /// (a name), read at once: the `Ok` of the slot's parts, or the `Err`. pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, ret: &str, span: Span) -> Expr { let first = self.returned.then(|| Expr::ident(ret)); - let parts: Vec = first.into_iter().chain((self.held()..self.fields.len()).map(|i| self.field(i))).collect(); + let parts: Vec = first + .into_iter() + .chain((self.held()..self.fields.len()).map(|i| self.field(i))) + .collect(); let ok = build_plain(t, &self.ok, &parts, span); let err_ty = t.ty(self.err, span); let (failed, err) = match self.returned { From 166dcee557daeaf6ea82df7fcd98aebbe1ae6473 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 18:18:45 -0700 Subject: [PATCH 24/26] fix(ts): judge a slotted function's lowering in the crate's typing environment Main's `lowers` now takes the typing environment of the body naming the instance; `inside` has none, so it takes the crate's, as `translated` does. Regenerates the lang fixture's snapshots after the merge. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/harness.ts | 560 ++++++++++++++++++++------ ts/fixtures/lang/expected/lengths.ts | 202 +++++----- ts/fixtures/lang/expected/lists.ts | 15 +- ts/fixtures/lang/expected/pointers.ts | 4 +- ts/src/lower/mir/scalar.rs | 2 +- 5 files changed, 538 insertions(+), 245 deletions(-) diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 53feeb031..292cd7736 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { args } from "./args.ts"; import { fromFns, maps, lent as arrays_lent, asSlices, given } from "./arrays.ts"; import { bytes as ascii_bytes, chars as ascii_chars, slices as ascii_slices } from "./ascii.ts"; import { atomics } from "./atomics.ts"; @@ -43,6 +44,7 @@ import { objects } from "./objects.ts"; import { orders, bytes as orders_bytes, tuples as orders_tuples, held as orders_held, btrees } from "./orders.ts"; import { lists as pointers_lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded, reattached } from "./pointers.ts"; import { refs, toRefs } from "./refs.ts"; +import { returns } from "./returns.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -62,180 +64,470 @@ import { zeros, impls, keys as zeros_keys, unread, writes as zeros_writes } from * case added at the end moves no other. */ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] { - return [["ints::u8_op", u8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", u16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", u32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", u64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", u128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", usizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", i8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", i16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", i32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", i64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", i128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", isizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", neg as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", cast as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_2100: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { - convert(data, out); + return [["ints::u8_op", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { + u8Op(a0, a1.data, a1.start, a1.length, a2); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", (a02: rt.u8, a12: rt.ByteSlice, a22: rt.ByteVec): undefined => { + u16Op(a02, a12.data, a12.start, a12.length, a22); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", (a03: rt.u8, a13: rt.ByteSlice, a23: rt.ByteVec): undefined => { + u32Op(a03, a13.data, a13.start, a13.length, a23); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", (a04: rt.u8, a14: rt.ByteSlice, a24: rt.ByteVec): undefined => { + u64Op(a04, a14.data, a14.start, a14.length, a24); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", (a05: rt.u8, a15: rt.ByteSlice, a25: rt.ByteVec): undefined => { + u128Op(a05, a15.data, a15.start, a15.length, a25); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", (a06: rt.u8, a16: rt.ByteSlice, a26: rt.ByteVec): undefined => { + usizeOp(a06, a16.data, a16.start, a16.length, a26); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", (a07: rt.u8, a17: rt.ByteSlice, a27: rt.ByteVec): undefined => { + i8Op(a07, a17.data, a17.start, a17.length, a27); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", (a08: rt.u8, a18: rt.ByteSlice, a28: rt.ByteVec): undefined => { + i16Op(a08, a18.data, a18.start, a18.length, a28); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", (a09: rt.u8, a19: rt.ByteSlice, a29: rt.ByteVec): undefined => { + i32Op(a09, a19.data, a19.start, a19.length, a29); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", (a010: rt.u8, a110: rt.ByteSlice, a210: rt.ByteVec): undefined => { + i64Op(a010, a110.data, a110.start, a110.length, a210); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", (a011: rt.u8, a111: rt.ByteSlice, a211: rt.ByteVec): undefined => { + i128Op(a011, a111.data, a111.start, a111.length, a211); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", (a012: rt.u8, a112: rt.ByteSlice, a212: rt.ByteVec): undefined => { + isizeOp(a012, a112.data, a112.start, a112.length, a212); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", (a013: rt.u8, a113: rt.ByteSlice, a213: rt.ByteVec): undefined => { + neg(a013, a113.data, a113.start, a113.length, a213); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", (a014: rt.u8, a114: rt.ByteSlice, a214: rt.ByteVec): undefined => { + cast(a014, a114.data, a114.start, a114.length, a214); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_2100: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { + convert(data.data, data.start, data.length, out); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::copies", (_2101: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { - shapes_copies(data2, out2); + shapes_copies(data2.data, data2.start, data2.length, out2); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::loops", (_2102: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { - loops(data3, out3); + loops(data3.data, data3.start, data3.length, out3); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::patterns", (_2103: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { - patterns(data4, out4); + patterns(data4.data, data4.start, data4.length, out4); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::closures", (_2104: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { - shapes_closures(data5, out5); + shapes_closures(data5.data, data5.start, data5.length, out5); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::discriminants", (_2105: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { - discriminants(data6, out6); + discriminants(data6.data, data6.start, data6.length, out6); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::library", (_2106: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { - library(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::ints", ints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_2107: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { - strings(data8, out8); + library(data7.data, data7.start, data7.length, out7); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::ints", (a015: rt.u8, a115: rt.ByteSlice, a215: rt.ByteVec): undefined => { + ints(a015, a115.data, a115.start, a115.length, a215); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_2107: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + strings(data8.data, data8.start, data8.length, out8); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::derived", (_2108: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { - derived(data9, out9); + derived(data9.data, data9.start, data9.length, out9); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::written", (_2109: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): undefined => { - fmt_written(data10, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", fmt_panics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_2110: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { - methods(data11, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::adaptors", adaptors as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", iters_consumers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_2111: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { - iters_ranges(data12, out12); + fmt_written(data10.data, data10.start, data10.length, out10); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", (a016: rt.u8, a116: rt.ByteSlice, a216: rt.ByteVec): undefined => { + fmt_panics(a016, a116.data, a116.start, a116.length, a216); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_2110: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { + methods(data11.data, data11.start, data11.length, out11); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::adaptors", (a017: rt.u8, a117: rt.ByteSlice, a217: rt.ByteVec): undefined => { + adaptors(a017, a117.data, a117.start, a117.length, a217); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", (a018: rt.u8, a118: rt.ByteSlice, a218: rt.ByteVec): undefined => { + iters_consumers(a018, a118.data, a118.start, a118.length, a218); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_2111: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { + iters_ranges(data12.data, data12.start, data12.length, out12); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::options", (_2112: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): undefined => { - iters_options(data13, out13); + iters_options(data13.data, data13.start, data13.length, out13); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::own", (_2113: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): undefined => { - own(data14, out14); + own(data14.data, data14.start, data14.length, out14); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::values", (_2114: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): undefined => { - iters_values(data15, out15); + iters_values(data15.data, data15.start, data15.length, out15); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::order", (_2115: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): undefined => { - shapes_order(data16, out16); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", hashMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", sets as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", btreeMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { - deques(data17, out17); + shapes_order(data16.data, data16.start, data16.length, out16); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", (a019: rt.u8, a119: rt.ByteSlice, a219: rt.ByteVec): undefined => { + hashMaps(a019, a119.data, a119.start, a119.length, a219); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", (a020: rt.u8, a120: rt.ByteSlice, a220: rt.ByteVec): undefined => { + sets(a020, a120.data, a120.start, a120.length, a220); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", (a021: rt.u8, a121: rt.ByteSlice, a221: rt.ByteVec): undefined => { + btreeMaps(a021, a121.data, a121.start, a121.length, a221); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { + deques(data17.data, data17.start, data17.length, out17); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::flows", (_2117: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): undefined => { - flows(data18, out18); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", keys_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", chars_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", strs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { - vecs(data19, out19); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", strs_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { - stores(data20, out20); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", chunks as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", cows as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", durations as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", combinators as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", splits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", nested_nested as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { - refs(data21, out21); + flows(data18.data, data18.start, data18.length, out18); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", (a022: rt.u8, a122: rt.ByteSlice, a222: rt.ByteVec): undefined => { + keys_keys(a022, a122.data, a122.start, a122.length, a222); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", (a023: rt.u8, a123: rt.ByteSlice, a223: rt.ByteVec): undefined => { + chars_chars(a023, a123.data, a123.start, a123.length, a223); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", (a024: rt.u8, a124: rt.ByteSlice, a224: rt.ByteVec): undefined => { + strs(a024, a124.data, a124.start, a124.length, a224); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { + vecs(data19.data, data19.start, data19.length, out19); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", (a025: rt.u8, a125: rt.ByteSlice, a225: rt.ByteVec): undefined => { + strs_slices(a025, a125.data, a125.start, a125.length, a225); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { + stores(data20.data, data20.start, data20.length, out20); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", (a026: rt.u8, a126: rt.ByteSlice, a226: rt.ByteVec): undefined => { + chunks(a026, a126.data, a126.start, a126.length, a226); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", (a027: rt.u8, a127: rt.ByteSlice, a227: rt.ByteVec): undefined => { + cows(a027, a127.data, a127.start, a127.length, a227); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", (a028: rt.u8, a128: rt.ByteSlice, a228: rt.ByteVec): undefined => { + durations(a028, a128.data, a128.start, a128.length, a228); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", (a029: rt.u8, a129: rt.ByteSlice, a229: rt.ByteVec): undefined => { + combinators(a029, a129.data, a129.start, a129.length, a229); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", (a030: rt.u8, a130: rt.ByteSlice, a230: rt.ByteVec): undefined => { + splits(a030, a130.data, a130.start, a130.length, a230); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", (a031: rt.u8, a131: rt.ByteSlice, a231: rt.ByteVec): undefined => { + nested_nested(a031, a131.data, a131.start, a131.length, a231); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { + refs(data21.data, data21.start, data21.length, out21); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::counts", (_2121: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): undefined => { - fmt_counts(data22, out22); + fmt_counts(data22.data, data22.start, data22.length, out22); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::rounding", (_2122: rt.u8, _3100: rt.ByteSlice, out23: rt.ByteVec): undefined => { rounding(out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", skips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", wrappers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", edits_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", floats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", atomics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { - dyns(data23, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", cells_cells as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { - dyns_shared(data24, out25); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", iters_ranked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", captures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { - locks(data25, out26); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", (a032: rt.u8, a132: rt.ByteSlice, a232: rt.ByteVec): undefined => { + skips(a032, a132.data, a132.start, a132.length, a232); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", (a033: rt.u8, a133: rt.ByteSlice, a233: rt.ByteVec): undefined => { + wrappers(a033, a133.data, a133.start, a133.length, a233); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", (a034: rt.u8, a134: rt.ByteSlice, a234: rt.ByteVec): undefined => { + edits_edits(a034, a134.data, a134.start, a134.length, a234); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", (a035: rt.u8, a135: rt.ByteSlice, a235: rt.ByteVec): undefined => { + decodes(a035, a135.data, a135.start, a135.length, a235); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", (a036: rt.u8, a136: rt.ByteSlice, a236: rt.ByteVec): undefined => { + floats(a036, a136.data, a136.start, a136.length, a236); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", (a037: rt.u8, a137: rt.ByteSlice, a237: rt.ByteVec): undefined => { + atomics(a037, a137.data, a137.start, a137.length, a237); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", (a038: rt.u8, a138: rt.ByteSlice, a238: rt.ByteVec): undefined => { + overrides(a038, a138.data, a138.start, a138.length, a238); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { + dyns(data23.data, data23.start, data23.length, out24); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", (a039: rt.u8, a139: rt.ByteSlice, a239: rt.ByteVec): undefined => { + cells_cells(a039, a139.data, a139.start, a139.length, a239); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { + dyns_shared(data24.data, data24.start, data24.length, out25); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", (a040: rt.u8, a140: rt.ByteSlice, a240: rt.ByteVec): undefined => { + iters_ranked(a040, a140.data, a140.start, a140.length, a240); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", (a041: rt.u8, a141: rt.ByteSlice, a241: rt.ByteVec): undefined => { + captures(a041, a141.data, a141.start, a141.length, a241); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { + locks(data25.data, data25.start, data25.length, out26); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::relock", (_2126: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): undefined => { - relock(data26, out27); + relock(data26.data, data26.start, data26.length, out27); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locals::locals", (_2127: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): undefined => { - locals(data27, out28); + locals(data27.data, data27.start, data27.length, out28); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::statics", (_2128: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): undefined => { - statics(data28, out29); + statics(data28.data, data28.start, data28.length, out29); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::rwlocks", (_2129: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): undefined => { - rwlocks(data29, out30); + rwlocks(data29.data, data29.start, data29.length, out30); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::borrows", (_2130: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): undefined => { - borrows_borrows(data30, out31); + borrows_borrows(data30.data, data30.start, data30.length, out31); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["defaults::defaults", (_2131: rt.u8, data31: rt.ByteSlice, out32: rt.ByteVec): undefined => { - defaults_defaults(data31, out32); + defaults_defaults(data31.data, data31.start, data31.length, out32); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::arcs", (_2132: rt.u8, data32: rt.ByteSlice, out33: rt.ByteVec): undefined => { - counts_arcs(data32, out33); + counts_arcs(data32.data, data32.start, data32.length, out33); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::rcs", (_2133: rt.u8, data33: rt.ByteSlice, out34: rt.ByteVec): undefined => { - rcs(data33, out34); + rcs(data33.data, data33.start, data33.length, out34); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_arcs", (_2134: rt.u8, data34: rt.ByteSlice, out35: rt.ByteVec): undefined => { - cyclicArcs(data34, out35); + cyclicArcs(data34.data, data34.start, data34.length, out35); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_rcs", (_2135: rt.u8, data35: rt.ByteSlice, out36: rt.ByteVec): undefined => { - cyclicRcs(data35, out36); + cyclicRcs(data35.data, data35.start, data35.length, out36); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_arcs", (_2136: rt.u8, data36: rt.ByteSlice, out37: rt.ByteVec): undefined => { - uniqueArcs(data36, out37); + uniqueArcs(data36.data, data36.start, data36.length, out37); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_rcs", (_2137: rt.u8, data37: rt.ByteSlice, out38: rt.ByteVec): undefined => { - uniqueRcs(data37, out38); + uniqueRcs(data37.data, data37.start, data37.length, out38); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::anys", (_2138: rt.u8, data38: rt.ByteSlice, out39: rt.ByteVec): undefined => { - anys(data38, out39); + anys(data38.data, data38.start, data38.length, out39); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::fns", (_2139: rt.u8, data39: rt.ByteSlice, out40: rt.ByteVec): undefined => { - fns(data39, out40); + fns(data39.data, data39.start, data39.length, out40); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::copies", (_2140: rt.u8, data40: rt.ByteSlice, out41: rt.ByteVec): undefined => { - pointers_copies(data40, out41); + pointers_copies(data40.data, data40.start, data40.length, out41); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lists", (_2141: rt.u8, data41: rt.ByteSlice, out42: rt.ByteVec): undefined => { - pointers_lists(data41, out42); + pointers_lists(data41.data, data41.start, data41.length, out42); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::nested", (_2142: rt.u8, data42: rt.ByteSlice, out43: rt.ByteVec): undefined => { - pointers_nested(data42, out43); + pointers_nested(data42.data, data42.start, data42.length, out43); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::places", (_2143: rt.u8, data43: rt.ByteSlice, out44: rt.ByteVec): undefined => { - pointers_places(data43, out44); + pointers_places(data43.data, data43.start, data43.length, out44); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::sentinels", (_2144: rt.u8, data44: rt.ByteSlice, out45: rt.ByteVec): undefined => { - sentinels(data44, out45); + sentinels(data44.data, data44.start, data44.length, out45); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::shared", (_2145: rt.u8, data45: rt.ByteSlice, out46: rt.ByteVec): undefined => { - pointers_shared(data45, out46); + pointers_shared(data45.data, data45.start, data45.length, out46); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::unchecked", (_2146: rt.u8, data46: rt.ByteSlice, out47: rt.ByteVec): undefined => { - unchecked(data46, out47); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", edits_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { - fromFns(data47, out48); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["objects::objects", (_2148: rt.u8, data48: rt.ByteSlice, out49: rt.ByteVec): undefined => { - objects(data48, out49); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["holds::holds", holds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_2149: rt.u8, data49: rt.ByteSlice, out50: rt.ByteVec): undefined => { - fmt_wrapped(data49, out50); + unchecked(data46.data, data46.start, data46.length, out47); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", (a042: rt.u8, a142: rt.ByteSlice, a242: rt.ByteVec): undefined => { + edits_bytes(a042, a142.data, a142.start, a142.length, a242); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { + fromFns(data47.data, data47.start, data47.length, out48); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", (a043: rt.u8, a143: rt.ByteSlice, a243: rt.ByteVec): undefined => { + optionals(a043, a143.data, a143.start, a143.length, a243); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["objects::objects", (_2148: rt.u8, data48: rt.ByteSlice, out49: rt.ByteVec): undefined => { + objects(data48.data, data48.start, data48.length, out49); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["holds::holds", (a044: rt.u8, a144: rt.ByteSlice, a244: rt.ByteVec): undefined => { + holds(a044, a144.data, a144.start, a144.length, a244); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_2149: rt.u8, data49: rt.ByteSlice, out50: rt.ByteVec): undefined => { + fmt_wrapped(data49.data, data49.start, data49.length, out50); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::to_refs", (_2150: rt.u8, data50: rt.ByteSlice, out51: rt.ByteVec): undefined => { - toRefs(data50, out51); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::orders", orders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_2151: rt.u8, data51: rt.ByteSlice, out52: rt.ByteVec): undefined => { - clonedArcs(data51, out52); + toRefs(data50.data, data50.start, data50.length, out51); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::orders", (a045: rt.u8, a145: rt.ByteSlice, a245: rt.ByteVec): undefined => { + orders(a045, a145.data, a145.start, a145.length, a245); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_2151: rt.u8, data51: rt.ByteSlice, out52: rt.ByteVec): undefined => { + clonedArcs(data51.data, data51.start, data51.length, out52); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_rcs", (_2152: rt.u8, data52: rt.ByteSlice, out53: rt.ByteVec): undefined => { - clonedRcs(data52, out53); + clonedRcs(data52.data, data52.start, data52.length, out53); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::copies", (_2153: rt.u8, data53: rt.ByteSlice, out54: rt.ByteVec): undefined => { - counts_copies(data53, out54); + counts_copies(data53.data, data53.start, data53.length, out54); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::cells", (_2154: rt.u8, data54: rt.ByteSlice, out55: rt.ByteVec): undefined => { - statics_cells(data54, out55); + statics_cells(data54.data, data54.start, data54.length, out55); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::returned", (_2155: rt.u8, data55: rt.ByteSlice, out56: rt.ByteVec): undefined => { - returned(data55, out56); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::values", hashes_values as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_2156: rt.u8, data56: rt.ByteSlice, out57: rt.ByteVec): undefined => { - random(data56, out57); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", floats_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", floats_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_2157: rt.u8, data57: rt.ByteSlice, out58: rt.ByteVec): undefined => { - orders_bytes(data57, out58); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::parts", slices_parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", slices_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_2158: rt.u8, data58: rt.ByteSlice, out59: rt.ByteVec): undefined => { - onces(data58, out59); + returned(data55.data, data55.start, data55.length, out56); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::values", (a046: rt.u8, a146: rt.ByteSlice, a246: rt.ByteVec): undefined => { + hashes_values(a046, a146.data, a146.start, a146.length, a246); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_2156: rt.u8, data56: rt.ByteSlice, out57: rt.ByteVec): undefined => { + random(data56.data, data56.start, data56.length, out57); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", (a047: rt.u8, a147: rt.ByteSlice, a247: rt.ByteVec): undefined => { + floats_formats(a047, a147.data, a147.start, a147.length, a247); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", (a048: rt.u8, a148: rt.ByteSlice, a248: rt.ByteVec): undefined => { + floats_parses(a048, a148.data, a148.start, a148.length, a248); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_2157: rt.u8, data57: rt.ByteSlice, out58: rt.ByteVec): undefined => { + orders_bytes(data57.data, data57.start, data57.length, out58); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::parts", (a049: rt.u8, a149: rt.ByteSlice, a249: rt.ByteVec): undefined => { + slices_parts(a049, a149.data, a149.start, a149.length, a249); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", (a050: rt.u8, a150: rt.ByteSlice, a250: rt.ByteVec): undefined => { + slices_drains(a050, a150.data, a150.start, a150.length, a250); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", (a051: rt.u8, a151: rt.ByteSlice, a251: rt.ByteVec): undefined => { + chunked(a051, a151.data, a151.start, a151.length, a251); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_2158: rt.u8, data58: rt.ByteSlice, out59: rt.ByteVec): undefined => { + onces(data58.data, data58.start, data58.length, out59); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::writes", (_2159: rt.u8, data59: rt.ByteSlice, out60: rt.ByteVec): undefined => { - fmt_writes(data59, out60); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", bounds_bounds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { - pointers_cells(data60, out61); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", ints_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", strs_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { - hashes_bytes(data61, out62); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", keys_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", strs_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { - pointers_rebound(data62, out63); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", slices_ranges as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_2163: rt.u8, data63: rt.ByteSlice, out64: rt.ByteVec): undefined => { - reducers(data63, out64); + fmt_writes(data59.data, data59.start, data59.length, out60); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", (a052: rt.u8, a152: rt.ByteSlice, a252: rt.ByteVec): undefined => { + bounds_bounds(a052, a152.data, a152.start, a152.length, a252); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { + pointers_cells(data60.data, data60.start, data60.length, out61); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", (a053: rt.u8, a153: rt.ByteSlice, a253: rt.ByteVec): undefined => { + ints_parses(a053, a153.data, a153.start, a153.length, a253); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", (a054: rt.u8, a154: rt.ByteSlice, a254: rt.ByteVec): undefined => { + strs_edits(a054, a154.data, a154.start, a154.length, a254); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", (a055: rt.u8, a155: rt.ByteSlice, a255: rt.ByteVec): undefined => { + subslices(a055, a155.data, a155.start, a155.length, a255); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { + hashes_bytes(data61.data, data61.start, data61.length, out62); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", (a056: rt.u8, a156: rt.ByteSlice, a256: rt.ByteVec): undefined => { + keys_bytes(a056, a156.data, a156.start, a156.length, a256); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", (a057: rt.u8, a157: rt.ByteSlice, a257: rt.ByteVec): undefined => { + strs_parses(a057, a157.data, a157.start, a157.length, a257); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { + pointers_rebound(data62.data, data62.start, data62.length, out63); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", (a058: rt.u8, a158: rt.ByteSlice, a258: rt.ByteVec): undefined => { + slices_ranges(a058, a158.data, a158.start, a158.length, a258); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_2163: rt.u8, data63: rt.ByteSlice, out64: rt.ByteVec): undefined => { + reducers(data63.data, data63.start, data63.length, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): undefined => { - writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { - pointers_made(data65, out66); + writers(data64.data, data64.start, data64.length, out65); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", (a059: rt.u8, a159: rt.ByteSlice, a259: rt.ByteVec): undefined => { + eqs(a059, a159.data, a159.start, a159.length, a259); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", (a060: rt.u8, a160: rt.ByteSlice, a260: rt.ByteVec): undefined => { + slices_edits(a060, a160.data, a160.start, a160.length, a260); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", (a061: rt.u8, a161: rt.ByteSlice, a261: rt.ByteVec): undefined => { + strs_iters(a061, a161.data, a161.start, a161.length, a261); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", (a062: rt.u8, a162: rt.ByteSlice, a262: rt.ByteVec): undefined => { + strs_drains(a062, a162.data, a162.start, a162.length, a262); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", (a063: rt.u8, a163: rt.ByteSlice, a263: rt.ByteVec): undefined => { + hinted(a063, a163.data, a163.start, a163.length, a263); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { + pointers_made(data65.data, data65.start, data65.length, out66); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_2166: rt.u8, data66: rt.ByteSlice, out67: rt.ByteVec): undefined => { - asSlices(data66, out67); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", widenings as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): undefined => { - uninhabited(data67, out68); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", lentKeys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", lentValues as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", singles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", singles_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", singles_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { - peekedOthers(data68, out69); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", hints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", folds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::zeros", zeros as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_2169: rt.u8, data69: rt.ByteSlice, out70: rt.ByteVec): undefined => { - maps(data69, out70); + asSlices(data66.data, data66.start, data66.length, out67); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", (a064: rt.u8, a164: rt.ByteSlice, a264: rt.ByteVec): undefined => { + widenings(a064, a164.data, a164.start, a164.length, a264); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): undefined => { + uninhabited(data67.data, data67.start, data67.length, out68); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", (a065: rt.u8, a165: rt.ByteSlice, a265: rt.ByteVec): undefined => { + lentKeys(a065, a165.data, a165.start, a165.length, a265); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", (a066: rt.u8, a166: rt.ByteSlice, a266: rt.ByteVec): undefined => { + lentValues(a066, a166.data, a166.start, a166.length, a266); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", (a067: rt.u8, a167: rt.ByteSlice, a267: rt.ByteVec): undefined => { + singles(a067, a167.data, a167.start, a167.length, a267); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", (a068: rt.u8, a168: rt.ByteSlice, a268: rt.ByteVec): undefined => { + singles_formats(a068, a168.data, a168.start, a168.length, a268); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", (a069: rt.u8, a169: rt.ByteSlice, a269: rt.ByteVec): undefined => { + singles_parses(a069, a169.data, a169.start, a169.length, a269); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { + peekedOthers(data68.data, data68.start, data68.length, out69); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", (a070: rt.u8, a170: rt.ByteSlice, a270: rt.ByteVec): undefined => { + hints(a070, a170.data, a170.start, a170.length, a270); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", (a071: rt.u8, a171: rt.ByteSlice, a271: rt.ByteVec): undefined => { + reserves(a071, a171.data, a171.start, a171.length, a271); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", (a072: rt.u8, a172: rt.ByteSlice, a272: rt.ByteVec): undefined => { + setOps(a072, a172.data, a172.start, a172.length, a272); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", (a073: rt.u8, a173: rt.ByteSlice, a273: rt.ByteVec): undefined => { + folds(a073, a173.data, a173.start, a173.length, a273); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::zeros", (a074: rt.u8, a174: rt.ByteSlice, a274: rt.ByteVec): undefined => { + zeros(a074, a174.data, a174.start, a174.length, a274); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_2169: rt.u8, data69: rt.ByteSlice, out70: rt.ByteVec): undefined => { + maps(data69.data, data69.start, data69.length, out70); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::lent", (_2170: rt.u8, data70: rt.ByteSlice, out71: rt.ByteVec): undefined => { - arrays_lent(data70, out71); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", floats_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", singles_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { - collections(data71, out72); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", zeros_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", zips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", zipsBack as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { - fmt_iters(data72, out73); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", unread as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", rangeFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", rangeMethods as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::iters", clones_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", compares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cycles::cycles", cycles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_2173: rt.u8, data73: rt.ByteSlice, out74: rt.ByteVec): undefined => { - lapsed(data73, out74); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", cows_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", cows_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u8s", wraps_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", wraps_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", wraps_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", wraps_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", wraps_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", wraps_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", wraps_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", wraps_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", wraps_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", wraps_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", wraps_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", wraps_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_2174: rt.u8, data74: rt.ByteSlice, out75: rt.ByteVec): undefined => { - enums(data74, out75); + arrays_lent(data70.data, data70.start, data70.length, out71); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", (a075: rt.u8, a175: rt.ByteSlice, a275: rt.ByteVec): undefined => { + floats_mulAdds(a075, a175.data, a175.start, a175.length, a275); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", (a076: rt.u8, a176: rt.ByteSlice, a276: rt.ByteVec): undefined => { + singles_mulAdds(a076, a176.data, a176.start, a176.length, a276); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { + collections(data71.data, data71.start, data71.length, out72); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", (a077: rt.u8, a177: rt.ByteSlice, a277: rt.ByteVec): undefined => { + unlikeEqs(a077, a177.data, a177.start, a177.length, a277); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", (a078: rt.u8, a178: rt.ByteSlice, a278: rt.ByteVec): undefined => { + impls(a078, a178.data, a178.start, a178.length, a278); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", (a079: rt.u8, a179: rt.ByteSlice, a279: rt.ByteVec): undefined => { + zeros_keys(a079, a179.data, a179.start, a179.length, a279); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", (a080: rt.u8, a180: rt.ByteSlice, a280: rt.ByteVec): undefined => { + arrays(a080, a180.data, a180.start, a180.length, a280); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", (a081: rt.u8, a181: rt.ByteSlice, a281: rt.ByteVec): undefined => { + zips(a081, a181.data, a181.start, a181.length, a281); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", (a082: rt.u8, a182: rt.ByteSlice, a282: rt.ByteVec): undefined => { + zipsBack(a082, a182.data, a182.start, a182.length, a282); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", (a083: rt.u8, a183: rt.ByteSlice, a283: rt.ByteVec): undefined => { + ownNes(a083, a183.data, a183.start, a183.length, a283); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { + fmt_iters(data72.data, data72.start, data72.length, out73); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", (a084: rt.u8, a184: rt.ByteSlice, a284: rt.ByteVec): undefined => { + unread(a084, a184.data, a184.start, a184.length, a284); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", (a085: rt.u8, a185: rt.ByteSlice, a285: rt.ByteVec): undefined => { + rangeFroms(a085, a185.data, a185.start, a185.length, a285); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", (a086: rt.u8, a186: rt.ByteSlice, a286: rt.ByteVec): undefined => { + rangeMethods(a086, a186.data, a186.start, a186.length, a286); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::iters", (a087: rt.u8, a187: rt.ByteSlice, a287: rt.ByteVec): undefined => { + clones_iters(a087, a187.data, a187.start, a187.length, a287); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", (a088: rt.u8, a188: rt.ByteSlice, a288: rt.ByteVec): undefined => { + cellEqs(a088, a188.data, a188.start, a188.length, a288); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", (a089: rt.u8, a189: rt.ByteSlice, a289: rt.ByteVec): undefined => { + compares(a089, a189.data, a189.start, a189.length, a289); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", (a090: rt.u8, a190: rt.ByteSlice, a290: rt.ByteVec): undefined => { + unlikeCompares(a090, a190.data, a190.start, a190.length, a290); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", (a091: rt.u8, a191: rt.ByteSlice, a291: rt.ByteVec): undefined => { + refOrders(a091, a191.data, a191.start, a191.length, a291); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cycles::cycles", (a092: rt.u8, a192: rt.ByteSlice, a292: rt.ByteVec): undefined => { + cycles(a092, a192.data, a192.start, a192.length, a292); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_2173: rt.u8, data73: rt.ByteSlice, out74: rt.ByteVec): undefined => { + lapsed(data73.data, data73.start, data73.length, out74); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", (a093: rt.u8, a193: rt.ByteSlice, a293: rt.ByteVec): undefined => { + cows_slices(a093, a193.data, a193.start, a193.length, a293); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", (a094: rt.u8, a194: rt.ByteSlice, a294: rt.ByteVec): undefined => { + cows_bytes(a094, a194.data, a194.start, a194.length, a294); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u8s", (a095: rt.u8, a195: rt.ByteSlice, a295: rt.ByteVec): undefined => { + wraps_u8s(a095, a195.data, a195.start, a195.length, a295); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", (a096: rt.u8, a196: rt.ByteSlice, a296: rt.ByteVec): undefined => { + wraps_u16s(a096, a196.data, a196.start, a196.length, a296); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", (a097: rt.u8, a197: rt.ByteSlice, a297: rt.ByteVec): undefined => { + wraps_u32s(a097, a197.data, a197.start, a197.length, a297); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", (a098: rt.u8, a198: rt.ByteSlice, a298: rt.ByteVec): undefined => { + wraps_u64s(a098, a198.data, a198.start, a198.length, a298); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", (a099: rt.u8, a199: rt.ByteSlice, a299: rt.ByteVec): undefined => { + wraps_u128s(a099, a199.data, a199.start, a199.length, a299); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", (a0100: rt.u8, a1100: rt.ByteSlice, a2100: rt.ByteVec): undefined => { + wraps_usizes(a0100, a1100.data, a1100.start, a1100.length, a2100); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", (a0101: rt.u8, a1101: rt.ByteSlice, a2101: rt.ByteVec): undefined => { + wraps_i8s(a0101, a1101.data, a1101.start, a1101.length, a2101); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", (a0102: rt.u8, a1102: rt.ByteSlice, a2102: rt.ByteVec): undefined => { + wraps_i16s(a0102, a1102.data, a1102.start, a1102.length, a2102); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", (a0103: rt.u8, a1103: rt.ByteSlice, a2103: rt.ByteVec): undefined => { + wraps_i32s(a0103, a1103.data, a1103.start, a1103.length, a2103); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", (a0104: rt.u8, a1104: rt.ByteSlice, a2104: rt.ByteVec): undefined => { + wraps_i64s(a0104, a1104.data, a1104.start, a1104.length, a2104); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", (a0105: rt.u8, a1105: rt.ByteSlice, a2105: rt.ByteVec): undefined => { + wraps_i128s(a0105, a1105.data, a1105.start, a1105.length, a2105); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", (a0106: rt.u8, a1106: rt.ByteSlice, a2106: rt.ByteVec): undefined => { + wraps_isizes(a0106, a1106.data, a1106.start, a1106.length, a2106); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_2174: rt.u8, data74: rt.ByteSlice, out75: rt.ByteVec): undefined => { + enums(data74.data, data74.start, data74.length, out75); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::segments", (_2175: rt.u8, data75: rt.ByteSlice, out76: rt.ByteVec): undefined => { - segments(data75, out76); + segments(data75.data, data75.start, data75.length, out76); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::uninit_runs", (_2176: rt.u8, data76: rt.ByteSlice, out77: rt.ByteVec): undefined => { - uninitRuns(data76, out77); + uninitRuns(data76.data, data76.start, data76.length, out77); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::beside_written", (_2177: rt.u8, data77: rt.ByteSlice, out78: rt.ByteVec): undefined => { - besideWritten(data77, out78); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", byteRefs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_2178: rt.u8, data78: rt.ByteSlice, out79: rt.ByteVec): undefined => { - orders_held(data78, out79); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", joins as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { - iteratedRuns(data79, out80); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", zeros_writes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { - orders_tuples(data80, out81); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", tuples_tuples as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", saturates_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", saturates_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", saturates_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", saturates_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", saturates_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", saturates_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", saturates_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", saturates_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", saturates_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", saturates_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", saturates_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", saturates_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", methods_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", methods_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", methods_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", methods_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", methods_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", methods_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", methods_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", methods_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", methods_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", methods_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", methods_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", methods_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", separated as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { - waiters(data81, out82); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::boxes", boxes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::bytes", ascii_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", ascii_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", ascii_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", given as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_2182: rt.u8, data82: rt.ByteSlice, out83: rt.ByteVec): undefined => { - pointers_taken(data82, out83); + besideWritten(data77.data, data77.start, data77.length, out78); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", (a0107: rt.u8, a1107: rt.ByteSlice, a2107: rt.ByteVec): undefined => { + byteRefs(a0107, a1107.data, a1107.start, a1107.length, a2107); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_2178: rt.u8, data78: rt.ByteSlice, out79: rt.ByteVec): undefined => { + orders_held(data78.data, data78.start, data78.length, out79); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", (a0108: rt.u8, a1108: rt.ByteSlice, a2108: rt.ByteVec): undefined => { + joins(a0108, a1108.data, a1108.start, a1108.length, a2108); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { + iteratedRuns(data79.data, data79.start, data79.length, out80); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", (a0109: rt.u8, a1109: rt.ByteSlice, a2109: rt.ByteVec): undefined => { + zeros_writes(a0109, a1109.data, a1109.start, a1109.length, a2109); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { + orders_tuples(data80.data, data80.start, data80.length, out81); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", (a0110: rt.u8, a1110: rt.ByteSlice, a2110: rt.ByteVec): undefined => { + tuples_tuples(a0110, a1110.data, a1110.start, a1110.length, a2110); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", (a0111: rt.u8, a1111: rt.ByteSlice, a2111: rt.ByteVec): undefined => { + saturates_u8s(a0111, a1111.data, a1111.start, a1111.length, a2111); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", (a0112: rt.u8, a1112: rt.ByteSlice, a2112: rt.ByteVec): undefined => { + saturates_u16s(a0112, a1112.data, a1112.start, a1112.length, a2112); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", (a0113: rt.u8, a1113: rt.ByteSlice, a2113: rt.ByteVec): undefined => { + saturates_u32s(a0113, a1113.data, a1113.start, a1113.length, a2113); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", (a0114: rt.u8, a1114: rt.ByteSlice, a2114: rt.ByteVec): undefined => { + saturates_u64s(a0114, a1114.data, a1114.start, a1114.length, a2114); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", (a0115: rt.u8, a1115: rt.ByteSlice, a2115: rt.ByteVec): undefined => { + saturates_u128s(a0115, a1115.data, a1115.start, a1115.length, a2115); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", (a0116: rt.u8, a1116: rt.ByteSlice, a2116: rt.ByteVec): undefined => { + saturates_usizes(a0116, a1116.data, a1116.start, a1116.length, a2116); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", (a0117: rt.u8, a1117: rt.ByteSlice, a2117: rt.ByteVec): undefined => { + saturates_i8s(a0117, a1117.data, a1117.start, a1117.length, a2117); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", (a0118: rt.u8, a1118: rt.ByteSlice, a2118: rt.ByteVec): undefined => { + saturates_i16s(a0118, a1118.data, a1118.start, a1118.length, a2118); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", (a0119: rt.u8, a1119: rt.ByteSlice, a2119: rt.ByteVec): undefined => { + saturates_i32s(a0119, a1119.data, a1119.start, a1119.length, a2119); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", (a0120: rt.u8, a1120: rt.ByteSlice, a2120: rt.ByteVec): undefined => { + saturates_i64s(a0120, a1120.data, a1120.start, a1120.length, a2120); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", (a0121: rt.u8, a1121: rt.ByteSlice, a2121: rt.ByteVec): undefined => { + saturates_i128s(a0121, a1121.data, a1121.start, a1121.length, a2121); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", (a0122: rt.u8, a1122: rt.ByteSlice, a2122: rt.ByteVec): undefined => { + saturates_isizes(a0122, a1122.data, a1122.start, a1122.length, a2122); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", (a0123: rt.u8, a1123: rt.ByteSlice, a2123: rt.ByteVec): undefined => { + methods_u8s(a0123, a1123.data, a1123.start, a1123.length, a2123); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", (a0124: rt.u8, a1124: rt.ByteSlice, a2124: rt.ByteVec): undefined => { + methods_u16s(a0124, a1124.data, a1124.start, a1124.length, a2124); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", (a0125: rt.u8, a1125: rt.ByteSlice, a2125: rt.ByteVec): undefined => { + methods_u32s(a0125, a1125.data, a1125.start, a1125.length, a2125); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", (a0126: rt.u8, a1126: rt.ByteSlice, a2126: rt.ByteVec): undefined => { + methods_u64s(a0126, a1126.data, a1126.start, a1126.length, a2126); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", (a0127: rt.u8, a1127: rt.ByteSlice, a2127: rt.ByteVec): undefined => { + methods_u128s(a0127, a1127.data, a1127.start, a1127.length, a2127); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", (a0128: rt.u8, a1128: rt.ByteSlice, a2128: rt.ByteVec): undefined => { + methods_usizes(a0128, a1128.data, a1128.start, a1128.length, a2128); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", (a0129: rt.u8, a1129: rt.ByteSlice, a2129: rt.ByteVec): undefined => { + methods_i8s(a0129, a1129.data, a1129.start, a1129.length, a2129); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", (a0130: rt.u8, a1130: rt.ByteSlice, a2130: rt.ByteVec): undefined => { + methods_i16s(a0130, a1130.data, a1130.start, a1130.length, a2130); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", (a0131: rt.u8, a1131: rt.ByteSlice, a2131: rt.ByteVec): undefined => { + methods_i32s(a0131, a1131.data, a1131.start, a1131.length, a2131); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", (a0132: rt.u8, a1132: rt.ByteSlice, a2132: rt.ByteVec): undefined => { + methods_i64s(a0132, a1132.data, a1132.start, a1132.length, a2132); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", (a0133: rt.u8, a1133: rt.ByteSlice, a2133: rt.ByteVec): undefined => { + methods_i128s(a0133, a1133.data, a1133.start, a1133.length, a2133); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", (a0134: rt.u8, a1134: rt.ByteSlice, a2134: rt.ByteVec): undefined => { + methods_isizes(a0134, a1134.data, a1134.start, a1134.length, a2134); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", (a0135: rt.u8, a1135: rt.ByteSlice, a2135: rt.ByteVec): undefined => { + separated(a0135, a1135.data, a1135.start, a1135.length, a2135); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { + waiters(data81.data, data81.start, data81.length, out82); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::boxes", (a0136: rt.u8, a1136: rt.ByteSlice, a2136: rt.ByteVec): undefined => { + boxes(a0136, a1136.data, a1136.start, a1136.length, a2136); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::bytes", (a0137: rt.u8, a1137: rt.ByteSlice, a2137: rt.ByteVec): undefined => { + ascii_bytes(a0137, a1137.data, a1137.start, a1137.length, a2137); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", (a0138: rt.u8, a1138: rt.ByteSlice, a2138: rt.ByteVec): undefined => { + ascii_chars(a0138, a1138.data, a1138.start, a1138.length, a2138); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", (a0139: rt.u8, a1139: rt.ByteSlice, a2139: rt.ByteVec): undefined => { + ascii_slices(a0139, a1139.data, a1139.start, a1139.length, a2139); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", (a0140: rt.u8, a1140: rt.ByteSlice, a2140: rt.ByteVec): undefined => { + given(a0140, a1140.data, a1140.start, a1140.length, a2140); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_2182: rt.u8, data82: rt.ByteSlice, out83: rt.ByteVec): undefined => { + pointers_taken(data82.data, data82.start, data82.length, out83); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::bytes", (_2183: rt.u8, data83: rt.ByteSlice, out84: rt.ByteVec): undefined => { - pointers_bytes(data83, out84); + pointers_bytes(data83.data, data83.start, data83.length, out84); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::loaded", (_2184: rt.u8, data84: rt.ByteSlice, out85: rt.ByteVec): undefined => { - loaded(data84, out85); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", btrees as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["lengths::lengths", lengths as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::option_items", (_2185: rt.u8, data85: rt.ByteSlice, out86: rt.ByteVec): undefined => { - optionItems(data85, out86); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["lists::lists", lists_lists as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::reattached", (_2186: rt.u8, data86: rt.ByteSlice, out87: rt.ByteVec): undefined => { - reattached(data86, out87); + loaded(data84.data, data84.start, data84.length, out85); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", (a0141: rt.u8, a1141: rt.ByteSlice, a2141: rt.ByteVec): undefined => { + btrees(a0141, a1141.data, a1141.start, a1141.length, a2141); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["lengths::lengths", (a0142: rt.u8, a1142: rt.ByteSlice, a2142: rt.ByteVec): undefined => { + lengths(a0142, a1142.data, a1142.start, a1142.length, a2142); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::option_items", (_2185: rt.u8, data85: rt.ByteSlice, out86: rt.ByteVec): undefined => { + optionItems(data85.data, data85.start, data85.length, out86); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["lists::lists", (a0143: rt.u8, a1143: rt.ByteSlice, a2143: rt.ByteVec): undefined => { + lists_lists(a0143, a1143.data, a1143.start, a1143.length, a2143); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::reattached", (_2186: rt.u8, data86: rt.ByteSlice, out87: rt.ByteVec): undefined => { + reattached(data86.data, data86.start, data86.length, out87); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", (a0144: rt.u8, a1144: rt.ByteSlice, a2144: rt.ByteVec): undefined => { + args(a0144, a1144.data, a1144.start, a1144.length, a2144); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", (a0145: rt.u8, a1145: rt.ByteSlice, a2145: rt.ByteVec): undefined => { + returns(a0145, a1145.data, a1145.start, a1145.length, a2145); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } @@ -264,20 +556,20 @@ export function op(name: string): rt.u8 { } /** Negate the signed type `kind` picks. */ -export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function neg(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - i8Neg(data, out); + i8Neg(dataData, dataStart, dataLen, out); } else if (_4 === 1) { - i16Neg(data, out); + i16Neg(dataData, dataStart, dataLen, out); } else if (_4 === 2) { - i32Neg(data, out); + i32Neg(dataData, dataStart, dataLen, out); } else if (_4 === 3) { - i64Neg(data, out); + i64Neg(dataData, dataStart, dataLen, out); } else if (_4 === 4) { - i128Neg(data, out); + i128Neg(dataData, dataStart, dataLen, out); } else { - isizeNeg(data, out); + isizeNeg(dataData, dataStart, dataLen, out); } } @@ -285,11 +577,11 @@ export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Cast from the type `kind` picks to the one the next byte does, or without one, to * a type `kind` also picks. */ -export function cast(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length === 0) { - ints_cast(kind, rt.u8Div(kind, 12), data, out); +export function cast(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen === 0) { + ints_cast(kind, rt.u8Div(kind, 12), dataData, dataStart, dataLen, out); } else { - ints_cast(kind, data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1), out); + ints_cast(kind, dataData[dataStart], dataData, dataStart + 1, dataLen - 1, out); } } diff --git a/ts/fixtures/lang/expected/lengths.ts b/ts/fixtures/lang/expected/lengths.ts index 83a3dd69f..23ee04ade 100644 --- a/ts/fixtures/lang/expected/lengths.ts +++ b/ts/fixtures/lang/expected/lengths.ts @@ -6,21 +6,21 @@ import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; import * as lengths_Tagged from "./lengths.Tagged.ts"; /** Each case at the length `kind` picks. */ -export function lengths(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lengths(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { - each$0(data, out); + each$0(dataData, dataStart, dataLen, out); } else if (_4 === 1) { - each$1(data, out); + each$1(dataData, dataStart, dataLen, out); } else if (_4 === 2) { - each$3(data, out); + each$3(dataData, dataStart, dataLen, out); } else { - each$17(data, out); + each$17(dataData, dataStart, dataLen, out); } } -export function each$0(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(0, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$0(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(0, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -30,29 +30,29 @@ export function each$0(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 0, true); - joined$0(data, rows.map(copy$array_u8), out); - joined$0(data, copy$array_array0_u8([rt.bytes(0).fill(165), rt.bytesFromFn(0, (i2: rt.usize): rt.u8 => { + joined$0(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); + joined$0(dataData, dataStart, dataLen, copy$array_array0_u8([rt.bytes(0).fill(165), rt.bytesFromFn(0, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$0(rows, out); recloned$u32_0(wide, out); - filledBytes$0(data, rt.bytesFromFn(0, (i3: rt.usize): rt.u8 => { + filledBytes$0(dataData, dataStart, dataLen, rt.bytesFromFn(0, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$0(data, rt.arrayFromFn(0, (i4: rt.usize): rt.u32 => { + filledWords$0(dataData, dataStart, dataLen, rt.arrayFromFn(0, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$0(data, rt.arrayFromFn(0, (i5: rt.usize): Uint8Array => { + filledRows$0(dataData, dataStart, dataLen, rt.arrayFromFn(0, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(0, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 0), j) & 0xff; }); }), out); - swapped$u8_0(data, rows, out); - swapped$u32_0(data, wide, out); + swapped$u8_0(dataData, dataStart, dataLen, rows, out); + swapped$u32_0(dataData, dataStart, dataLen, wide, out); } -export function each$1(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(1, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$1(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(1, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -62,29 +62,29 @@ export function each$1(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 4, true); - joined$1(data, rows.map(copy$array_u8), out); - joined$1(data, copy$array_array1_u8([rt.bytes(1).fill(165), rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { + joined$1(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); + joined$1(dataData, dataStart, dataLen, copy$array_array1_u8([rt.bytes(1).fill(165), rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$1(rows, out); recloned$u32_1(wide, out); - filledBytes$1(data, rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { + filledBytes$1(dataData, dataStart, dataLen, rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$1(data, rt.arrayFromFn(1, (i4: rt.usize): rt.u32 => { + filledWords$1(dataData, dataStart, dataLen, rt.arrayFromFn(1, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$1(data, rt.arrayFromFn(1, (i5: rt.usize): Uint8Array => { + filledRows$1(dataData, dataStart, dataLen, rt.arrayFromFn(1, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(1, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 1), j) & 0xff; }); }), out); - swapped$u8_1(data, rows, out); - swapped$u32_1(data, wide, out); + swapped$u8_1(dataData, dataStart, dataLen, rows, out); + swapped$u32_1(dataData, dataStart, dataLen, wide, out); } -export function each$17(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(17, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$17(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(17, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(17, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -94,29 +94,29 @@ export function each$17(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 68, true); - joined$17(data, rows.map(copy$array_u8), out); - joined$17(data, copy$array_array17_u8([rt.bytes(17).fill(165), rt.bytesFromFn(17, (i2: rt.usize): rt.u8 => { + joined$17(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); + joined$17(dataData, dataStart, dataLen, copy$array_array17_u8([rt.bytes(17).fill(165), rt.bytesFromFn(17, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$17(rows, out); recloned$u32_17(wide, out); - filledBytes$17(data, rt.bytesFromFn(17, (i3: rt.usize): rt.u8 => { + filledBytes$17(dataData, dataStart, dataLen, rt.bytesFromFn(17, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$17(data, rt.arrayFromFn(17, (i4: rt.usize): rt.u32 => { + filledWords$17(dataData, dataStart, dataLen, rt.arrayFromFn(17, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$17(data, rt.arrayFromFn(17, (i5: rt.usize): Uint8Array => { + filledRows$17(dataData, dataStart, dataLen, rt.arrayFromFn(17, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(17, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 17), j) & 0xff; }); }), out); - swapped$u8_17(data, rows, out); - swapped$u32_17(data, wide, out); + swapped$u8_17(dataData, dataStart, dataLen, rows, out); + swapped$u32_17(dataData, dataStart, dataLen, wide, out); } -export function each$3(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(3, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$3(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(3, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -126,45 +126,45 @@ export function each$3(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 12, true); - joined$3(data, rows.map(copy$array_u8), out); - joined$3(data, copy$array_array3_u8([rt.bytes(3).fill(165), rt.bytesFromFn(3, (i2: rt.usize): rt.u8 => { + joined$3(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); + joined$3(dataData, dataStart, dataLen, copy$array_array3_u8([rt.bytes(3).fill(165), rt.bytesFromFn(3, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$3(rows, out); recloned$u32_3(wide, out); - filledBytes$3(data, rt.bytesFromFn(3, (i3: rt.usize): rt.u8 => { + filledBytes$3(dataData, dataStart, dataLen, rt.bytesFromFn(3, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$3(data, rt.arrayFromFn(3, (i4: rt.usize): rt.u32 => { + filledWords$3(dataData, dataStart, dataLen, rt.arrayFromFn(3, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$3(data, rt.arrayFromFn(3, (i5: rt.usize): Uint8Array => { + filledRows$3(dataData, dataStart, dataLen, rt.arrayFromFn(3, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(3, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 3), j) & 0xff; }); }), out); - swapped$u8_3(data, rows, out); - swapped$u32_3(data, wide, out); + swapped$u8_3(dataData, dataStart, dataLen, rows, out); + swapped$u32_3(dataData, dataStart, dataLen, wide, out); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0)), undefined, true); +export function joined$0(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 1)), undefined, true); +export function joined$1(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 1)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 17)), undefined, true); +export function joined$17(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 17)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 3)), undefined, true); +export function joined$3(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 3)), undefined, true); } /** @@ -395,7 +395,7 @@ export function recloned$u32_3(rows: rt.u32[][], out: rt.ByteVec): void { } } -export function filledBytes$0(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$0(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(0), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_u8_tuple2_u8_u8(item); @@ -411,7 +411,7 @@ export function filledBytes$0(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byte rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -432,7 +432,7 @@ export function filledBytes$0(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byte } } -export function filledBytes$1(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$1(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(1), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_u8_tuple2_u8_u8(item); @@ -448,7 +448,7 @@ export function filledBytes$1(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byte rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -469,7 +469,7 @@ export function filledBytes$1(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byte } } -export function filledBytes$17(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$17(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(17), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_u8_tuple2_u8_u8(item); @@ -485,7 +485,7 @@ export function filledBytes$17(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byt rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -506,7 +506,7 @@ export function filledBytes$17(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byt } } -export function filledBytes$3(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$3(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(3), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8(item); @@ -522,7 +522,7 @@ export function filledBytes$3(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byte rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -543,7 +543,7 @@ export function filledBytes$3(data: rt.ByteSlice, fill: Uint8Array, out: rt.Byte } } -export function filledWords$0(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$0(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(0), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_u32_tuple2_u8_u8(item); @@ -559,7 +559,7 @@ export function filledWords$0(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -580,7 +580,7 @@ export function filledWords$0(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe } } -export function filledWords$1(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$1(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(1), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_u32_tuple2_u8_u8(item); @@ -596,7 +596,7 @@ export function filledWords$1(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -617,7 +617,7 @@ export function filledWords$1(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe } } -export function filledWords$17(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$17(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(17), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_u32_tuple2_u8_u8(item); @@ -633,7 +633,7 @@ export function filledWords$17(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteV rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -654,7 +654,7 @@ export function filledWords$17(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteV } } -export function filledWords$3(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$3(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(3), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u32_tuple2_u8_u8(item); @@ -670,7 +670,7 @@ export function filledWords$3(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -691,7 +691,7 @@ export function filledWords$3(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe } } -export function filledRows$0(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$0(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 0 }, (): Uint8Array => { return (new Uint8Array(0) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -709,7 +709,7 @@ export function filledRows$0(data: rt.ByteSlice, fill: Uint8Array[], out: rt.Byt rt.ptrWrite(uninit, [copy$array_array0_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -724,13 +724,13 @@ export function filledRows$0(data: rt.ByteSlice, fill: Uint8Array[], out: rt.Byt for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array0_u8(v, out); + put$lengths_Put_array0_u8(v.data, v.start, v.length, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } } -export function filledRows$1(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$1(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 1 }, (): Uint8Array => { return (new Uint8Array(1) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -748,7 +748,7 @@ export function filledRows$1(data: rt.ByteSlice, fill: Uint8Array[], out: rt.Byt rt.ptrWrite(uninit, [copy$array_array1_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -763,13 +763,13 @@ export function filledRows$1(data: rt.ByteSlice, fill: Uint8Array[], out: rt.Byt for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array1_u8(v, out); + put$lengths_Put_array1_u8(v.data, v.start, v.length, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } } -export function filledRows$17(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$17(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 17 }, (): Uint8Array => { return (new Uint8Array(17) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -787,7 +787,7 @@ export function filledRows$17(data: rt.ByteSlice, fill: Uint8Array[], out: rt.By rt.ptrWrite(uninit, [copy$array_array17_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -802,13 +802,13 @@ export function filledRows$17(data: rt.ByteSlice, fill: Uint8Array[], out: rt.By for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array17_u8(v, out); + put$lengths_Put_array17_u8(v.data, v.start, v.length, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } } -export function filledRows$3(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$3(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 3 }, (): Uint8Array => { return (new Uint8Array(3) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -826,7 +826,7 @@ export function filledRows$3(data: rt.ByteSlice, fill: Uint8Array[], out: rt.Byt rt.ptrWrite(uninit, [copy$array_array3_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(data)) { + for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -841,7 +841,7 @@ export function filledRows$3(data: rt.ByteSlice, fill: Uint8Array[], out: rt.Byt for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array3_u8(v, out); + put$lengths_Put_array3_u8(v.data, v.start, v.length, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } @@ -855,27 +855,27 @@ export function put$lengths_Put_u32(self: rt.u32, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(self).reverse()), undefined, true); } -export function put$lengths_Put_array0_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array0_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); } -export function put$lengths_Put_array17_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array17_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); } -export function put$lengths_Put_array1_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array1_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); } -export function put$lengths_Put_array3_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array3_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); } /** * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_0(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -888,7 +888,7 @@ export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -926,7 +926,7 @@ export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_1(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -939,7 +939,7 @@ export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -977,7 +977,7 @@ export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_17(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -990,7 +990,7 @@ export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byt const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1028,7 +1028,7 @@ export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byt * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_3(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -1041,7 +1041,7 @@ export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1079,7 +1079,7 @@ export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_0(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1094,7 +1094,7 @@ export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1132,7 +1132,7 @@ export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_1(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1147,7 +1147,7 @@ export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1185,7 +1185,7 @@ export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_17(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1200,7 +1200,7 @@ export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.By const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1238,7 +1238,7 @@ export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.By * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_3(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1253,7 +1253,7 @@ export function swapped$u8_3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; diff --git a/ts/fixtures/lang/expected/lists.ts b/ts/fixtures/lang/expected/lists.ts index c553e8c4b..59a8e6b4e 100644 --- a/ts/fixtures/lang/expected/lists.ts +++ b/ts/fixtures/lang/expected/lists.ts @@ -27,13 +27,13 @@ export function items(l: rt.LinkedList, out: rt.ByteVec): void { * bytes, then how they compare, hash, iterate, and print. `kind` picks whether a split * past the end ends it, which panics. */ -export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lists(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _93!: rt.i32; let x2!: rt.u8 | undefined; let x3!: rt.Place | undefined; let l: rt.LinkedList = rt.listNew() as rt.LinkedList; let m: rt.LinkedList = rt.listNew() as rt.LinkedList; - l1: for (const b of rt.byteSliceView(data)) { + l1: for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _13: rt.u8 = rt.u8Rem(b, 13); if (_13 === 0) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.listPopFront(l), 238)); @@ -150,9 +150,9 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterRev(it3), undefined, true); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.listIter(l)), 231)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.listIter(l), rt.usizeRem(kind as rt.usize, 4)), 230)); - edges(data, out); + edges(dataData, dataStart, dataLen, out); printed(l, m, out); - tallies(data, out); + tallies(dataData, dataStart, dataLen, out); if (rt.u8Rem(kind, 4) === 0) { rt.iterExtendBytes(out, rt.listIter(rt.listSplitOff(m, rt.usizeAdd(rt.usizeAdd(m.n, 1), rt.u8Rem(rt.u8Div(kind, 4), 2) as rt.usize))), undefined, true); } @@ -162,7 +162,8 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `split_off` and `append` at 0, either side of the middle, and the end, and the list * `collect`, `From`, and `extend` make, empty ones included. */ -export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { +export function edges(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _4: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const whole: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _4); const len: rt.usize = whole.n; @@ -247,8 +248,8 @@ export function printed(l: rt.LinkedList, m: rt.LinkedList, out: r } /** A list of `Tally`s, which JS changes in place rather than through places. */ -export function tallies(data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): lists_Tally.Tally => { +export function tallies(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _4: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): lists_Tally.Tally => { return { n: _2 as rt.u16 }; }); const l: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _4); diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index 891d89b49..5f7224ba5 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -1317,14 +1317,14 @@ export function nextRead$pointers_Loaded(items: rt.Iter): Loaded. * read, as zlib's stream takes its window each round, by a callee over a type parameter: * one into an array and one into a struct. */ -export function reattached(data: rt.ByteSlice, out: rt.ByteVec): void { +export function reattached(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const window: pointers_Window.Window = { at: rt.NULL }; let buf: rt.u16[] = Array.from({ length: 4 }, (): rt.u16 => { return 0; }); const slot: pointers_Slot.Slot = { at: rt.NULL }; let pair: Reattached.Reattached = { _0: 0, _1: 0 }; - for (const n of rt.byteSliceView(data)) { + for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { const _17: rt.u16[] = buf; attach$array4_u16(rt.place(() => window.at, (value) => window.at = value), _17); const _18: rt.u16 = (((n as rt.u16)) << 7) & 0xffff; diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 64f43b535..03b01445b 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -196,7 +196,7 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { rustc_hir::def::DefKind::Fn | rustc_hir::def::DefKind::AssocFn ) || self.census || self.roots.contains(&instance) - || !self.lowers(instance) + || !self.lowers(self.typing_env(), instance) || tcx.asyncness(did).is_async() || crate::lower::iter::is_next(tcx, did); (!outside).then_some(did) From 6c614fb71e6c2bd145611925ad30f26597608a0e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:38:47 -0700 Subject: [PATCH 25/26] perf(ts): take a byte slice whole where the callee would make it anyway A parameter passed as its parts that the body makes into an object, at entry or at a use, only moves that object from the caller into the callee. Through `take_u64` that made Chrome's `btree/` workloads 1.06x `main`'s time. `parted` now runs the callee's own analysis and keeps a slice as parts only where the body holds it so and never makes it. A body's answer depends on what its callees take, so the instances a call reaches settle together as a greatest fixpoint, recursion included. Co-Authored-By: Claude Opus 5.5 --- ts/MIGRATE.md | 7 +- ts/README.md | 11 +- ts/fixtures/bind/expected/core/option.ts | 4 +- ts/fixtures/bind/expected/harness.ts | 9 +- ts/fixtures/codec/expected/bench.ts | 120 +++-- .../codec/expected/coding/decode.Decoder.ts | 6 +- .../codec/expected/coding/encode.Encoder.ts | 13 +- .../codec/expected/coding/version.Versions.ts | 6 +- ts/fixtures/codec/expected/harness.ts | 53 +-- .../codec/expected/lite/group.Group.ts | 6 +- .../codec/expected/lite/probe.Probe.ts | 6 +- ts/fixtures/lang/brands.ts | 4 +- ts/fixtures/lang/expected/args.Scale.ts | 4 +- ts/fixtures/lang/expected/args.ts | 172 ++++--- ts/fixtures/lang/expected/arrays.ts | 138 +++--- ts/fixtures/lang/expected/ascii.ts | 15 +- ts/fixtures/lang/expected/atomics.ts | 90 ++-- ts/fixtures/lang/expected/borrows.ts | 4 +- ts/fixtures/lang/expected/bounds.ts | 35 +- ts/fixtures/lang/expected/boxes.ts | 93 ++-- ts/fixtures/lang/expected/captures.ts | 62 ++- ts/fixtures/lang/expected/cells.ts | 4 +- ts/fixtures/lang/expected/chars.ts | 14 +- ts/fixtures/lang/expected/chunks.ts | 75 ++-- ts/fixtures/lang/expected/clones.ts | 13 +- ts/fixtures/lang/expected/collections.ts | 121 ++--- ts/fixtures/lang/expected/combinators.ts | 3 +- ts/fixtures/lang/expected/core/num.ts | 420 +++++++++--------- ts/fixtures/lang/expected/core/num/nonzero.ts | 158 +++---- ts/fixtures/lang/expected/core/option.ts | 43 +- ts/fixtures/lang/expected/core/str.ts | 100 ++--- ts/fixtures/lang/expected/counts.ts | 33 +- ts/fixtures/lang/expected/cows.ts | 45 +- ts/fixtures/lang/expected/cycles.ts | 134 +++--- ts/fixtures/lang/expected/defaults.ts | 4 +- ts/fixtures/lang/expected/durations.ts | 23 +- ts/fixtures/lang/expected/dyns.ts | 16 +- ts/fixtures/lang/expected/edits.ts | 36 +- ts/fixtures/lang/expected/errors.ts | 23 +- ts/fixtures/lang/expected/floats.ts | 45 +- ts/fixtures/lang/expected/fmt.ts | 105 ++--- ts/fixtures/lang/expected/folds.ts | 5 +- ts/fixtures/lang/expected/generics.ts | 3 +- ts/fixtures/lang/expected/harness.ts | 28 +- ts/fixtures/lang/expected/hashes.ts | 43 +- ts/fixtures/lang/expected/hints.ts | 53 +-- ts/fixtures/lang/expected/holds.ts | 50 +-- ts/fixtures/lang/expected/ints.ts | 355 +++++++-------- ts/fixtures/lang/expected/iters.ts | 340 +++++++------- ts/fixtures/lang/expected/joins.ts | 14 +- ts/fixtures/lang/expected/keys.ts | 139 +++--- ts/fixtures/lang/expected/lengths.ts | 202 ++++----- ts/fixtures/lang/expected/lists.ts | 15 +- ts/fixtures/lang/expected/locals.ts | 4 +- ts/fixtures/lang/expected/locks.ts | 14 +- ts/fixtures/lang/expected/methods.ts | 60 +-- ts/fixtures/lang/expected/nested.ts | 71 ++- ts/fixtures/lang/expected/objects.ts | 3 +- ts/fixtures/lang/expected/orders.ts | 31 +- ts/fixtures/lang/expected/pointers.ts | 91 ++-- ts/fixtures/lang/expected/refs.ts | 103 ++--- ts/fixtures/lang/expected/returns.ts | 35 +- ts/fixtures/lang/expected/saturates.ts | 60 +-- ts/fixtures/lang/expected/separated.ts | 161 ++----- ts/fixtures/lang/expected/shapes.ts | 255 +++++------ ts/fixtures/lang/expected/singles.ts | 47 +- ts/fixtures/lang/expected/slices.ts | 399 ++++++----------- ts/fixtures/lang/expected/splits.ts | 123 +++-- ts/fixtures/lang/expected/statics.ts | 12 +- ts/fixtures/lang/expected/strs.ts | 139 +++--- ts/fixtures/lang/expected/tuples.ts | 56 +-- ts/fixtures/lang/expected/utf8.ts | 6 +- ts/fixtures/lang/expected/wrappers.ts | 3 +- ts/fixtures/lang/expected/wraps.ts | 36 +- ts/fixtures/lang/expected/zeros.ts | 25 +- ts/fixtures/lang/src/args.rs | 76 +++- ts/fixtures/stock/expected/buf.ts | 58 ++- .../stock/expected/bytes/buf/buf_mut.ts | 14 +- ts/fixtures/stock/expected/harness.ts | 12 +- ts/src/lower/mir/mod.rs | 3 + ts/src/lower/mir/scalar.rs | 114 ++++- ts/src/lower/mod.rs | 6 + ts/tests/fixtures.rs | 4 +- 83 files changed, 2627 insertions(+), 2914 deletions(-) diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index e2936b60a..f32e271fd 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,9 +2,10 @@ ## Unreleased -- A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter as - its `data`, `start`, and `length`: `read(buf, form)` is - `read(buf.data, buf.start, buf.length, form)`. One that returns a `Result` of byte slices +- A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter + whose object its body never makes as its `data`, `start`, and `length`: + `read(buf, form)` is `read(buf.data, buf.start, buf.length, form)`. A caller takes + which from the output. One that returns a `Result` of byte slices and scalars returns its error or `undefined`, and leaves the `Ok`'s parts in a module-level slot, such as `sliceOut`. If the `Ok`'s first part is a number, it returns that, or `undefined` for an error, and leaves the rest, or the error as `err`, in the diff --git a/ts/README.md b/ts/README.md index a9c0585a6..a540f8d05 100644 --- a/ts/README.md +++ b/ts/README.md @@ -680,9 +680,14 @@ they need. for the `Result`s below ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). - A function only translated code calls takes each `&[u8]` or `&[u8; N]` parameter as three, its `data`, `start`, and `length`, which its body holds as that local's parts: - not a root, which the outside calls, a closure, or an `async fn`. One the body borrows, - or would make whole twice on a path or in a loop, is made on entry, and the function as - a value is an arrow that takes the slice whole. `just ts bench` measured it + not a root, which the outside calls, a closure, or an `async fn`. One whose object the + body would make anyway, to borrow it, to pass it to a function taking it whole, or at + all, it takes whole: as parts, the callee would just make the object instead of the caller. + That made Chrome's `btree/` workloads 1.06x `main`'s time through a helper that + rebuilt the slice it was passed. What a body makes depends on what its callees take, so + the functions a call reaches settle together, recursion included, each dropping the + slices it would make until none does. The function as a value is an arrow that takes + the slice whole. `just ts bench` measured parts no faster than passing the slice whole, since V8 already removes what an inlined call doesn't keep: Chrome's varint decode at 0.98-0.99 times the time and frame decode at 1.01-1.05 over two runs, with the A/A route within 0.05, Firefox and Bun within their diff --git a/ts/fixtures/bind/expected/core/option.ts b/ts/fixtures/bind/expected/core/option.ts index 892fad36c..261f6df81 100644 --- a/ts/fixtures/bind/expected/core/option.ts +++ b/ts/fixtures/bind/expected/core/option.ts @@ -3,9 +3,9 @@ import * as rt from "../rt.ts"; import type * as Nibble from "../bind/nibble.ts"; -export function unwrapOr$1a4gm66(self: rt.ByteSlice | undefined, defaultData: Uint8Array, defaultStart: number, defaultLen: number): rt.ByteSlice { +export function unwrapOr$1rbuegs(self: rt.ByteSlice | undefined, default_: rt.ByteSlice): rt.ByteSlice { if (self === undefined) { - return new rt.ByteSlice(defaultData, defaultStart, defaultLen); + return default_; } return self; } diff --git a/ts/fixtures/bind/expected/harness.ts b/ts/fixtures/bind/expected/harness.ts index 961015c9d..fa1a90457 100644 --- a/ts/fixtures/bind/expected/harness.ts +++ b/ts/fixtures/bind/expected/harness.ts @@ -6,7 +6,7 @@ import * as checksum from "./bind/checksum.ts"; import * as Nibble from "./bind/nibble.ts"; import * as skip from "./bind/skip.ts"; import * as Tally from "./bind/tally.ts"; -import { unwrapOr$1a4gm66 as option_unwrapOr$1a4gm66, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$174crag as option_mapOr$174crag } from "./core/option.ts"; +import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$174crag as option_mapOr$174crag } from "./core/option.ts"; /** * Split the input as `Blob`, compare and hash the parts, skip its leading zeros, and @@ -67,7 +67,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { rt.drop(held); } rt.byteVecPush(out, count.strong & 0xff); - keys(input.data, input.start, input.length, bytes, out); + keys(input, bytes, out); const _0: rt.ByteVec = out; if (_128) { rt.drop(held); @@ -81,10 +81,9 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * Collections keyed by `Blob`s, equal by their bytes wherever they are sliced from, and by * `Nibble`s, equal by their low bits: what each finds, keeps, and orders. */ -export function keys(inputData: Uint8Array, inputStart: number, inputLen: number, bytes: Blob.Blob, out: rt.ByteVec): void { +export function keys(input: rt.ByteSlice, bytes: Blob.Blob, out: rt.ByteVec): void { let _12!: rt.usize; let _143!: rt.u8; - const input: rt.ByteSlice = new rt.ByteSlice(inputData, inputStart, inputLen); const seen: rt.HashSet = rt.hashNew(rt.hashing(Blob.hash$Hash as (a0: Blob.Blob, a1: rt.Hasher) => undefined, Blob.eq$cmp_PartialEq, true)) as rt.HashSet; const counts: rt.HashMap = rt.hashNew(rt.hashing(Blob.hash$Hash as (a0: Blob.Blob, a1: rt.Hasher) => undefined, Blob.eq$cmp_PartialEq, true)) as rt.HashMap; const sorted: rt.BTreeSet = rt.btreeNew(Blob.cmp$cmp_Ord) as rt.BTreeSet; @@ -106,7 +105,7 @@ export function keys(inputData: Uint8Array, inputStart: number, inputLen: number } rt.byteVecPush(out, rt.hashLen(seen) & 0xff); rt.byteVecPush(out, rt.hashLen(counts) & 0xff); - const probe: Blob.Blob = Blob.copyFromSlice(option_unwrapOr$1a4gm66(rt.byteSliceGetRange(input, 0, 2), input.data, input.start, input.length)); + const probe: Blob.Blob = Blob.copyFromSlice(option_unwrapOr$1rbuegs(rt.byteSliceGetRange(input, 0, 2), input)); rt.byteVecPush(out, rt.hashContains(seen, probe) ? 1 : 0); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(counts, probe), 0)); rt.byteVecPush(out, rt.btreeContains(sorted, probe) ? 1 : 0); diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 42631c5e7..e77639d01 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -22,31 +22,31 @@ export function run(input: rt.ByteSlice): rt.ByteVec { if (input.length - 1 !== 0) { const selector: rt.u8 = input.data[input.start + 1]; if (op === 0) { - encoded(encodeVarints(input.data, input.start + 2, input.length - 2, 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(input.data, input.start + 2, input.length - 2, 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(input.data, input.start + 2, input.length - 2, 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(input.data, input.start + 2, input.length - 2, 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(input.data, input.start + 2, input.length - 2, 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, input.data, input.start + 2, input.length - 2, out); + iterate(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 7) { - decoded(decodeSplit(input.data, input.start + 2, input.length - 2, 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(input.data, input.start + 2, input.length - 2, out); + ordered(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 9) { - rescale(selector, input.data, input.start + 2, input.length - 2, out); + rescale(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 10) { - stamp(input.data, input.start + 2, input.length - 2, out); + stamp(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 11) { - interleave(input.data, input.start + 2, input.length - 2, out); + interleave(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 12) { - order(selector, input.data, input.start + 2, input.length - 2, out); + order(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - decoded(decodeGroup(input.data, input.start + 2, input.length - 2, liteVersion(selector), out), out); + decoded(decodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } return out; } @@ -68,10 +68,10 @@ export function decoded(result: rt.Result, o } /** The same value, `count` times. */ -export function encodeVarints(dataData: Uint8Array, dataStart: number, dataLen: number, form: Form.Form, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); +export function encodeVarints(data: rt.ByteSlice, form: Form.Form, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _6[0]; - const value: rt.u64 = takeU64(_6[1].data, _6[1].start, _6[1].length)[0]; + const value: rt.u64 = takeU64(_6[1])[0]; const w: Encoder.Encoder = Encoder.new(out, form); let iterStart: rt.usize = 0; const iterEnd: rt.usize = rt.u64Low(count); @@ -85,8 +85,8 @@ export function encodeVarints(dataData: Uint8Array, dataStart: number, dataLen: } /** Every varint on the wire: how many, and the last. */ -export function decodeVarints(wireData: Uint8Array, wireStart: number, wireLen: number, form: Form.Form, out: rt.ByteVec): rt.Result { - const r: Decoder.Decoder = Decoder.new(wireData, wireStart, wireLen, form); +export function decodeVarints(wire: rt.ByteSlice, form: Form.Form, out: rt.ByteVec): rt.Result { + const r: Decoder.Decoder = Decoder.new(wire, form); let count: rt.usize = 0; let last: rt.u64 = 0; while (!Decoder.isEmpty(r)) { @@ -108,20 +108,20 @@ export function decodeVarints(wireData: Uint8Array, wireStart: number, wireLen: * zigzag timestamp delta, then the size. The first frame has no delta and its own size, * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ -export function encodeFrames(dataData: Uint8Array, dataStart: number, dataLen: number, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { +export function encodeFrames(data: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { let _32!: rt.usize; let _38!: [rt.i64, rt.u64]; - const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _6[0]; - const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1].data, _6[1].start, _6[1].length); + const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); const delta: rt.u64 = _9[0]; - const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1].data, _9[1].start, _9[1].length); + const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); const first: rt.u64 = _12[0]; - const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1].data, _12[1].start, _12[1].length); + const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); const size: rt.u64 = _15[0]; - const _18: [rt.u64, rt.ByteSlice] = takeU64(_15[1].data, _15[1].start, _15[1].length); + const _18: [rt.u64, rt.ByteSlice] = takeU64(_15[1]); const keyEvery: rt.u64 = _18[0]; - const keySize: rt.u64 = takeU64(_18[1].data, _18[1].start, _18[1].length)[0]; + const keySize: rt.u64 = takeU64(_18[1])[0]; const _24: rt.i64 = rt.i64Cast(delta); const _23: [rt.i64, rt.usize] = [_24, rt.u64Low(keyEvery)]; const delta2: rt.i64 = _24; @@ -161,8 +161,8 @@ export function encodeFrames(dataData: Uint8Array, dataStart: number, dataLen: n } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ -export function decodeFrames(wireData: Uint8Array, wireStart: number, wireLen: number, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const r: Decoder.Decoder = Decoder.new(wireData, wireStart, wireLen, Form.from$convert_From_lite_version_Version(version)); +export function decodeFrames(wire: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { + const r: Decoder.Decoder = Decoder.new(wire, Form.from$convert_From_lite_version_Version(version)); let count: rt.usize = 0; let total: rt.u64 = 0; let last: rt.i64 = 0; @@ -194,8 +194,8 @@ export function decodeFrames(wireData: Uint8Array, wireStart: number, wireLen: n * decoded again from its start on the next. How many, their total size, the last delta, * and how many decodes came up short. */ -export function decodeSplit(dataData: Uint8Array, dataStart: number, dataLen: number, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); +export function decodeSplit(data: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const read2: rt.usize = rt.max(rt.u64Low(_6[0]), 1); let start: rt.usize = 0; let end: rt.usize = 0; @@ -209,8 +209,7 @@ export function decodeSplit(dataData: Uint8Array, dataStart: number, dataLen: nu if (!(start < end)) { continue l2; } - const _27: rt.ByteSlice = rt.byteSliceRange(_6[1], start, end); - const r: Decoder.Decoder = Decoder.new(_27.data, _27.start, _27.length, Form.from$convert_From_lite_version_Version(version)); + const r: Decoder.Decoder = Decoder.new(rt.byteSliceRange(_6[1], start, end), Form.from$convert_From_lite_version_Version(version)); const _32: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError> = frameHeader(r); if (_32.ok) { const delta: rt.i64 = _32.value[0]; @@ -253,9 +252,9 @@ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], Dec } /** One size-prefixed GROUP header, starting at the first frame. */ -export function encodeGroup(dataData: Uint8Array, dataStart: number, dataLen: number, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); - const group: Group.Group = { subscribe: _6[0], sequence: takeU64(_6[1].data, _6[1].start, _6[1].length)[0], frameStart: 0 }; +export function encodeGroup(data: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); + const group: Group.Group = { subscribe: _6[0], sequence: takeU64(_6[1])[0], frameStart: 0 }; return Group.encode$coding_encode_Encode_lite_version_Version(group, Encoder.new(out, Form.from$convert_From_lite_version_Version(version)), version); } @@ -264,14 +263,14 @@ export function encodeGroup(dataData: Uint8Array, dataStart: number, dataLen: nu * up, summed over a quarter of the key space, and removed again. The sum of the values * found. */ -export function ordered(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { let _15!: rt.u32; let _28!: rt.u32; let _66!: rt.u32; const _10: (a0: rt.u32) => rt.u32 = (i4: rt.u32): rt.u32 => { return rt.u32Rem(rt.u32Mul(i4, 40503), 1 << 16); }; - const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(dataData, dataStart, dataLen)[0], 65536)); + const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; let iterStart: rt.u32 = 0; const iterEnd: rt.u32 = count2; @@ -311,8 +310,8 @@ export function ordered(dataData: Uint8Array, dataStart: number, dataLen: number * `selector` picks, each by `u32`'s own `Ord`: the first, middle, and last of the order, * the greatest and least, or the first key, the length, and the last key or its value. */ -export function order(selector: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let v: rt.u32[] = rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u64Low(rt.u64Clamp(takeU64(dataData, dataStart, dataLen)[0], 1, 65536))), (i: rt.u32): rt.u32 => { +export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v: rt.u32[] = rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u64Low(rt.u64Clamp(takeU64(data)[0], 1, 65536))), (i: rt.u32): rt.u32 => { return rt.u32Rem(rt.u32Mul(i, 40503), 1 << 16); }), undefined, 4, true); if (selector === 0) { @@ -377,8 +376,7 @@ export function order(selector: rt.u8, dataData: Uint8Array, dataStart: number, * One iterator chain over every byte, picked by `chain`, with closures that cost little * next to the iterator protocol they run through. */ -export function iterate(chain: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (chain === 0) { putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u8 => { return _214 >> 1; @@ -431,18 +429,18 @@ export function iterate(chain: rt.u8, dataData: Uint8Array, dataStart: number, d * `Timestamp::convert` in `u128`, or the same in `u64` (selector 1), which overflows * sooner. How many converted, how many overflowed, and the last converted. */ -export function rescale(selector: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function rescale(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _26!: rt.usize; let scaled!: rt.u64 | undefined; - const _6: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _6[0]; - const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1].data, _6[1].start, _6[1].length); + const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); const start: rt.u64 = _9[0]; - const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1].data, _9[1].start, _9[1].length); + const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); const step: rt.u64 = _12[0]; - const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1].data, _12[1].start, _12[1].length); + const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); const from: rt.u64 = _15[0]; - const to: rt.u64 = takeU64(_15[1].data, _15[1].start, _15[1].length)[0]; + const to: rt.u64 = takeU64(_15[1])[0]; let converted: rt.u64 = 0; let overflowed: rt.u64 = 0; let last: rt.u64 = 0; @@ -495,14 +493,14 @@ export function bounded(value: rt.u128): rt.u64 | undefined { * A track's frames stamped one duration apart by [`Timestamp::checked_add`], as a * publisher stamps them. How many were stamped, how many overflowed, and the last. */ -export function stamp(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _5: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); +export function stamp(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _5[0]; - const _8: [rt.u64, rt.ByteSlice] = takeU64(_5[1].data, _5[1].start, _5[1].length); + const _8: [rt.u64, rt.ByteSlice] = takeU64(_5[1]); const start: rt.u64 = _8[0]; - const _11: [rt.u64, rt.ByteSlice] = takeU64(_8[1].data, _8[1].start, _8[1].length); + const _11: [rt.u64, rt.ByteSlice] = takeU64(_8[1]); const step: rt.u64 = _11[0]; - const scale: rt.u64 = takeU64(_11[1].data, _11[1].start, _11[1].length)[0]; + const scale: rt.u64 = takeU64(_11[1])[0]; let time: Timestamp.Timestamp = { value: start, scale }; let stamped: rt.u64 = 0; let overflowed: rt.u64 = 0; @@ -531,13 +529,13 @@ export function stamp(dataData: Uint8Array, dataStart: number, dataLen: number, * comparison per frame taken. How many came from each track, and how many times the * interleave switched tracks. */ -export function interleave(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _5: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); +export function interleave(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _5[0]; - const _9: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_5[1].data, _5[1].start, _5[1].length); + const _9: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_5[1]); const a: Timestamp.Timestamp = copy$bench_Timestamp(_9[0]); const aStep: rt.u64 = _9[1]; - const _12: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_9[2].data, _9[2].start, _9[2].length); + const _12: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_9[2]); const b: Timestamp.Timestamp = copy$bench_Timestamp(_12[0]); const bStep: rt.u64 = _12[1]; let fromA: rt.u64 = 0; @@ -565,17 +563,17 @@ export function interleave(dataData: Uint8Array, dataStart: number, dataLen: num } /** A track's first timestamp and its frame duration: start, step, and scale. */ -export function track(dataData: Uint8Array, dataStart: number, dataLen: number): [Timestamp.Timestamp, rt.u64, rt.ByteSlice] { - const _4: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart, dataLen); +export function track(data: rt.ByteSlice): [Timestamp.Timestamp, rt.u64, rt.ByteSlice] { + const _4: [rt.u64, rt.ByteSlice] = takeU64(data); const value: rt.u64 = _4[0]; - const _7: [rt.u64, rt.ByteSlice] = takeU64(_4[1].data, _4[1].start, _4[1].length); + const _7: [rt.u64, rt.ByteSlice] = takeU64(_4[1]); const step: rt.u64 = _7[0]; - const _10: [rt.u64, rt.ByteSlice] = takeU64(_7[1].data, _7[1].start, _7[1].length); + const _10: [rt.u64, rt.ByteSlice] = takeU64(_7[1]); return [{ value, scale: _10[0] }, step, _10[1]] as [Timestamp.Timestamp, rt.u64, rt.ByteSlice]; } -export function decodeGroup(wireData: Uint8Array, wireStart: number, wireLen: number, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const _6: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(wireData, wireStart, wireLen, version); +export function decodeGroup(wire: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { + const _6: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(wire, version); if (_6.ok) { const val: [Group.Group, rt.usize] = _6.value; const group: Group.Group = val[0]; diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 3570fa92d..18a6a3454 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -30,8 +30,8 @@ export interface Decoder { } /** Read `buf`, with varints in the given form. */ -function new_(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): Decoder { - return { buf: new rt.ByteSlice(bufData, bufStart, bufLen), form, len: bufLen, need: 0, control: undefined, uncounted: 0 }; +function new_(buf: rt.ByteSlice, form: Form.Form): Decoder { + return { buf, form, len: buf.length, need: 0, control: undefined, uncounted: 0 }; } /** @@ -89,7 +89,7 @@ export function sub(self: Decoder, len: rt.usize): rt.Result { - const _3: rt.Result = varint(self, vLen as rt.u64); +export function bytes(self: Encoder, v: rt.ByteSlice): rt.Result { + const _3: rt.Result = varint(self, v.length as rt.u64); if (_3.ok) { - slice(self, vData, vStart, vLen); + slice(self, v); return rt.OK; } return _3; @@ -82,8 +82,7 @@ export function bytes(self: Encoder, vData: Uint8Array, vStart: number, vLen: nu /** Write a varint length, then the UTF-8 bytes. */ export function string(self: Encoder, v: string): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(v); - return bytes(self, _3.data, _3.start, _3.length); + return bytes(self, rt.stringAsBytes(v)); } /** diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 1a7d31d60..666469815 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -10,11 +10,11 @@ import * as coding_version_Version from "../coding/version.Version.ts"; import type * as lite_version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$coding_decode_Decode_coding_varint_Form(bufData: Uint8Array, bufStart: number, bufLen: number, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { - const r: Decoder.Decoder = Decoder.new(bufData, bufStart, bufLen, version); +export function decodeSlice$coding_decode_Decode_coding_varint_Form(buf: rt.ByteSlice, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { + const r: Decoder.Decoder = Decoder.new(buf, version); const _5: rt.Result = decode$coding_decode_Decode_coding_varint_Form(r, version); if (_5.ok) { - return rt.Ok([_5.value, rt.usizeSub(bufLen, Decoder.remaining(r))] as [Versions, rt.usize]); + return rt.Ok([_5.value, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Versions, rt.usize]); } return _5; } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index ed8310918..9387c42a1 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -25,11 +25,7 @@ export function cases(): Array<(a0: rt.ByteSlice, a1: rt.ByteVec) => undefined> decodeScript(a0.data, a0.start, a0.length, a1); }, (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { encodeScript(a02.data, a02.start, a02.length, a12); - }, (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { - zigzag(a03.data, a03.start, a03.length, a13); - }, (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { - sizes(a04.data, a04.start, a04.length, a14); - }, (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + }, zigzag as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, sizes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { roundtrip$coding_version_Versions(a05.data, a05.start, a05.length, a15); }, (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { roundtripLite$lite_group_Group(a06.data, a06.start, a06.length, a16); @@ -97,8 +93,7 @@ export function putUsize(out: rt.ByteVec, value: rt.usize): void { } /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ -export function takeU64(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u64, rt.ByteSlice] { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function takeU64(data: rt.ByteSlice): [rt.u64, rt.ByteSlice] { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, 8); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -208,7 +203,7 @@ export function decodeScript(dataData: Uint8Array, dataStart: number, dataLen: n if (mid > dataLen - 2) { rt.panic("mid > len"); } - const r: Decoder.Decoder = Decoder.new(dataData, dataStart + 2 + mid, dataLen - 2 - mid, form(selector)); + const r: Decoder.Decoder = Decoder.new(new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid), form(selector)); for (const _21 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { const _26: rt.Result = decodeStep(r, _21, out); if (_26.ok) { @@ -329,20 +324,15 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n if (mid > dataLen - 2) { rt.panic("mid > len"); } - let valuesData: Uint8Array = dataData; - let valuesStart: number = dataStart + 2 + mid; - let valuesLen: number = dataLen - 2 - mid; + let values: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); const buf: rt.ByteVec = new rt.ByteVec(); const _20: Form.Form = form(selector); const w: Encoder.Encoder = Encoder.new(buf, _20); const prefixes: Prefix.Prefix[] = []; for (const step of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { - const _30: [rt.u64, rt.ByteSlice] = takeU64(valuesData, valuesStart, valuesLen); + const _30: [rt.u64, rt.ByteSlice] = takeU64(values); const value: rt.u64 = _30[0]; - const slice: rt.ByteSlice = _30[1]; - valuesData = slice.data; - valuesStart = slice.start; - valuesLen = slice.length; + values = _30[1]; const _33: rt.u8 = rt.u8Rem(step, 10); if (_33 === 0) { Encoder.u8(w, rt.u64Low(value) & 0xff); @@ -368,7 +358,7 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n } else if (_33 === 5) { const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; const _51: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.u64ToBeBytes(value)), 0, part); - result = Encoder.bytes(w, _51.data, _51.start, _51.length); + result = Encoder.bytes(w, _51); } else if (_33 === 6) { const _60: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(rt.byteSliceFrom(rt.u64ToBeBytes(value)))); if (_60.ok) { @@ -421,17 +411,17 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n } } -export function zigzag(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const value: rt.u64 = takeU64(dataData, dataStart, dataLen)[0]; +export function zigzag(data: rt.ByteSlice, out: rt.ByteVec): void { + const value: rt.u64 = takeU64(data)[0]; const signed: rt.i64 = rt.i64Cast(value); putU64(out, varint_zigzag(signed)); putU64(out, rt.u64Cast(unzigzag(value))); putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); } -export function sizes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { let _9!: rt.u8; - const value: rt.u64 = takeU64(dataData, dataStart, dataLen)[0]; + const value: rt.u64 = takeU64(data)[0]; let iterStart: rt.u8 = 0; const iterEnd: rt.u8 = 3; while ((_9 = iterStart++) < iterEnd) { @@ -448,7 +438,7 @@ export function sizes(dataData: Uint8Array, dataStart: number, dataLen: number, export function roundtrip$coding_version_Versions(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { if (dataLen !== 0) { const form_: Form.Form = form(dataData[dataStart]); - const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$coding_decode_Decode_coding_varint_Form(dataData, dataStart + 1, dataLen - 1, form_); + const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$coding_decode_Decode_coding_varint_Form(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), form_); if (_8.ok) { const value: Versions.Versions = _8.value[0]; putUsize(out, _8.value[1]); @@ -469,7 +459,7 @@ export function roundtrip$coding_version_Versions(dataData: Uint8Array, dataStar export function roundtripLite$lite_group_Group(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { if (dataLen !== 0) { const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); - const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(dataData, dataStart + 1, dataLen - 1, version); + const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); if (_8.ok) { const value: Group.Group = _8.value[0]; putUsize(out, _8.value[1]); @@ -491,7 +481,7 @@ export function roundtripLite$lite_group_Group(dataData: Uint8Array, dataStart: export function roundtripLite$lite_probe_Probe(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { if (dataLen !== 0) { const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); - const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$coding_decode_Decode_lite_version_Version(dataData, dataStart + 1, dataLen - 1, version); + const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); if (_8.ok) { const value: Probe.Probe = _8.value[0]; putUsize(out, _8.value[1]); @@ -513,15 +503,15 @@ export function roundtripLite$lite_probe_Probe(dataData: Uint8Array, dataStart: export function encodeMessages(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { if (dataLen !== 0) { const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); - const _10: [rt.u64, rt.ByteSlice] = takeU64(dataData, dataStart + 1, dataLen - 1); + const _10: [rt.u64, rt.ByteSlice] = takeU64(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)); const subscribe: rt.u64 = _10[0]; - const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1].data, _10[1].start, _10[1].length); + const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1]); const sequence: rt.u64 = _13[0]; - const _16: [rt.u64, rt.ByteSlice] = takeU64(_13[1].data, _13[1].start, _13[1].length); + const _16: [rt.u64, rt.ByteSlice] = takeU64(_13[1]); const frameStart: rt.u64 = _16[0]; - const _19: [rt.u64, rt.ByteSlice] = takeU64(_16[1].data, _16[1].start, _16[1].length); + const _19: [rt.u64, rt.ByteSlice] = takeU64(_16[1]); const bitrate: rt.u64 = _19[0]; - const rtt: rt.u64 = takeU64(_19[1].data, _19[1].start, _19[1].length)[0]; + const rtt: rt.u64 = takeU64(_19[1])[0]; encodeMessage$lite_group_Group({ subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }, version, out); encodeMessage$lite_probe_Probe({ bitrate: rt.u64CheckedSub(bitrate, 1), rtt: thenSome$1ugl8af(rt.u64Rem(rtt, 3) !== 0, rtt) }, version, out); const versions: Versions.Versions = Versions.from$convert_From_array2_coding_version_Version([{ _0: subscribe }, { _0: sequence }]); @@ -570,7 +560,8 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, b0: { if (dataLen !== 0) { const selector: rt.u8 = dataData[dataStart]; - const value: rt.u64 = takeU64(dataData, dataStart + 1, dataLen - 1)[0]; + const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const value: rt.u64 = takeU64(data2)[0]; const _10: rt.u8 = rt.u8Rem(selector, 8); if (_10 === 0) { err = { tag: "InvalidMessage", _0: value } as DecodeError.DecodeError; @@ -581,7 +572,7 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, } 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(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 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/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index bea81c8f0..36e26a6a0 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -11,11 +11,11 @@ import { decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Version_T import * as lite_version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$coding_decode_Decode_lite_version_Version(bufData: Uint8Array, bufStart: number, bufLen: number, version: lite_version_Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { - const r: Decoder.Decoder = Decoder.new(bufData, bufStart, bufLen, Form.from$convert_From_lite_version_Version(version)); +export function decodeSlice$coding_decode_Decode_lite_version_Version(buf: rt.ByteSlice, version: lite_version_Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { + const r: Decoder.Decoder = Decoder.new(buf, Form.from$convert_From_lite_version_Version(version)); const _5: rt.Result = decode$coding_decode_Decode_lite_version_Version(r, version); if (_5.ok) { - return rt.Ok([_5.value, rt.usizeSub(bufLen, Decoder.remaining(r))] as [Group, rt.usize]); + return rt.Ok([_5.value, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Group, rt.usize]); } return _5; } diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index 321e43675..d2a0dda2a 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -13,11 +13,11 @@ import * as lite_version_Version from "../lite/version.Version.ts"; import type * as Control from "../stats.Control.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$coding_decode_Decode_lite_version_Version(bufData: Uint8Array, bufStart: number, bufLen: number, version: lite_version_Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { - const r: Decoder.Decoder = Decoder.new(bufData, bufStart, bufLen, Form.from$convert_From_lite_version_Version(version)); +export function decodeSlice$coding_decode_Decode_lite_version_Version(buf: rt.ByteSlice, version: lite_version_Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { + const r: Decoder.Decoder = Decoder.new(buf, Form.from$convert_From_lite_version_Version(version)); const _5: rt.Result = decode$coding_decode_Decode_lite_version_Version(r, version); if (_5.ok) { - return rt.Ok([_5.value, rt.usizeSub(bufLen, Decoder.remaining(r))] as [Probe, rt.usize]); + return rt.Ok([_5.value, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Probe, rt.usize]); } return _5; } diff --git a/ts/fixtures/lang/brands.ts b/ts/fixtures/lang/brands.ts index 706883cf3..17f935230 100644 --- a/ts/fixtures/lang/brands.ts +++ b/ts/fixtures/lang/brands.ts @@ -9,9 +9,9 @@ import { returnedNever, tailBreak } from "./shapes.ts"; export function mixed(data: rt.ByteSlice): void { returnedNever(7, 1); - const meters: Meters.Meters = { _0: tailBreak(data.data, data.start, data.length) as rt.u64 }; + const meters: Meters.Meters = { _0: tailBreak(data) as rt.u64 }; // @ts-expect-error A `u16` is not a `u8`. - returnedNever(tailBreak(data.data, data.start, data.length), 1); + returnedNever(tailBreak(data), 1); // @ts-expect-error A `u32` is not a `usize`. returnedNever(1, 0xffffffff as rt.u32); // @ts-expect-error A `u64` is not a `u8`, even as a number. diff --git a/ts/fixtures/lang/expected/args.Scale.ts b/ts/fixtures/lang/expected/args.Scale.ts index 4f8ec6a02..e9e62c3c7 100644 --- a/ts/fixtures/lang/expected/args.Scale.ts +++ b/ts/fixtures/lang/expected/args.Scale.ts @@ -6,8 +6,8 @@ export interface Scale { _0: rt.u8; } -export function weigh$args_Weigh(self: Scale, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), self._0, (a: rt.u8, b: rt.u8): rt.u8 => { +export function weigh$args_Weigh(self: Scale, data: rt.ByteSlice): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(data)), self._0, (a: rt.u8, b: rt.u8): rt.u8 => { return rt.u8WrappingAdd(a, b ^ 90); }); } diff --git a/ts/fixtures/lang/expected/args.ts b/ts/fixtures/lang/expected/args.ts index 81c8817f2..aa5376bef 100644 --- a/ts/fixtures/lang/expected/args.ts +++ b/ts/fixtures/lang/expected/args.ts @@ -2,11 +2,11 @@ import * as rt from "./rt.ts"; import * as args_Scale from "./args.Scale.ts"; -import { map$1p38hze as option_map$1p38hze, map$1yogfym as option_map$1yogfym, mapOr$0dk8jdr as option_mapOr$0dk8jdr } from "./core/option.ts"; +import { map$0waqle9 as option_map$0waqle9, map$1yogfym as option_map$1yogfym, mapOr$0dk8jdr as option_mapOr$0dk8jdr } from "./core/option.ts"; /** A use that needs the slice itself. */ -export function opaque(sData: Uint8Array, sStart: number, sLen: number): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, sLen))), sLen & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { +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); }); } @@ -34,18 +34,17 @@ export function len(_dataData: Uint8Array, _dataStart: number, dataLen: number): return dataLen; } -/** A parameter borrowed, which makes it whole on entry. */ -export function byRef(dataData: Uint8Array, dataStart: number, dataLen: number): rt.usize { - return lenOf(new rt.ByteSlice(dataData, dataStart, dataLen)); +/** A parameter borrowed, which takes it whole. */ +export function byRef(data: rt.ByteSlice): rt.usize { + return lenOf(data); } export function lenOf(data: rt.ByteSlice): rt.usize { return data.length; } -/** A parameter made whole in a loop, which makes it whole on entry. */ -export function kept(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.u8): rt.ByteSlice[] { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +/** A parameter made whole in a loop, which takes it whole. */ +export function kept(data: rt.ByteSlice, n: rt.u8): rt.ByteSlice[] { const all: rt.ByteSlice[] = []; const _6: rt.u8 = rt.u8Rem(n, 4); let iterStart: rt.u8 = 0; @@ -59,30 +58,84 @@ export function kept(dataData: Uint8Array, dataStart: number, dataLen: number, n } /** A reference to an array of bytes. */ -export function word(wData: Uint8Array, wStart: number, _wLen: number): rt.u32 { - return ((wData[wStart] << 24) | (wData[wStart + 1] << 16) | (wData[wStart + 2] << 8) | wData[wStart + 3]) >>> 0; +export function word(w: rt.ByteSlice): rt.u32 { + return ((w.data[w.start] << 24) | (w.data[w.start + 1] << 16) | (w.data[w.start + 2] << 8) | w.data[w.start + 3]) >>> 0; } /** Two slices, perhaps the same. */ -export function both(aData: Uint8Array, aStart: number, aLen: number, bData: Uint8Array, bStart: number, bLen: number): rt.u8 { - return opaque(aData, aStart, aLen) ^ (len(bData, bStart, bLen) & 0xff); +export function both(a: rt.ByteSlice, bData: Uint8Array, bStart: number, bLen: number): rt.u8 { + return opaque(a) ^ (len(bData, bStart, bLen) & 0xff); } /** A recursive count of the bytes before a zero. */ -export function depth(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); +export function depth(data: rt.ByteSlice): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_2 !== undefined) { if (_2[0] !== 0) { - return rt.u8Add(1, depth(_2[1].data, _2[1].start, _2[1].length)); + return rt.u8Add(1, depth(_2[1])); } } return 0; } +/** Passed along to one that takes it whole, so taken whole too. */ +export function relay(data: rt.ByteSlice): rt.u8 { + return opaque(data); +} + +/** Passed along to one that takes its parts, so taken as parts too. */ +export function relaySum(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + return sum(dataData, dataStart, dataLen); +} + +/** Recursive, and made whole at the bottom, so taken whole all the way down. */ +export function lastRun(data: rt.ByteSlice): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); + if (_2 !== undefined) { + if (_2[0] !== 0) { + return lastRun(_2[1]); + } + } + return opaque(data); +} + +/** Mutually recursive, each reading bytes, so both take parts. */ +export function evens(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (dataLen === 0) { + return 0; + } + return rt.u8WrappingAdd(dataData[dataStart], odds(dataData, dataStart + 1, dataLen - 1)); +} + +export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (dataLen === 0) { + return 0; + } + return evens(dataData, dataStart + 1, dataLen - 1); +} + +/** Mutually recursive, where `ping` makes its slice whole and `pong` only splits its own. */ +export function ping(data: rt.ByteSlice): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); + if (_2 !== undefined) { + if (rt.u8Rem(_2[0], 3) !== 0) { + return pong(_2[1].data, _2[1].start, _2[1].length); + } + } + return opaque(data); +} + +export function pong(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (dataLen === 0) { + return 0; + } + return dataData[dataStart] ^ ping(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)); +} + /** A slice chosen by a call that does something. */ -export function pick(out: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): rt.ByteSlice { +export function pick(out: rt.ByteVec, data: rt.ByteSlice): rt.ByteSlice { rt.byteVecPush(out, 187); - return rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.usizeDiv(dataLen, 2)); + return rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); } export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { @@ -90,51 +143,44 @@ export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { return n; } -export function pair(n: rt.u8, sData: Uint8Array, sStart: number, sLen: number): rt.u8 { - return n ^ opaque(sData, sStart, sLen); +export function pair(n: rt.u8, s: rt.ByteSlice): rt.u8 { + return n ^ opaque(s); } -export function weigh$args_Scale(w: args_Scale.Scale, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - return args_Scale.weigh$args_Weigh(w, dataData, dataStart, dataLen); +export function weigh$args_Scale(w: args_Scale.Scale, data: rt.ByteSlice): rt.u8 { + return args_Scale.weigh$args_Weigh(w, data); } -export function args(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function args(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.ByteSlice) => rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); - const _4: rt.u8 = rt.u8Rem(kind, 6); + const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { rt.byteVecPush(out, sum(data.data, data.start, data.length)); rt.byteVecPush(out, len(data.data, data.start, data.length) & 0xff); - rt.byteVecPush(out, byRef(data.data, data.start, data.length) & 0xff); - rt.byteVecPush(out, rt.iterFold(rt.iterMap(rt.iterSlice(kept(data.data, data.start, data.length, kind)), (s: rt.ByteSlice): rt.u8 => { - const _33: rt.ByteSlice = s; - return opaque(_33.data, _33.start, _33.length); + rt.byteVecPush(out, byRef(data) & 0xff); + rt.byteVecPush(out, rt.iterFold(rt.iterMap(rt.iterSlice(kept(data, kind)), (s: rt.ByteSlice): rt.u8 => { + return opaque(s); }), 0, (a05: rt.u8, a1: rt.u8): rt.u8 => { return rt.u8WrappingAdd(a05, a1); })); } else if (_4 === 1) { if (data.length >= 4) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(word(data.data, data.start, 4), 1)))); - rt.byteVecPush(out, both(data.data, data.start + 4, data.length - 4, data.data, data.start + 4, data.length - 4)); - const _35: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 4); - rt.byteVecPush(out, both(_35.data, _35.start, _35.length, data.data, data.start + 4, data.length - 4)); + const w: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 4); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(word(w), 1)))); + rt.byteVecPush(out, both(new rt.ByteSlice(data.data, data.start + 4, data.length - 4), data.data, data.start + 4, data.length - 4)); + rt.byteVecPush(out, both(w, data.data, data.start + 4, data.length - 4)); } - const _38: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 64)); - rt.byteVecPush(out, depth(_38.data, _38.start, _38.length)); + rt.byteVecPush(out, depth(rt.byteSliceRange(data, 0, rt.min(data.length, 64)))); } else if (_4 === 2) { - rt.iterExtendBytes(out, rt.iterOption(option_map$1p38hze(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_2: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + rt.iterExtendBytes(out, rt.iterOption(option_map$0waqle9(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_2: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { return _2[1]; - }), (a0: rt.ByteSlice): rt.u8 => { - return opaque(a0.data, a0.start, a0.length); - })), undefined, true); + }), opaque)), undefined, true); if (!(rt.usizeRem(data.length, 2) === 0)) { f = (a03: rt.ByteSlice): rt.u8 => { return sum(a03.data, a03.start, a03.length); }; } else { - f = (a02: rt.ByteSlice): rt.u8 => { - return opaque(a02.data, a02.start, a02.length); - }; + f = opaque; } rt.byteVecPush(out, f(data)); rt.byteVecPush(out, option_mapOr$0dk8jdr(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { @@ -143,13 +189,11 @@ export function args(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL return len(a04.data, a04.start, a04.length); }) & 0xff); } else if (_4 === 3) { - const _60: rt.u8 = code(out, 1); - const _61: rt.ByteSlice = pick(out, data.data, data.start, data.length); - rt.byteVecPush(out, pair(_60, _61.data, _61.start, _61.length)); + rt.byteVecPush(out, pair(code(out, 1), pick(out, data))); } else if (_4 === 4) { const seen: rt.ByteVec = new rt.ByteVec(); const note: (a0: rt.u8) => undefined = (b2: rt.u8): undefined => { - rt.byteVecPush(seen, b2 ^ opaque(data.data, data.start, data.length)); + rt.byteVecPush(seen, b2 ^ opaque(data)); }; const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3); while (true) { @@ -160,11 +204,39 @@ export function args(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL note(_70); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen)); + } else if (_4 === 6) { + const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 64)); + rt.byteVecPush(out, relay(data2)); + rt.byteVecPush(out, relaySum(data2.data, data2.start, data2.length)); + rt.byteVecPush(out, lastRun(data2)); + rt.byteVecPush(out, evens(data2.data, data2.start, data2.length)); + rt.byteVecPush(out, ping(data2)); + rt.byteVecPush(out, pong(data2.data, data2.start, data2.length)); + } else if (_4 === 7) { + const mid: number = rt.usizeDiv(data.length, 2); + if (mid > data.length) { + rt.panic("mid > len"); + } + const mid2: number = rt.usizeDiv(data.length, 2); + if (mid2 > data.length) { + rt.panic("mid > len"); + } + const halves: rt.ByteSlice[] = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2)]; + const iter2: rt.Iter = rt.iterSlice(halves); + while (true) { + const _111: rt.ByteSlice | rt.Done = iter2.next(); + if (_111 === rt.DONE) { + break; + } + const _138: rt.ByteSlice = _111; + rt.byteVecPush(out, sum(_138.data, _138.start, _138.length)); + rt.byteVecPush(out, relay(_111)); + } + rt.byteVecPush(out, relaySum(halves[1].data, halves[1].start, halves[1].length)); + rt.byteVecPush(out, sum(data.data, data.start, data.length)); } else { - rt.byteVecPush(out, weigh$args_Scale({ _0: kind }, data.data, data.start, data.length)); - const _86: args_Scale.Scale = { _0: 3 }; - const _87: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 2)); - rt.byteVecPush(out, args_Scale.weigh$args_Weigh(_86, _87.data, _87.start, _87.length)); + rt.byteVecPush(out, weigh$args_Scale({ _0: kind }, data)); + rt.byteVecPush(out, args_Scale.weigh$args_Weigh({ _0: 3 }, rt.byteSliceRange(data, rt.min(data.length, 2)))); } } diff --git a/ts/fixtures/lang/expected/arrays.ts b/ts/fixtures/lang/expected/arrays.ts index d3d7a8d42..93a77cdea 100644 --- a/ts/fixtures/lang/expected/arrays.ts +++ b/ts/fixtures/lang/expected/arrays.ts @@ -9,9 +9,9 @@ import { then$11x7xqs } from "./core/bool.ts"; import { isSomeAnd$09tpccf, unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1j8xzu6 as option_map$1j8xzu6, map$1jcn6wm as option_map$1jcn6wm, map$0rbsrz6 as option_map$0rbsrz6, mapOr$1surhce as option_mapOr$1surhce } from "./core/option.ts"; /** Each byte an operation, its value the operand; each puts what it read. */ -export function fromFns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function fromFns(data: rt.ByteSlice, out: rt.ByteVec): void { let s!: string; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(op, 5); if (_10 === 0) { const seen: rt.usize[] = []; @@ -106,9 +106,9 @@ export function counted$5(op: rt.u8): rt.usize[] { * the closure captured by reference and by move, of `Option`s whose `None` is `rt.None`, * and of arrays, each element the closure's own to change. */ -export function maps(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function maps(data: rt.ByteSlice, out: rt.ByteVec): void { let s!: string; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(op, 5); if (_10 === 0) { const seen: rt.ByteVec = new rt.ByteVec(); @@ -216,7 +216,7 @@ export function shifted$3(op: rt.u8): rt.u64[] { * the operand: bytes, wide integers, and strings, each lent as its place, arrays of bytes * as their views, and other arrays as themselves. Writes through each land in the array. */ -export function lent(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: Uint8Array = rt.bytes(3); const wide: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { return 0; @@ -232,7 +232,7 @@ export function lent(dataData: Uint8Array, dataStart: number, dataLen: number, o const pairs: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { return copy$array_u32(item2); }); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const i: rt.usize = op as rt.usize; const _21: rt.u8 = rt.u8Rem(op, 6); if (_21 === 0) { @@ -332,7 +332,7 @@ export function lent(dataData: Uint8Array, dataStart: number, dataLen: number, o * Arrays as slices, of bytes and of other values, empty ones included; each byte an * operation, its value the operand. Writes through `as_mut_slice` land in the array. */ -export function asSlices(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function asSlices(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: Uint8Array = rt.bytes(4); const wide: rt.u16[] = Array.from({ length: 3 }, (): rt.u16 => { return 0; @@ -348,7 +348,7 @@ export function asSlices(dataData: Uint8Array, dataStart: number, dataLen: numbe const pairs: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { return copy$array_u32(item2); }); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const i: rt.usize = op as rt.usize; const _22: rt.u8 = rt.u8Rem(op, 8); if (_22 === 0) { @@ -441,61 +441,56 @@ export function written(bytes: rt.ByteSlice, wide: rt.u16[], op: rt.u8): void { * fields, and parts of a longer slice. Writes through each land in the array, and a copy shares nothing with * it. Of no bytes, one, three, and many. */ -export function given(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function given(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { - givenN$0(dataData, dataStart, dataLen, out); - taken$0(dataData, dataStart, dataLen, out); + givenN$0(data, out); + taken$0(data, out); } else if (_4 === 1) { - givenN$1(dataData, dataStart, dataLen, out); - taken$1(dataData, dataStart, dataLen, out); + givenN$1(data, out); + taken$1(data, out); } else if (_4 === 2) { - givenN$3(dataData, dataStart, dataLen, out); - taken$3(dataData, dataStart, dataLen, out); - fields(dataData, dataStart, dataLen, out); + givenN$3(data, out); + taken$3(data, out); + fields(data, out); } else { - givenN$40(dataData, dataStart, dataLen, out); - taken$32(dataData, dataStart, dataLen, out); + givenN$40(data, out); + taken$32(data, out); } } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$0(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytesAt$0(data: rt.ByteSlice, at: rt.usize): Uint8Array { return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$1(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytesAt$1(data: rt.ByteSlice, at: rt.usize): Uint8Array { return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$3(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytesAt$3(data: rt.ByteSlice, at: rt.usize): Uint8Array { return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$32(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytesAt$32(data: rt.ByteSlice, at: rt.usize): Uint8Array { return rt.bytesFromFn(32, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$40(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize): Uint8Array { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytesAt$40(data: rt.ByteSlice, at: rt.usize): Uint8Array { return rt.bytesFromFn(40, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); }); } @@ -624,10 +619,9 @@ export function putSome$5(out: rt.ByteVec, a: Uint8Array | undefined): void { } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$0(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); - const a: Uint8Array = copy$array_u8(bytesAt$0(data.data, data.start, data.length, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$0(data.data, data.start, data.length, 0)); +export function givenN$0(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$0(data, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$0(data, 0)); const copied: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -649,7 +643,7 @@ export function givenN$0(dataData: Uint8Array, dataStart: number, dataLen: numbe } put$0(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$0(data.data, data.start, data.length, rt.usizeMul(k, 2)); + return bytesAt$0(data, rt.usizeMul(k, 2)); }), undefined, 0, true); rt.byteSliceFrom(v[rt.idx(v, 0)]); rt.byteSliceFrom(a); @@ -722,10 +716,9 @@ export function givenN$0(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$1(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); - const a: Uint8Array = copy$array_u8(bytesAt$1(data.data, data.start, data.length, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$1(data.data, data.start, data.length, 1)); +export function givenN$1(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$1(data, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$1(data, 1)); const copied: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -750,7 +743,7 @@ export function givenN$1(dataData: Uint8Array, dataStart: number, dataLen: numbe } put$1(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$1(data.data, data.start, data.length, rt.usizeMul(k, 2)); + return bytesAt$1(data, rt.usizeMul(k, 2)); }), undefined, 1, true); const _50: rt.ByteSlice = rt.byteSliceFrom(v[rt.idx(v, 0)]); const _52: rt.ByteSlice = rt.byteSliceFrom(a); @@ -841,10 +834,9 @@ export function givenN$1(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$3(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); - const a: Uint8Array = copy$array_u8(bytesAt$3(data.data, data.start, data.length, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$3(data.data, data.start, data.length, 3)); +export function givenN$3(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$3(data, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$3(data, 3)); const copied: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -869,7 +861,7 @@ export function givenN$3(dataData: Uint8Array, dataStart: number, dataLen: numbe } put$3(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$3(data.data, data.start, data.length, rt.usizeMul(k, 2)); + return bytesAt$3(data, rt.usizeMul(k, 2)); }), undefined, 3, true); const _50: rt.ByteSlice = rt.byteSliceFrom(v[rt.idx(v, 0)]); const _52: rt.ByteSlice = rt.byteSliceFrom(a); @@ -960,10 +952,9 @@ export function givenN$3(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$40(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); - const a: Uint8Array = copy$array_u8(bytesAt$40(data.data, data.start, data.length, 0)); - const b: Uint8Array = copy$array_u8(bytesAt$40(data.data, data.start, data.length, 40)); +export function givenN$40(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$40(data, 0)); + const b: Uint8Array = copy$array_u8(bytesAt$40(data, 40)); const copied: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); const cloned: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); @@ -988,7 +979,7 @@ export function givenN$40(dataData: Uint8Array, dataStart: number, dataLen: numb } put$40(out, [copy$array_u8(a), copy$array_u8(b)]); const v: Uint8Array[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$40(data.data, data.start, data.length, rt.usizeMul(k, 2)); + return bytesAt$40(data, rt.usizeMul(k, 2)); }), undefined, 40, true); const _50: rt.ByteSlice = rt.byteSliceFrom(v[rt.idx(v, 0)]); const _52: rt.ByteSlice = rt.byteSliceFrom(a); @@ -1082,9 +1073,9 @@ export function givenN$40(dataData: Uint8Array, dataStart: number, dataLen: numb * [`given`] of a field's `[u8; 3]`, swapped, replaced, taken, and formatted through its * own `Debug`. */ -export function fields(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$3(dataData, dataStart, dataLen, 2)); - const held: Framed.Framed = { bytes: copy$array_u8(bytesAt$3(dataData, dataStart, dataLen, 0)) }; +export function fields(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$3(data, 2)); + const held: Framed.Framed = { bytes: copy$array_u8(bytesAt$3(data, 0)) }; const _7: rt.ByteSlice = rt.byteSliceFrom(held.bytes); const _8: rt.ByteSlice = rt.byteSliceFrom(a); const swapped = rt.byteSliceToArray(_7); @@ -1105,27 +1096,28 @@ export function fields(dataData: Uint8Array, dataStart: number, dataLen: number, _41.data.set(rt.bytes(3), _41.start); put$3(out, [taken2, copy$array_u8(held.bytes)]); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(shown)); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), (d: rt.u8): boolean => { + if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d: rt.u8): boolean => { return rt.u8Rem(d, 3) === 1; })) { [rt.byteSliceFrom(old), rt.byteSliceFrom(a)] as [rt.ByteSlice, rt.ByteSlice]; if (rt.eqBytes(rt.byteSliceFrom(old), rt.byteSliceFrom(a))) { + const arg = data.length; const kind: string = "!="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(dataLen, f)]; + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; const _60: rt.Arguments | undefined = ["fields of ", args4[0]]; - const arg = rt.byteSliceView(rt.byteSliceFrom(old)); - const arg2 = rt.byteSliceView(rt.byteSliceFrom(a)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), _60); + const arg2 = rt.byteSliceView(rt.byteSliceFrom(old)); + const arg3 = rt.byteSliceView(rt.byteSliceFrom(a)); + rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _60); } } } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$0(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$0(dataData, dataStart, dataLen, 1)); +export function taken$0(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$0(data, 1)); rt.byteSliceFrom(a); put$0(out, [rt.bytes(0), copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(0).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(0).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 0); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); @@ -1135,13 +1127,13 @@ export function taken$0(dataData: Uint8Array, dataStart: number, dataLen: number } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$1(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$1(dataData, dataStart, dataLen, 1)); +export function taken$1(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$1(data, 1)); const _5: rt.ByteSlice = rt.byteSliceFrom(a); const taken = rt.byteSliceToArray(_5); _5.data.set(rt.bytes(1), _5.start); put$1(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(1).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(1).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 1); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); @@ -1153,13 +1145,13 @@ export function taken$1(dataData: Uint8Array, dataStart: number, dataLen: number } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$3(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$3(dataData, dataStart, dataLen, 1)); +export function taken$3(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$3(data, 1)); const _5: rt.ByteSlice = rt.byteSliceFrom(a); const taken = rt.byteSliceToArray(_5); _5.data.set(rt.bytes(3), _5.start); put$3(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(3).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(3).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 3); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); @@ -1171,13 +1163,13 @@ export function taken$3(dataData: Uint8Array, dataStart: number, dataLen: number } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$32(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const a: Uint8Array = copy$array_u8(bytesAt$32(dataData, dataStart, dataLen, 1)); +export function taken$32(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: Uint8Array = copy$array_u8(bytesAt$32(data, 1)); const _5: rt.ByteSlice = rt.byteSliceFrom(a); const taken = rt.byteSliceToArray(_5); _5.data.set(rt.bytes(32), _5.start); put$32(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), rt.iterSlice(rt.bytes(32).fill(119))), undefined, true); + const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(32).fill(119))), undefined, true); const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 32); if (_17 !== undefined) { rt.byteSliceFill(_17, 102); diff --git a/ts/fixtures/lang/expected/ascii.ts b/ts/fixtures/lang/expected/ascii.ts index bdf2b96ca..dbfa7d13f 100644 --- a/ts/fixtures/lang/expected/ascii.ts +++ b/ts/fixtures/lang/expected/ascii.ts @@ -35,9 +35,8 @@ export function upperText(s: rt.Place): void { * Read `e` alternately from the front and the back as `data`'s bits say, putting its * length before each step, then what `Display` writes of what is left. */ -export function steps$ascii_EscapeDefault(e: rt.Iter, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function steps$ascii_EscapeDefault(e: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { let next!: rt.u8 | undefined; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let i: rt.usize = 0; while (true) { rt.byteVecPush(out, e.len() & 0xff); @@ -72,9 +71,8 @@ export function steps$ascii_EscapeDefault(e: rt.Iter, dataData: Uint8Arra } /** Every byte, through each method of `u8`. */ -export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _67!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const all: rt.ByteVec = rt.iterToByteVec(new rt.RangeInclusive(0, 255, rt.u8Step), undefined, true); b0: { const _6: rt.u8 = rt.u8Rem(kind, 4); @@ -161,7 +159,7 @@ export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data if (_149 === rt.DONE) { break b0; } - steps$ascii_EscapeDefault(rt.escapeAscii(_149), data.data, data.start, data.length, out); + steps$ascii_EscapeDefault(rt.escapeAscii(_149), data, out); } } } @@ -171,9 +169,9 @@ export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * The chars at each edge, then each of `data`'s big-endian `u32`s that is one, through * each method of `char`. */ -export function chars(_1: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function chars(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const all: rt.char[] = [0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].slice(); - const _9: rt.Iter = rt.iterFilterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), 4), (c2: rt.ByteSlice): rt.char | undefined => { + const _9: rt.Iter = rt.iterFilterMap(rt.byteSliceChunks(data, 4), (c2: rt.ByteSlice): rt.char | undefined => { return rt.charFromU32(rt.u32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c2, i2), 0); }))); @@ -213,9 +211,8 @@ export function chars(_1: rt.u8, dataData: Uint8Array, dataStart: number, dataLe * `data` as bytes and as text, through the ASCII methods of slices and `str`, and those * of a `Vec` and a `String` they deref to. */ -export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let next!: rt.u8 | undefined; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const half: rt.usize = rt.usizeDiv(data.length, 2); if (half > data.length) { rt.panic("mid > len"); diff --git a/ts/fixtures/lang/expected/atomics.ts b/ts/fixtures/lang/expected/atomics.ts index b68b31ea5..7e1e180da 100644 --- a/ts/fixtures/lang/expected/atomics.ts +++ b/ts/fixtures/lang/expected/atomics.ts @@ -24,12 +24,11 @@ export function order(b: rt.u8, valid: rt.AtomicOrdering[]): rt.AtomicOrdering { * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i16s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.i16; let current!: rt.i16; let result!: rt.Result; let x!: rt.i16; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(2); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -138,12 +137,11 @@ export function i16s(dataData: Uint8Array, dataStart: number, dataLen: number, o * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i32s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.i32; let current!: rt.i32; let result!: rt.Result; let x!: rt.i32; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -252,12 +250,11 @@ export function i32s(dataData: Uint8Array, dataStart: number, dataLen: number, o * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i64s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.i64; let current!: rt.i64; let result!: rt.Result; let x!: rt.i64; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -366,12 +363,11 @@ export function i64s(dataData: Uint8Array, dataStart: number, dataLen: number, o * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i8s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.i8; let current!: rt.i8; let result!: rt.Result; let x!: rt.i8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = Uint8Array.of(0); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -480,12 +476,11 @@ export function i8s(dataData: Uint8Array, dataStart: number, dataLen: number, ou * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function isizes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.isize; let current!: rt.isize; let result!: rt.Result; let x!: rt.isize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -594,12 +589,11 @@ export function isizes(dataData: Uint8Array, dataStart: number, dataLen: number, * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u16s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.u16; let current!: rt.u16; let result!: rt.Result; let x!: rt.u16; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(2); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -708,12 +702,11 @@ export function u16s(dataData: Uint8Array, dataStart: number, dataLen: number, o * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u32s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.u32; let current!: rt.u32; let result!: rt.Result; let x!: rt.u32; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -822,12 +815,11 @@ export function u32s(dataData: Uint8Array, dataStart: number, dataLen: number, o * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u64s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.u64; let current!: rt.u64; let result!: rt.Result; let x!: rt.u64; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -936,12 +928,11 @@ export function u64s(dataData: Uint8Array, dataStart: number, dataLen: number, o * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u8s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.u8; let current!: rt.u8; let result!: rt.Result; let x!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = Uint8Array.of(0); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1050,12 +1041,11 @@ export function u8s(dataData: Uint8Array, dataStart: number, dataLen: number, ou * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function usizes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: rt.usize; let current!: rt.usize; let result!: rt.Result; let x!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1160,23 +1150,23 @@ export function usizes(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(atomic.v))); } -export function bools(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function bools(data: rt.ByteSlice, out: rt.ByteVec): void { let old!: boolean; - const flag: rt.Atomic = new rt.Atomic(isSomeAnd$09tpccf(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), (_2: rt.u8): boolean => { + const flag: rt.Atomic = new rt.Atomic(isSomeAnd$09tpccf(rt.byteSliceFirst(data), (_2: rt.u8): boolean => { return (_2 & 1) === 1; })); - let dataData2: Uint8Array = dataData; - let dataStart2: number = dataStart; - let dataLen2: number = dataLen; - while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const b: rt.u8 = dataData2[dataStart2 + 1]; - const restData: Uint8Array = dataData2; - const restStart: number = dataStart2 + 2; - const restLen: number = dataLen2 - 2; - dataData2 = restData; - dataStart2 = restStart; - dataLen2 = restLen; + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const b: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; const op2: rt.u8 = op; const b2: rt.u8 = b; const v: boolean = (b2 & 1) === 1; @@ -1233,11 +1223,11 @@ export function sent(stats: Stats.Stats, ord: rt.AtomicOrdering): rt.u64 { return rt.atomicLoad(stats.sent, ord); } -export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { let stats2!: rt.Arc; const stats: rt.Arc = new rt.Arc(Stats.default$Default()); const peer: rt.Arc = rt.arcClone(stats); - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { if (!((b & 1) === 0)) { stats2 = peer; } else { @@ -1248,39 +1238,39 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, rt.atomicStore(stats2.value.open, b > 128, 1); rt.byteVecPush(out, rt.atomicLoad(stats2.value.open, 2) ? 1 : 0); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sent(peer.value, order(dataLen & 0xff, [0, 2, 4]))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sent(peer.value, order(data.length & 0xff, [0, 2, 4]))))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.atomicLoad(peer.value.peers, 4)))); rt.byteVecPush(out, stats.strong & 0xff); peer[Symbol.dispose](); stats[Symbol.dispose](); } -export function atomics(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function atomics(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 12); if (_4 === 0) { - u8s(dataData, dataStart, dataLen, out); + u8s(data, out); } else if (_4 === 1) { - u16s(dataData, dataStart, dataLen, out); + u16s(data, out); } else if (_4 === 2) { - u32s(dataData, dataStart, dataLen, out); + u32s(data, out); } else if (_4 === 3) { - u64s(dataData, dataStart, dataLen, out); + u64s(data, out); } else if (_4 === 4) { - usizes(dataData, dataStart, dataLen, out); + usizes(data, out); } else if (_4 === 5) { - i8s(dataData, dataStart, dataLen, out); + i8s(data, out); } else if (_4 === 6) { - i16s(dataData, dataStart, dataLen, out); + i16s(data, out); } else if (_4 === 7) { - i32s(dataData, dataStart, dataLen, out); + i32s(data, out); } else if (_4 === 8) { - i64s(dataData, dataStart, dataLen, out); + i64s(data, out); } else if (_4 === 9) { - isizes(dataData, dataStart, dataLen, out); + isizes(data, out); } else if (_4 === 10) { - bools(dataData, dataStart, dataLen, out); + bools(data, out); } else { - shared(dataData, dataStart, dataLen, out); + shared(data, out); } } diff --git a/ts/fixtures/lang/expected/borrows.ts b/ts/fixtures/lang/expected/borrows.ts index eec2729f7..7211645be 100644 --- a/ts/fixtures/lang/expected/borrows.ts +++ b/ts/fixtures/lang/expected/borrows.ts @@ -10,7 +10,7 @@ import { mapOr$0qqbaqw as option_mapOr$0qqbaqw, mapOr$0ucbp7g as option_mapOr$0u * Each byte an operation on the cells, its value the operand; each puts what it read and * what dropped. */ -export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const count: rt.Cell = new rt.Cell(0); const pair: rt.Cell<[rt.u64, rt.u64]> = new rt.Cell([0, 0] as [rt.u64, rt.u64]); @@ -18,7 +18,7 @@ export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number const polling: borrows_Polling.Polling = borrows_Polling.default$Default(); const shared: rt.RefCell = new rt.RefCell(new rt.ByteVec()); const owned: rt.RefCell = new rt.RefCell(new borrows_Noisy.Noisy(170, rt.arcClone(log))); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _25: rt.u8 = rt.u8Rem(op, 10); if (_25 === 0) { const _28: rt.u32 = rt.u32WrappingAdd(count.v, op as rt.u32); diff --git a/ts/fixtures/lang/expected/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index 96de03583..11be217b4 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -114,21 +114,20 @@ export function within$tuple2_ops_Bound_u8_ops_Bound_u8(set: rt.BTreeSet, * `kind` picks the collection and how its range is given. The first two bytes pick the * kinds of the range's bounds, the next two their values, and the rest are the items. */ -export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.localKeyWithBorrowMut(LOG, (a0: rt.ByteVec): undefined => { rt.byteVecClear(a0); }); - if (dataLen >= 4) { - const s: rt.u8 = dataData[dataStart]; - const e: rt.u8 = dataData[dataStart + 1]; - const a: rt.u8 = dataData[dataStart + 2]; - const b: rt.u8 = dataData[dataStart + 3]; - const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 4, dataLen - 4); - const reach: rt.usize = rt.usizeAdd(data2.length, 2); + if (data.length >= 4) { + const s: rt.u8 = data.data[data.start]; + const e: rt.u8 = data.data[data.start + 1]; + const a: rt.u8 = data.data[data.start + 2]; + const b: rt.u8 = data.data[data.start + 3]; + const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 4).length, 2); const _18: [rt.usize, rt.usize] = [rt.usizeRem(a as rt.usize, reach), rt.usizeRem(b as rt.usize, reach)]; const i: rt.usize = _18[0]; const j: rt.usize = _18[1]; - const items: bounds_Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): bounds_Item.Item => { + const items: bounds_Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))), (_2: rt.u8): bounds_Item.Item => { return new bounds_Item.Item(_2); }), undefined, 1, true); const _28: rt.u8 = rt.u8Rem(kind, 6); @@ -146,11 +145,11 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat x[Symbol.dispose](); } rt.drop(iter); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); + const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 4)); const _49: [rt.RangeBound, rt.RangeBound] = [bound$ref_usize(s, i), bound$ref_usize(e, j)]; rt.iterExtendBytes(out, rt.iterRev(rt.byteVecDrain(bytes, _49)), "fold", true); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_216: rt.u8): rt.u32 => { + const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))), (_216: rt.u8): rt.u32 => { return rt.u32Add(_216 as rt.u32, 1000); }), undefined, 4, true); const drain: rt.Iter = rt.vecDrain(words, range); @@ -174,14 +173,14 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat flush(out); rt.drop(drain2); flush(out); - const bytes2: rt.ByteVec = rt.byteSliceToByteVec(data2); + const bytes2: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 4)); const _94: Asked.Asked = asked$usize(s, e, i, j); rt.byteVecPush(out, rt.ownedCount(rt.byteVecDrain(bytes2, rt.boundsOf(_94, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize))) & 0xff); flush(out); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2)), undefined, true); } else if (_28 === 2) { const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data2))); + const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); while (true) { const _104: [rt.usize, rt.u8] | rt.Done = iter2.next(); if (_104 === rt.DONE) { @@ -219,7 +218,7 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat }), undefined, true); rt.dequeDrop(queue, rt.drop); } else if (_28 === 3) { - const _155: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data2))), (_210: [rt.usize, rt.u8]): [rt.u8, rt.u8] => { + const _155: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))), (_210: [rt.usize, rt.u8]): [rt.u8, rt.u8] => { return [_210[1], _210[0] & 0xff] as [rt.u8, rt.u8]; }); const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _155, true, undefined, undefined, undefined, 2, true); @@ -246,7 +245,7 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat _189[1].v = rt.u8WrappingAdd(_189[1].v, 100); } rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); - const _199: rt.Iter = rt.iterSlice(rt.byteSliceView(data2)); + const _199: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))); const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _199, true, undefined, undefined, 1, true); rt.iterExtendBytes(out, rt.iterRev(rt.btreeRangeKeys(set, range2)), "next"); rt.byteVecPush(out, within$tuple2_ops_Bound_u8_ops_Bound_u8(set, range2) & 0xff); @@ -255,7 +254,7 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const _215: Asked.Asked = asked$u8(s, e, a, b); rt.byteVecPush(out, rt.iterCount(rt.btreeRange(empty, rt.boundsOf(_215, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8))) & 0xff); flush(out); - const _218: rt.Iter = rt.iterSlice(rt.byteSliceView(data2)); + const _218: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))); const set2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _218, true, undefined, undefined, 1, true); const _222: Asked.Asked = asked$u8(s, e, a, b); const range3: rt.Iter = rt.btreeRangeKeys(set2, rt.boundsOf(_222, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8)); @@ -272,7 +271,7 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const b2: Key.Key = _238[1]; const set3: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; const map2: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data2))); + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); while (true) { const _247: [rt.usize, rt.u8] | rt.Done = iter5.next(); if (_247 === rt.DONE) { @@ -300,7 +299,7 @@ export function bounds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat flush(out); rt.iterExtendBytes(out, rt.btreeValues(map2), undefined, true); const pairs: rt.BTreeSet<[rt.u8, Key.Key]> = rt.btreeNew(rt.cmpTuple<[rt.u8, Key.Key], rt.Ordering>([rt.cmp, Key.cmp$cmp_Ord])) as rt.BTreeSet<[rt.u8, Key.Key]>; - for (const k2 of rt.byteSliceView(data2)) { + for (const k2 of rt.byteSliceView(rt.byteSliceRange(data, 4))) { rt.btreeAdd(pairs, [k2, { _0: k2 }] as [rt.u8, Key.Key]); } const _299: [[rt.u8, Key.Key], [rt.u8, Key.Key]] = [[a2._0, a2] as [rt.u8, Key.Key], [b2._0, b2] as [rt.u8, Key.Key]]; diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index e530eca8e..745dd00c2 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -40,9 +40,9 @@ export function hash$slice_u16(value: rt.u16[]): rt.u64 { return rt.hashFinish(h); } -export function hash$slice_u8(valueData: Uint8Array, valueStart: number, valueLen: number): rt.u64 { +export function hash$slice_u8(value: rt.ByteSlice): rt.u64 { const h: rt.Hasher = rt.hasher(); - rt.hashBytes(new rt.ByteSlice(valueData, valueStart, valueLen), h); + rt.hashBytes(value, h); return rt.hashFinish(h); } @@ -53,9 +53,9 @@ export function hash$str(value: string): rt.u64 { } /** Puts `b`'s length and bytes. */ -export function bytes(bData: Uint8Array, bStart: number, bLen: number, out: rt.ByteVec): void { - rt.byteVecPush(out, bLen & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(bData, bStart, bLen)); +export function bytes(b: rt.ByteSlice, out: rt.ByteVec): void { + rt.byteVecPush(out, b.length & 0xff); + rt.byteVecExtendFromSlice(out, b); } /** Puts `b`'s length and each `u16`'s bytes. */ @@ -118,98 +118,73 @@ export function set$u8(slot: rt.Place, value: rt.ByteSlice): void slot.v = value; } -export function boxes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(dataLen, 1))); +export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); const _15: rt.u8 = rt.u8Rem(kind, 6); if (_15 === 0) { const source: rt.ByteVec = rt.byteSliceToByteVec(data2); let fromRef: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); scramble(rt.place(() => fromRef, (value3) => fromRef = value3)); - const _720: rt.ByteSlice = fromRef; - bytes(_720.data, _720.start, _720.length, out); + bytes(fromRef, out); const fromMut: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(rt.byteVecSlice(source), 0))); rt.byteSliceView(fromMut).sort(); - const _721: rt.ByteSlice = fromMut; - bytes(_721.data, _721.start, _721.length, out); - const _33: rt.ByteSlice = rt.byteVecSlice(source); - bytes(_33.data, _33.start, _33.length, out); - const _722: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - bytes(_722.data, _722.start, _722.length, out); + bytes(fromMut, out); + bytes(rt.byteVecSlice(source), out); + bytes(rt.byteSliceFrom(rt.byteSliceToArray(data2)), out); const spare: rt.ByteVec = new rt.ByteVec(64); rt.byteVecExtendFromSlice(spare, data2); let fromVec: rt.ByteSlice = rt.byteVecSlice(spare); scramble(rt.place(() => fromVec, (value4) => fromVec = value4)); - const _723: rt.ByteSlice = fromVec; - bytes(_723.data, _723.start, _723.length, out); + bytes(fromVec, out); let boxed: rt.ByteSlice = rt.byteVecSlice(rt.byteVecFrom(rt.byteVecView(source))); scramble(rt.place(() => boxed, (value5) => boxed = value5)); - const _724: rt.ByteSlice = boxed; - bytes(_724.data, _724.start, _724.length, out); + bytes(boxed, out); const array: Uint8Array = Uint8Array.of(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data2), 1), 2, 3, 4); let fromArray: rt.ByteSlice = rt.byteSliceFrom(copy$array_u8(array)); scramble(rt.place(() => fromArray, (value6) => fromArray = value6)); - const _725: rt.ByteSlice = fromArray; - bytes(_725.data, _725.start, _725.length, out); - const _68: rt.ByteSlice = rt.byteSliceFrom(array); - bytes(_68.data, _68.start, _68.length, out); + bytes(fromArray, out); + bytes(rt.byteSliceFrom(array), out); const coerced: rt.ByteSlice = rt.byteSliceFrom(copy$array_u8(array)); rt.idx(coerced, 0); coerced.data[coerced.start] = 9; - const _726: rt.ByteSlice = coerced; - bytes(_726.data, _726.start, _726.length, out); - const _79: rt.ByteSlice = rt.byteSliceFrom(array); - bytes(_79.data, _79.start, _79.length, out); + bytes(coerced, out); + bytes(rt.byteSliceFrom(array), out); const collected: rt.ByteSlice = rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_27: rt.u8): rt.u8 => { return _27 ^ 85; }), undefined, true)); - const _727: rt.ByteSlice = collected; - bytes(_727.data, _727.start, _727.length, out); + bytes(collected, out); let cloned: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(collected)); scramble(rt.place(() => cloned, (value7) => cloned = value7)); - const _728: rt.ByteSlice = cloned; - bytes(_728.data, _728.start, _728.length, out); - const _729: rt.ByteSlice = collected; - bytes(_729.data, _729.start, _729.length, out); + bytes(cloned, out); + bytes(collected, out); const empty: rt.ByteSlice = rt.byteSliceFrom(new Uint8Array(0)); - const _730: rt.ByteSlice = empty; - bytes(_730.data, _730.start, _730.length, out); - const _731: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(empty)); - bytes(_731.data, _731.start, _731.length, out); - const _732: rt.ByteSlice = rt.byteVecSlice(rt.byteCowIntoOwned(data2)); - bytes(_732.data, _732.start, _732.length, out); - const _733: rt.ByteSlice = rt.byteVecSlice(rt.byteCowIntoOwned(rt.byteSliceToByteVec(data2))); - bytes(_733.data, _733.start, _733.length, out); + bytes(empty, out); + bytes(rt.byteSliceFrom(rt.byteSliceToArray(empty)), out); + bytes(rt.byteVecSlice(rt.byteCowIntoOwned(data2)), out); + bytes(rt.byteVecSlice(rt.byteCowIntoOwned(rt.byteSliceToByteVec(data2))), out); const v: rt.ByteVec = rt.byteSliceToByteVec(fromRef); rt.byteVecPush(v, 238); rt.byteVecExtendFromSlice(v, fromVec); - const _126: rt.ByteSlice = rt.byteVecSlice(v); - bytes(_126.data, _126.start, _126.length, out); - const _131: rt.ByteSlice = rt.byteVecSlice(rt.byteSliceToByteVec(cloned)); - bytes(_131.data, _131.start, _131.length, out); + bytes(rt.byteVecSlice(v), out); + bytes(rt.byteVecSlice(rt.byteSliceToByteVec(cloned)), out); let slot: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); const _136: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); set$u8(rt.place(() => slot, (value8) => slot = value8), _136); - const _735: rt.ByteSlice = slot; - bytes(_735.data, _735.start, _735.length, out); + bytes(slot, out); const _143: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); const old2 = slot; slot = _143; - const _736: rt.ByteSlice = old2; - bytes(_736.data, _736.start, _736.length, out); + bytes(old2, out); const taken2 = slot; slot = rt.byteSliceFrom(new Uint8Array(0)); - const _737: rt.ByteSlice = taken2; - bytes(_737.data, _737.start, _737.length, out); - const _738: rt.ByteSlice = slot; - bytes(_738.data, _738.start, _738.length, out); + bytes(taken2, out); + bytes(slot, out); let other: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(9)); const swapped = slot; slot = other; other = swapped; - const _739: rt.ByteSlice = slot; - bytes(_739.data, _739.start, _739.length, out); - const _740: rt.ByteSlice = other; - bytes(_740.data, _740.start, _740.length, out); + bytes(slot, out); + bytes(other, out); let sum: rt.u8 = 0; const iter: rt.Iter = rt.iterSlice(rt.byteSliceView(boxed)); while (true) { @@ -233,7 +208,7 @@ export function boxes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data return o & 0xff; })); rt.byteVecPush(out, rt.byteSliceEq(a, data2) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_slice_u8(a), hash$slice_u8(data2.data, data2.start, data2.length)) ? 1 : 0); + rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_slice_u8(a), hash$slice_u8(data2)) ? 1 : 0); rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(hash$boxed_Box_slice_u8(b)).reverse()), undefined, true); rt.byteVecPush(out, a.length & 0xff); rt.byteVecPush(out, a.length === 0 ? 1 : 0); @@ -432,7 +407,7 @@ export function boxes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_634[1]).reverse()), undefined, true); } } else { - const s: string = text(data2.data, data2.start, data2.length); + const s: string = text(data2); const fromRef4: string = s; const fromString: string = s; const into2: string = s; diff --git a/ts/fixtures/lang/expected/captures.ts b/ts/fixtures/lang/expected/captures.ts index f0c509715..a788a4642 100644 --- a/ts/fixtures/lang/expected/captures.ts +++ b/ts/fixtures/lang/expected/captures.ts @@ -10,8 +10,7 @@ export function through$u8s(n: rt.Place, b: rt.u8): rt.u8 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u8s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -112,8 +111,7 @@ export function through$u16s(n: rt.Place, b: rt.u16): rt.u16 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u16s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(2); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -214,8 +212,7 @@ export function through$u32s(n: rt.Place, b: rt.u32): rt.u32 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u32s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -316,8 +313,7 @@ export function through$u64s(n: rt.Place, b: rt.u64): rt.u64 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u64s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -418,8 +414,7 @@ export function through$u128s(n: rt.Place, b: rt.u128): rt.u128 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u128s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u128s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(16); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -520,8 +515,7 @@ export function through$usizes(n: rt.Place, b: rt.usize): rt.usize { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function usizes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -615,8 +609,7 @@ export function usizes(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i8s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -717,8 +710,7 @@ export function through$i8s(n: rt.Place, b: rt.i8): rt.i8 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i16s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(2); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -819,8 +811,7 @@ export function through$i16s(n: rt.Place, b: rt.i16): rt.i16 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i32s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -921,8 +912,7 @@ export function through$i32s(n: rt.Place, b: rt.i32): rt.i32 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i64s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1023,8 +1013,7 @@ export function through$i64s(n: rt.Place, b: rt.i64): rt.i64 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i128s(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i128s(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(16); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1125,8 +1114,7 @@ export function through$i128s(n: rt.Place, b: rt.i128): rt.i128 { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function isizes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1227,32 +1215,32 @@ export function through$isizes(n: rt.Place, b: rt.isize): rt.isize { } /** Run [`writes`] over the integer type `kind` picks. */ -export function captures(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function captures(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 12); if (_4 === 0) { - u8s(dataData, dataStart, dataLen, out); + u8s(data, out); } else if (_4 === 1) { - u16s(dataData, dataStart, dataLen, out); + u16s(data, out); } else if (_4 === 2) { - u32s(dataData, dataStart, dataLen, out); + u32s(data, out); } else if (_4 === 3) { - u64s(dataData, dataStart, dataLen, out); + u64s(data, out); } else if (_4 === 4) { - u128s(dataData, dataStart, dataLen, out); + u128s(data, out); } else if (_4 === 5) { - usizes(dataData, dataStart, dataLen, out); + usizes(data, out); } else if (_4 === 6) { - i8s(dataData, dataStart, dataLen, out); + i8s(data, out); } else if (_4 === 7) { - i16s(dataData, dataStart, dataLen, out); + i16s(data, out); } else if (_4 === 8) { - i32s(dataData, dataStart, dataLen, out); + i32s(data, out); } else if (_4 === 9) { - i64s(dataData, dataStart, dataLen, out); + i64s(data, out); } else if (_4 === 10) { - i128s(dataData, dataStart, dataLen, out); + i128s(data, out); } else { - isizes(dataData, dataStart, dataLen, out); + isizes(data, out); } } diff --git a/ts/fixtures/lang/expected/cells.ts b/ts/fixtures/lang/expected/cells.ts index 96efe3581..33a9aaa93 100644 --- a/ts/fixtures/lang/expected/cells.ts +++ b/ts/fixtures/lang/expected/cells.ts @@ -505,7 +505,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** Steps on the cell and value type `kind` picks. */ -export function cells(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cells(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const cases: Array<(a0: rt.ByteSlice, a1: rt.ByteVec) => undefined> = [(a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { cellU8(a0.data, a0.start, a0.length, a1); }, (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { @@ -527,7 +527,7 @@ export function cells(kind: rt.u8, dataData: Uint8Array, dataStart: number, data }, (a010: rt.ByteSlice, a110: rt.ByteVec): undefined => { lockString(a010.data, a010.start, a010.length, a110); }]; - cases[rt.idx(cases, rt.usizeRem(kind as rt.usize, cases.length))](new rt.ByteSlice(dataData, dataStart, dataLen), out); + cases[rt.idx(cases, rt.usizeRem(kind as rt.usize, cases.length))](data, out); } /** Steps of an operation and an operand on one cell, each putting what it read. */ diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 031e46f36..1fd6c6623 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -5,9 +5,9 @@ import { unwrapOr$0k15iai as option_unwrapOr$0k15iai } from "./core/option.ts"; import { put as fmt_put } from "./fmt.ts"; /** The scalars to try: the edges, then each big-endian `u32` in `data`, zero-padded. */ -export function scalars(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32[] { +export function scalars(data: rt.ByteSlice): rt.u32[] { const all: rt.u32[] = [0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice(); - let rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); + let rest: rt.ByteSlice = data; while (true) { if (!((rest.length === 0))) { const buf: Uint8Array = rt.bytes(4); @@ -65,10 +65,10 @@ export function class_(c: rt.char): rt.u8 { return 2; } -export function chars(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { - for (const _10 of scalars(dataData, dataStart, dataLen)) { + for (const _10 of scalars(data)) { const _14: rt.char | undefined = rt.charFromU32(_10); if (_14 === undefined) { rt.byteVecPush(out, 255); @@ -79,7 +79,7 @@ export function chars(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } } } else if (_4 === 1) { - for (const n2 of scalars(dataData, dataStart, dataLen)) { + for (const n2 of scalars(data)) { const c2: rt.char = option_unwrapOr$0k15iai(rt.charFromU32(n2), (n2 & 0xff) as rt.char); rt.byteVecPush(out, c2 & 0xff); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(c2 & 0xffff))); @@ -92,7 +92,7 @@ export function chars(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16))); } } else if (_4 === 2) { - const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(dataData, dataStart, dataLen)), (a0: rt.u32): rt.char | undefined => { + const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); }), "next", 4); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; @@ -119,7 +119,7 @@ export function chars(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_128 as rt.u32))); } } else { - for (const _140 of scalars(dataData, dataStart, dataLen)) { + for (const _140 of scalars(data)) { const _144: rt.char | undefined = rt.charFromU32(_140); if (_144 !== undefined) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(_144, f)]; diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index 7d1d7284a..04bbaca58 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import type * as Header from "./chunks.Header.ts"; -import { mapOr$03wh65t as option_mapOr$03wh65t } from "./core/option.ts"; +import { mapOr$1jgrjsu as option_mapOr$1jgrjsu } from "./core/option.ts"; export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Header.Header | undefined { if (dataLen >= 2) { @@ -26,25 +26,24 @@ export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): export const take4Out: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export function word(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): rt.u32 { - return ((chunkData[chunkStart] << 24) | (chunkData[chunkStart + 1] << 16) | (chunkData[chunkStart + 2] << 8) | chunkData[chunkStart + 3]) >>> 0; +export function word(chunk: rt.ByteSlice): rt.u32 { + return ((chunk.data[chunk.start] << 24) | (chunk.data[chunk.start + 1] << 16) | (chunk.data[chunk.start + 2] << 8) | chunk.data[chunk.start + 3]) >>> 0; } -export function pick(aData: Uint8Array, aStart: number, aLen: number, bData: Uint8Array, bStart: number, bLen: number, first: boolean): rt.ByteSlice { +export function pick(a: rt.ByteSlice, b: rt.ByteSlice, first: boolean): rt.ByteSlice { if (!first) { - return new rt.ByteSlice(bData, bStart, bLen); + return b; } - return new rt.ByteSlice(aData, aStart, aLen); + return a; } -export function reader(chunkData: Uint8Array, chunkStart: number, chunkLen: number): (a0: rt.usize) => rt.u8 { - const captured = new rt.ByteSlice(chunkData, chunkStart, chunkLen); +export function reader(chunk: rt.ByteSlice): (a0: rt.usize) => rt.u8 { return (i: rt.usize): rt.u8 => { const _3: rt.usize = rt.usizeRem(i, 2); if (!(_3 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _3); } - return captured.data[captured.start + _3]; + return chunk.data[chunk.start + _3]; }; } @@ -58,36 +57,36 @@ export function ends(chunkData: Uint8Array, chunkStart: number, _chunkLen: numbe return [chunkData[chunkStart], new rt.ByteSlice(chunkData, chunkStart + 1, 2), chunkData[chunkStart + 3]] as [rt.u8, rt.ByteSlice, rt.u8]; } -export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let chosen2!: rt.ByteSlice; const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - const _6: Header.Header | undefined = header(dataData, dataStart, dataLen); + const _6: Header.Header | undefined = header(data.data, data.start, data.length); if (_6 !== undefined) { const h: Header.Header = _6; rt.byteVecExtendFromSlice(out, h.tag); rt.byteVecPush(out, h.tag.data[h.tag.start + 1]); rt.byteVecPush(out, h.rest.length & 0xff); } - const err: rt.u8 | undefined = take4(dataData, dataStart, dataLen); - const part2: Uint8Array = take4Out.p_0Data; - const part3: number = take4Out.p_0Start; - const part4: number = take4Out.p_0Len; - const part5: Uint8Array = take4Out.p_1Data; - const part6: number = take4Out.p_1Start; - const part7: number = take4Out.p_1Len; + const err: rt.u8 | undefined = take4(data.data, data.start, data.length); + const part3: Uint8Array = take4Out.p_0Data; + const part4: number = take4Out.p_0Start; + const part5: number = take4Out.p_0Len; + const part6: Uint8Array = take4Out.p_1Data; + const part7: number = take4Out.p_1Start; + const part8: number = take4Out.p_1Len; if (err === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(part2, part3, part4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part2[part3 + 1] << 8) | part2[part3 + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part2, part3, part4); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(new rt.ByteSlice(part3, part4, part5))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part3[part4 + 1] << 8) | part3[part4 + 2]) << 16) >> 16))); + const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part3, part4, part5); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part5, part6, part7)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part6, part7, part8)); } else { rt.byteVecPush(out, err as rt.u8); } } else if (_4 === 1) { const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), 4)); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4)); while (true) { const _64: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_64 === rt.DONE) { @@ -109,24 +108,24 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(before)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(after)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(buf)); - const pair: Uint8Array = Uint8Array.of(dataLen & 0xff, 3); + const pair: Uint8Array = Uint8Array.of(data.length & 0xff, 3); bump(rt.byteSliceFrom(pair)); bump(rt.byteSliceFrom(pair)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pair)); } else if (_4 === 2) { - if (dataLen >= 2) { - const b: rt.ByteSlice = option_mapOr$03wh65t((dataLen - 2 >= 2 ? [new rt.ByteSlice(dataData, dataStart + 2, 2), new rt.ByteSlice(dataData, dataStart + 4, dataLen - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, dataData, dataStart, 2, (_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 = option_mapOr$1jgrjsu((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 chosen: rt.ByteSlice = pick(dataData, dataStart, 2, b.data, b.start, b.length, rt.usizeRem(dataLen, 2) === 0); - const read: (a0: rt.usize) => rt.u8 = reader(chosen.data, chosen.start, chosen.length); + 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 captured = new rt.ByteSlice(dataData, dataStart, 2); 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 = captured.data[captured.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); } @@ -134,11 +133,11 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat }; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(both(0), both(1)))); rt.byteVecExtendFromSlice(out, b); - rt.byteVecPush(out, (dataLen - 2) & 0xff); + rt.byteVecPush(out, part2.length & 0xff); } } else if (_4 === 3) { const lit: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); - const _143: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); + const _143: rt.u8 | undefined = rt.byteSliceFirst(data); b8: { if (_143 !== undefined) { if (rt.u8Rem(_143, 2) === 0) { @@ -152,13 +151,13 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, chosen2.data[chosen2.start + 1]); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chosen2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(lit), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - if (dataLen >= 3) { - const chunk2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, 3); + if (data.length >= 3) { + const chunk2: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 3); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); } } else if (_4 === 4) { - const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): Uint8Array => { + const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { const b2: rt.u8 = _2; return Uint8Array.of(b2, rt.u8WrappingAdd(b2, 3)); }), undefined, 2, true); @@ -195,9 +194,9 @@ export function chunks(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat return p2.data[p2.start + 1]; })), undefined, true); } else { - let restData3: Uint8Array = dataData; - let restStart3: number = dataStart; - let restLen3: number = dataLen; + let restData3: Uint8Array = data.data; + let restStart3: number = data.start; + let restLen3: number = data.length; let sum: rt.u32 = 0; while (true) { const _261Data: Uint8Array = restData3; diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 8ea7ff0a0..715d8b7ca 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -6599,11 +6599,10 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur * Each of std's iterators and adaptors, partly read and cloned, read in turns with its * clone. */ -export function iters(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _263!: [rt.ByteSlice, rt.ByteSlice]; let _269!: rt.usize; let it!: rt.Peekable; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const plan: Plan.Plan = { data, at: kind as rt.usize }; const n: rt.usize = option_mapOr$1surhce(rt.byteSliceFirst(data), 1, (_2: rt.u8): rt.u8 => { return rt.u8Add(rt.u8Rem(_2, 4), 1); @@ -7176,9 +7175,9 @@ export function iters(kind: rt.u8, dataData: Uint8Array, dataStart: number, data return x13; }, out); } else if (_9 === 13) { - owned(data.data, data.start, data.length, plan, out); + owned(data, plan, out); } else if (_9 === 14) { - closures(data.data, data.start, data.length, plan, out); + closures(data, plan, out); } else { const _582: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const make = (captured: rt.u8): (a0: rt.u8) => rt.u8 => { @@ -7388,8 +7387,7 @@ export function unordered$iter_Map_collections_hash_map_Iter_u8_u8_clones_iters_ * Iterators that own what they yield, each item cloned by its own `Clone` as the iterator * is, and dropped as each iterator drops. */ -export function owned(dataData: Uint8Array, dataStart: number, dataLen: number, plan: Plan.Plan, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function owned(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); const logged: (a0: rt.u8) => clones_Logged.Logged = (id: rt.u8): clones_Logged.Logged => { return new clones_Logged.Logged(id, rt.arcClone(log)); @@ -7495,8 +7493,7 @@ export function owned(dataData: Uint8Array, dataStart: number, dataLen: number, * Adaptors of closures that capture values that drop, which their clones clone and drop * with them, and closures cloned on their own. */ -export function closures(dataData: Uint8Array, dataStart: number, dataLen: number, plan: Plan.Plan, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function closures(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); const logged: (a0: rt.u8) => clones_Logged.Logged = (id: rt.u8): clones_Logged.Logged => { return new clones_Logged.Logged(id, rt.arcClone(log)); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index 9804036e0..ca4d5a865 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -60,12 +60,11 @@ export function rankByte(r: Rank.Rank): rt.u8 { } /** A `HashMap` by each kind of key, through a script of inserts, lookups, and removals. */ -export function hashMaps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _174!: rt.usize; let _299!: rt.usize; let _377!: rt.u8; let _429!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _443: (a0: collections_Nibble.Nibble) => rt.u64 = (n: collections_Nibble.Nibble): rt.u64 => { const h2: rt.Hasher = rt.hasher(); collections_Nibble.hash$Hash_hash_DefaultHasher(n, h2); @@ -464,8 +463,7 @@ export function claim(map: rt.HashMap, k: rt.u8, } /** `HashSet` and `BTreeSet`, each with the same script. */ -export function sets(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _159: (a0: collections_Nibble.Nibble | undefined) => rt.u8 = (n2: collections_Nibble.Nibble | undefined): rt.u8 => { return option_mapOr$0q0ymkh(n2, 238, (n3: collections_Nibble.Nibble): rt.u8 => { return n3._0; @@ -637,12 +635,11 @@ export function sets(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** `BTreeMap`: ordered by the key's `Ord`, through inserts, removals, and ranges. */ -export function btreeMaps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let within!: rt.ByteVec; let _185!: rt.usize; let _365!: rt.usize; let _422!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; @@ -930,9 +927,8 @@ export function touch(q: rt.VecDeque): rt.VecDeque { } /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ -export function deques(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { let drained2!: rt.ByteVec; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; for (const b of rt.byteSliceView(data)) { @@ -1050,9 +1046,8 @@ export function deques(dataData: Uint8Array, dataStart: number, dataLen: number, } /** `vec![a, b]` and `vec![x; n]`, of bytes, numbers, `Copy` tuples, and types that clone. */ -export function vecs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { let name!: string; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const n: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 2), 0) as rt.usize, 5); @@ -1170,8 +1165,7 @@ export function hold(pair: [rt.u8, rt.u8]): Holder.Holder { * A `Copy` aggregate a std call stores by value is the container's own copy: changing * one stored element leaves the value it came from and the other elements as they were. */ -export function stores(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const pair: [rt.u8, rt.u8] = same([a, b] as [rt.u8, rt.u8]); @@ -1398,9 +1392,9 @@ export function sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(s * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_String_collections_HashMap_u8_Option_String(map: rt.HashMap, dataData: Uint8Array, dataStart: number, dataLen: number, value: (a0: rt.u8) => string | undefined, out: rt.ByteVec): void { +export function optional$Option_String_collections_HashMap_u8_Option_String(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => string | undefined, out: rt.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const k: rt.u8 = rt.u8Rem(b, 8); const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); if (_14 === 0) { @@ -1439,9 +1433,9 @@ export function optional$Option_String_collections_HashMap_u8_Option_String(map: * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rt.BTreeMap, dataData: Uint8Array, dataStart: number, dataLen: number, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { +export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rt.BTreeMap, data: rt.ByteSlice, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const k: rt.u8 = rt.u8Rem(b, 8); const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); if (_14 === 0) { @@ -1480,9 +1474,9 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rt.BTr * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rt.HashMap, dataData: Uint8Array, dataStart: number, dataLen: number, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { +export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const k: rt.u8 = rt.u8Rem(b, 8); const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); if (_14 === 0) { @@ -1521,9 +1515,9 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rt.Hash * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$unit_collections_BTreeMap_u8_unit(map: rt.BTreeMap, dataData: Uint8Array, dataStart: number, dataLen: number, value: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +export function optional$unit_collections_BTreeMap_u8_unit(map: rt.BTreeMap, data: rt.ByteSlice, value: (a0: rt.u8) => undefined, out: rt.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const k: rt.u8 = rt.u8Rem(b, 8); const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); if (_14 === 0) { @@ -1562,9 +1556,9 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rt.BTreeMap, dataData: Uint8Array, dataStart: number, dataLen: number, value: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +export function optional$unit_collections_HashMap_u8_unit(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => undefined, out: rt.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const k: rt.u8 = rt.u8Rem(b, 8); const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); if (_14 === 0) { @@ -1618,26 +1612,26 @@ export function made$collections_HashMap_u8_Option_String(): rt.HashMap, dataData, dataStart, dataLen, some, out); + optional$Option_u8_collections_HashMap_u8_Option_u8(rt.hashNew() as rt.HashMap, data, some, out); } else if (_4 === 1) { - optional$Option_u8_collections_BTreeMap_u8_Option_u8(made$collections_BTreeMap_u8_Option_u8(), dataData, dataStart, dataLen, some, out); + optional$Option_u8_collections_BTreeMap_u8_Option_u8(made$collections_BTreeMap_u8_Option_u8(), data, some, out); } else if (_4 === 2) { - optional$unit_collections_HashMap_u8_unit(rt.hashNew() as rt.HashMap, dataData, dataStart, dataLen, (_22: rt.u8): undefined => {}, out); + optional$unit_collections_HashMap_u8_unit(rt.hashNew() as rt.HashMap, data, (_22: rt.u8): undefined => {}, out); } else if (_4 === 3) { - optional$unit_collections_BTreeMap_u8_unit(rt.btreeNew(rt.cmp) as rt.BTreeMap, dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + optional$unit_collections_BTreeMap_u8_unit(rt.btreeNew(rt.cmp) as rt.BTreeMap, data, (_2: rt.u8): undefined => {}, out); } else if (_4 === 4) { - optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), dataData, dataStart, dataLen, (b2: rt.u8): string | undefined => { + optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rt.u8): string | undefined => { return option_map$0oc32h1(some(b2), (b3: rt.u8): string => { return rt.fmtToString((f: rt.Formatter) => rt.u8Display(b3, f)); }); }, out); } else { const map: rt.HashMap<[rt.u8, boolean], rt.u8 | undefined> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, boolean], rt.u8 | undefined>; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const k: [rt.u8, boolean] = [rt.u8Rem(b, 4), (b & 16) !== 0]; const _29: rt.u8 = rt.u8Rem(rt.u8Div(b, 32), 4); if (_29 === 0) { @@ -1672,8 +1666,7 @@ export function optionals(kind: rt.u8, dataData: Uint8Array, dataStart: number, * in the runtime's, so what each yields is sorted first. The `Nibble` an op yields shows * which set's key of two equal ones std's picks. */ -export function setOps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function setOps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const mid: number = rt.usizeDiv(data.length, 2); if (mid > data.length) { rt.panic("mid > len"); @@ -1714,41 +1707,31 @@ export function setOps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _55: rt.u8 = rt.u8Rem(kind, 5); if (_55 === 0) { - const _57: rt.ByteSlice = left; - const _58: rt.ByteSlice = right; - setOpsOf$u8(_57.data, _57.start, _57.length, _58.data, _58.start, _58.length, (b6: rt.u8): rt.u8 => { + setOpsOf$u8(left, right, (b6: rt.u8): rt.u8 => { return rt.u8Rem(b6, 32); }, (v3: rt.u8): rt.u8 => { return v3; }, out); } else if (_55 === 1) { - const _61: rt.ByteSlice = left; - const _62: rt.ByteSlice = right; - setOpsOf$array2_u8(_61.data, _61.start, _61.length, _62.data, _62.start, _62.length, (b5: rt.u8): Uint8Array => { + setOpsOf$array2_u8(left, right, (b5: rt.u8): Uint8Array => { return Uint8Array.of(rt.u8Rem(b5, 4), rt.u8Rem(rt.u8Div(b5, 4), 4)); }, (k2: rt.ByteSlice): rt.u8 => { return ((k2.data[k2.start] << 4) & 0xff) | k2.data[k2.start + 1]; }, out); } else if (_55 === 2) { - const _65: rt.ByteSlice = left; - const _66: rt.ByteSlice = right; - setOpsOf$Option_u8(_65.data, _65.start, _65.length, _66.data, _66.start, _66.length, (b4: rt.u8): rt.u8 | undefined => { + setOpsOf$Option_u8(left, right, (b4: rt.u8): rt.u8 | undefined => { return thenSome$0d5am30(rt.u8Rem(b4, 32) !== 0, rt.u8Rem(b4, 32)); }, (v2: rt.u8 | undefined): rt.u8 => { return option_unwrapOr$0r2bmpr(v2, 238); }, out); } else if (_55 === 3) { - const _69: rt.ByteSlice = left; - const _70: rt.ByteSlice = right; - setOpsOf$collections_Nibble(_69.data, _69.start, _69.length, _70.data, _70.start, _70.length, (a0: rt.u8): collections_Nibble.Nibble => { + setOpsOf$collections_Nibble(left, right, (a0: rt.u8): collections_Nibble.Nibble => { return { _0: a0 }; }, (n: collections_Nibble.Nibble): rt.u8 => { return n._0; }, out); } else { - const _73: rt.ByteSlice = left; - const _74: rt.ByteSlice = right; - setOpsOf$cmp_Reverse_Option_u8(_73.data, _73.start, _73.length, _74.data, _74.start, _74.length, (b3: rt.u8): rt.u8 | undefined => { + setOpsOf$cmp_Reverse_Option_u8(left, right, (b3: rt.u8): rt.u8 | undefined => { return thenSome$0d5am30(rt.u8Rem(b3, 32) !== 0, rt.u8Rem(b3, 32)); }, (v: rt.u8 | undefined): rt.u8 => { return option_unwrapOr$0r2bmpr(v, 238); @@ -1757,9 +1740,7 @@ export function setOps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } -export function setOpsOf$Option_u8(leftData: Uint8Array, leftStart: number, leftLen: number, rightData: Uint8Array, rightStart: number, rightLen: number, make: (a0: rt.u8) => rt.u8 | undefined, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const left: rt.ByteSlice = new rt.ByteSlice(leftData, leftStart, leftLen); - const right: rt.ByteSlice = new rt.ByteSlice(rightData, rightStart, rightLen); +export function setOpsOf$Option_u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => rt.u8 | undefined, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.u8 | undefined => { return make(_2); }); @@ -1856,9 +1837,7 @@ export function setOpsOf$Option_u8(leftData: Uint8Array, leftStart: number, left } } -export function setOpsOf$array2_u8(leftData: Uint8Array, leftStart: number, leftLen: number, rightData: Uint8Array, rightStart: number, rightLen: number, make: (a0: rt.u8) => Uint8Array, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const left: rt.ByteSlice = new rt.ByteSlice(leftData, leftStart, leftLen); - const right: rt.ByteSlice = new rt.ByteSlice(rightData, rightStart, rightLen); +export function setOpsOf$array2_u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => Uint8Array, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): Uint8Array => { return make(_2); }); @@ -1955,9 +1934,7 @@ export function setOpsOf$array2_u8(leftData: Uint8Array, leftStart: number, left } } -export function setOpsOf$cmp_Reverse_Option_u8(leftData: Uint8Array, leftStart: number, leftLen: number, rightData: Uint8Array, rightStart: number, rightLen: number, make: (a0: rt.u8) => rt.u8 | undefined, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const left: rt.ByteSlice = new rt.ByteSlice(leftData, leftStart, leftLen); - const right: rt.ByteSlice = new rt.ByteSlice(rightData, rightStart, rightLen); +export function setOpsOf$cmp_Reverse_Option_u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => rt.u8 | undefined, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.u8 | undefined => { return make(_2); }); @@ -2054,9 +2031,7 @@ export function setOpsOf$cmp_Reverse_Option_u8(leftData: Uint8Array, leftStart: } } -export function setOpsOf$collections_Nibble(leftData: Uint8Array, leftStart: number, leftLen: number, rightData: Uint8Array, rightStart: number, rightLen: number, make: (a0: rt.u8) => collections_Nibble.Nibble, put: (a0: collections_Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const left: rt.ByteSlice = new rt.ByteSlice(leftData, leftStart, leftLen); - const right: rt.ByteSlice = new rt.ByteSlice(rightData, rightStart, rightLen); +export function setOpsOf$collections_Nibble(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => collections_Nibble.Nibble, put: (a0: collections_Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): collections_Nibble.Nibble => { return make(_2); }); @@ -2153,9 +2128,7 @@ export function setOpsOf$collections_Nibble(leftData: Uint8Array, leftStart: num } } -export function setOpsOf$u8(leftData: Uint8Array, leftStart: number, leftLen: number, rightData: Uint8Array, rightStart: number, rightLen: number, make: (a0: rt.u8) => rt.u8, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const left: rt.ByteSlice = new rt.ByteSlice(leftData, leftStart, leftLen); - const right: rt.ByteSlice = new rt.ByteSlice(rightData, rightStart, rightLen); +export function setOpsOf$u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.u8 => { return make(_2); }); @@ -3578,7 +3551,7 @@ export function partialCmp$cmp_PartialOrd_collections_Right_array2_u8(selfData: * A `Right` against each of `data`, with the same remainders by 3 and 4 but at the * positions `kind` picks, where only `ne`'s or only `eq`'s is, and one fewer for bit 6. */ -export function rights(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number): Right.Right[] { +export function rights(kind: rt.u8, data: rt.ByteSlice): Right.Right[] { const _5: [rt.usize, rt.usize] = [(kind & 7) as rt.usize, ((kind >> 3) & 7) as rt.usize]; const byNe: rt.usize = _5[0]; const byEq: rt.usize = _5[1]; @@ -3591,7 +3564,7 @@ export function rights(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } return 3; }; - const rights: Right.Right[] = rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))), (_2: [rt.usize, rt.u8]): Right.Right => { + const rights: Right.Right[] = rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): Right.Right => { return { _0: rt.u16Add(_2[1] as rt.u16, step(_2[0])) }; }), undefined, 2, true); if ((kind & 64) !== 0) { @@ -3613,15 +3586,14 @@ export function putEq(eq: boolean, log: rt.Cell, out: rt.ByteVec): void * `ne` disagree on at the positions `kind` picks, and a deque wrapped around its buffer. * Then `next_if_eq` of such sequences, matching and missing. */ -export function unlikeEqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Cell = new rt.Cell(0); const lefts: () => Left.Left[] = (): Left.Left[] => { return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): Left.Left => { return { _0: _23 as rt.u16, _1: log }; }), undefined, 8, true); }; - const rights_: Right.Right[] = rights(kind, data.data, data.start, data.length); + const rights_: Right.Right[] = rights(kind, data); const byEq: rt.usize = ((kind >> 3) & 7) as rt.usize; const at: (a0: rt.usize) => rt.u16 = (i: rt.usize): rt.u16 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.u16; @@ -3946,8 +3918,7 @@ export function each$collections_Quirky_cell_RefCell_collections_Quirky_collecti * lengths, empty, nested, and with items `eq` and `ne` disagree on at the positions * `kind` picks. */ -export function ownNes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _34: (a0: collections_Picky.Picky[], a1: rt.usize) => rt.u16 = (v: collections_Picky.Picky[], i: rt.usize): rt.u16 => { return option_mapOr$0bnr5nu(rt.sliceGet(v, i), 0, (p: collections_Picky.Picky): rt.u16 => { return p._0; @@ -4244,10 +4215,9 @@ export function putCmp(order: rt.Ordering, log: rt.Cell, out: rt.ByteVec * B-tree keys, and a `RefCell` against itself. Then, as `kind` picks, a `RefCell` compared * while mutably borrowed, which panics, or held by an `Arc` that finds itself equal first. */ -export function cellEqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _688!: [Quirky.Quirky, Quirky.Quirky]; let _mutable!: rt.RefCell; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const log: rt.Cell = new rt.Cell(0); const at: (a0: rt.usize) => rt.u16 = (i: rt.usize): rt.u16 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.u16; @@ -4599,8 +4569,7 @@ export function cellEqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, da * what they point at, against a reference by the impl against it, and of byte arrays, * both by value and through references. */ -export function unlikeCompares(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function unlikeCompares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _9: (a0: rt.Ordering | undefined, a1: rt.Cell, a2: rt.ByteVec) => undefined = (o: rt.Ordering | undefined, log2: rt.Cell, out2: rt.ByteVec): undefined => { rt.byteVecPush(out2, option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { return o2 & 0xff; @@ -4614,7 +4583,7 @@ export function unlikeCompares(kind: rt.u8, dataData: Uint8Array, dataStart: num }), undefined, 8, true); }; const rights_: () => Right.Right[] = (): Right.Right[] => { - return rights(kind, data.data, data.start, data.length); + return rights(kind, data); }; const _12: [Left.Left[], Right.Right[]] = [lefts(), rights_()]; const mine: Left.Left[] = _12[0]; @@ -4677,10 +4646,10 @@ export function partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed(self: Boxe * impls: `&ByRef`'s, `ByVal`'s through `&ByVal`, `Mixed`'s and `&Mixed`'s, and each * through `&&T`. Then `Box`'s. */ -export function refOrders(_kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let data2!: rt.ByteSlice; - if (!((dataLen === 0))) { - data2 = new rt.ByteSlice(dataData, dataStart, dataLen); + if (!((data.length === 0))) { + data2 = data; } else { data2 = rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(0)), 0); } diff --git a/ts/fixtures/lang/expected/combinators.ts b/ts/fixtures/lang/expected/combinators.ts index 99b3a44f3..47b0ae87b 100644 --- a/ts/fixtures/lang/expected/combinators.ts +++ b/ts/fixtures/lang/expected/combinators.ts @@ -6,8 +6,7 @@ import { isSomeAnd$09tpccf, isNoneOr$1s1o3ss, unwrapOr$0r2bmpr as option_unwrapO import { isOkAnd$0jj0nkw, isErrAnd$0b01a39, ok$1c77lmd, err$05f656d, asRef$1glrxiq, map$1qqg34g as result_map$1qqg34g, map$132mdj8 as result_map$132mdj8, mapOr$1mu5bvh as result_mapOr$1mu5bvh, mapOrElse$0jxx67n as result_mapOrElse$0jxx67n, mapErr$12w1s5x as result_mapErr$12w1s5x, mapErr$1lsqfgi as result_mapErr$1lsqfgi, inspect$16o3gle as result_inspect$16o3gle, inspectErr$06tv5sa, unwrapOrDefault$1exw7nd as result_unwrapOrDefault$1exw7nd, and$0l7ltae as result_and$0l7ltae, andThen$0hd6ik8 as result_andThen$0hd6ik8, or$1xcfx3w as result_or$1xcfx3w, orElse$13ay4um as result_orElse$13ay4um, unwrapOr$0a4h2e7 as result_unwrapOr$0a4h2e7, unwrapOrElse$1reohq9 as result_unwrapOrElse$1reohq9, unwrapOrElse$009ibtw as result_unwrapOrElse$009ibtw, copied$0ma6p21, clone$04fntvl as result_clone$04fntvl } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ -export function combinators(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function combinators(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const a: rt.u8 | undefined = filter$0v80fk8(rt.byteSliceFirst(data), (x: rt.u8): boolean => { return rt.u8Rem(x, 3) !== 0; }); diff --git a/ts/fixtures/lang/expected/core/num.ts b/ts/fixtures/lang/expected/core/num.ts index 94a678f8b..73e77f237 100644 --- a/ts/fixtures/lang/expected/core/num.ts +++ b/ts/fixtures/lang/expected/core/num.ts @@ -51,33 +51,33 @@ export function runtime$0bn0geu(radix: rt.u32): never { rt.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); } -export function fromAsciiBytesRadixImpl$1j0vyv2(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = rt.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128); - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -88,9 +88,9 @@ export function fromAsciiBytesRadixImpl$1j0vyv2(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -203,33 +203,33 @@ export function fromAsciiBytesRadixImpl$1j0vyv2(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1ayhtfx(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > -32768; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -240,9 +240,9 @@ export function fromAsciiBytesRadixImpl$1ayhtfx(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -355,33 +355,33 @@ export function fromAsciiBytesRadixImpl$1ayhtfx(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1brz7e9(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0p2idzk(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > -2147483648; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -392,9 +392,9 @@ export function fromAsciiBytesRadixImpl$1brz7e9(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -507,33 +507,33 @@ export function fromAsciiBytesRadixImpl$1brz7e9(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0qgc5vk(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = rt.i64Gt(0, { hi: -0x80000000, lo: 0 } as rt.i64); - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -544,9 +544,9 @@ export function fromAsciiBytesRadixImpl$0qgc5vk(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -659,33 +659,33 @@ export function fromAsciiBytesRadixImpl$0qgc5vk(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$09s4lo6(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > -128; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -696,9 +696,9 @@ export function fromAsciiBytesRadixImpl$09s4lo6(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -811,33 +811,33 @@ export function fromAsciiBytesRadixImpl$09s4lo6(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0gsq3mw(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$05ylgyc(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > -2147483648; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -848,9 +848,9 @@ export function fromAsciiBytesRadixImpl$0gsq3mw(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -963,87 +963,81 @@ export function fromAsciiBytesRadixImpl$0gsq3mw(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromStr$04in3ec(src: string): rt.Result { - return fromStrRadix$00d2t0z(src, 10); +export function fromStr$0zyj6he(src: string): rt.Result { + return fromStrRadix$0366bau(src, 10); } -export function fromStr$0itzmqn(src: string): rt.Result { - return fromStrRadix$1pa0ruh(src, 10); +export function fromStr$17ewwma(src: string): rt.Result { + return fromStrRadix$02mhuxs(src, 10); } -export function fromStr$1czfc3o(src: string): rt.Result { - return fromStrRadix$0bx4ko0(src, 10); +export function fromStr$0zhqfgx(src: string): rt.Result { + return fromStrRadix$1bgm1z0(src, 10); } -export function fromStr$0j0pk4t(src: string): rt.Result { - return fromStrRadix$1c5e8ay(src, 10); +export function fromStr$116mp4t(src: string): rt.Result { + return fromStrRadix$11y6fsf(src, 10); } -export function fromStr$1lgb5f6(src: string): rt.Result { - return fromStrRadix$09xsupv(src, 10); +export function fromStr$0ovlgjd(src: string): rt.Result { + return fromStrRadix$0s9rspw(src, 10); } -export function fromStr$05ll6v8(src: string): rt.Result { - return fromStrRadix$0xkpex4(src, 10); +export function fromStr$1grmucc(src: string): rt.Result { + return fromStrRadix$1473bi0(src, 10); } -export function fromStrRadix$00d2t0z(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$1j0vyv2(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0366bau(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0xhcrxt(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1pa0ruh(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$1ayhtfx(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$02mhuxs(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0jbbuu8(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0bx4ko0(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$1brz7e9(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1bgm1z0(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0p2idzk(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1c5e8ay(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0qgc5vk(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$11y6fsf(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$01tfvb9(rt.stringAsBytes(src), radix); } -export function fromStrRadix$09xsupv(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$09s4lo6(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0s9rspw(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$18og5o1(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0xkpex4(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0gsq3mw(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1473bi0(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$05ylgyc(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1dzxy8l(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = rt.u128Gt(0, 0); - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1054,9 +1048,9 @@ export function fromAsciiBytesRadixImpl$1dzxy8l(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -1169,33 +1163,33 @@ export function fromAsciiBytesRadixImpl$1dzxy8l(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$03r1s26(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > 0; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1206,9 +1200,9 @@ export function fromAsciiBytesRadixImpl$03r1s26(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -1321,33 +1315,33 @@ export function fromAsciiBytesRadixImpl$03r1s26(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0xuname(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > 0; - if (srcLen === 1) { - const value5 = srcData[srcStart]; + if (src.length === 1) { + const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value6 = srcData[srcStart]; + if (src.length >= 1) { + const value6 = src.data[src.start]; if (value6 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value6 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1358,9 +1352,9 @@ export function fromAsciiBytesRadixImpl$0xuname(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -1473,33 +1467,33 @@ export function fromAsciiBytesRadixImpl$0xuname(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0rjswpp(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = rt.u64Gt(0, 0); - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1510,9 +1504,9 @@ export function fromAsciiBytesRadixImpl$0rjswpp(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -1625,33 +1619,33 @@ export function fromAsciiBytesRadixImpl$0rjswpp(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1sotks5(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > 0; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1662,9 +1656,9 @@ export function fromAsciiBytesRadixImpl$1sotks5(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -1777,33 +1771,33 @@ export function fromAsciiBytesRadixImpl$1sotks5(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$16nq9v5(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$00hojjd(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; let _12_1Len!: number; if (!(2 > radix)) { if (!(radix > 36)) { - if (!(srcLen === 0)) { + if (!(src.length === 0)) { const isSignedTy: boolean = 0 > 0; - if (srcLen === 1) { - const value7 = srcData[srcStart]; + if (src.length === 1) { + const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); } } b3: { - if (srcLen >= 1) { - const value8 = srcData[srcStart]; + if (src.length >= 1) { + const value8 = src.data[src.start]; if (value8 === 43) { _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart + 1; - _12_1Len = srcLen - 1; + _12_1Data = src.data; + _12_1Start = src.start + 1; + _12_1Len = src.length - 1; break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = new rt.ByteSlice(srcData, srcStart + 1, srcLen - 1); + const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1814,9 +1808,9 @@ export function fromAsciiBytesRadixImpl$16nq9v5(srcData: Uint8Array, srcStart: n } } _12_0 = true; - _12_1Data = srcData; - _12_1Start = srcStart; - _12_1Len = srcLen; + _12_1Data = src.data; + _12_1Start = src.start; + _12_1Len = src.length; } const isPositive: boolean = _12_0; let digitsData: Uint8Array = _12_1Data; @@ -1929,58 +1923,52 @@ export function fromAsciiBytesRadixImpl$16nq9v5(srcData: Uint8Array, srcStart: n fromAsciiBytesRadixPanic(radix); } -export function fromStr$0nzirqb(src: string): rt.Result { - return fromStrRadix$0aggpkp(src, 10); +export function fromStr$0qvzsmz(src: string): rt.Result { + return fromStrRadix$0g0g31i(src, 10); } -export function fromStr$0xayo7b(src: string): rt.Result { - return fromStrRadix$1queob6(src, 10); +export function fromStr$0yqu2i9(src: string): rt.Result { + return fromStrRadix$1ku3myt(src, 10); } -export function fromStr$1t0zoao(src: string): rt.Result { - return fromStrRadix$1ovtdjc(src, 10); +export function fromStr$08wf09w(src: string): rt.Result { + return fromStrRadix$05zvwcf(src, 10); } -export function fromStr$1s0pfra(src: string): rt.Result { - return fromStrRadix$0cic1mm(src, 10); +export function fromStr$1ypcnp8(src: string): rt.Result { + return fromStrRadix$1gp4jqq(src, 10); } -export function fromStr$13au6mu(src: string): rt.Result { - return fromStrRadix$1uup0fy(src, 10); +export function fromStr$1hq0zfa(src: string): rt.Result { + return fromStrRadix$0nj08um(src, 10); } -export function fromStr$1vgxk0s(src: string): rt.Result { - return fromStrRadix$1xobho4(src, 10); +export function fromStr$10ypyht(src: string): rt.Result { + return fromStrRadix$0tjqkb6(src, 10); } -export function fromStrRadix$0aggpkp(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$1dzxy8l(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0g0g31i(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0r1q6uy(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1queob6(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$03r1s26(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1ku3myt(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1ukmfx2(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1ovtdjc(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0xuname(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$05zvwcf(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0ax4wbr(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0cic1mm(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0rjswpp(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1gp4jqq(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$02xpj41(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1uup0fy(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$1sotks5(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0nj08um(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1n9fygl(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1xobho4(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$16nq9v5(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0tjqkb6(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$00hojjd(rt.stringAsBytes(src), radix); } //# sourceMappingURL=num.ts.map diff --git a/ts/fixtures/lang/expected/core/num/nonzero.ts b/ts/fixtures/lang/expected/core/num/nonzero.ts index 906324557..cf00ca76f 100644 --- a/ts/fixtures/lang/expected/core/num/nonzero.ts +++ b/ts/fixtures/lang/expected/core/num/nonzero.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../../rt.ts"; -import { fromAsciiBytesRadixImpl$1j0vyv2 as num_fromAsciiBytesRadixImpl$1j0vyv2, fromAsciiBytesRadixImpl$1ayhtfx as num_fromAsciiBytesRadixImpl$1ayhtfx, fromAsciiBytesRadixImpl$1brz7e9 as num_fromAsciiBytesRadixImpl$1brz7e9, fromAsciiBytesRadixImpl$0qgc5vk as num_fromAsciiBytesRadixImpl$0qgc5vk, fromAsciiBytesRadixImpl$09s4lo6 as num_fromAsciiBytesRadixImpl$09s4lo6, fromAsciiBytesRadixImpl$0gsq3mw as num_fromAsciiBytesRadixImpl$0gsq3mw, fromAsciiBytesRadixImpl$1dzxy8l as num_fromAsciiBytesRadixImpl$1dzxy8l, fromAsciiBytesRadixImpl$03r1s26 as num_fromAsciiBytesRadixImpl$03r1s26, fromAsciiBytesRadixImpl$0xuname as num_fromAsciiBytesRadixImpl$0xuname, fromAsciiBytesRadixImpl$0rjswpp as num_fromAsciiBytesRadixImpl$0rjswpp, fromAsciiBytesRadixImpl$1sotks5 as num_fromAsciiBytesRadixImpl$1sotks5, fromAsciiBytesRadixImpl$16nq9v5 as num_fromAsciiBytesRadixImpl$16nq9v5 } from "../../core/num.ts"; +import { fromAsciiBytesRadixImpl$0xhcrxt as num_fromAsciiBytesRadixImpl$0xhcrxt, fromAsciiBytesRadixImpl$0jbbuu8 as num_fromAsciiBytesRadixImpl$0jbbuu8, fromAsciiBytesRadixImpl$0p2idzk as num_fromAsciiBytesRadixImpl$0p2idzk, fromAsciiBytesRadixImpl$01tfvb9 as num_fromAsciiBytesRadixImpl$01tfvb9, fromAsciiBytesRadixImpl$18og5o1 as num_fromAsciiBytesRadixImpl$18og5o1, fromAsciiBytesRadixImpl$05ylgyc as num_fromAsciiBytesRadixImpl$05ylgyc, fromAsciiBytesRadixImpl$0r1q6uy as num_fromAsciiBytesRadixImpl$0r1q6uy, fromAsciiBytesRadixImpl$1ukmfx2 as num_fromAsciiBytesRadixImpl$1ukmfx2, fromAsciiBytesRadixImpl$0ax4wbr as num_fromAsciiBytesRadixImpl$0ax4wbr, fromAsciiBytesRadixImpl$02xpj41 as num_fromAsciiBytesRadixImpl$02xpj41, fromAsciiBytesRadixImpl$1n9fygl as num_fromAsciiBytesRadixImpl$1n9fygl, fromAsciiBytesRadixImpl$00hojjd as num_fromAsciiBytesRadixImpl$00hojjd } from "../../core/num.ts"; -export function fromAsciiBytesRadixImpl$15iy33v(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1sotks5(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$1kc6lwg(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1n9fygl(src, radix); if (_3.ok) { const _7: rt.u8 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -15,17 +15,16 @@ export function fromAsciiBytesRadixImpl$15iy33v(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$1cr4vnw(src: string): rt.Result { - return fromStrRadix$14i0wt8(src, 10); +export function fromStr$0evev4b(src: string): rt.Result { + return fromStrRadix$1dc3cul(src, 10); } -export function fromStrRadix$14i0wt8(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$15iy33v(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1dc3cul(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1kc6lwg(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0tx2uar(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$03r1s26(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$0gd2ptq(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1ukmfx2(src, radix); if (_3.ok) { const _7: rt.u16 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -36,17 +35,16 @@ export function fromAsciiBytesRadixImpl$0tx2uar(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$0lgcgfz(src: string): rt.Result { - return fromStrRadix$1lxegnk(src, 10); +export function fromStr$1lm2uzl(src: string): rt.Result { + return fromStrRadix$1cv6o7i(src, 10); } -export function fromStrRadix$1lxegnk(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0tx2uar(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1cv6o7i(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0gd2ptq(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0vo422q(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0xuname(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$0v1vsb2(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0ax4wbr(src, radix); if (_3.ok) { const _7: rt.u32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -57,17 +55,16 @@ export function fromAsciiBytesRadixImpl$0vo422q(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$0nnqa9n(src: string): rt.Result { - return fromStrRadix$1d9m2yx(src, 10); +export function fromStr$0gvyqp3(src: string): rt.Result { + return fromStrRadix$18imw6k(src, 10); } -export function fromStrRadix$1d9m2yx(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0vo422q(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$18imw6k(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0v1vsb2(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1k0ip8i(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0rjswpp(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$0573ey0(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$02xpj41(src, radix); if (_3.ok) { const _7: rt.u64 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -78,17 +75,16 @@ export function fromAsciiBytesRadixImpl$1k0ip8i(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$1oqlbkr(src: string): rt.Result { - return fromStrRadix$1jz5doi(src, 10); +export function fromStr$19lq810(src: string): rt.Result { + return fromStrRadix$1u3fi38(src, 10); } -export function fromStrRadix$1jz5doi(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$1k0ip8i(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$1u3fi38(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0573ey0(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0bfc7q3(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1dzxy8l(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$09eombh(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0r1q6uy(src, radix); if (_3.ok) { const _7: rt.u128 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -99,17 +95,16 @@ export function fromAsciiBytesRadixImpl$0bfc7q3(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$0tkab53(src: string): rt.Result { - return fromStrRadix$1d0ksj7(src, 10); +export function fromStr$1lyc2jq(src: string): rt.Result { + return fromStrRadix$0yvapq5(src, 10); } -export function fromStrRadix$1d0ksj7(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0bfc7q3(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0yvapq5(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$09eombh(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$036kmns(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$16nq9v5(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$0fv7s51(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$00hojjd(src, radix); if (_3.ok) { const _7: rt.usize | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -120,17 +115,16 @@ export function fromAsciiBytesRadixImpl$036kmns(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$1q8byvk(src: string): rt.Result { - return fromStrRadix$07g34i1(src, 10); +export function fromStr$06k4xxy(src: string): rt.Result { + return fromStrRadix$0rmwudb(src, 10); } -export function fromStrRadix$07g34i1(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$036kmns(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0rmwudb(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0fv7s51(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0q4iztu(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$09s4lo6(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$0o9g9le(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$18og5o1(src, radix); if (_3.ok) { const _7: rt.i8 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -141,17 +135,16 @@ export function fromAsciiBytesRadixImpl$0q4iztu(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$0ujk11v(src: string): rt.Result { - return fromStrRadix$17bacti(src, 10); +export function fromStr$0xht6mx(src: string): rt.Result { + return fromStrRadix$0qjnxek(src, 10); } -export function fromStrRadix$17bacti(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0q4iztu(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0qjnxek(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0o9g9le(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0n730jy(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1ayhtfx(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$067wd9q(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0jbbuu8(src, radix); if (_3.ok) { const _7: rt.i16 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -162,17 +155,16 @@ export function fromAsciiBytesRadixImpl$0n730jy(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$0rlmwxp(src: string): rt.Result { - return fromStrRadix$059mp1l(src, 10); +export function fromStr$021o7ki(src: string): rt.Result { + return fromStrRadix$0dk3w71(src, 10); } -export function fromStrRadix$059mp1l(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0n730jy(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0dk3w71(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$067wd9q(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$05fgplu(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1brz7e9(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$09l5q1f(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0p2idzk(src, radix); if (_3.ok) { const _7: rt.i32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -183,17 +175,16 @@ export function fromAsciiBytesRadixImpl$05fgplu(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$06ydblo(src: string): rt.Result { - return fromStrRadix$0kf0g60(src, 10); +export function fromStr$1myv2t6(src: string): rt.Result { + return fromStrRadix$0o6ntrm(src, 10); } -export function fromStrRadix$0kf0g60(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$05fgplu(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0o6ntrm(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$09l5q1f(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$04mobn7(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0qgc5vk(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$1tchpbx(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$01tfvb9(src, radix); if (_3.ok) { const _7: rt.i64 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -204,17 +195,16 @@ export function fromAsciiBytesRadixImpl$04mobn7(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$1oeehgy(src: string): rt.Result { - return fromStrRadix$0ynvtyj(src, 10); +export function fromStr$10p52cj(src: string): rt.Result { + return fromStrRadix$0ebk8xe(src, 10); } -export function fromStrRadix$0ynvtyj(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$04mobn7(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0ebk8xe(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1tchpbx(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0k91ogu(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1j0vyv2(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$0naj586(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0xhcrxt(src, radix); if (_3.ok) { const _7: rt.i128 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -225,17 +215,16 @@ export function fromAsciiBytesRadixImpl$0k91ogu(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$1b9wkfh(src: string): rt.Result { - return fromStrRadix$0cet6d1(src, 10); +export function fromStr$081k88g(src: string): rt.Result { + return fromStrRadix$17xzbib(src, 10); } -export function fromStrRadix$0cet6d1(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$0k91ogu(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$17xzbib(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0naj586(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$18uzx16(srcData: Uint8Array, srcStart: number, srcLen: number, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0gsq3mw(srcData, srcStart, srcLen, radix); +export function fromAsciiBytesRadixImpl$1ylh0b8(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$05ylgyc(src, radix); if (_3.ok) { const _7: rt.isize | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -246,13 +235,12 @@ export function fromAsciiBytesRadixImpl$18uzx16(srcData: Uint8Array, srcStart: n return _3; } -export function fromStr$1hl5h4e(src: string): rt.Result { - return fromStrRadix$1bz0mya(src, 10); +export function fromStr$1gsgexo(src: string): rt.Result { + return fromStrRadix$0k1ynqn(src, 10); } -export function fromStrRadix$1bz0mya(src: string, radix: rt.u32): rt.Result { - const _3: rt.ByteSlice = rt.stringAsBytes(src); - return fromAsciiBytesRadixImpl$18uzx16(_3.data, _3.start, _3.length, radix); +export function fromStrRadix$0k1ynqn(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1ylh0b8(rt.stringAsBytes(src), radix); } //# sourceMappingURL=nonzero.ts.map diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 7390470f2..6cf5dfb77 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; +import { opaque as args_opaque, len as args_len } from "../args.ts"; import type * as borrows_Noisy from "../borrows.Noisy.ts"; import type * as bounds_Item from "../bounds.Item.ts"; import * as clones_Logged from "../clones.Logged.ts"; @@ -35,7 +36,8 @@ import type * as locals_Noisy from "../locals.Noisy.ts"; import type * as orders_Item from "../orders.Item.ts"; import type * as Loaded from "../pointers.Loaded.ts"; import type * as pointers_Pair from "../pointers.Pair.ts"; -import { sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; +import type * as returns_Error from "../returns.Error.ts"; +import { sum as separated_sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; import type * as separated_Pair from "../separated.Pair.ts"; import { from$convert_From_shapes_Dir_u8 } from "../shapes.ts"; import type * as shapes_Dir from "../shapes.Dir.ts"; @@ -46,7 +48,6 @@ import { digest as slices_digest, digestWords } from "../slices.ts"; import type * as slices_Item from "../slices.Item.ts"; import * as slices_Noisy from "../slices.Noisy.ts"; import type * as slices_Pair from "../slices.Pair.ts"; -import type * as Short from "../splits.Short.ts"; import type * as Loud from "../zeros.Loud.ts"; import * as zeros_Tagged from "../zeros.Tagged.ts"; @@ -577,11 +578,18 @@ export function map$0qyyft9(self: rt.u16[] | undefined, _: (a0: rt.u16[]) => rt. return digestWords(self); } +export function map$0waqle9(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { + if (self === undefined) { + return undefined; + } + return args_opaque(self); +} + export function map$1uuzv15(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { if (self === undefined) { return undefined; } - return sum(self); + return separated_sum(self); } export function map$1xk4yz1(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { @@ -669,6 +677,13 @@ export function map$0jcaaxx(self: [rt.u8 | undefined, rt.u8] | undefined, f: (a0 return f(self); } +export function map$1yogfym(self: [rt.u8, rt.ByteSlice] | undefined, f: (a0: [rt.u8, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$1hdkvwd(self: [rt.u8, rt.u8] | undefined, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 | undefined { if (self === undefined) { return undefined; @@ -1163,7 +1178,14 @@ export function mapOr$18m1ie6(self: rt.ByteSlice | undefined, default_: rt.u8, _ if (self === undefined) { return default_; } - return sum(self); + return separated_sum(self); +} + +export function mapOr$0dk8jdr(self: rt.ByteSlice | undefined, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return args_len(self.data, self.start, self.length); } export function mapOr$189goit(self: slices_Noisy.Noisy | undefined, default_: rt.u8, f: (a0: slices_Noisy.Noisy) => rt.u8): rt.u8 { @@ -1467,21 +1489,28 @@ export function okOr$07zal2e(self: rt.u32[] | undefined, err: rt.u8): rt.Result< return rt.Ok(self); } -export function okOr$0jslmu4(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { +export function okOr$0gtm15y(self: rt.ByteSlice | undefined, err: rt.u8 | undefined): rt.Result { if (self === undefined) { return rt.Err(err); } return rt.Ok(self); } -export function okOr$0q0ogpn(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8 | undefined): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> { +export function okOr$12p77jh(self: rt.ByteSlice | undefined, err: returns_Error.Error): rt.Result { if (self === undefined) { return rt.Err(err); } return rt.Ok(self); } -export function okOr$1np0z7r(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: Short.Short): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { +export function okOr$0tezn0w(self: rt.ByteSlice | undefined, _: undefined): rt.Result { + if (self === undefined) { + return rt.ERR; + } + return rt.Ok(self); +} + +export function okOr$0q0ogpn(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8 | undefined): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> { if (self === undefined) { return rt.Err(err); } diff --git a/ts/fixtures/lang/expected/core/str.ts b/ts/fixtures/lang/expected/core/str.ts index 45c53e44b..c46867777 100644 --- a/ts/fixtures/lang/expected/core/str.ts +++ b/ts/fixtures/lang/expected/core/str.ts @@ -1,108 +1,108 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import { fromStr$04in3ec as num_fromStr$04in3ec, fromStr$0itzmqn as num_fromStr$0itzmqn, fromStr$1czfc3o as num_fromStr$1czfc3o, fromStr$0j0pk4t as num_fromStr$0j0pk4t, fromStr$1lgb5f6 as num_fromStr$1lgb5f6, fromStr$05ll6v8 as num_fromStr$05ll6v8, fromStr$0nzirqb as num_fromStr$0nzirqb, fromStr$0xayo7b as num_fromStr$0xayo7b, fromStr$1t0zoao as num_fromStr$1t0zoao, fromStr$1s0pfra as num_fromStr$1s0pfra, fromStr$13au6mu as num_fromStr$13au6mu, fromStr$1vgxk0s as num_fromStr$1vgxk0s } from "../core/num.ts"; -import { fromStr$1cr4vnw as nonzero_fromStr$1cr4vnw, fromStr$0lgcgfz as nonzero_fromStr$0lgcgfz, fromStr$0nnqa9n as nonzero_fromStr$0nnqa9n, fromStr$1oqlbkr as nonzero_fromStr$1oqlbkr, fromStr$0tkab53 as nonzero_fromStr$0tkab53, fromStr$1q8byvk as nonzero_fromStr$1q8byvk, fromStr$0ujk11v as nonzero_fromStr$0ujk11v, fromStr$0rlmwxp as nonzero_fromStr$0rlmwxp, fromStr$06ydblo as nonzero_fromStr$06ydblo, fromStr$1oeehgy as nonzero_fromStr$1oeehgy, fromStr$1b9wkfh as nonzero_fromStr$1b9wkfh, fromStr$1hl5h4e as nonzero_fromStr$1hl5h4e } from "../core/num/nonzero.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$17ewwma as num_fromStr$17ewwma, fromStr$0zhqfgx as num_fromStr$0zhqfgx, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1grmucc as num_fromStr$1grmucc, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0yqu2i9 as num_fromStr$0yqu2i9, fromStr$08wf09w as num_fromStr$08wf09w, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa, fromStr$10ypyht as num_fromStr$10ypyht } from "../core/num.ts"; +import { fromStr$0evev4b as nonzero_fromStr$0evev4b, fromStr$1lm2uzl as nonzero_fromStr$1lm2uzl, fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStr$06k4xxy as nonzero_fromStr$06k4xxy, fromStr$0xht6mx as nonzero_fromStr$0xht6mx, fromStr$021o7ki as nonzero_fromStr$021o7ki, fromStr$1myv2t6 as nonzero_fromStr$1myv2t6, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStr$081k88g as nonzero_fromStr$081k88g, fromStr$1gsgexo as nonzero_fromStr$1gsgexo } from "../core/num/nonzero.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "../core/str/traits.ts"; export function parse$0vh4cry(self: string): rt.Result { return traits_fromStr$05d44vn(self); } -export function parse$10fbnat(self: string): rt.Result { - return num_fromStr$04in3ec(self); +export function parse$082ztwj(self: string): rt.Result { + return num_fromStr$0zyj6he(self); } -export function parse$03wo3fg(self: string): rt.Result { - return num_fromStr$0itzmqn(self); +export function parse$0xnscjy(self: string): rt.Result { + return num_fromStr$17ewwma(self); } -export function parse$0n1hysl(self: string): rt.Result { - return num_fromStr$1czfc3o(self); +export function parse$12szghw(self: string): rt.Result { + return num_fromStr$0zhqfgx(self); } -export function parse$0clhdfr(self: string): rt.Result { - return num_fromStr$0j0pk4t(self); +export function parse$11m1f1e(self: string): rt.Result { + return num_fromStr$116mp4t(self); } -export function parse$1g7h2lx(self: string): rt.Result { - return num_fromStr$1lgb5f6(self); +export function parse$1ci7nyc(self: string): rt.Result { + return num_fromStr$0ovlgjd(self); } -export function parse$0xv93nb(self: string): rt.Result { - return num_fromStr$05ll6v8(self); +export function parse$07xyv4i(self: string): rt.Result { + return num_fromStr$1grmucc(self); } -export function parse$1gx0slj(self: string): rt.Result { - return nonzero_fromStr$1b9wkfh(self); +export function parse$1bh1yup(self: string): rt.Result { + return nonzero_fromStr$081k88g(self); } -export function parse$19hh5l5(self: string): rt.Result { - return nonzero_fromStr$0rlmwxp(self); +export function parse$034rhh2(self: string): rt.Result { + return nonzero_fromStr$021o7ki(self); } -export function parse$1wk8j8i(self: string): rt.Result { - return nonzero_fromStr$06ydblo(self); +export function parse$1wp6z3o(self: string): rt.Result { + return nonzero_fromStr$1myv2t6(self); } -export function parse$0zmco93(self: string): rt.Result { - return nonzero_fromStr$1oeehgy(self); +export function parse$00wf0ig(self: string): rt.Result { + return nonzero_fromStr$10p52cj(self); } -export function parse$1t9x185(self: string): rt.Result { - return nonzero_fromStr$0ujk11v(self); +export function parse$1bfudtm(self: string): rt.Result { + return nonzero_fromStr$0xht6mx(self); } -export function parse$1jrkp2i(self: string): rt.Result { - return nonzero_fromStr$1hl5h4e(self); +export function parse$16jvjal(self: string): rt.Result { + return nonzero_fromStr$1gsgexo(self); } -export function parse$1qgvwsg(self: string): rt.Result { - return nonzero_fromStr$0tkab53(self); +export function parse$0y8gj7z(self: string): rt.Result { + return nonzero_fromStr$1lyc2jq(self); } -export function parse$1osnhn3(self: string): rt.Result { - return nonzero_fromStr$0lgcgfz(self); +export function parse$0y6waa4(self: string): rt.Result { + return nonzero_fromStr$1lm2uzl(self); } -export function parse$1gszg8m(self: string): rt.Result { - return nonzero_fromStr$0nnqa9n(self); +export function parse$1s5pqso(self: string): rt.Result { + return nonzero_fromStr$0gvyqp3(self); } -export function parse$06gw7w3(self: string): rt.Result { - return nonzero_fromStr$1oqlbkr(self); +export function parse$129b0a7(self: string): rt.Result { + return nonzero_fromStr$19lq810(self); } -export function parse$1srq5rw(self: string): rt.Result { - return nonzero_fromStr$1cr4vnw(self); +export function parse$150tkxc(self: string): rt.Result { + return nonzero_fromStr$0evev4b(self); } -export function parse$15q33cp(self: string): rt.Result { - return nonzero_fromStr$1q8byvk(self); +export function parse$02m155k(self: string): rt.Result { + return nonzero_fromStr$06k4xxy(self); } -export function parse$0685pdb(self: string): rt.Result { - return num_fromStr$0nzirqb(self); +export function parse$069o3rw(self: string): rt.Result { + return num_fromStr$0qvzsmz(self); } -export function parse$0bmbg8t(self: string): rt.Result { - return num_fromStr$0xayo7b(self); +export function parse$0fi19ig(self: string): rt.Result { + return num_fromStr$0yqu2i9(self); } -export function parse$1jryscd(self: string): rt.Result { - return num_fromStr$1t0zoao(self); +export function parse$1aq2uo0(self: string): rt.Result { + return num_fromStr$08wf09w(self); } -export function parse$0sdtyv9(self: string): rt.Result { - return num_fromStr$1s0pfra(self); +export function parse$0o4ono0(self: string): rt.Result { + return num_fromStr$1ypcnp8(self); } -export function parse$01247e1(self: string): rt.Result { - return num_fromStr$13au6mu(self); +export function parse$0at0fdl(self: string): rt.Result { + return num_fromStr$1hq0zfa(self); } -export function parse$15yahcp(self: string): rt.Result { - return num_fromStr$1vgxk0s(self); +export function parse$08wetap(self: string): rt.Result { + return num_fromStr$10ypyht(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/expected/counts.ts b/ts/fixtures/lang/expected/counts.ts index bd6e9809e..9381f6867 100644 --- a/ts/fixtures/lang/expected/counts.ts +++ b/ts/fixtures/lang/expected/counts.ts @@ -29,11 +29,11 @@ export function flush(log: rt.Mutex, out: rt.ByteVec): void { * Each byte an operation on pools of strong and weak handles, the rest of it the * handle it picks; each puts what it read. */ -export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const strong: rt.Arc[] = []; const weak: rt.Weak[] = []; - l1: for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + l1: for (const op of rt.byteSliceView(data)) { const pick: rt.usize = op >> 4 as rt.usize; const _19: rt.u8 = rt.u8Rem(op, 12); if (_19 === 0) { @@ -209,7 +209,7 @@ export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, o * `Noisy` whose own `Clone` runs, or a `Vec` of handles. Each clone is kept or * dropped, and each byte puts the picked handle's count and what dropped. */ -export function clonedArcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { let _191: boolean = false; let _192: boolean = false; const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); @@ -220,7 +220,7 @@ export function clonedArcs(dataData: Uint8Array, dataStart: number, dataLen: num const shared: ArcShared.ArcShared[] = []; const noisy: counts_Noisy.Noisy[] = []; const lists: rt.Arc[][] = []; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const pick: rt.usize = op >> 4 as rt.usize; const at = rt.idx(handles, rt.usizeRem(pick, handles.length)); const keep: boolean = (op & 8) !== 0; @@ -351,13 +351,13 @@ export function clonedArcs(dataData: Uint8Array, dataStart: number, dataLen: num * handles to itself; then kept, dropped, or dropped with a handle outside. Each puts what it read and what * dropped. */ -export function cyclicArcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { let node!: rt.Arc; let _95: boolean = false; const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const kept: rt.Arc[] = []; const outside: rt.Weak[] = []; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _15: rt.Arc> = rt.arcClone(log); _95 = true; const noisy: counts_Noisy.Noisy = new counts_Noisy.Noisy(op, _15); @@ -441,10 +441,9 @@ export function cyclicArcs(dataData: Uint8Array, dataStart: number, dataLen: num * the rest of it the handle it picks; each puts what it read and the picked * handle's counts. */ -export function uniqueArcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { let _52!: rt.Place | undefined; let value2!: rt.Place; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const strong: rt.Arc[] = [new rt.Arc(0)]; const weak: rt.Weak[] = []; const iterS: Uint8Array = rt.byteSliceView(data); @@ -567,7 +566,7 @@ export function uniqueArcs(dataData: Uint8Array, dataStart: number, dataLen: num * `Noisy` whose own `Clone` runs, or a `Vec` of handles. Each clone is kept or * dropped, and each byte puts the picked handle's count and what dropped. */ -export function clonedRcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { let _191: boolean = false; let _192: boolean = false; const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); @@ -578,7 +577,7 @@ export function clonedRcs(dataData: Uint8Array, dataStart: number, dataLen: numb const shared: RcShared.RcShared[] = []; const noisy: counts_Noisy.Noisy[] = []; const lists: rt.Arc[][] = []; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const pick: rt.usize = op >> 4 as rt.usize; const at = rt.idx(handles, rt.usizeRem(pick, handles.length)); const keep: boolean = (op & 8) !== 0; @@ -709,13 +708,13 @@ export function clonedRcs(dataData: Uint8Array, dataStart: number, dataLen: numb * handles to itself; then kept, dropped, or dropped with a handle outside. Each puts what it read and what * dropped. */ -export function cyclicRcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { let node!: rt.Arc; let _95: boolean = false; const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const kept: rt.Arc[] = []; const outside: rt.Weak[] = []; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _15: rt.Arc> = rt.arcClone(log); _95 = true; const noisy: counts_Noisy.Noisy = new counts_Noisy.Noisy(op, _15); @@ -798,11 +797,11 @@ export function cyclicRcs(dataData: Uint8Array, dataStart: number, dataLen: numb * Each byte an operation on pools of strong and weak handles, the rest of it the * handle it picks; each puts what it read. */ -export function rcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const strong: rt.Arc[] = []; const weak: rt.Weak[] = []; - l1: for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + l1: for (const op of rt.byteSliceView(data)) { const pick: rt.usize = op >> 4 as rt.usize; const _19: rt.u8 = rt.u8Rem(op, 12); if (_19 === 0) { @@ -977,10 +976,9 @@ export function rcs(dataData: Uint8Array, dataStart: number, dataLen: number, ou * the rest of it the handle it picks; each puts what it read and the picked * handle's counts. */ -export function uniqueRcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { let _52!: rt.Place | undefined; let value2!: rt.Place; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const strong: rt.Arc[] = [new rt.Arc(0)]; const weak: rt.Weak[] = []; const iterS: Uint8Array = rt.byteSliceView(data); @@ -1102,8 +1100,7 @@ export function uniqueRcs(dataData: Uint8Array, dataStart: number, dataLen: numb * `Counted`, and through `Option<&mut>` a byte and an `Option`; each puts what it made * and how many clones `Counted` counted. */ -export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const clones: rt.Cell = new rt.Cell(0); const counted: counts_Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): counts_Counted.Counted => { return { id: _2, clones }; diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index 8daa8ed60..cfbfab9ce 100644 --- a/ts/fixtures/lang/expected/cows.ts +++ b/ts/fixtures/lang/expected/cows.ts @@ -23,9 +23,9 @@ export function cow(s: string, owned: boolean): string { return s; } -export function cows(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cows(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let r!: rt.Result; - const s: string = text(dataData, dataStart, dataLen); + const s: string = text(data); const owned: boolean = (kind & 128) !== 0; const first: string = option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, "/").next()), ""); const _14: rt.u8 = rt.u8Rem(kind, 6); @@ -147,8 +147,8 @@ export function cows(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** A slice of `u16`s read from `data`, two bytes each. */ -export function words(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u16[] { - return rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), 2), (c: rt.ByteSlice): rt.u16 => { +export function words(data: rt.ByteSlice): rt.u16[] { + return rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, 2), (c: rt.ByteSlice): rt.u16 => { rt.idx(c, 0); return ((((c.data[c.start] as rt.u16)) << 8) & 0xffff) | rt.optionUnwrap(rt.byteSliceLast(c)) as rt.u16; }), undefined, 2, true); @@ -192,9 +192,9 @@ export function hashed$slice_u16(v: rt.u16[]): rt.u64 { return rt.hashFinish(h); } -export function hashed$slice_u8(vData: Uint8Array, vStart: number, vLen: number): rt.u64 { +export function hashed$slice_u8(v: rt.ByteSlice): rt.u64 { const h: rt.Hasher = rt.hasher(); - rt.hashBytes(new rt.ByteSlice(vData, vStart, vLen), h); + rt.hashBytes(v, h); return rt.hashFinish(h); } @@ -202,11 +202,11 @@ export function hashed$slice_u8(vData: Uint8Array, vStart: number, vLen: number) * `Cow<[u16]>`: made each way, collected, and read, changed through `to_mut`, compared, * ordered, and hashed against each sequence, matched on, and held in a field and as a key. */ -export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let made!: rt.u16[]; let _359!: rt.Cow; let c4!: rt.Cow; - const v: rt.u16[] = words(dataData, dataStart, dataLen); + const v: rt.u16[] = words(data); const owned: boolean = (kind & 128) !== 0; const half: rt.u16[] = rt.sliceRange(v, 0, rt.usizeDiv(v.length, 2)); const _15: rt.u8 = rt.u8Rem(kind, 6); @@ -402,7 +402,7 @@ export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args6[0]])); } else { const log: rt.Cell = new rt.Cell(0); - const items: cows_Tally.Tally[] = rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), 4), (_2: rt.u8): cows_Tally.Tally => { + const items: cows_Tally.Tally[] = rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_2: rt.u8): cows_Tally.Tally => { return new cows_Tally.Tally(_2, log); }), undefined, 8, true); if (!owned) { @@ -459,15 +459,15 @@ export function repoint$u16(s: rt.Place, to: rt.u16[]): void { } /** Point `s` at `to`, through the `&mut` a caller passes. */ -export function repoint$u8(s: rt.Place, toData: Uint8Array, toStart: number, toLen: number): void { - s.v = new rt.ByteSlice(toData, toStart, toLen); +export function repoint$u8(s: rt.Place, to: rt.ByteSlice): void { + s.v = to; } -export function made(sData: Uint8Array, sStart: number, sLen: number, owned: boolean): rt.ByteCow { +export function made(s: rt.ByteSlice, owned: boolean): rt.ByteCow { if (!owned) { - return new rt.ByteSlice(sData, sStart, sLen); + return s; } - return rt.byteSliceToByteVec(new rt.ByteSlice(sData, sStart, sLen)); + return rt.byteSliceToByteVec(s); } /** @@ -475,19 +475,18 @@ export function made(sData: Uint8Array, sStart: number, sLen: number, owned: boo * touching what it borrowed, compared against each form of bytes, hashed, printed, and * matched on. */ -export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _85!: boolean; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const owned: boolean = (kind & 128) !== 0; const half: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeDiv(data.length, 2)); - let c: rt.ByteCow = made(data.data, data.start, data.length, owned); + let c: rt.ByteCow = made(data, owned); rt.byteVecPush(out, rt.byteCowSlice(c).length & 0xff); const part2 = rt.min(rt.byteCowSlice(c).length, 3); rt.byteVecExtendFromSlice(out, rt.byteSliceRange(rt.byteCowSlice(c), 0, part2)); - const _35: rt.ByteCow = made(half.data, half.start, half.length, !owned); + const _35: rt.ByteCow = made(half, !owned); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rt.byteCowSlice(c)), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rt.byteCowSlice(_35)), f, rt.u8Debug)]; fmt_put(out, rt.fmtFormat([args2[0], " ", args2[1]])); - const _47: rt.ByteCow = made(half.data, half.start, half.length, !owned); + const _47: rt.ByteCow = made(half, !owned); const _44: boolean = rt.eqBytes(c, _47); const _49: boolean = rt.eqBytes(c, data); const _55: rt.ByteVec = rt.byteSliceToByteVec(data); @@ -496,9 +495,9 @@ export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data const _59: boolean = rt.eqBytes(rt.byteCowSlice(c), rt.byteSliceFrom(Uint8Array.of(0, 0))); const _63: boolean = rt.eqBytes(data, c); const _66: boolean = !rt.eqBytes(rt.byteSliceToByteVec(data), c); - const _74: rt.ByteCow = made(half.data, half.start, half.length, owned); + const _74: rt.ByteCow = made(half, owned); const _70: boolean = rt.cmpBytes(c, _74) > 0; - const _75: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$slice_u8(data.data, data.start, data.length)); + const _75: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$slice_u8(data)); const _79: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$Vec_u8(rt.byteSliceToByteVec(data))); if (c instanceof rt.ByteSlice) { _85 = true; @@ -522,9 +521,9 @@ export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data (c as rt.ByteVec) = _103; } rt.byteVecExtendFromSlice(out, rt.byteCowSlice(kept)); - let e: rt.ByteCow = made(data.data, data.start, data.length, !owned); + let e: rt.ByteCow = made(data, !owned); if (e instanceof rt.ByteSlice) { - repoint$u8(rt.place(() => (e as rt.ByteSlice) as rt.ByteSlice, (value) => (e as rt.ByteSlice) = value), half.data, half.start, half.length); + repoint$u8(rt.place(() => (e as rt.ByteSlice) as rt.ByteSlice, (value) => (e as rt.ByteSlice) = value), half); } else { rt.byteVecTruncate(e as rt.ByteVec, 1); } diff --git a/ts/fixtures/lang/expected/cycles.ts b/ts/fixtures/lang/expected/cycles.ts index e5dfd6b26..3f2e05d0d 100644 --- a/ts/fixtures/lang/expected/cycles.ts +++ b/ts/fixtures/lang/expected/cycles.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import { thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$1a4gm66 as option_unwrapOr$1a4gm66, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1u07cey as option_map$1u07cey, map$05nbzug as option_map$05nbzug, mapOr$0djjvgl as option_mapOr$0djjvgl, mapOr$1surhce as option_mapOr$1surhce, mapOr$02k4ito as option_mapOr$02k4ito, mapOr$06gg5x7 as option_mapOr$06gg5x7 } from "./core/option.ts"; +import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1u07cey as option_map$1u07cey, map$05nbzug as option_map$05nbzug, mapOr$0djjvgl as option_mapOr$0djjvgl, mapOr$1surhce as option_mapOr$1surhce, mapOr$02k4ito as option_mapOr$02k4ito, mapOr$06gg5x7 as option_mapOr$06gg5x7 } from "./core/option.ts"; import * as cycles_Countdown from "./cycles.Countdown.ts"; import * as cycles_Logged from "./cycles.Logged.ts"; @@ -19,7 +19,7 @@ export function flush(log: rt.RefCell, out: rt.ByteVec): void { * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$cycles_Countdown_cycles_cycles_closure4(it: cycles_Countdown.Countdown, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$cycles_Countdown_cycles_cycles_closure4(it: cycles_Countdown.Countdown, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(rt.iterFrom(it, (it: cycles_Countdown.Countdown) => cycles_Countdown.next$iter_Iterator(it)), { v: cycles_Countdown.clone$Clone }); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -27,7 +27,7 @@ export function read$cycles_Countdown_cycles_cycles_closure4(it: cycles_Countdow rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -67,7 +67,7 @@ export function read$cycles_Countdown_cycles_cycles_closure4(it: cycles_Countdow * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -75,7 +75,7 @@ export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_c rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -115,7 +115,7 @@ export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_c * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -123,7 +123,7 @@ export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -163,7 +163,7 @@ export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: cycles_Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(it: rt.Iter, steps: rt.ByteSlice, put: (a0: cycles_Logged.Logged) => rt.u8, out: rt.ByteVec): void { let item!: cycles_Logged.Logged | undefined; const it2: rt.Iter = rt.iterCycle(it, { i: { v: cycles_Logged.clone$Clone } }); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -171,7 +171,7 @@ export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6 rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -214,7 +214,7 @@ export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6 * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Empty_u8_cycles_cycles_closure3(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Empty_u8_cycles_cycles_closure3(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -222,7 +222,7 @@ export function read$iter_Empty_u8_cycles_cycles_closure3(it: rt.Iter, st rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -262,7 +262,7 @@ export function read$iter_Empty_u8_cycles_cycles_closure3(it: rt.Iter, st * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rt.Iter<[rt.usize, rt.u8]>, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: [rt.usize, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rt.Iter<[rt.usize, rt.u8]>, steps: rt.ByteSlice, put: (a0: [rt.usize, rt.u8]) => rt.u8, out: rt.ByteVec): void { let item!: [rt.usize, rt.u8] | undefined; const it2: rt.Iter<[rt.usize, rt.u8]> = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -270,7 +270,7 @@ export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rt. rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -310,7 +310,7 @@ export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rt. * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it, { i: { f: rt.closureClone }, f: rt.closureClone }); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -318,7 +318,7 @@ export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closure rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -359,7 +359,7 @@ export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closure * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -367,7 +367,7 @@ export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cyc rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -407,7 +407,7 @@ export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cyc * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -415,7 +415,7 @@ export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rt. rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -455,7 +455,7 @@ export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rt. * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rt.Peekable, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rt.Peekable, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -463,7 +463,7 @@ export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rt.P rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -503,7 +503,7 @@ export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rt.P * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -511,7 +511,7 @@ export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter< rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -551,7 +551,7 @@ export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter< * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -559,7 +559,7 @@ export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rt.Ite rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -599,7 +599,7 @@ export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rt.Ite * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -607,7 +607,7 @@ export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter< rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -647,7 +647,7 @@ export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter< * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rt.RangeInclusive, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rt.RangeInclusive, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -655,7 +655,7 @@ export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rt.RangeIn rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -695,7 +695,7 @@ export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rt.RangeIn * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rt.RangeInclusive, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rt.RangeInclusive, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -703,7 +703,7 @@ export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rt.RangeIn rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -743,7 +743,7 @@ export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rt.RangeIn * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$ops_Range_u8_cycles_cycles_closure5(it: rt.Range, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$ops_Range_u8_cycles_cycles_closure5(it: rt.Range, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -751,7 +751,7 @@ export function read$ops_Range_u8_cycles_cycles_closure5(it: rt.Range, st rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -791,7 +791,7 @@ export function read$ops_Range_u8_cycles_cycles_closure5(it: rt.Range, st * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -799,7 +799,7 @@ export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rt.Iter>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -839,7 +839,7 @@ export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rt.Iter, stepsData: Uint8Array, stepsStart: number, stepsLen: number, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function read$slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { let item!: rt.u8 | undefined; const it2: rt.Iter = rt.iterCycle(it); const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); @@ -847,7 +847,7 @@ export function read$slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, st rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(stepsData, stepsStart, stepsLen))), 12); + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); while (true) { const _22: rt.u8 | rt.Done = iter.next(); if (_22 === rt.DONE) { @@ -886,85 +886,82 @@ export function read$slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, st * `cycle` of std's iterators and adaptors and of the crate's own, each partly read, * empty, or both, the first byte of `data` a count and the rest the steps `read` takes. */ -export function cycles(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let item!: rt.u8 | undefined; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const n: rt.usize = option_mapOr$1surhce(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.u8 => { return rt.u8Rem(_2, 5); }) as rt.usize; - const _8: rt.ByteSlice | undefined = rt.byteSliceGetRange(data, 1); - const _10: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of()); - const steps: rt.ByteSlice = option_unwrapOr$1a4gm66(_8, _10.data, _10.start, _10.length); + const steps: rt.ByteSlice = option_unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 1), rt.byteSliceFrom(Uint8Array.of())); const _12: rt.u8 = rt.u8Rem(kind, 6); if (_12 === 0) { const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.iterNth(it, n); - read$slice_Iter_u8_cycles_cycles_closure1(it, steps.data, steps.start, steps.length, (x18: rt.u8): rt.u8 => { + read$slice_Iter_u8_cycles_cycles_closure1(it, steps, (x18: rt.u8): rt.u8 => { return x18; }, out); const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.iterForEach(rt.iterBorrow(it2), (_a03: rt.u8): undefined => { undefined; }); - read$slice_Iter_u8_cycles_cycles_closure1(it2, steps.data, steps.start, steps.length, (x19: rt.u8): rt.u8 => { + read$slice_Iter_u8_cycles_cycles_closure1(it2, steps, (x19: rt.u8): rt.u8 => { return x19; }, out); - read$slice_Iter_u8_cycles_cycles_closure1(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0))), steps.data, steps.start, steps.length, (x20: rt.u8): rt.u8 => { + read$slice_Iter_u8_cycles_cycles_closure1(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0))), steps, (x20: rt.u8): rt.u8 => { return x20; }, out); - read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), n), steps.data, steps.start, steps.length, (x21: rt.u8): rt.u8 => { + read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), n), steps, (x21: rt.u8): rt.u8 => { return x21; }, out); - read$option_IntoIter_u8_cycles_cycles_closure2(rt.iterOption(n & 0xff), steps.data, steps.start, steps.length, (x22: rt.u8): rt.u8 => { + read$option_IntoIter_u8_cycles_cycles_closure2(rt.iterOption(n & 0xff), steps, (x22: rt.u8): rt.u8 => { return x22; }, out); rt.iterEmpty(); - read$iter_Empty_u8_cycles_cycles_closure3(rt.iterEmpty() as rt.Iter, steps.data, steps.start, steps.length, (x23: rt.u8): rt.u8 => { + read$iter_Empty_u8_cycles_cycles_closure3(rt.iterEmpty() as rt.Iter, steps, (x23: rt.u8): rt.u8 => { return x23; }, out); - read$cycles_Countdown_cycles_cycles_closure4({ _0: rt.u8Mul(n & 0xff, 2) }, steps.data, steps.start, steps.length, (x24: rt.u8): rt.u8 => { + read$cycles_Countdown_cycles_cycles_closure4({ _0: rt.u8Mul(n & 0xff, 2) }, steps, (x24: rt.u8): rt.u8 => { return x24; }, out); } else if (_12 === 1) { const lo: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8); const hi: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 9), 12); - read$ops_Range_u8_cycles_cycles_closure5(new rt.Range(lo, hi), steps.data, steps.start, steps.length, (x8: rt.u8): rt.u8 => { + read$ops_Range_u8_cycles_cycles_closure5(new rt.Range(lo, hi), steps, (x8: rt.u8): rt.u8 => { return x8; }, out); const range: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u8Step); range.next(); - read$ops_RangeInclusive_u8_cycles_cycles_closure6(range.clone(), steps.data, steps.start, steps.length, (x9: rt.u8): rt.u8 => { + read$ops_RangeInclusive_u8_cycles_cycles_closure6(range.clone(), steps, (x9: rt.u8): rt.u8 => { return x9; }, out); rt.iterForEach(rt.iterBorrow(range), (_a02: rt.u8): undefined => { undefined; }); - read$ops_RangeInclusive_u8_cycles_cycles_closure7(range, steps.data, steps.start, steps.length, (x10: rt.u8): rt.u8 => { + read$ops_RangeInclusive_u8_cycles_cycles_closure7(range, steps, (x10: rt.u8): rt.u8 => { return x10; }, out); read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): boolean => { return rt.u8Rem(_25, 3) !== 0; - }), steps.data, steps.start, steps.length, (x12: rt.u8): rt.u8 => { + }), steps, (x12: rt.u8): rt.u8 => { return x12; }, out); - read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterTake(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), 2)), steps.data, steps.start, steps.length, (x13: rt.u8): rt.u8 => { + read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterTake(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), 2)), steps, (x13: rt.u8): rt.u8 => { return x13; }, out); - read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(data)), rt.usizeAdd(n, 1)), steps.data, steps.start, steps.length, (x14: rt.u8): rt.u8 => { + read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(data)), rt.usizeAdd(n, 1)), steps, (x14: rt.u8): rt.u8 => { return x14; }, out); - read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), n), steps.data, steps.start, steps.length, (x15: rt.u8): rt.u8 => { + read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), n), steps, (x15: rt.u8): rt.u8 => { return x15; }, out); - read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), steps.data, steps.start, steps.length, (_29: [rt.usize, rt.u8]): rt.u8 => { + read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), steps, (_29: [rt.usize, rt.u8]): rt.u8 => { return (_29[0] & 0xff) ^ _29[1]; }, out); const peeked: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); rt.peekablePeek(peeked); - read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(peeked, steps.data, steps.start, steps.length, (x16: rt.u8): rt.u8 => { + read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(peeked, steps, (x16: rt.u8): rt.u8 => { return x16; }, out); - read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(rt.iterFlatten(rt.byteSliceChunks(data, rt.usizeAdd(n, 1)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), steps.data, steps.start, steps.length, (x17: rt.u8): rt.u8 => { + read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(rt.iterFlatten(rt.byteSliceChunks(data, rt.usizeAdd(n, 1)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), steps, (x17: rt.u8): rt.u8 => { return x17; }, out); } else if (_12 === 2) { @@ -1018,9 +1015,9 @@ export function cycles(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat }, true)); rt.drop(it3); } else if (_12 === 3) { - closures(data.data, data.start, data.length, steps.data, steps.start, steps.length, out); + closures(data, steps, out); } else if (_12 === 4) { - owned(data.data, data.start, data.length, n, steps.data, steps.start, steps.length, out); + owned(data, n, steps, out); } else { const it4: rt.Iter = rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))); rt.iterNth(it4, n); @@ -1047,10 +1044,10 @@ export function cycles(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat })); } rt.byteVecPush(out, rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))).clone().sizeHint()[0] & 0xff); - read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it4.clone(), steps.data, steps.start, steps.length, (x2: rt.u8): rt.u8 => { + read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it4.clone(), steps, (x2: rt.u8): rt.u8 => { return x2; }, out); - read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))), steps.data, steps.start, steps.length, (x3: rt.u8): rt.u8 => { + read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))), steps, (x3: rt.u8): rt.u8 => { return x3; }, out); } @@ -1060,8 +1057,7 @@ export function cycles(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * Adaptors whose closures log as they are called and hold a value that logs as it is * cloned and dropped: when each clone of them is made, and when each drops. */ -export function closures(dataData: Uint8Array, dataStart: number, dataLen: number, stepsData: Uint8Array, stepsStart: number, stepsLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function closures(data: rt.ByteSlice, steps: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); const logged: (a0: rt.u8) => cycles_Logged.Logged = (id: rt.u8): cycles_Logged.Logged => { return new cycles_Logged.Logged(id, rt.arcClone(log)); @@ -1125,7 +1121,7 @@ export function closures(dataData: Uint8Array, dataStart: number, dataLen: numbe captured4[Symbol.dispose](); }); }; - read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(rt.iterFilter(it3, make3(gate)), stepsData, stepsStart, stepsLen, (x4: rt.u8): rt.u8 => { + read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(rt.iterFilter(it3, make3(gate)), steps, (x4: rt.u8): rt.u8 => { return x4; }, out); flush(log.value, out); @@ -1166,12 +1162,12 @@ export function closures(dataData: Uint8Array, dataStart: number, dataLen: numbe * Iterators that own their items, each cloned as the iterator is at each wrap, and * dropped as `nth` skips them and as the cycle drops what it holds and its clone. */ -export function owned(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize, stepsData: Uint8Array, stepsStart: number, stepsLen: number, out: rt.ByteVec): void { +export function owned(data: rt.ByteSlice, n: rt.usize, steps: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); const logged: (a0: rt.u8) => cycles_Logged.Logged = (id: rt.u8): cycles_Logged.Logged => { return new cycles_Logged.Logged(id, rt.arcClone(log)); }; - const it: rt.Iter = rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), 4), (_2: rt.u8): cycles_Logged.Logged => { + const it: rt.Iter = rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_2: rt.u8): cycles_Logged.Logged => { return logged(_2 & 112); }), undefined, 8, true), rt.drop); rt.drop(rt.iterToOption(it.next())); @@ -1204,7 +1200,7 @@ export function owned(dataData: Uint8Array, dataStart: number, dataLen: number, flush(log.value, out); rt.drop(it2); flush(log.value, out); - read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(clone, stepsData, stepsStart, stepsLen, (x4: cycles_Logged.Logged): rt.u8 => { + read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(clone, steps, (x4: cycles_Logged.Logged): rt.u8 => { const _07: rt.u8 = cycles_Logged.id(x4); x4[Symbol.dispose](); return _07; diff --git a/ts/fixtures/lang/expected/defaults.ts b/ts/fixtures/lang/expected/defaults.ts index 253470717..c39d7d4e9 100644 --- a/ts/fixtures/lang/expected/defaults.ts +++ b/ts/fixtures/lang/expected/defaults.ts @@ -41,9 +41,9 @@ export function made$unit(): void { } /** Each byte an operation, its value the operand; each puts what it read. */ -export function defaults(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { let s!: string; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(op, 9); if (_10 === 0) { made$unit(); diff --git a/ts/fixtures/lang/expected/durations.ts b/ts/fixtures/lang/expected/durations.ts index e8b0a580c..b9fb7878d 100644 --- a/ts/fixtures/lang/expected/durations.ts +++ b/ts/fixtures/lang/expected/durations.ts @@ -8,8 +8,7 @@ import * as durations_Window from "./durations.Window.ts"; import { put as fmt_put } from "./fmt.ts"; /** A `u64` and a `u32` from the front of `data`, big-endian and zero-padded. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u64, rt.u32, rt.ByteSlice] { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function take(data: rt.ByteSlice): [rt.u64, rt.u32, rt.ByteSlice] { const buf: Uint8Array = rt.bytes(12); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -29,8 +28,8 @@ export function take(dataData: Uint8Array, dataStart: number, dataLen: number): } /** A `Duration` from the front of `data`, whose nanoseconds never carry. */ -export function duration(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.Duration, rt.ByteSlice] { - const _5: [rt.u64, rt.u32, rt.ByteSlice] = take(dataData, dataStart, dataLen); +export function duration(data: rt.ByteSlice): [rt.Duration, rt.ByteSlice] { + const _5: [rt.u64, rt.u32, rt.ByteSlice] = take(data); return [rt.durationNew(_5[0], rt.u32Rem(_5[1], 1000000000)), _5[2]] as [rt.Duration, rt.ByteSlice]; } @@ -59,10 +58,10 @@ export function shrink(d: rt.Place, by: rt.Duration): void { d.v = rt.durationSub(d.v, by); } -export function durations(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _6: [rt.Duration, rt.ByteSlice] = duration(dataData, dataStart, dataLen); +export function durations(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _6: [rt.Duration, rt.ByteSlice] = duration(data); const a: rt.Duration = _6[0]; - const _9: [rt.Duration, rt.ByteSlice] = duration(_6[1].data, _6[1].start, _6[1].length); + const _9: [rt.Duration, rt.ByteSlice] = duration(_6[1]); const b: rt.Duration = _9[0]; const word: Uint8Array = rt.bytes(4); const k: rt.usize = rt.min(_9[1].length, rt.byteSliceFrom(word).length); @@ -70,10 +69,10 @@ export function durations(kind: rt.u8, dataData: Uint8Array, dataStart: number, const n: rt.u32 = rt.u32FromBeBytes(word); const _24: rt.u8 = rt.u8Rem(kind, 14); if (_24 === 0) { - const _28: [rt.u64, rt.u32, rt.ByteSlice] = take(dataData, dataStart, dataLen); + const _28: [rt.u64, rt.u32, rt.ByteSlice] = take(data); putDuration(out, rt.durationNew(_28[0], _28[1])); } else if (_24 === 1) { - const units: rt.u64 = take(dataData, dataStart, dataLen)[0]; + const units: rt.u64 = take(data)[0]; putDuration(out, rt.durationFromSecs(units)); putDuration(out, rt.durationFromMillis(units)); putDuration(out, rt.durationFromMicros(units)); @@ -200,10 +199,10 @@ export function durations(kind: rt.u8, dataData: Uint8Array, dataStart: number, v2[at] = rt.durationDiv(v2[at], n); putDuration(out, v2[rt.idx(v2, 0)]); } else if (_24 === 12) { - const units2: rt.u64 = take(dataData, dataStart, dataLen)[0]; + const units2: rt.u64 = take(data)[0]; const wide: Uint8Array = rt.bytes(16); - const k2: rt.usize = rt.min(dataLen, rt.byteSliceFrom(wide).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, k2), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, k2)); + const k2: rt.usize = rt.min(data.length, rt.byteSliceFrom(wide).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, k2), rt.byteSliceRange(data, 0, k2)); putDuration(out, rt.durationFromMins(units2)); putDuration(out, rt.durationFromHours(units2)); putDuration(out, rt.durationFromNanosU128(rt.u128FromBeBytes(wide))); diff --git a/ts/fixtures/lang/expected/dyns.ts b/ts/fixtures/lang/expected/dyns.ts index 93f438c4f..8d043d1ba 100644 --- a/ts/fixtures/lang/expected/dyns.ts +++ b/ts/fixtures/lang/expected/dyns.ts @@ -547,8 +547,8 @@ export function twice(f: (a0: rt.u8) => rt.u8, x: rt.u8): rt.u8 { return f(f(x)); } -export function bumpAll(f: (a0: rt.u8) => undefined, xsData: Uint8Array, xsStart: number, xsLen: number): void { - for (const _5 of rt.byteSliceView(new rt.ByteSlice(xsData, xsStart, xsLen))) { +export function bumpAll(f: (a0: rt.u8) => undefined, xs: rt.ByteSlice): void { + for (const _5 of rt.byteSliceView(xs)) { f(_5); } } @@ -573,11 +573,10 @@ export function flip(x: rt.u8): rt.u8 { return x ^ 90; } -export function fns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function fns(data: rt.ByteSlice, out: rt.ByteVec): void { let ptr!: (a0: rt.u8) => rt.u8; - if (dataLen >= 2) { - const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); - const _10: [rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1]]; + if (data.length >= 2) { + const _10: [rt.u8, rt.u8] = [data.data[data.start], data.data[data.start + 1]]; const a: rt.u8 = _10[0]; const b: rt.u8 = _10[1]; const mul: (a0: rt.u8) => rt.u8 = (x: rt.u8): rt.u8 => { @@ -603,7 +602,7 @@ export function fns(dataData: Uint8Array, dataStart: number, dataLen: number, ou bumpAll((x2: rt.u8): undefined => { sum = rt.u32WrappingAdd(sum, x2 as rt.u32); rt.byteVecPush(seen, x2); - }, rest.data, rest.start, rest.length); + }, rt.byteSliceRange(data, 2)); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(seen), f, rt.u8Debug)]; fmt_put(out, rt.fmtFormat([args6[0], " ", args6[1], " "])); const fs: Array<(a0: rt.u8) => rt.u8> = [adder(a), halve, mul, ptr]; @@ -624,7 +623,8 @@ export function fns(dataData: Uint8Array, dataStart: number, dataLen: number, ou if (_115 === rt.DONE) { break; } - const y: rt.u8 = _115[1](option_unwrapOr$0r2bmpr(rt.byteSliceGet(rest, _115[0]), b)); + const i: rt.usize = _115[0]; + const y: rt.u8 = _115[1](option_unwrapOr$0r2bmpr(rt.byteSliceGet(rt.byteSliceRange(data, 2), i), b)); const _133: rt.u32 = hook.f(y); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(y, f), (f: rt.Formatter) => rt.u32Display(_133, f)]; fmt_put(out, rt.fmtFormat([args8[0], ":", args8[1], " "])); diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index 26e5a5c68..7579ae0b4 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -27,15 +27,12 @@ export function putU16s(out: rt.ByteVec, v: rt.u16[]): void { rt.byteVecPush(out, 254); } -export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _104: (a0: rt.u16) => edits_Named.Named = (w: rt.u16): edits_Named.Named => { - const _4: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16))); - return { id: w, name: text(_4.data, _4.start, _4.length) }; + return { id: w, name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16)))) }; }; const _604: (a0: rt.u16) => edits_Named.Named = (w2: rt.u16): edits_Named.Named => { - const _44: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(w2 & 0xff)); - return { id: w2, name: text(_44.data, _44.start, _44.length) }; + return { id: w2, name: text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; }; const _605: (a0: edits_Named.Named[]) => rt.u16[] = (v8: edits_Named.Named[]): rt.u16[] => { return rt.iterToArray(rt.iterMap(rt.iterSlice(v8), (n: edits_Named.Named): rt.u16 => { @@ -70,8 +67,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data putU16s(out, [_33[0], _33[1]]); } const names: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_233: rt.u8): string => { - const _433: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(_233)); - return text(_433.data, _433.start, _433.length); + return text(rt.byteSliceFrom(Uint8Array.of(_233))); }), undefined, 12, true); rt.vecRetain(names, (s3: string): boolean => { return rt.stringLen(s3) > 1; @@ -145,8 +141,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data fmt_put(out, _144.name); } const names2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): string => { - const _431: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3))); - return text(_431.data, _431.start, _431.length); + return text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3)))); }), undefined, 12, true); rt.vecDedupBy(names2, rt.same); rt.byteVecPush(out, names2.length & 0xff); @@ -197,8 +192,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } const names3: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_221: rt.u8): string => { const b8: rt.u8 = _221; - const _422: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16))); - return text(_422.data, _422.start, _422.length); + return text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); }), undefined, 12, true); rt.sliceSort(names3, rt.cmpLt(rt.cmpStr)); for (const _263 of names3) { @@ -223,13 +217,11 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } v6.reverse(); putU16s(out, v6); - const _332: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3))); const named: edits_Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_212: rt.u16): edits_Named.Named => { const w6: rt.u16 = _212; - const _514: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(w6 & 0xff)); - return { id: w6, name: text(_514.data, _514.start, _514.length) }; + return { id: w6, name: text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; }), undefined, 16, true); - const probe: edits_Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: text(_332.data, _332.start, _332.length) }; + const probe: edits_Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; rt.byteVecPush(out, rt.sliceContains(named, probe, edits_Named.eq$cmp_PartialEq) ? 1 : 0); rt.byteVecPush(out, rt.sliceContains(words, rt.u16Mul(at(2) as rt.u16, 3), rt.same) ? 1 : 0); const _361: rt.u8 = at(3); @@ -245,8 +237,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } else if (_8 === 4) { const named2: edits_Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_28: rt.u16): edits_Named.Named => { const w4: rt.u16 = _28; - const _57: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(w4 & 0xff)); - return { id: w4, name: text(_57.data, _57.start, _57.length) }; + return { id: w4, name: text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; }), undefined, 16, true); const cloned: edits_Named.Named[] = named2.map(edits_Named.clone$Clone); rt.byteVecPush(out, rt.eqSlice(edits_Named.eq$cmp_PartialEq)(cloned, named2) ? 1 : 0); @@ -271,7 +262,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data return a027.slice(); }); rt.byteVecPush(out, rt.eqSlice(rt.eqSlice(rt.same))(_453, nested) ? 1 : 0); - const pair: [string, rt.u8] = [text(data.data, data.start, data.length), at(0)]; + const pair: [string, rt.u8] = [text(data), at(0)]; const copy: [string, rt.u8] = rt.tupleClone(pair, [undefined, undefined]); fmt_put(out, copy[0]); const _470: [rt.u8, string] = [copy[1], copy[0]]; @@ -284,7 +275,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.vecExtendFromSlice(grown, words); putU16s(out, grown); } else if (_8 === 5) { - let tally: edits_Tally.Tally = { n: at(0), names: [text(data.data, data.start, data.length)] }; + let tally: edits_Tally.Tally = { n: at(0), names: [text(data)] }; const default_ = edits_Tally.default$Default(); const taken3 = tally; tally = default_; @@ -380,7 +371,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.byteVecPush(out, 6 & 0xff); rt.byteVecPush(out, rt.u8Mul(4 & 0xff, 1 & 0xff)); } else { - const s2: string = text(data.data, data.start, data.length); + const s2: string = text(data); const sep: rt.char[] = [47, 97]; rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(sep)) ? 1 : 0); rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(rt.sliceRange(sep, 0))) ? 1 : 0); @@ -426,8 +417,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * array, on every short prefix of the input and on a slice that starts past its storage's, * and those that lend a closure another element JS copies, as its place. */ -export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), 0); }; diff --git a/ts/fixtures/lang/expected/errors.ts b/ts/fixtures/lang/expected/errors.ts index b6880284a..67b4a0d98 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -5,7 +5,7 @@ import { then$0afp4no } from "./core/bool.ts"; import { eq$09vw48j as convert_eq$09vw48j } from "./core/char/convert.ts"; import { eq$18sin5z as num_error_eq$18sin5z } from "./core/num/error.ts"; import { eq$04qb8k3 as result_eq$04qb8k3, eq$10fppe8 as result_eq$10fppe8, eq$0ecfqx9 as result_eq$0ecfqx9, eq$0nlhjpf as result_eq$0nlhjpf, eq$04iua4k as result_eq$04iua4k, eq$1dhtbkj as result_eq$1dhtbkj, eq$0pe0qmq as result_eq$0pe0qmq, eq$1mpp8xa as result_eq$1mpp8xa, eq$0grmb7g as result_eq$0grmb7g, eq$19kc15f as result_eq$19kc15f, eq$0rj0czq as result_eq$0rj0czq, eq$1hq3neq as result_eq$1hq3neq, eq$08241oi as result_eq$08241oi, eq$0bl30vt as result_eq$0bl30vt, eq$1fkhuzl as result_eq$1fkhuzl, eq$0p1bb4y as result_eq$0p1bb4y, eq$03gbayb as result_eq$03gbayb, err$1ujom0k, err$02r96h1, err$0jf6smd, map$0fm1w6u as result_map$0fm1w6u, map$0r57egs as result_map$0r57egs, mapErr$0u5yxjj as result_mapErr$0u5yxjj } from "./core/result.ts"; -import { parse$0vh4cry, parse$10fbnat, parse$1g7h2lx, parse$1gszg8m, parse$0sdtyv9, parse$01247e1 } from "./core/str.ts"; +import { parse$0vh4cry, parse$082ztwj, parse$1ci7nyc, parse$1s5pqso, parse$0o4ono0, parse$0at0fdl } from "./core/str.ts"; import { eq$1f3e51k as str_error_eq$1f3e51k } from "./core/str/error.ts"; /** Each pair's `==` and `!=`, a bit each. */ @@ -396,31 +396,31 @@ export function parsed$f64(all: string[]): rt.Result export function parsed$i128(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$10fbnat(s); + return parse$082ztwj(s); }), undefined, 32, true); } export function parsed$i8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1g7h2lx(s); + return parse$1ci7nyc(s); }), undefined, 2, true); } export function parsed$num_NonZero_u32(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1gszg8m(s); + return parse$1s5pqso(s); }), undefined, 8, true); } export function parsed$u64(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0sdtyv9(s); + return parse$0o4ono0(s); }), undefined, 16, true); } export function parsed$u8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$01247e1(s); + return parse$0at0fdl(s); }), undefined, 2, true); } @@ -428,8 +428,7 @@ export function parsed$u8(all: string[]): rt.Result[] { * The values of the type `kind` picks, from the edges and the input as text of digits, * signs, and letters, or as bytes. */ -export function eqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let input: string = ""; for (const b of rt.byteSliceView(data)) { const _14: rt.char[] = [48, 49, 50, 53, 57, 43, 45, 46, 101, 97, 98, 78, 116, 102, 233]; @@ -486,7 +485,7 @@ export function eqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe }), undefined, 16, true), out); } else if (_32 === 12) { pairs$Result_Option_u8_num_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s6: string): rt.Result => { - return result_map$0r57egs(parse$01247e1(s6), (v10: rt.u8): rt.u8 | undefined => { + return result_map$0r57egs(parse$0at0fdl(s6), (v10: rt.u8): rt.u8 | undefined => { return rt.u8CheckedSub(v10, 1); }); }), undefined, 2, true), out); @@ -497,7 +496,7 @@ export function eqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe }); }), undefined, 8, true), out); pairs$Result_u8_num_IntErrorKind(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s8: string): rt.Result => { - return result_mapErr$0u5yxjj(parse$01247e1(s8), (e: rt.ParseIntError): rt.IntErrorKind => { + return result_mapErr$0u5yxjj(parse$0at0fdl(s8), (e: rt.ParseIntError): rt.IntErrorKind => { return e.kind; }); }), undefined, 2, true), out); @@ -515,7 +514,7 @@ export function eqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe pairs$Option_Result_u8_num_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result | undefined => { const _73: string = s; return then$0afp4no(!((s.length === 0)), (): rt.Result => { - return parse$01247e1(_73); + return parse$0at0fdl(_73); }); }), undefined, 2, true), out); pairs$Vec_Result_bool_str_ParseBoolError(rt.iterToArray(rt.iterMap(rt.sliceChunks(all, 2), parsed$bool), undefined, 12, true), out); @@ -529,7 +528,7 @@ export function eqs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe return err$1ujom0k(parse$0vh4cry(s4)); }), "next", 0), out); pairs$num_ParseIntError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s5: string): rt.ParseIntError | undefined => { - return err$0jf6smd(parse$1g7h2lx(s5)); + return err$0jf6smd(parse$1ci7nyc(s5)); }), "next", 1), out); } } diff --git a/ts/fixtures/lang/expected/floats.ts b/ts/fixtures/lang/expected/floats.ts index 8457d1185..3417c6ae3 100644 --- a/ts/fixtures/lang/expected/floats.ts +++ b/ts/fixtures/lang/expected/floats.ts @@ -7,14 +7,13 @@ import * as floats_Reading from "./floats.Reading.ts"; import { put as fmt_put } from "./fmt.ts"; /** An `f64` from the front of `data`, its bits big-endian and zero-padded. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.f64, rt.ByteSlice] { - const _4: [rt.u64, rt.ByteSlice] = takeBits(dataData, dataStart, dataLen); +export function take(data: rt.ByteSlice): [rt.f64, rt.ByteSlice] { + const _4: [rt.u64, rt.ByteSlice] = takeBits(data); return [rt.f64FromBits(_4[0]), _4[1]] as [rt.f64, rt.ByteSlice]; } /** The bits [`take`] reads, as a seed, which no NaN quieted on the way. */ -export function takeBits(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u64, rt.ByteSlice] { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function takeBits(data: rt.ByteSlice): [rt.u64, rt.ByteSlice] { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -53,12 +52,12 @@ export function raise(level: rt.Place, by: rt.f64): void { level.v = level.v * 2.0; } -export function floats(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let zeros!: boolean; let _242!: rt.f64; - const _6: [rt.f64, rt.ByteSlice] = take(dataData, dataStart, dataLen); + const _6: [rt.f64, rt.ByteSlice] = take(data); const a: rt.f64 = _6[0]; - const _9: [rt.f64, rt.ByteSlice] = take(_6[1].data, _6[1].start, _6[1].length); + const _9: [rt.f64, rt.ByteSlice] = take(_6[1]); const b: rt.f64 = _9[0]; const _10: rt.u8 = rt.u8Rem(kind, 10); if (_10 === 0) { @@ -109,8 +108,8 @@ export function floats(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(rt.isizeFromF64(a)))); } else if (_10 === 2) { const wide: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(dataLen, 16); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, n), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n)); + const n: rt.usize = rt.min(data.length, 16); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, n), rt.byteSliceRange(data, 0, n)); const v: rt.u128 = rt.u128FromBeBytes(wide); const iter3: rt.Iter = rt.iterSlice([(rt.u128Low(v) & 0xff) as rt.f64, (rt.u128Low(v) & 0xffff) as rt.f64, rt.u128Low(v) as rt.f64, rt.u64ToF64(rt.u64Cast(v)), rt.u128ToF64(v), rt.u128Low(v) as rt.f64, (rt.u128Low(v) << 24) >> 24 as rt.f64, (rt.u128Low(v) << 16) >> 16 as rt.f64, (rt.u128Low(v) | 0) as rt.f64, rt.i64ToF64(rt.i64Cast(v)), rt.i128ToF64(rt.i128Cast(v)), (rt.u128Low(v) | 0) as rt.f64, rt.u128Low(v) as rt.f64, (rt.u128Low(v) << 16) >> 16 as rt.f64, rt.u128And(v, 1) === 1 ? 1.0 : 0.0, (rt.u128Low(v) & 0xff) as rt.f64, 1.8446744073709552e19, -9.223372036854776e18, 3.402823669209385e38]); while (true) { @@ -273,13 +272,13 @@ export function floats(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * first would tie, a product of half `c`'s last place, subnormal sums, products past `f64::MAX` that the sum brings back, and * each side of where the runtime's fast path ends. */ -export function mulAdds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function mulAdds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _53!: [rt.f64, rt.f64, rt.f64]; let _103!: rt.f64; let ea4!: rt.i64; b0: { if (!(rt.u8Rem(kind, 2) === 0)) { - let state: rt.u64 = rt.u64Or(takeBits(dataData, dataStart, dataLen)[0], 1); + let state: rt.u64 = rt.u64Or(takeBits(data)[0], 1); let iterStart: rt.i32 = 0; const iterEnd: rt.i32 = 32; while (true) { @@ -345,10 +344,10 @@ export function mulAdds(kind: rt.u8, dataData: Uint8Array, dataStart: number, da putF64(out, rt.f64MulAdd(_53[0], _53[1], _53[2])); } } - const _9: [rt.f64, rt.ByteSlice] = take(dataData, dataStart, dataLen); + const _9: [rt.f64, rt.ByteSlice] = take(data); const a: rt.f64 = _9[0]; - const _12: [rt.f64, rt.ByteSlice] = take(_9[1].data, _9[1].start, _9[1].length); - putF64(out, rt.f64MulAdd(a, _12[0], take(_12[1].data, _12[1].start, _12[1].length)[0])); + const _12: [rt.f64, rt.ByteSlice] = take(_9[1]); + putF64(out, rt.f64MulAdd(a, _12[0], take(_12[1])[0])); } } @@ -369,8 +368,8 @@ export function step(state: rt.Place): rt.u64 { * `f64`'s `Display`, `Debug`, `LowerExp`, and `UpperExp`, with a precision from the byte * after the double, which rounds the exact value half to even, and every other option. */ -export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _6: [rt.f64, rt.ByteSlice] = take(dataData, dataStart, dataLen); +export function formats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _6: [rt.f64, rt.ByteSlice] = take(data); const a: rt.f64 = _6[0]; const p: rt.usize = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_6[1]), 0) as rt.usize; b0: { @@ -386,9 +385,9 @@ export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(a, f), (f: rt.Formatter) => rt.f64LowerExp(a, f), (f: rt.Formatter) => rt.f64Debug(a, f)]; fmt_put(out, rt.fmtFormat([rt.fmtSpec({ precision: 1100 }, args6[0]), " ", rt.fmtSpec({ precision: 800 }, args6[1]), " ", rt.fmtSpec({ precision: 1100 }, args6[2]), " ", rt.fmtSpec({ precision: 65535 }, args6[0])])); } else if (_13 === 2) { - const _72: [rt.f64, rt.ByteSlice] = take(_6[1].data, _6[1].start, _6[1].length); + const _72: [rt.f64, rt.ByteSlice] = take(_6[1]); const b: rt.f64 = _72[0]; - const c: rt.f64 = take(_72[1].data, _72[1].start, _72[1].length)[0]; + const c: rt.f64 = take(_72[1])[0]; putF64(out, rt.f64Clamp(a, b, c)); } else if (_13 === 3) { const _78: rt.f64 | undefined = a * 0.5; @@ -397,7 +396,7 @@ export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const args8: rt.Fmt[] = [(f: rt.Formatter) => floats_Reading.fmt$fmt_Debug(part, f)]; fmt_put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", rt.fmtSpec({ precision: 2 }, args8[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); } else { - let state: rt.u64 = rt.u64Or(takeBits(dataData, dataStart, dataLen)[0], 1); + let state: rt.u64 = rt.u64Or(takeBits(data)[0], 1); let iterStart: rt.i32 = 0; const iterEnd: rt.i32 = 64; while (iterStart++ < iterEnd) { @@ -424,18 +423,18 @@ export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, da * `str::parse::` by std's grammar, with its errors, of the input as text, of bytes * mapped into the grammar's alphabet, or of decimals made from a seed. */ -export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _60!: rt.usize; b0: { const _4: rt.u8 = rt.u8Rem(kind, 3); if (_4 === 0) { - const _6: rt.Result = rt.strFromUtf8(new rt.ByteSlice(dataData, dataStart, dataLen)); + const _6: rt.Result = rt.strFromUtf8(data); if (_6.ok) { one(_6.value, out); } } else if (_4 === 1) { let s: string = ""; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const _21: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); const _22: rt.usize = rt.usizeRem(b as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); rt.idx(_21, _22); @@ -443,7 +442,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } one(s, out); } else { - let state: rt.u64 = rt.u64Or(takeBits(dataData, dataStart, dataLen)[0], 1); + let state: rt.u64 = rt.u64Or(takeBits(data)[0], 1); let iterStart: rt.i32 = 0; const iterEnd: rt.i32 = 16; while (true) { diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index d8c985716..c19f86727 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -33,12 +33,12 @@ export function put(out: rt.ByteVec, s: string): void { } /** Integers of every width, with each spec. */ -export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 12); if (_4 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n)); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); const v: rt.u8 = rt.u8FromBeBytes(buf); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8Debug(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8UpperHex(v, f)]; put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[1]), " ", rt.fmtSpec({ width: 3 }, args2[1])])); @@ -49,8 +49,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f))); } else if (_4 === 1) { const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n2)); + const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(data, 0, n2)); const v2: rt.u16 = rt.u16FromBeBytes(buf2); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16Debug(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16UpperHex(v2, f)]; put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rt.fmtSpec({ alternate: true }, args8[2]), " ", rt.fmtSpec({ alternate: true }, args8[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rt.fmtSpec({ alternate: true }, args8[1]), " ", rt.fmtSpec({ width: 3 }, args8[1])])); @@ -61,8 +61,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f))); } else if (_4 === 2) { const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n3)); + const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(data, 0, n3)); const v3: rt.u32 = rt.u32FromBeBytes(buf3); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32Debug(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32UpperHex(v3, f)]; put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rt.fmtSpec({ alternate: true }, args14[2]), " ", rt.fmtSpec({ alternate: true }, args14[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rt.fmtSpec({ alternate: true }, args14[1]), " ", rt.fmtSpec({ width: 3 }, args14[1])])); @@ -73,8 +73,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f))); } else if (_4 === 3) { const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf4).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n4)); + const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(data, 0, n4)); const v4: rt.u64 = rt.u64FromBeBytes(buf4); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64Debug(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64UpperHex(v4, f)]; put(out, rt.fmtFormat([args20[0], " ", args20[1], " ", rt.fmtSpec({ width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rt.fmtSpec({ alternate: true }, args20[2]), " ", rt.fmtSpec({ alternate: true }, args20[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rt.fmtSpec({ alternate: true }, args20[1]), " ", rt.fmtSpec({ width: 3 }, args20[1])])); @@ -85,8 +85,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f))); } else if (_4 === 4) { const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf5).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n5)); + const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(data, 0, n5)); const v5: rt.u128 = rt.u128FromBeBytes(buf5); const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128Debug(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128UpperHex(v5, f)]; put(out, rt.fmtFormat([args26[0], " ", args26[1], " ", rt.fmtSpec({ width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rt.fmtSpec({ alternate: true }, args26[2]), " ", rt.fmtSpec({ alternate: true }, args26[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rt.fmtSpec({ alternate: true }, args26[1]), " ", rt.fmtSpec({ width: 3 }, args26[1])])); @@ -97,8 +97,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f))); } else if (_4 === 5) { const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf6).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n6)); + const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(data, 0, n6)); const v6: rt.usize = rt.usizeFromBeBytes(buf6); const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeDebug(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeUpperHex(v6, f)]; put(out, rt.fmtFormat([args32[0], " ", args32[1], " ", rt.fmtSpec({ width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rt.fmtSpec({ alternate: true }, args32[2]), " ", rt.fmtSpec({ alternate: true }, args32[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rt.fmtSpec({ alternate: true }, args32[1]), " ", rt.fmtSpec({ width: 3 }, args32[1])])); @@ -109,8 +109,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f))); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf7).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n7)); + const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(data, 0, n7)); const v7: rt.i8 = rt.i8FromBeBytes(buf7); const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8Debug(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8UpperHex(v7, f)]; put(out, rt.fmtFormat([args38[0], " ", args38[1], " ", rt.fmtSpec({ width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rt.fmtSpec({ alternate: true }, args38[2]), " ", rt.fmtSpec({ alternate: true }, args38[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rt.fmtSpec({ alternate: true }, args38[1]), " ", rt.fmtSpec({ width: 3 }, args38[1])])); @@ -121,8 +121,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f))); } else if (_4 === 7) { const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf8).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n8)); + const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(data, 0, n8)); const v8: rt.i16 = rt.i16FromBeBytes(buf8); const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16Debug(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16UpperHex(v8, f)]; put(out, rt.fmtFormat([args44[0], " ", args44[1], " ", rt.fmtSpec({ width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rt.fmtSpec({ alternate: true }, args44[2]), " ", rt.fmtSpec({ alternate: true }, args44[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rt.fmtSpec({ alternate: true }, args44[1]), " ", rt.fmtSpec({ width: 3 }, args44[1])])); @@ -133,8 +133,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f))); } else if (_4 === 8) { const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf9).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n9)); + const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(data, 0, n9)); const v9: rt.i32 = rt.i32FromBeBytes(buf9); const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32Debug(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32UpperHex(v9, f)]; put(out, rt.fmtFormat([args50[0], " ", args50[1], " ", rt.fmtSpec({ width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rt.fmtSpec({ alternate: true }, args50[2]), " ", rt.fmtSpec({ alternate: true }, args50[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rt.fmtSpec({ alternate: true }, args50[1]), " ", rt.fmtSpec({ width: 3 }, args50[1])])); @@ -145,8 +145,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f))); } else if (_4 === 9) { const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf10).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n10)); + const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(data, 0, n10)); const v10: rt.i64 = rt.i64FromBeBytes(buf10); const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64Debug(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64UpperHex(v10, f)]; put(out, rt.fmtFormat([args56[0], " ", args56[1], " ", rt.fmtSpec({ width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rt.fmtSpec({ alternate: true }, args56[2]), " ", rt.fmtSpec({ alternate: true }, args56[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rt.fmtSpec({ alternate: true }, args56[1]), " ", rt.fmtSpec({ width: 3 }, args56[1])])); @@ -157,8 +157,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f))); } else if (_4 === 10) { const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf11).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n11)); + const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(data, 0, n11)); const v11: rt.i128 = rt.i128FromBeBytes(buf11); const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128Debug(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128UpperHex(v11, f)]; put(out, rt.fmtFormat([args62[0], " ", args62[1], " ", rt.fmtSpec({ width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rt.fmtSpec({ alternate: true }, args62[2]), " ", rt.fmtSpec({ alternate: true }, args62[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rt.fmtSpec({ alternate: true }, args62[1]), " ", rt.fmtSpec({ width: 3 }, args62[1])])); @@ -169,8 +169,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL put(out, rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f))); } else { const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(dataLen, rt.byteSliceFrom(buf12).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n12)); + const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(data, 0, n12)); const v12: rt.isize = rt.isizeFromBeBytes(buf12); const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeDebug(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeUpperHex(v12, f)]; put(out, rt.fmtFormat([args68[0], " ", args68[1], " ", rt.fmtSpec({ width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rt.fmtSpec({ alternate: true }, args68[2]), " ", rt.fmtSpec({ alternate: true }, args68[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rt.fmtSpec({ alternate: true }, args68[1]), " ", rt.fmtSpec({ width: 3 }, args68[1])])); @@ -183,9 +183,8 @@ export function ints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Strings padded and escaped, and bytes that may not be UTF-8. */ -export function strings(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function strings(data: rt.ByteSlice, out: rt.ByteVec): void { let flag!: boolean; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); for (const _9 of rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 3)))) { const _15: rt.usize = rt.usizeRem(_9 as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽𽀀𿱀", "😀 🇦", "゙゚ン", "{}"].length); if (!(_15 < 14)) { @@ -236,12 +235,11 @@ export function strings(dataData: Uint8Array, dataStart: number, dataLen: number } } -export function nested(dataData: Uint8Array, dataStart: number, dataLen: number): Nested.Nested { +export function nested(data: rt.ByteSlice): Nested.Nested { let _22!: shapes_Shape.Shape; let _49!: fmt_Pair.Pair | undefined; let _61!: rt.Result; let _90!: Kind.Kind; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -288,12 +286,11 @@ export function nested(dataData: Uint8Array, dataStart: number, dataLen: number) } /** Derived `Debug` of every shape, compact and pretty, with options passed to fields. */ -export function derived(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function derived(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; - const value: Nested.Nested = nested(data.data, data.start, data.length); + const value: Nested.Nested = nested(data); const args2: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; put(out, rt.fmtFormat([args2[0]])); const args4: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; @@ -360,11 +357,10 @@ export function logged(log: rt.ByteVec, dataData: Uint8Array, dataStart: number, } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ -export function written(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function written(data: rt.ByteSlice, out: rt.ByteVec): void { let _116!: rt.u8 | undefined; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const hex: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; const args2: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rt.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; @@ -413,8 +409,8 @@ export function written(dataData: Uint8Array, dataStart: number, dataLen: number const _222: Noted.Noted = { _0: 2 }; const args20: rt.Fmt[] = [(f: rt.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rt.Formatter) => Noted.fmt$fmt_Display(_222, f)]; put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args20[1])])); - if (!((dataLen === 0))) { - put(out, logged(log, dataData, dataStart, dataLen)); + if (!((data.length === 0))) { + put(out, logged(log, data.data, data.start, data.length)); } const _241: rt.u8 = at(13); const part2 = note(log, _241); @@ -437,8 +433,7 @@ export function written(dataData: Uint8Array, dataStart: number, dataLen: number * Widths and precisions from arguments, by position and by name, and one past * `u16::MAX`, which panics. */ -export function counts(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function counts(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -485,12 +480,11 @@ export function rounding(out: rt.ByteVec): void { } /** Panics, each with the message native Rust formats. */ -export function panics(kind: rt.u8, restData: Uint8Array, restStart: number, restLen: number, out: rt.ByteVec): void { +export function panics(kind: rt.u8, rest: rt.ByteSlice, out: rt.ByteVec): void { let r!: rt.Result; let r2!: rt.Result; let r4!: rt.Result; let r5!: rt.Result; - const rest: rt.ByteSlice = new rt.ByteSlice(restData, restStart, restLen); const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest), 0); const _7: rt.u8 = rt.u8Rem(kind, 20); if (_7 === 0) { @@ -616,10 +610,9 @@ export function panics(kind: rt.u8, restData: Uint8Array, restStart: number, res * std's ranges' `Debug`, which passes its options to each bound, and an `Arc`'s `Debug` * and `Display`, which pass them to what it holds. */ -export function wrapped(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function wrapped(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const _6: [rt.i32, rt.i32] = [rt.i32Sub(at(0) as rt.i32, 128), rt.i32Sub(at(1) as rt.i32, 100)]; const a: rt.i32 = _6[0]; @@ -734,8 +727,7 @@ export function wrapped(dataData: Uint8Array, dataStart: number, dataLen: number * head however its buffer wraps, sets and maps in braces, nested, and pretty. A hash * collection holds at most one entry, since std leaves their order unspecified. */ -export function collections(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -825,13 +817,12 @@ export function collections(dataData: Uint8Array, dataStart: number, dataLen: nu * a field passes the options to it, and one without writes its name unpadded. A * `ControlFlow` that `?` would break with holds the `Err` or `None` it was applied to. */ -export function enums(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function enums(data: rt.ByteSlice, out: rt.ByteVec): void { let flow!: rt.Result; let unit!: rt.Result; let erred!: rt.Result; let none!: rt.u8 | undefined; let unitNone!: undefined | rt.None; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -853,9 +844,7 @@ export function enums(dataData: Uint8Array, dataStart: number, dataLen: number, const part2 = pick$enums_Option_u8(at(7), thenSome$0d5am30(rt.u8Rem(at(8), 2) === 0, at(9))); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(part2, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", rt.fmtSpec({ debugHex: "x" }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0])])); - const _108: rt.u8 = at(10); - const _111: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 3)); - const part4 = pick$enums_ref_slice_u8(_108, _111.data, _111.start, _111.length); + const part4 = pick$enums_ref_slice_u8(at(10), rt.byteSliceRange(data, 0, rt.min(data.length, 3))); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(part4, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug))]; put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0]), "|", rt.fmtSpec({ debugHex: "x" }, args10[0]), "|", rt.fmtSpec({ width: 3 }, args10[0])])); const _128: rt.u8 = at(11); @@ -966,13 +955,13 @@ export function pick$enums_fmt_Clip(by: rt.u8, x: Clip.Clip): rt.RangeBound; } -export function pick$enums_ref_slice_u8(by: rt.u8, xData: Uint8Array, xStart: number, xLen: number): rt.RangeBound { +export function pick$enums_ref_slice_u8(by: rt.u8, x: rt.ByteSlice): rt.RangeBound { const _3: rt.u8 = rt.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: new rt.ByteSlice(xData, xStart, xLen) } as rt.RangeBound; + return { tag: "Included", _0: x } as rt.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: new rt.ByteSlice(xData, xStart, xLen) } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rt.RangeBound; } return { tag: "Unbounded" } as rt.RangeBound; } @@ -1004,8 +993,7 @@ export function pick$enums_u8(by: rt.u8, x: rt.u8): rt.RangeBound { * element's `Debug` with the formatter's options: consumed from either end, empty, and * pretty. A hash iterator holds at most one entry, since std leaves their order unspecified. */ -export function iters(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -2162,10 +2150,9 @@ export function result(out: rt.ByteVec, r: rt.Result): v } /** `fmt::Write` for a `String`, through `&mut W`, and for the crate's own writers. */ -export function writes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const c: rt.char = option_unwrapOr$0k15iai(rt.charFromU32(rt.u32Mul(at(0) as rt.u32, 257)), 63); let s: string = ""; diff --git a/ts/fixtures/lang/expected/folds.ts b/ts/fixtures/lang/expected/folds.ts index f0ab82e3e..5e4508ff9 100644 --- a/ts/fixtures/lang/expected/folds.ts +++ b/ts/fixtures/lang/expected/folds.ts @@ -208,10 +208,9 @@ export function state$u8_usize(out: rt.ByteVec, v: rt.usize, r: rt.RangeInclusiv * Each read of empty, single, and full ranges of the integer type `kind` picks, and at * its limits. */ -export function folds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const _8: [rt.u8, rt.u8, rt.usize] = [at(0), at(1), rt.usizeRem(at(2) as rt.usize, 6)]; const a: rt.u8 = _8[0]; diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 9c54ca00a..92cdcd688 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -15,8 +15,7 @@ import type * as shapes_Shape from "./shapes.Shape.ts"; import type * as Track from "./shapes.Track.ts"; /** Each method once per instance: `Wrap` of a struct, an enum, a number, and itself. */ -export function methods(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 48d57b60d..99fb68efd 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { args } from "./args.ts"; import { fromFns, maps, lent as arrays_lent, asSlices, given, flattened as arrays_flattened } from "./arrays.ts"; import { bytes as ascii_bytes, chars as ascii_chars, slices as ascii_slices } from "./ascii.ts"; import { atomics } from "./atomics.ts"; @@ -43,6 +44,7 @@ import { objects } from "./objects.ts"; import { orders, bytes as orders_bytes, tuples as orders_tuples, held as orders_held, btrees } from "./orders.ts"; import { lists as pointers_lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded, reattached, partWritten } from "./pointers.ts"; import { refs, toRefs } from "./refs.ts"; +import { returns } from "./returns.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -109,9 +111,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::rounding", (_2122: rt.u8, _3100: rt.ByteSlice, out23: rt.ByteVec): undefined => { rounding(out23); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", skips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", wrappers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", edits_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", floats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", atomics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { - dyns(data23, out24); + dyns(data23.data, data23.start, data23.length, out24); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", cells_cells as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { - dyns_shared(data24, out25); + dyns_shared(data24.data, data24.start, data24.length, out25); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", iters_ranked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", captures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { locks(data25, out26); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::relock", (_2126: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): undefined => { @@ -139,13 +141,13 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_rcs", (_2137: rt.u8, data37: rt.ByteSlice, out38: rt.ByteVec): undefined => { uniqueRcs(data37, out38); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::anys", (_2138: rt.u8, data38: rt.ByteSlice, out39: rt.ByteVec): undefined => { - anys(data38, out39); + anys(data38.data, data38.start, data38.length, out39); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::fns", (_2139: rt.u8, data39: rt.ByteSlice, out40: rt.ByteVec): undefined => { fns(data39, out40); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::copies", (_2140: rt.u8, data40: rt.ByteSlice, out41: rt.ByteVec): undefined => { pointers_copies(data40, out41); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lists", (_2141: rt.u8, data41: rt.ByteSlice, out42: rt.ByteVec): undefined => { - pointers_lists(data41, out42); + pointers_lists(data41.data, data41.start, data41.length, out42); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::nested", (_2142: rt.u8, data42: rt.ByteSlice, out43: rt.ByteVec): undefined => { pointers_nested(data42, out43); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::places", (_2143: rt.u8, data43: rt.ByteSlice, out44: rt.ByteVec): undefined => { @@ -153,7 +155,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::sentinels", (_2144: rt.u8, data44: rt.ByteSlice, out45: rt.ByteVec): undefined => { sentinels(data44, out45); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::shared", (_2145: rt.u8, data45: rt.ByteSlice, out46: rt.ByteVec): undefined => { - pointers_shared(data45, out46); + pointers_shared(data45.data, data45.start, data45.length, out46); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::unchecked", (_2146: rt.u8, data46: rt.ByteSlice, out47: rt.ByteVec): undefined => { unchecked(data46, out47); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", edits_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { @@ -184,7 +186,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) fmt_writes(data59, out60); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", bounds_bounds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { pointers_cells(data60, out61); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", ints_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", strs_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", (a053: rt.u8, a153: rt.ByteSlice, a253: rt.ByteVec): undefined => { + ints_parses(a053, a153.data, a153.start, a153.length, a253); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", (a054: rt.u8, a154: rt.ByteSlice, a254: rt.ByteVec): undefined => { + strs_edits(a054, a154.data, a154.start, a154.length, a254); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { hashes_bytes(data61, out62); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", keys_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", strs_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { pointers_rebound(data62, out63); @@ -192,7 +198,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reducers(data63, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): undefined => { writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", (a062: rt.u8, a162: rt.ByteSlice, a262: rt.ByteVec): undefined => { + strs_drains(a062, a162.data, a162.start, a162.length, a262); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { pointers_made(data65, out66); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_2166: rt.u8, data66: rt.ByteSlice, out67: rt.ByteVec): undefined => { asSlices(data66, out67); @@ -222,7 +230,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) orders_held(data78, out79); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", joins as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { iteratedRuns(data79, out80); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", zeros_writes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", (a0109: rt.u8, a1109: rt.ByteSlice, a2109: rt.ByteVec): undefined => { + zeros_writes(a0109, a1109.data, a1109.start, a1109.length, a2109); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { orders_tuples(data80, out81); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", tuples_tuples as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", saturates_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", saturates_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", saturates_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", saturates_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", saturates_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", saturates_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", saturates_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", saturates_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", saturates_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", saturates_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", saturates_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", saturates_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", methods_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", methods_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", methods_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", methods_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", methods_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", methods_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", methods_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", methods_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", methods_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", methods_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", methods_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", methods_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", separated as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { waiters(data81, out82); @@ -238,7 +248,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reattached(data86, out87); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_2187: rt.u8, data87: rt.ByteSlice, out88: rt.ByteVec): undefined => { partWritten(data87, out88); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hashes.ts b/ts/fixtures/lang/expected/hashes.ts index 0a369064c..e7403f7d1 100644 --- a/ts/fixtures/lang/expected/hashes.ts +++ b/ts/fixtures/lang/expected/hashes.ts @@ -70,9 +70,9 @@ export function digest$Vec_u8(value: rt.ByteVec, out: rt.ByteVec): void { } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array0_u8(valueData: Uint8Array, valueStart: number, valueLen: number, out: rt.ByteVec): void { +export function digest$array0_u8(value: rt.ByteSlice, out: rt.ByteVec): void { const h: rt.Hasher = rt.hasher(); - rt.hashBytes(new rt.ByteSlice(valueData, valueStart, valueLen), h); + rt.hashBytes(value, h); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); } @@ -84,9 +84,9 @@ export function digest$array2_hashes_Dir(value: hashes_Dir.Dir[], out: rt.ByteVe } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array2_u8(valueData: Uint8Array, valueStart: number, valueLen: number, out: rt.ByteVec): void { +export function digest$array2_u8(value: rt.ByteSlice, out: rt.ByteVec): void { const h: rt.Hasher = rt.hasher(); - rt.hashBytes(new rt.ByteSlice(valueData, valueStart, valueLen), h); + rt.hashBytes(value, h); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); } @@ -98,9 +98,9 @@ export function digest$array3_u32(value: rt.u32[], out: rt.ByteVec): void { } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array3_u8(valueData: Uint8Array, valueStart: number, valueLen: number, out: rt.ByteVec): void { +export function digest$array3_u8(value: rt.ByteSlice, out: rt.ByteVec): void { const h: rt.Hasher = rt.hasher(); - rt.hashBytes(new rt.ByteSlice(valueData, valueStart, valueLen), h); + rt.hashBytes(value, h); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); } @@ -203,9 +203,9 @@ export function digest$slice_u16(value: rt.u16[], out: rt.ByteVec): void { } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$slice_u8(valueData: Uint8Array, valueStart: number, valueLen: number, out: rt.ByteVec): void { +export function digest$slice_u8(value: rt.ByteSlice, out: rt.ByteVec): void { const h: rt.Hasher = rt.hasher(); - rt.hashBytes(new rt.ByteSlice(valueData, valueStart, valueLen), h); + rt.hashBytes(value, h); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); } @@ -329,9 +329,8 @@ export function digest$usize(value: rt.usize, out: rt.ByteVec): void { } /** The bytes of `data` from `at`, as many as fit, as one big-endian number. */ -export function wide(dataData: Uint8Array, dataStart: number, dataLen: number, at: rt.usize, n: rt.usize): rt.u128 { +export function wide(data: rt.ByteSlice, at: rt.usize, n: rt.usize): rt.u128 { let _10!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let v: rt.u128 = 0; const _7: rt.usize = rt.usizeAdd(at, n); let iterStart: rt.usize = at; @@ -345,11 +344,10 @@ export function wide(dataData: Uint8Array, dataStart: number, dataLen: number, a } /** The hash of a value of each type `kind` picks, made of `data`. */ -export function values(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let shape!: hashes_Shape.Shape; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const w: (a0: rt.usize, a1: rt.usize) => rt.u128 = (at: rt.usize, n3: rt.usize): rt.u128 => { - return wide(data.data, data.start, data.length, at, n3); + return wide(data, at, n3); }; const _5: rt.u8 = rt.u8Rem(kind, 5); if (_5 === 0) { @@ -464,8 +462,7 @@ export function values(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * builds hash a value alike, through a reference too, and values `Hash` sees as equal * alike, so ordering by its hashes leaves the same set. `hash_one` drops what it takes. */ -export function random(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function random(data: rt.ByteSlice, out: rt.ByteVec): void { const s: rt.RandomState = rt.randomState(); const copy: rt.RandomState = s; const other: Priorities$random.Priorities = Priorities$random.default$random_Default(); @@ -477,7 +474,7 @@ export function random(dataData: Uint8Array, dataStart: number, dataLen: number, } const i: rt.usize = _11[0]; const b: rt.u8 = _11[1]; - const n: rt.u64 = rt.u64Cast(wide(data.data, data.start, data.length, i, 8)); + const n: rt.u64 = rt.u64Cast(wide(data, i, 8)); const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(rt.byteSliceRange(data, i)), "✓"); const built: rt.Hasher = rt.buildHasher(s); rt.hash64(n, built); @@ -516,8 +513,7 @@ export function random(dataData: Uint8Array, dataStart: number, dataLen: number, * `Vec`: its length as a `usize`, then the bytes. Held in a tuple, an `Option`, and an * `Arc` too, and through `RandomState`'s `hash_one`, which hashes each form alike. */ -export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { const iter: rt.RangeInclusive = new rt.RangeInclusive(0, rt.min(data.length, 5), rt.usizeStep); while (true) { const _8: rt.usize | rt.Done = iter.next(); @@ -526,7 +522,7 @@ export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, } const i: rt.usize = _8; const s: rt.ByteSlice = rt.byteSliceRange(data, 0, i); - digest$slice_u8(s.data, s.start, s.length, out); + digest$slice_u8(s, out); digest$Vec_u8(rt.byteSliceToByteVec(s), out); digest$tuple2_ref_slice_u8_u8([s, i & 0xff] as [rt.ByteSlice, rt.u8], out); digest$Option_Vec_u8(rt.byteSliceToByteVec(s), out); @@ -534,8 +530,7 @@ export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, digest$sync_Arc_Vec_u8(_28, out); _28[Symbol.dispose](); } - const _32: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of()); - digest$array0_u8(_32.data, _32.start, _32.length, out); + digest$array0_u8(rt.byteSliceFrom(Uint8Array.of()), out); digest$tuple2_array0_u8_Option_array0_u8([Uint8Array.of(), Uint8Array.of()] as [Uint8Array, Uint8Array | undefined], out); const state: rt.RandomState = rt.randomState(); const iter2: rt.Iter = rt.byteSliceWindows(data, 3); @@ -554,10 +549,8 @@ export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, const _59: rt.u8 = rt.u8Rem(_41.data[_41.start], 2); rt.idx(_41, 1); const pair: Uint8Array = Uint8Array.of(_59, rt.u8Rem(_41.data[_41.start + 1], 2)); - const _72: rt.ByteSlice = rt.byteSliceFrom(a); - digest$array3_u8(_72.data, _72.start, _72.length, out); - const _74: rt.ByteSlice = rt.byteSliceFrom(pair); - digest$array2_u8(_74.data, _74.start, _74.length, out); + digest$array3_u8(rt.byteSliceFrom(a), out); + digest$array2_u8(rt.byteSliceFrom(pair), out); digest$tuple2_array2_u8_array3_u8([pair, a] as [Uint8Array, Uint8Array], out); digest$Option_array2_u8(pair, out); const _83: rt.Arc = new rt.Arc(copy$array_u8(a)); diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index ebf7f0f4b..29edc347d 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -3,7 +3,7 @@ import * as rt from "./rt.ts"; import { copy$array_u32, copy$array_u64 } from "./lib.ts"; import { thenSome$1ugl8af } from "./core/bool.ts"; -import { unwrapOr$1a4gm66 as option_unwrapOr$1a4gm66, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$0ow0wo0 as option_mapOr$0ow0wo0, mapOr$0r2th8w as option_mapOr$0r2th8w, mapOr$0pdoq6p as option_mapOr$0pdoq6p, mapOr$0amk6zv as option_mapOr$0amk6zv, mapOr$1umcrqz as option_mapOr$1umcrqz, mapOr$08xwngs as option_mapOr$08xwngs } from "./core/option.ts"; +import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$0ow0wo0 as option_mapOr$0ow0wo0, mapOr$0r2th8w as option_mapOr$0r2th8w, mapOr$0pdoq6p as option_mapOr$0pdoq6p, mapOr$0amk6zv as option_mapOr$0amk6zv, mapOr$1umcrqz as option_mapOr$1umcrqz, mapOr$08xwngs as option_mapOr$08xwngs } from "./core/option.ts"; import { unwrapOr$0u9zzk3 as result_unwrapOr$0u9zzk3 } from "./core/result.ts"; import * as hints_Countdown from "./hints.Countdown.ts"; import * as Endless from "./hints.Endless.ts"; @@ -1700,9 +1700,8 @@ export function u32Of(n: rt.u64): rt.u32 { * lengths `data`'s first two bytes pick or of its fourth byte on, as each reads from the * front or the back by the third byte's other bits. */ -export function hints(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let it!: rt.Peekable; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -1720,9 +1719,7 @@ export function hints(kind: rt.u8, dataData: Uint8Array, dataStart: number, data const m: rt.u64 = _7[1]; const steps: rt.u8 = at(2); const arm: rt.u8 = steps >> 5; - const _33: rt.ByteSlice | undefined = rt.byteSliceGetRange(data, 3); - const _35: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of()); - const bytes: rt.ByteSlice = option_unwrapOr$1a4gm66(_33, _35.data, _35.start, _35.length); + const bytes: rt.ByteSlice = option_unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 3), rt.byteSliceFrom(Uint8Array.of())); const _37: rt.u8 = rt.u8Rem(kind, 24); if (_37 === 0) { const _39: rt.u8 = rt.u8Rem(arm, 5); @@ -2149,30 +2146,30 @@ export function hints(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * a `TrustedLen` iterator, and after the first of another, which it reserves for again * whenever it fills. */ -export function reserves(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function reserves(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(rt.u8Div(kind, 13), 6); if (_4 === 0) { - typed$u8_hints_reserves_closure0(kind, dataData, dataStart, dataLen, (i5: rt.u32): rt.u8 => { + typed$u8_hints_reserves_closure0(kind, data, (i5: rt.u32): rt.u8 => { return i5 & 0xff; }, { vec: 2147483647, pairs: 268435455, set: 469762048, map: 117440512 }, out); } else if (_4 === 1) { - typed$u32_hints_reserves_closure1(kind, dataData, dataStart, dataLen, (i4: rt.u32): rt.u32 => { + typed$u32_hints_reserves_closure1(kind, data, (i4: rt.u32): rt.u32 => { return i4; }, { vec: 536870911, pairs: 268435455, set: 234881024, map: 117440512 }, out); } else if (_4 === 2) { - typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind, dataData, dataStart, dataLen, (i3: rt.u32): [rt.u8, rt.u8, rt.u8] => { + typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind, data, (i3: rt.u32): [rt.u8, rt.u8, rt.u8] => { return [i3 & 0xff, 0, 0] as [rt.u8, rt.u8, rt.u8]; }, { vec: 715827882, pairs: 268435455, set: 234881024, map: 117440512 }, out); } else if (_4 === 3) { - typed$tuple2_u64_u8_hints_reserves_closure3(kind, dataData, dataStart, dataLen, (i2: rt.u32): [rt.u64, rt.u8] => { + typed$tuple2_u64_u8_hints_reserves_closure3(kind, data, (i2: rt.u32): [rt.u64, rt.u8] => { return [i2 as rt.u64, i2 & 0xff] as [rt.u64, rt.u8]; }, { vec: 134217727, pairs: 89478485, set: 58720256, map: 58720256 }, out); } else if (_4 === 5) { - typed$hints_Unit_hints_reserves_closure4(kind, dataData, dataStart, dataLen, (_2: rt.u32): hints_Unit.Unit => { + typed$hints_Unit_hints_reserves_closure4(kind, data, (_2: rt.u32): hints_Unit.Unit => { return {}; }, { vec: 4294967295, pairs: 536870911, set: 536870911, map: 234881024 }, out); } else { - typed$array275_u32_hints_reserves_closure5(kind, dataData, dataStart, dataLen, (i: rt.u32): rt.u32[] => { + typed$array275_u32_hints_reserves_closure5(kind, data, (i: rt.u32): rt.u32[] => { return Array.from({ length: 275 }, (): rt.u32 => { return i; }); @@ -2181,13 +2178,12 @@ export function reserves(kind: rt.u8, dataData: Uint8Array, dataStart: number, d } /** `reserves` of elements `make` makes. */ -export function typed$array275_u32_hints_reserves_closure5(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u32) => rt.u32[], most: Most.Most, out: rt.ByteVec): void { +export function typed$array275_u32_hints_reserves_closure5(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32[], most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const coll: rt.u8 = rt.u8Rem(kind, 13); const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); @@ -2254,13 +2250,12 @@ export function typed$array275_u32_hints_reserves_closure5(kind: rt.u8, dataData } /** `reserves` of elements `make` makes. */ -export function typed$hints_Unit_hints_reserves_closure4(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u32) => hints_Unit.Unit, most: Most.Most, out: rt.ByteVec): void { +export function typed$hints_Unit_hints_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => hints_Unit.Unit, most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const coll: rt.u8 = rt.u8Rem(kind, 13); const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); @@ -2327,13 +2322,12 @@ export function typed$hints_Unit_hints_reserves_closure4(kind: rt.u8, dataData: } /** `reserves` of elements `make` makes. */ -export function typed$tuple2_u64_u8_hints_reserves_closure3(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u32) => [rt.u64, rt.u8], most: Most.Most, out: rt.ByteVec): void { +export function typed$tuple2_u64_u8_hints_reserves_closure3(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => [rt.u64, rt.u8], most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const coll: rt.u8 = rt.u8Rem(kind, 13); const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); @@ -2400,13 +2394,12 @@ export function typed$tuple2_u64_u8_hints_reserves_closure3(kind: rt.u8, dataDat } /** `reserves` of elements `make` makes. */ -export function typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u32) => [rt.u8, rt.u8, rt.u8], most: Most.Most, out: rt.ByteVec): void { +export function typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => [rt.u8, rt.u8, rt.u8], most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const coll: rt.u8 = rt.u8Rem(kind, 13); const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); @@ -2473,13 +2466,12 @@ export function typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind: rt.u8, dataD } /** `reserves` of elements `make` makes. */ -export function typed$u32_hints_reserves_closure1(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u32) => rt.u32, most: Most.Most, out: rt.ByteVec): void { +export function typed$u32_hints_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32, most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const coll: rt.u8 = rt.u8Rem(kind, 13); const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); @@ -2546,13 +2538,12 @@ export function typed$u32_hints_reserves_closure1(kind: rt.u8, dataData: Uint8Ar } /** `reserves` of elements `make` makes. */ -export function typed$u8_hints_reserves_closure0(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u32) => rt.u8, most: Most.Most, out: rt.ByteVec): void { +export function typed$u8_hints_reserves_closure0(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u8, most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const coll: rt.u8 = rt.u8Rem(kind, 13); const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index 72c21e6fd..234798d63 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -13,23 +13,22 @@ export function whole(p: [string, Row.Row, rt.u8]): rt.u8 { return (rt.stringLen(p[0]) & 0xff) ^ p[1].cells[1] ^ p[2]; } -export function holds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function holds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const _10: rt.u8 = rt.u8Rem(kind, 7); if (_10 === 0) { - places(a, b, data.data, data.start, data.length, out); + places(a, b, data, out); } else if (_10 === 1) { - indexed(data.data, data.start, data.length, out); + indexed(data, out); } else if (_10 === 2) { - reborrows(a, b, data.data, data.start, data.length, out); + reborrows(a, b, data, out); } else if (_10 === 3) { - copies(a, data.data, data.start, data.length, out); + copies(a, data, out); } else if (_10 === 4) { - closures(a, b, data.data, data.start, data.length, out); + closures(a, b, data, out); } else if (_10 === 5) { - parts(a, b, data.data, data.start, data.length, out); + parts(a, b, data, out); } else { ranges(data.data, data.start, data.length, out); } @@ -39,7 +38,7 @@ export function holds(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * A `&mut` through nested indexes lent as an `rt.Place`, each index assigned again while * it lives, and one through a reference assigned another. */ -export function places(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function places(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const item = copy$array_u8(rt.bytes(4)); const grid: Uint8Array[] = Array.from({ length: 4 }, (): Uint8Array => { return copy$array_u8(item); @@ -48,7 +47,7 @@ export function places(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: numb const _16: [rt.usize, rt.usize] = [rt.u8Rem(a, 4) as rt.usize, rt.u8Rem(b, 4) as rt.usize]; let i: rt.usize = _16[0]; let j: rt.usize = _16[1]; - for (const k of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const k of rt.byteSliceView(data)) { const _30: rt.usize = i; if (!(_30 < 4)) { rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); @@ -105,20 +104,18 @@ export function places(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: numb * Shared and mutable borrows of an element, the index assigned again before the read, * and kept across iterations. */ -export function indexed(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { let i: rt.usize = 0; const kept: rt.u8[] = []; - while (i < dataLen) { + while (i < data.length) { const _9: rt.usize = i; - if (_9 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _9); - } + rt.idx(data, _9); i = rt.usizeAdd(i, 1); - rt.byteVecPush(out, dataData[dataStart + _9]); - kept.push(dataData[dataStart + _9]); + rt.byteVecPush(out, data.data[data.start + _9]); + kept.push(data.data[data.start + _9]); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); - const v: rt.ByteVec = rt.byteSliceToByteVec(new rt.ByteSlice(dataData, dataStart, dataLen)); + const v: rt.ByteVec = rt.byteSliceToByteVec(data); let i2: rt.usize = 0; while (i2 < v.length) { const at = rt.idx(v, i2); @@ -133,7 +130,7 @@ export function indexed(dataData: Uint8Array, dataStart: number, dataLen: number * A reborrow through a reference that is then assigned another, shared and mutable, in a * loop. */ -export function reborrows(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function reborrows(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let x: rt.u8 = a; let y: rt.u8 = b; let r: rt.Place = rt.place(() => x, (value) => x = value); @@ -144,7 +141,7 @@ export function reborrows(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: n rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(x, y)), undefined, true); let r2: rt.u8 = a; const kept: rt.u8[] = []; - for (const _25 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const _25 of rt.byteSliceView(data)) { const s2: rt.u8 = r2; r2 = _25; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(s2, r2)), undefined, true); @@ -157,16 +154,16 @@ export function reborrows(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: n * A copy of a reference whose source is assigned another, and of an `Option` a range's * `next` assigns again. */ -export function copies(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function copies(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let r: rt.u8 = a; const kept: rt.u8[] = []; - for (const _9 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const _9 of rt.byteSliceView(data)) { const s: rt.u8 = r; r = _9; kept.push(s); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); - const range: rt.Range = new rt.Range(0, dataLen); + const range: rt.Range = new rt.Range(0, data.length); let cur: rt.usize | undefined = range.start < range.end ? range.start++ : undefined; const some: boolean = cur !== undefined; const copied: rt.usize | undefined = cur; @@ -193,10 +190,9 @@ export function copies(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLe * Closures made in a loop that capture a reference to what that iteration reads, called * after it: an element, a payload, a field, and a value a loop breaks with. */ -export function closures(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _31!: rt.usize; let _47!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const arr: Uint8Array = Uint8Array.of(a, b, 3, 4, 5, 6, 7, 8); const rows: Row.Row[] = [{ cells: rt.bytes(4).fill(a) }, { cells: rt.bytes(4).fill(b) }, { cells: rt.bytes(4).fill(7) }]; const v: rt.ByteVec = rt.byteSliceToByteVec(data); @@ -277,7 +273,7 @@ export function closures(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: nu * A tuple of references and a number, read by its fields and whole after the variables * it was made of are assigned again, and one made in a loop from a variable it assigns. */ -export function parts(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function parts(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const rows: Row.Row[] = [{ cells: rt.bytes(4).fill(a) }, { cells: rt.bytes(4).fill(b) }]; let s: string = "ab"; let x: Row.Row = rows[0]; @@ -293,7 +289,7 @@ export function parts(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: numbe rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); rt.byteVecPush(out, x.cells[0] ^ n); let total: rt.u8 = 0; - for (const _47 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const _47 of rt.byteSliceView(data)) { const p: [rt.u8, rt.u8] = [n, _47]; n = rt.u8WrappingMul(n, 3); total = rt.u8WrappingAdd(rt.u8WrappingAdd(total, p[0]), _47); diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 51a4253fe..49b37a30a 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -2,16 +2,15 @@ import * as rt from "./rt.ts"; import { toDigit$01k9ewn } from "./core/char/methods.ts"; -import { fromStr$04in3ec as num_fromStr$04in3ec, fromStr$0itzmqn as num_fromStr$0itzmqn, fromStr$1czfc3o as num_fromStr$1czfc3o, fromStr$0j0pk4t as num_fromStr$0j0pk4t, fromStr$1lgb5f6 as num_fromStr$1lgb5f6, fromStr$05ll6v8 as num_fromStr$05ll6v8, fromStrRadix$00d2t0z as num_fromStrRadix$00d2t0z, fromStrRadix$1pa0ruh as num_fromStrRadix$1pa0ruh, fromStrRadix$0bx4ko0 as num_fromStrRadix$0bx4ko0, fromStrRadix$1c5e8ay as num_fromStrRadix$1c5e8ay, fromStrRadix$09xsupv as num_fromStrRadix$09xsupv, fromStrRadix$0xkpex4 as num_fromStrRadix$0xkpex4, fromStr$0nzirqb as num_fromStr$0nzirqb, fromStr$0xayo7b as num_fromStr$0xayo7b, fromStr$1t0zoao as num_fromStr$1t0zoao, fromStr$1s0pfra as num_fromStr$1s0pfra, fromStr$13au6mu as num_fromStr$13au6mu, fromStr$1vgxk0s as num_fromStr$1vgxk0s, fromStrRadix$0aggpkp as num_fromStrRadix$0aggpkp, fromStrRadix$1queob6 as num_fromStrRadix$1queob6, fromStrRadix$1ovtdjc as num_fromStrRadix$1ovtdjc, fromStrRadix$0cic1mm as num_fromStrRadix$0cic1mm, fromStrRadix$1uup0fy as num_fromStrRadix$1uup0fy, fromStrRadix$1xobho4 as num_fromStrRadix$1xobho4 } from "./core/num.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$17ewwma as num_fromStr$17ewwma, fromStr$0zhqfgx as num_fromStr$0zhqfgx, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1grmucc as num_fromStr$1grmucc, fromStrRadix$0366bau as num_fromStrRadix$0366bau, fromStrRadix$02mhuxs as num_fromStrRadix$02mhuxs, fromStrRadix$1bgm1z0 as num_fromStrRadix$1bgm1z0, fromStrRadix$11y6fsf as num_fromStrRadix$11y6fsf, fromStrRadix$0s9rspw as num_fromStrRadix$0s9rspw, fromStrRadix$1473bi0 as num_fromStrRadix$1473bi0, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0yqu2i9 as num_fromStr$0yqu2i9, fromStr$08wf09w as num_fromStr$08wf09w, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa, fromStr$10ypyht as num_fromStr$10ypyht, fromStrRadix$0g0g31i as num_fromStrRadix$0g0g31i, fromStrRadix$1ku3myt as num_fromStrRadix$1ku3myt, fromStrRadix$05zvwcf as num_fromStrRadix$05zvwcf, fromStrRadix$1gp4jqq as num_fromStrRadix$1gp4jqq, fromStrRadix$0nj08um as num_fromStrRadix$0nj08um, fromStrRadix$0tjqkb6 as num_fromStrRadix$0tjqkb6 } from "./core/num.ts"; import { isSomeAnd$09tpccf, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$11c0we2 as option_unwrapOr$11c0we2 } from "./core/option.ts"; import { eq$0pee78b as result_eq$0pee78b, eq$1mi4cle as result_eq$1mi4cle, eq$1ukayff as result_eq$1ukayff, eq$1hy1is1 as result_eq$1hy1is1, eq$1hd8lo9 as result_eq$1hd8lo9, eq$0w2dfat as result_eq$0w2dfat, eq$06vyx9e as result_eq$06vyx9e, eq$08241oi as result_eq$08241oi, eq$0nbftnc as result_eq$0nbftnc, eq$1gq81ib as result_eq$1gq81ib, eq$12e5exx as result_eq$12e5exx, eq$1xhgva4 as result_eq$1xhgva4, unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7, unwrapOr$0nhd29g as result_unwrapOr$0nhd29g, unwrapOr$09i71ei as result_unwrapOr$09i71ei } from "./core/result.ts"; -import { parse$10fbnat, parse$03wo3fg, parse$0n1hysl, parse$0clhdfr, parse$1g7h2lx, parse$0xv93nb, parse$0685pdb, parse$0bmbg8t, parse$1jryscd, parse$0sdtyv9, parse$01247e1, parse$15yahcp } from "./core/str.ts"; +import { parse$082ztwj, parse$0xnscjy, parse$12szghw, parse$11m1f1e, parse$1ci7nyc, parse$07xyv4i, parse$069o3rw, parse$0fi19ig, parse$1aq2uo0, parse$0o4ono0, parse$0at0fdl, parse$08wetap } from "./core/str.ts"; import { put as fmt_put } from "./fmt.ts"; import * as Scaled from "./ints.Scaled.ts"; /** Apply operation `op` to operands taken from `data`. */ -export function u8Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v3: rt.u8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v3)) === v3 ? 1 : 0); @@ -174,8 +173,7 @@ export function u8Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen } /** Apply operation `op` to operands taken from `data`. */ -export function u16Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v3: rt.u16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v3)) === v3 ? 1 : 0); @@ -338,8 +336,7 @@ export function u16Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `op` to operands taken from `data`. */ -export function u32Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v3: rt.u32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v3)) === v3 ? 1 : 0); @@ -502,8 +499,7 @@ export function u32Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `op` to operands taken from `data`. */ -export function u64Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v3: rt.u64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v3)))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v3)), v3) ? 1 : 0); @@ -666,8 +662,7 @@ export function u64Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `op` to operands taken from `data`. */ -export function u128Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v3: rt.u128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3))); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v3)), v3) ? 1 : 0); @@ -830,8 +825,7 @@ export function u128Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `op` to operands taken from `data`. */ -export function usizeOp(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function usizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v3: rt.usize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v3)) === v3 ? 1 : 0); @@ -994,8 +988,7 @@ export function usizeOp(op: rt.u8, dataData: Uint8Array, dataStart: number, data } /** Apply operation `op` to operands taken from `data`. */ -export function i8Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v3: rt.i8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v3)) === v3 ? 1 : 0); @@ -1158,8 +1151,7 @@ export function i8Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen } /** Apply operation `op` to operands taken from `data`. */ -export function i16Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v3: rt.i16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v3)) === v3 ? 1 : 0); @@ -1322,8 +1314,7 @@ export function i16Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `op` to operands taken from `data`. */ -export function i32Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v3: rt.i32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v3)) === v3 ? 1 : 0); @@ -1486,8 +1477,7 @@ export function i32Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `op` to operands taken from `data`. */ -export function i64Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v3: rt.i64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v3)))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v3)), v3) ? 1 : 0); @@ -1650,8 +1640,7 @@ export function i64Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `op` to operands taken from `data`. */ -export function i128Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v3: rt.i128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3))); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v3)), v3) ? 1 : 0); @@ -1814,8 +1803,7 @@ export function i128Op(op: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `op` to operands taken from `data`. */ -export function isizeOp(op: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function isizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _68: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v3: rt.isize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v3)) === v3 ? 1 : 0); @@ -1978,8 +1966,7 @@ export function isizeOp(op: rt.u8, dataData: Uint8Array, dataStart: number, data } /** Negate, which overflows at the minimum. */ -export function i8Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i8Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1987,8 +1974,7 @@ export function i8Neg(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Negate, which overflows at the minimum. */ -export function i16Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i16Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(2); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -1996,8 +1982,7 @@ export function i16Neg(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Negate, which overflows at the minimum. */ -export function i32Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i32Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -2005,8 +1990,7 @@ export function i32Neg(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Negate, which overflows at the minimum. */ -export function i64Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i64Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -2014,8 +1998,7 @@ export function i64Neg(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Negate, which overflows at the minimum. */ -export function i128Neg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i128Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(16); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -2023,8 +2006,7 @@ export function i128Neg(dataData: Uint8Array, dataStart: number, dataLen: number } /** Negate, which overflows at the minimum. */ -export function isizeNeg(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function isizeNeg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -2032,8 +2014,7 @@ export function isizeNeg(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ -export function cast(from: rt.u8, to: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function cast(from: rt.u8, to: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _5: rt.u8 = rt.u8Rem(from, 12); if (_5 === 0) { const buf: Uint8Array = Uint8Array.of(0); @@ -2699,8 +2680,7 @@ export function cast(from: rt.u8, to: rt.u8, dataData: Uint8Array, dataStart: nu } /** Conversions that check, and ones that cannot fail. */ -export function convert(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function convert(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -3081,7 +3061,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_25, radix), 99)))); } const radix2: rt.u32 = radix; - const _40: rt.Result = num_fromStrRadix$1uup0fy(_19.value, radix2); + const _40: rt.Result = num_fromStrRadix$0nj08um(_19.value, radix2); if (_40.ok) { const arg48 = _40.value; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg48, f)]; @@ -3110,8 +3090,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); } if (radix2 === 10) { - const parsed: rt.Result = parse$01247e1(_19.value); - const from: rt.Result = num_fromStr$13au6mu(_19.value); + const parsed: rt.Result = parse$0at0fdl(_19.value); + const from: rt.Result = num_fromStr$1hq0zfa(_19.value); if (from.ok) { max = rt.u8Mul(from.value === 255 ? 1 : 0, 4); } else { @@ -3130,7 +3110,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _128: string = s; const radix3: rt.u32 = radix; - const _131: rt.Result = num_fromStrRadix$1uup0fy(_128, radix3); + const _131: rt.Result = num_fromStrRadix$0nj08um(_128, radix3); if (_131.ok) { const arg47 = _131.value; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg47, f)]; @@ -3159,8 +3139,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); } if (radix3 === 10) { - const parsed2: rt.Result = parse$01247e1(_128); - const from2: rt.Result = num_fromStr$13au6mu(_128); + const parsed2: rt.Result = parse$0at0fdl(_128); + const from2: rt.Result = num_fromStr$1hq0zfa(_128); if (from2.ok) { max2 = rt.u8Mul(from2.value === 255 ? 1 : 0, 4); } else { @@ -3179,7 +3159,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix4: rt.u32 = _199; for (const _207 of edges(255, 0, 8, radix4)) { const radix5: rt.u32 = radix4; - const _218: rt.Result = num_fromStrRadix$1uup0fy(_207, radix5); + const _218: rt.Result = num_fromStrRadix$0nj08um(_207, radix5); if (_218.ok) { const arg46 = _218.value; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg46, f)]; @@ -3208,8 +3188,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); } if (radix5 === 10) { - const parsed3: rt.Result = parse$01247e1(_207); - const from3: rt.Result = num_fromStr$13au6mu(_207); + const parsed3: rt.Result = parse$0at0fdl(_207); + const from3: rt.Result = num_fromStr$1hq0zfa(_207); if (from3.ok) { max3 = rt.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { @@ -3233,7 +3213,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text), "1"); const radix7: rt.u32 = radix6; - const _315: rt.Result = num_fromStrRadix$1uup0fy(_310, radix7); + const _315: rt.Result = num_fromStrRadix$0nj08um(_310, radix7); if (_315.ok) { const arg45 = _315.value; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg45, f)]; @@ -3262,8 +3242,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); } if (radix7 === 10) { - const parsed4: rt.Result = parse$01247e1(_310); - const from4: rt.Result = num_fromStr$13au6mu(_310); + const parsed4: rt.Result = parse$0at0fdl(_310); + const from4: rt.Result = num_fromStr$1hq0zfa(_310); if (from4.ok) { max4 = rt.u8Mul(from4.value === 255 ? 1 : 0, 4); } else { @@ -3291,7 +3271,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_399, radix8), 99)))); } const radix9: rt.u32 = radix8; - const _414: rt.Result = num_fromStrRadix$1queob6(_393.value, radix9); + const _414: rt.Result = num_fromStrRadix$1ku3myt(_393.value, radix9); if (_414.ok) { const arg44 = _414.value; const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg44, f)]; @@ -3320,8 +3300,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); } if (radix9 === 10) { - const parsed5: rt.Result = parse$0bmbg8t(_393.value); - const from5: rt.Result = num_fromStr$0xayo7b(_393.value); + const parsed5: rt.Result = parse$0fi19ig(_393.value); + const from5: rt.Result = num_fromStr$0yqu2i9(_393.value); if (from5.ok) { max5 = rt.u8Mul(from5.value === 65535 ? 1 : 0, 4); } else { @@ -3340,7 +3320,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _502: string = s3; const radix10: rt.u32 = radix8; - const _505: rt.Result = num_fromStrRadix$1queob6(_502, radix10); + const _505: rt.Result = num_fromStrRadix$1ku3myt(_502, radix10); if (_505.ok) { const arg43 = _505.value; const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg43, f)]; @@ -3369,8 +3349,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); } if (radix10 === 10) { - const parsed6: rt.Result = parse$0bmbg8t(_502); - const from6: rt.Result = num_fromStr$0xayo7b(_502); + const parsed6: rt.Result = parse$0fi19ig(_502); + const from6: rt.Result = num_fromStr$0yqu2i9(_502); if (from6.ok) { max6 = rt.u8Mul(from6.value === 65535 ? 1 : 0, 4); } else { @@ -3389,7 +3369,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix11: rt.u32 = _573; for (const _581 of edges(65535, 0, 16, radix11)) { const radix12: rt.u32 = radix11; - const _592: rt.Result = num_fromStrRadix$1queob6(_581, radix12); + const _592: rt.Result = num_fromStrRadix$1ku3myt(_581, radix12); if (_592.ok) { const arg42 = _592.value; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg42, f)]; @@ -3418,8 +3398,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); } if (radix12 === 10) { - const parsed7: rt.Result = parse$0bmbg8t(_581); - const from7: rt.Result = num_fromStr$0xayo7b(_581); + const parsed7: rt.Result = parse$0fi19ig(_581); + const from7: rt.Result = num_fromStr$0yqu2i9(_581); if (from7.ok) { max7 = rt.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { @@ -3443,7 +3423,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _684: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text2), "1"); const radix14: rt.u32 = radix13; - const _689: rt.Result = num_fromStrRadix$1queob6(_684, radix14); + const _689: rt.Result = num_fromStrRadix$1ku3myt(_684, radix14); if (_689.ok) { const arg41 = _689.value; const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg41, f)]; @@ -3472,8 +3452,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); } if (radix14 === 10) { - const parsed8: rt.Result = parse$0bmbg8t(_684); - const from8: rt.Result = num_fromStr$0xayo7b(_684); + const parsed8: rt.Result = parse$0fi19ig(_684); + const from8: rt.Result = num_fromStr$0yqu2i9(_684); if (from8.ok) { max8 = rt.u8Mul(from8.value === 65535 ? 1 : 0, 4); } else { @@ -3501,7 +3481,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_773, radix15), 99)))); } const radix16: rt.u32 = radix15; - const _788: rt.Result = num_fromStrRadix$1ovtdjc(_767.value, radix16); + const _788: rt.Result = num_fromStrRadix$05zvwcf(_767.value, radix16); if (_788.ok) { const arg40 = _788.value; const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg40, f)]; @@ -3530,8 +3510,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); } if (radix16 === 10) { - const parsed9: rt.Result = parse$1jryscd(_767.value); - const from9: rt.Result = num_fromStr$1t0zoao(_767.value); + const parsed9: rt.Result = parse$1aq2uo0(_767.value); + const from9: rt.Result = num_fromStr$08wf09w(_767.value); if (from9.ok) { max9 = rt.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); } else { @@ -3550,7 +3530,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _876: string = s5; const radix17: rt.u32 = radix15; - const _879: rt.Result = num_fromStrRadix$1ovtdjc(_876, radix17); + const _879: rt.Result = num_fromStrRadix$05zvwcf(_876, radix17); if (_879.ok) { const arg39 = _879.value; const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg39, f)]; @@ -3579,8 +3559,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); } if (radix17 === 10) { - const parsed10: rt.Result = parse$1jryscd(_876); - const from10: rt.Result = num_fromStr$1t0zoao(_876); + const parsed10: rt.Result = parse$1aq2uo0(_876); + const from10: rt.Result = num_fromStr$08wf09w(_876); if (from10.ok) { max10 = rt.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); } else { @@ -3599,7 +3579,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix18: rt.u32 = _947; for (const _955 of edges(4294967295, 0, 32, radix18)) { const radix19: rt.u32 = radix18; - const _966: rt.Result = num_fromStrRadix$1ovtdjc(_955, radix19); + const _966: rt.Result = num_fromStrRadix$05zvwcf(_955, radix19); if (_966.ok) { const arg38 = _966.value; const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg38, f)]; @@ -3628,8 +3608,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); } if (radix19 === 10) { - const parsed11: rt.Result = parse$1jryscd(_955); - const from11: rt.Result = num_fromStr$1t0zoao(_955); + const parsed11: rt.Result = parse$1aq2uo0(_955); + const from11: rt.Result = num_fromStr$08wf09w(_955); if (from11.ok) { max11 = rt.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { @@ -3653,7 +3633,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1058: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text3), "1"); const radix21: rt.u32 = radix20; - const _1063: rt.Result = num_fromStrRadix$1ovtdjc(_1058, radix21); + const _1063: rt.Result = num_fromStrRadix$05zvwcf(_1058, radix21); if (_1063.ok) { const arg37 = _1063.value; const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg37, f)]; @@ -3682,8 +3662,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); } if (radix21 === 10) { - const parsed12: rt.Result = parse$1jryscd(_1058); - const from12: rt.Result = num_fromStr$1t0zoao(_1058); + const parsed12: rt.Result = parse$1aq2uo0(_1058); + const from12: rt.Result = num_fromStr$08wf09w(_1058); if (from12.ok) { max12 = rt.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); } else { @@ -3711,7 +3691,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1147, radix22), 99)))); } const radix23: rt.u32 = radix22; - const _1162: rt.Result = num_fromStrRadix$0cic1mm(_1141.value, radix23); + const _1162: rt.Result = num_fromStrRadix$1gp4jqq(_1141.value, radix23); if (_1162.ok) { const arg36 = _1162.value; const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg36, f)]; @@ -3740,8 +3720,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]])); } if (radix23 === 10) { - const parsed13: rt.Result = parse$0sdtyv9(_1141.value); - const from13: rt.Result = num_fromStr$1s0pfra(_1141.value); + const parsed13: rt.Result = parse$0o4ono0(_1141.value); + const from13: rt.Result = num_fromStr$1ypcnp8(_1141.value); if (from13.ok) { max13 = rt.u8Mul(rt.u64Eq(from13.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3760,7 +3740,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1250: string = s7; const radix24: rt.u32 = radix22; - const _1253: rt.Result = num_fromStrRadix$0cic1mm(_1250, radix24); + const _1253: rt.Result = num_fromStrRadix$1gp4jqq(_1250, radix24); if (_1253.ok) { const arg35 = _1253.value; const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg35, f)]; @@ -3789,8 +3769,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]])); } if (radix24 === 10) { - const parsed14: rt.Result = parse$0sdtyv9(_1250); - const from14: rt.Result = num_fromStr$1s0pfra(_1250); + const parsed14: rt.Result = parse$0o4ono0(_1250); + const from14: rt.Result = num_fromStr$1ypcnp8(_1250); if (from14.ok) { max14 = rt.u8Mul(rt.u64Eq(from14.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3809,7 +3789,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix25: rt.u32 = _1321; for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, 64, radix25)) { const radix26: rt.u32 = radix25; - const _1340: rt.Result = num_fromStrRadix$0cic1mm(_1329, radix26); + const _1340: rt.Result = num_fromStrRadix$1gp4jqq(_1329, radix26); if (_1340.ok) { const arg34 = _1340.value; const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg34, f)]; @@ -3838,8 +3818,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]])); } if (radix26 === 10) { - const parsed15: rt.Result = parse$0sdtyv9(_1329); - const from15: rt.Result = num_fromStr$1s0pfra(_1329); + const parsed15: rt.Result = parse$0o4ono0(_1329); + const from15: rt.Result = num_fromStr$1ypcnp8(_1329); if (from15.ok) { max15 = rt.u8Mul(rt.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3863,7 +3843,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1432: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text4), "1"); const radix28: rt.u32 = radix27; - const _1437: rt.Result = num_fromStrRadix$0cic1mm(_1432, radix28); + const _1437: rt.Result = num_fromStrRadix$1gp4jqq(_1432, radix28); if (_1437.ok) { const arg33 = _1437.value; const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg33, f)]; @@ -3892,8 +3872,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]])); } if (radix28 === 10) { - const parsed16: rt.Result = parse$0sdtyv9(_1432); - const from16: rt.Result = num_fromStr$1s0pfra(_1432); + const parsed16: rt.Result = parse$0o4ono0(_1432); + const from16: rt.Result = num_fromStr$1ypcnp8(_1432); if (from16.ok) { max16 = rt.u8Mul(rt.u64Eq(from16.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3921,7 +3901,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1521, radix29), 99)))); } const radix30: rt.u32 = radix29; - const _1536: rt.Result = num_fromStrRadix$0aggpkp(_1515.value, radix30); + const _1536: rt.Result = num_fromStrRadix$0g0g31i(_1515.value, radix30); if (_1536.ok) { const arg32 = _1536.value; const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg32, f)]; @@ -3950,8 +3930,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]])); } if (radix30 === 10) { - const parsed17: rt.Result = parse$0685pdb(_1515.value); - const from17: rt.Result = num_fromStr$0nzirqb(_1515.value); + const parsed17: rt.Result = parse$069o3rw(_1515.value); + const from17: rt.Result = num_fromStr$0qvzsmz(_1515.value); if (from17.ok) { max17 = rt.u8Mul(rt.u128Eq(from17.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -3970,7 +3950,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1624: string = s9; const radix31: rt.u32 = radix29; - const _1627: rt.Result = num_fromStrRadix$0aggpkp(_1624, radix31); + const _1627: rt.Result = num_fromStrRadix$0g0g31i(_1624, radix31); if (_1627.ok) { const arg31 = _1627.value; const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg31, f)]; @@ -3999,8 +3979,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]])); } if (radix31 === 10) { - const parsed18: rt.Result = parse$0685pdb(_1624); - const from18: rt.Result = num_fromStr$0nzirqb(_1624); + const parsed18: rt.Result = parse$069o3rw(_1624); + const from18: rt.Result = num_fromStr$0qvzsmz(_1624); if (from18.ok) { max18 = rt.u8Mul(rt.u128Eq(from18.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -4019,7 +3999,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix32: rt.u32 = _1695; for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, 128, radix32)) { const radix33: rt.u32 = radix32; - const _1713: rt.Result = num_fromStrRadix$0aggpkp(_1702, radix33); + const _1713: rt.Result = num_fromStrRadix$0g0g31i(_1702, radix33); if (_1713.ok) { const arg30 = _1713.value; const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg30, f)]; @@ -4048,8 +4028,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]])); } if (radix33 === 10) { - const parsed19: rt.Result = parse$0685pdb(_1702); - const from19: rt.Result = num_fromStr$0nzirqb(_1702); + const parsed19: rt.Result = parse$069o3rw(_1702); + const from19: rt.Result = num_fromStr$0qvzsmz(_1702); if (from19.ok) { max19 = rt.u8Mul(rt.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -4073,7 +4053,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1805: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text5), "1"); const radix35: rt.u32 = radix34; - const _1810: rt.Result = num_fromStrRadix$0aggpkp(_1805, radix35); + const _1810: rt.Result = num_fromStrRadix$0g0g31i(_1805, radix35); if (_1810.ok) { const arg29 = _1810.value; const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg29, f)]; @@ -4102,8 +4082,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]])); } if (radix35 === 10) { - const parsed20: rt.Result = parse$0685pdb(_1805); - const from20: rt.Result = num_fromStr$0nzirqb(_1805); + const parsed20: rt.Result = parse$069o3rw(_1805); + const from20: rt.Result = num_fromStr$0qvzsmz(_1805); if (from20.ok) { max20 = rt.u8Mul(rt.u128Eq(from20.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -4131,7 +4111,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1894, radix36), 99)))); } const radix37: rt.u32 = radix36; - const _1909: rt.Result = num_fromStrRadix$1xobho4(_1888.value, radix37); + const _1909: rt.Result = num_fromStrRadix$0tjqkb6(_1888.value, radix37); if (_1909.ok) { const arg28 = _1909.value; const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg28, f)]; @@ -4160,8 +4140,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); } if (radix37 === 10) { - const parsed21: rt.Result = parse$15yahcp(_1888.value); - const from21: rt.Result = num_fromStr$1vgxk0s(_1888.value); + const parsed21: rt.Result = parse$08wetap(_1888.value); + const from21: rt.Result = num_fromStr$10ypyht(_1888.value); if (from21.ok) { max21 = rt.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); } else { @@ -4180,7 +4160,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1997: string = s11; const radix38: rt.u32 = radix36; - const _2000: rt.Result = num_fromStrRadix$1xobho4(_1997, radix38); + const _2000: rt.Result = num_fromStrRadix$0tjqkb6(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg27, f)]; @@ -4209,8 +4189,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); } if (radix38 === 10) { - const parsed22: rt.Result = parse$15yahcp(_1997); - const from22: rt.Result = num_fromStr$1vgxk0s(_1997); + const parsed22: rt.Result = parse$08wetap(_1997); + const from22: rt.Result = num_fromStr$10ypyht(_1997); if (from22.ok) { max22 = rt.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); } else { @@ -4229,7 +4209,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix39: rt.u32 = _2068; for (const _2076 of edges(4294967295, 0, 32, radix39)) { const radix40: rt.u32 = radix39; - const _2087: rt.Result = num_fromStrRadix$1xobho4(_2076, radix40); + const _2087: rt.Result = num_fromStrRadix$0tjqkb6(_2076, radix40); if (_2087.ok) { const arg26 = _2087.value; const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg26, f)]; @@ -4258,8 +4238,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); } if (radix40 === 10) { - const parsed23: rt.Result = parse$15yahcp(_2076); - const from23: rt.Result = num_fromStr$1vgxk0s(_2076); + const parsed23: rt.Result = parse$08wetap(_2076); + const from23: rt.Result = num_fromStr$10ypyht(_2076); if (from23.ok) { max23 = rt.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { @@ -4283,7 +4263,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2179: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text6), "1"); const radix42: rt.u32 = radix41; - const _2184: rt.Result = num_fromStrRadix$1xobho4(_2179, radix42); + const _2184: rt.Result = num_fromStrRadix$0tjqkb6(_2179, radix42); if (_2184.ok) { const arg25 = _2184.value; const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg25, f)]; @@ -4312,8 +4292,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); } if (radix42 === 10) { - const parsed24: rt.Result = parse$15yahcp(_2179); - const from24: rt.Result = num_fromStr$1vgxk0s(_2179); + const parsed24: rt.Result = parse$08wetap(_2179); + const from24: rt.Result = num_fromStr$10ypyht(_2179); if (from24.ok) { max24 = rt.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); } else { @@ -4341,7 +4321,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2268, radix43), 99)))); } const radix44: rt.u32 = radix43; - const _2283: rt.Result = num_fromStrRadix$09xsupv(_2262.value, radix44); + const _2283: rt.Result = num_fromStrRadix$0s9rspw(_2262.value, radix44); if (_2283.ok) { const arg24 = _2283.value; const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg24, f)]; @@ -4370,8 +4350,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); } if (radix44 === 10) { - const parsed25: rt.Result = parse$1g7h2lx(_2262.value); - const from25: rt.Result = num_fromStr$1lgb5f6(_2262.value); + const parsed25: rt.Result = parse$1ci7nyc(_2262.value); + const from25: rt.Result = num_fromStr$0ovlgjd(_2262.value); if (from25.ok) { max25 = rt.u8Mul(from25.value === 127 ? 1 : 0, 4); } else { @@ -4390,7 +4370,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2371: string = s13; const radix45: rt.u32 = radix43; - const _2374: rt.Result = num_fromStrRadix$09xsupv(_2371, radix45); + const _2374: rt.Result = num_fromStrRadix$0s9rspw(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg23, f)]; @@ -4419,8 +4399,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); } if (radix45 === 10) { - const parsed26: rt.Result = parse$1g7h2lx(_2371); - const from26: rt.Result = num_fromStr$1lgb5f6(_2371); + const parsed26: rt.Result = parse$1ci7nyc(_2371); + const from26: rt.Result = num_fromStr$0ovlgjd(_2371); if (from26.ok) { max26 = rt.u8Mul(from26.value === 127 ? 1 : 0, 4); } else { @@ -4439,7 +4419,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix46: rt.u32 = _2442; for (const _2453 of edges(127, rt.u128Add(127, 1), 8, radix46)) { const radix47: rt.u32 = radix46; - const _2464: rt.Result = num_fromStrRadix$09xsupv(_2453, radix47); + const _2464: rt.Result = num_fromStrRadix$0s9rspw(_2453, radix47); if (_2464.ok) { const arg22 = _2464.value; const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg22, f)]; @@ -4468,8 +4448,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); } if (radix47 === 10) { - const parsed27: rt.Result = parse$1g7h2lx(_2453); - const from27: rt.Result = num_fromStr$1lgb5f6(_2453); + const parsed27: rt.Result = parse$1ci7nyc(_2453); + const from27: rt.Result = num_fromStr$0ovlgjd(_2453); if (from27.ok) { max27 = rt.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { @@ -4493,7 +4473,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2556: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text7), "1"); const radix49: rt.u32 = radix48; - const _2561: rt.Result = num_fromStrRadix$09xsupv(_2556, radix49); + const _2561: rt.Result = num_fromStrRadix$0s9rspw(_2556, radix49); if (_2561.ok) { const arg21 = _2561.value; const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg21, f)]; @@ -4522,8 +4502,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); } if (radix49 === 10) { - const parsed28: rt.Result = parse$1g7h2lx(_2556); - const from28: rt.Result = num_fromStr$1lgb5f6(_2556); + const parsed28: rt.Result = parse$1ci7nyc(_2556); + const from28: rt.Result = num_fromStr$0ovlgjd(_2556); if (from28.ok) { max28 = rt.u8Mul(from28.value === 127 ? 1 : 0, 4); } else { @@ -4551,7 +4531,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2645, radix50), 99)))); } const radix51: rt.u32 = radix50; - const _2660: rt.Result = num_fromStrRadix$1pa0ruh(_2639.value, radix51); + const _2660: rt.Result = num_fromStrRadix$02mhuxs(_2639.value, radix51); if (_2660.ok) { const arg20 = _2660.value; const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg20, f)]; @@ -4580,8 +4560,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); } if (radix51 === 10) { - const parsed29: rt.Result = parse$03wo3fg(_2639.value); - const from29: rt.Result = num_fromStr$0itzmqn(_2639.value); + const parsed29: rt.Result = parse$0xnscjy(_2639.value); + const from29: rt.Result = num_fromStr$17ewwma(_2639.value); if (from29.ok) { max29 = rt.u8Mul(from29.value === 32767 ? 1 : 0, 4); } else { @@ -4600,7 +4580,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2748: string = s15; const radix52: rt.u32 = radix50; - const _2751: rt.Result = num_fromStrRadix$1pa0ruh(_2748, radix52); + const _2751: rt.Result = num_fromStrRadix$02mhuxs(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg19, f)]; @@ -4629,8 +4609,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); } if (radix52 === 10) { - const parsed30: rt.Result = parse$03wo3fg(_2748); - const from30: rt.Result = num_fromStr$0itzmqn(_2748); + const parsed30: rt.Result = parse$0xnscjy(_2748); + const from30: rt.Result = num_fromStr$17ewwma(_2748); if (from30.ok) { max30 = rt.u8Mul(from30.value === 32767 ? 1 : 0, 4); } else { @@ -4649,7 +4629,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix53: rt.u32 = _2819; for (const _2830 of edges(32767, rt.u128Add(32767, 1), 16, radix53)) { const radix54: rt.u32 = radix53; - const _2841: rt.Result = num_fromStrRadix$1pa0ruh(_2830, radix54); + const _2841: rt.Result = num_fromStrRadix$02mhuxs(_2830, radix54); if (_2841.ok) { const arg18 = _2841.value; const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg18, f)]; @@ -4678,8 +4658,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); } if (radix54 === 10) { - const parsed31: rt.Result = parse$03wo3fg(_2830); - const from31: rt.Result = num_fromStr$0itzmqn(_2830); + const parsed31: rt.Result = parse$0xnscjy(_2830); + const from31: rt.Result = num_fromStr$17ewwma(_2830); if (from31.ok) { max31 = rt.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { @@ -4703,7 +4683,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2933: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text8), "1"); const radix56: rt.u32 = radix55; - const _2938: rt.Result = num_fromStrRadix$1pa0ruh(_2933, radix56); + const _2938: rt.Result = num_fromStrRadix$02mhuxs(_2933, radix56); if (_2938.ok) { const arg17 = _2938.value; const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg17, f)]; @@ -4732,8 +4712,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); } if (radix56 === 10) { - const parsed32: rt.Result = parse$03wo3fg(_2933); - const from32: rt.Result = num_fromStr$0itzmqn(_2933); + const parsed32: rt.Result = parse$0xnscjy(_2933); + const from32: rt.Result = num_fromStr$17ewwma(_2933); if (from32.ok) { max32 = rt.u8Mul(from32.value === 32767 ? 1 : 0, 4); } else { @@ -4761,7 +4741,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3022, radix57), 99)))); } const radix58: rt.u32 = radix57; - const _3037: rt.Result = num_fromStrRadix$0bx4ko0(_3016.value, radix58); + const _3037: rt.Result = num_fromStrRadix$1bgm1z0(_3016.value, radix58); if (_3037.ok) { const arg16 = _3037.value; const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg16, f)]; @@ -4790,8 +4770,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); } if (radix58 === 10) { - const parsed33: rt.Result = parse$0n1hysl(_3016.value); - const from33: rt.Result = num_fromStr$1czfc3o(_3016.value); + const parsed33: rt.Result = parse$12szghw(_3016.value); + const from33: rt.Result = num_fromStr$0zhqfgx(_3016.value); if (from33.ok) { max33 = rt.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); } else { @@ -4810,7 +4790,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3125: string = s17; const radix59: rt.u32 = radix57; - const _3128: rt.Result = num_fromStrRadix$0bx4ko0(_3125, radix59); + const _3128: rt.Result = num_fromStrRadix$1bgm1z0(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg15, f)]; @@ -4839,8 +4819,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); } if (radix59 === 10) { - const parsed34: rt.Result = parse$0n1hysl(_3125); - const from34: rt.Result = num_fromStr$1czfc3o(_3125); + const parsed34: rt.Result = parse$12szghw(_3125); + const from34: rt.Result = num_fromStr$0zhqfgx(_3125); if (from34.ok) { max34 = rt.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); } else { @@ -4859,7 +4839,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix60: rt.u32 = _3196; for (const _3207 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix60)) { const radix61: rt.u32 = radix60; - const _3218: rt.Result = num_fromStrRadix$0bx4ko0(_3207, radix61); + const _3218: rt.Result = num_fromStrRadix$1bgm1z0(_3207, radix61); if (_3218.ok) { const arg14 = _3218.value; const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg14, f)]; @@ -4888,8 +4868,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); } if (radix61 === 10) { - const parsed35: rt.Result = parse$0n1hysl(_3207); - const from35: rt.Result = num_fromStr$1czfc3o(_3207); + const parsed35: rt.Result = parse$12szghw(_3207); + const from35: rt.Result = num_fromStr$0zhqfgx(_3207); if (from35.ok) { max35 = rt.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { @@ -4913,7 +4893,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text9), "1"); const radix63: rt.u32 = radix62; - const _3315: rt.Result = num_fromStrRadix$0bx4ko0(_3310, radix63); + const _3315: rt.Result = num_fromStrRadix$1bgm1z0(_3310, radix63); if (_3315.ok) { const arg13 = _3315.value; const args142: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg13, f)]; @@ -4942,8 +4922,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); } if (radix63 === 10) { - const parsed36: rt.Result = parse$0n1hysl(_3310); - const from36: rt.Result = num_fromStr$1czfc3o(_3310); + const parsed36: rt.Result = parse$12szghw(_3310); + const from36: rt.Result = num_fromStr$0zhqfgx(_3310); if (from36.ok) { max36 = rt.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); } else { @@ -4971,7 +4951,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3399, radix64), 99)))); } const radix65: rt.u32 = radix64; - const _3414: rt.Result = num_fromStrRadix$1c5e8ay(_3393.value, radix65); + const _3414: rt.Result = num_fromStrRadix$11y6fsf(_3393.value, radix65); if (_3414.ok) { const arg12 = _3414.value; const args146: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg12, f)]; @@ -5000,8 +4980,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]])); } if (radix65 === 10) { - const parsed37: rt.Result = parse$0clhdfr(_3393.value); - const from37: rt.Result = num_fromStr$0j0pk4t(_3393.value); + const parsed37: rt.Result = parse$11m1f1e(_3393.value); + const from37: rt.Result = num_fromStr$116mp4t(_3393.value); if (from37.ok) { max37 = rt.u8Mul(rt.i64Eq(from37.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5020,7 +5000,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3502: string = s19; const radix66: rt.u32 = radix64; - const _3505: rt.Result = num_fromStrRadix$1c5e8ay(_3502, radix66); + const _3505: rt.Result = num_fromStrRadix$11y6fsf(_3502, radix66); if (_3505.ok) { const arg11 = _3505.value; const args150: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg11, f)]; @@ -5049,8 +5029,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]])); } if (radix66 === 10) { - const parsed38: rt.Result = parse$0clhdfr(_3502); - const from38: rt.Result = num_fromStr$0j0pk4t(_3502); + const parsed38: rt.Result = parse$11m1f1e(_3502); + const from38: rt.Result = num_fromStr$116mp4t(_3502); if (from38.ok) { max38 = rt.u8Mul(rt.i64Eq(from38.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5069,7 +5049,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix67: rt.u32 = _3573; for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rt.u128, rt.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rt.u128, 1), 64, radix67)) { const radix68: rt.u32 = radix67; - const _3595: rt.Result = num_fromStrRadix$1c5e8ay(_3584, radix68); + const _3595: rt.Result = num_fromStrRadix$11y6fsf(_3584, radix68); if (_3595.ok) { const arg10 = _3595.value; const args154: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg10, f)]; @@ -5098,8 +5078,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]])); } if (radix68 === 10) { - const parsed39: rt.Result = parse$0clhdfr(_3584); - const from39: rt.Result = num_fromStr$0j0pk4t(_3584); + const parsed39: rt.Result = parse$11m1f1e(_3584); + const from39: rt.Result = num_fromStr$116mp4t(_3584); if (from39.ok) { max39 = rt.u8Mul(rt.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5123,7 +5103,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3687: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text10), "1"); const radix70: rt.u32 = radix69; - const _3692: rt.Result = num_fromStrRadix$1c5e8ay(_3687, radix70); + const _3692: rt.Result = num_fromStrRadix$11y6fsf(_3687, radix70); if (_3692.ok) { const arg9 = _3692.value; const args158: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg9, f)]; @@ -5152,8 +5132,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]])); } if (radix70 === 10) { - const parsed40: rt.Result = parse$0clhdfr(_3687); - const from40: rt.Result = num_fromStr$0j0pk4t(_3687); + const parsed40: rt.Result = parse$11m1f1e(_3687); + const from40: rt.Result = num_fromStr$116mp4t(_3687); if (from40.ok) { max40 = rt.u8Mul(rt.i64Eq(from40.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5181,7 +5161,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3776, radix71), 99)))); } const radix72: rt.u32 = radix71; - const _3791: rt.Result = num_fromStrRadix$00d2t0z(_3770.value, radix72); + const _3791: rt.Result = num_fromStrRadix$0366bau(_3770.value, radix72); if (_3791.ok) { const arg8 = _3791.value; const args162: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg8, f)]; @@ -5210,8 +5190,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]])); } if (radix72 === 10) { - const parsed41: rt.Result = parse$10fbnat(_3770.value); - const from41: rt.Result = num_fromStr$04in3ec(_3770.value); + const parsed41: rt.Result = parse$082ztwj(_3770.value); + const from41: rt.Result = num_fromStr$0zyj6he(_3770.value); if (from41.ok) { max41 = rt.u8Mul(rt.i128Eq(from41.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5230,7 +5210,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3879: string = s21; const radix73: rt.u32 = radix71; - const _3882: rt.Result = num_fromStrRadix$00d2t0z(_3879, radix73); + const _3882: rt.Result = num_fromStrRadix$0366bau(_3879, radix73); if (_3882.ok) { const arg7 = _3882.value; const args166: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg7, f)]; @@ -5259,8 +5239,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]])); } if (radix73 === 10) { - const parsed42: rt.Result = parse$10fbnat(_3879); - const from42: rt.Result = num_fromStr$04in3ec(_3879); + const parsed42: rt.Result = parse$082ztwj(_3879); + const from42: rt.Result = num_fromStr$0zyj6he(_3879); if (from42.ok) { max42 = rt.u8Mul(rt.i128Eq(from42.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5279,7 +5259,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix74: rt.u32 = _3950; for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, rt.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 1), 128, radix74)) { const radix75: rt.u32 = radix74; - const _3972: rt.Result = num_fromStrRadix$00d2t0z(_3961, radix75); + const _3972: rt.Result = num_fromStrRadix$0366bau(_3961, radix75); if (_3972.ok) { const arg6 = _3972.value; const args170: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg6, f)]; @@ -5308,8 +5288,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]])); } if (radix75 === 10) { - const parsed43: rt.Result = parse$10fbnat(_3961); - const from43: rt.Result = num_fromStr$04in3ec(_3961); + const parsed43: rt.Result = parse$082ztwj(_3961); + const from43: rt.Result = num_fromStr$0zyj6he(_3961); if (from43.ok) { max43 = rt.u8Mul(rt.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5333,7 +5313,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _4064: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text11), "1"); const radix77: rt.u32 = radix76; - const _4069: rt.Result = num_fromStrRadix$00d2t0z(_4064, radix77); + const _4069: rt.Result = num_fromStrRadix$0366bau(_4064, radix77); if (_4069.ok) { const arg5 = _4069.value; const args174: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg5, f)]; @@ -5362,8 +5342,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]])); } if (radix77 === 10) { - const parsed44: rt.Result = parse$10fbnat(_4064); - const from44: rt.Result = num_fromStr$04in3ec(_4064); + const parsed44: rt.Result = parse$082ztwj(_4064); + const from44: rt.Result = num_fromStr$0zyj6he(_4064); if (from44.ok) { max44 = rt.u8Mul(rt.i128Eq(from44.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5391,7 +5371,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_4153, radix78), 99)))); } const radix79: rt.u32 = radix78; - const _4168: rt.Result = num_fromStrRadix$0xkpex4(_4147.value, radix79); + const _4168: rt.Result = num_fromStrRadix$1473bi0(_4147.value, radix79); if (_4168.ok) { const arg4 = _4168.value; const args178: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg4, f)]; @@ -5420,8 +5400,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); } if (radix79 === 10) { - const parsed45: rt.Result = parse$0xv93nb(_4147.value); - const from45: rt.Result = num_fromStr$05ll6v8(_4147.value); + const parsed45: rt.Result = parse$07xyv4i(_4147.value); + const from45: rt.Result = num_fromStr$1grmucc(_4147.value); if (from45.ok) { max45 = rt.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); } else { @@ -5440,7 +5420,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _4256: string = s23; const radix80: rt.u32 = radix78; - const _4259: rt.Result = num_fromStrRadix$0xkpex4(_4256, radix80); + const _4259: rt.Result = num_fromStrRadix$1473bi0(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; const args182: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg3, f)]; @@ -5469,8 +5449,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); } if (radix80 === 10) { - const parsed46: rt.Result = parse$0xv93nb(_4256); - const from46: rt.Result = num_fromStr$05ll6v8(_4256); + const parsed46: rt.Result = parse$07xyv4i(_4256); + const from46: rt.Result = num_fromStr$1grmucc(_4256); if (from46.ok) { max46 = rt.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); } else { @@ -5489,7 +5469,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix81: rt.u32 = _4327; for (const _4338 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix81)) { const radix82: rt.u32 = radix81; - const _4349: rt.Result = num_fromStrRadix$0xkpex4(_4338, radix82); + const _4349: rt.Result = num_fromStrRadix$1473bi0(_4338, radix82); if (_4349.ok) { const arg2 = _4349.value; const args186: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; @@ -5518,8 +5498,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); } if (radix82 === 10) { - const parsed47: rt.Result = parse$0xv93nb(_4338); - const from47: rt.Result = num_fromStr$05ll6v8(_4338); + const parsed47: rt.Result = parse$07xyv4i(_4338); + const from47: rt.Result = num_fromStr$1grmucc(_4338); if (from47.ok) { max47 = rt.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); } else { @@ -5543,7 +5523,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _4441: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text12), "1"); const radix84: rt.u32 = radix83; - const _4446: rt.Result = num_fromStrRadix$0xkpex4(_4441, radix84); + const _4446: rt.Result = num_fromStrRadix$1473bi0(_4441, radix84); if (_4446.ok) { const arg = _4446.value; const args190: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg, f)]; @@ -5572,8 +5552,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); } if (radix84 === 10) { - const parsed48: rt.Result = parse$0xv93nb(_4441); - const from48: rt.Result = num_fromStr$05ll6v8(_4441); + const parsed48: rt.Result = parse$07xyv4i(_4441); + const from48: rt.Result = num_fromStr$1grmucc(_4441); if (from48.ok) { max48 = rt.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); } else { @@ -5594,8 +5574,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * itself, wider, and to `usize` and `isize` where std has `From`; and a `char`'s and the * crate's own, which convert the same way. */ -export function widenings(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function widenings(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 13); if (_4 === 0) { const buf: Uint8Array = Uint8Array.of(0); diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 302e1afc7..8aafa5244 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -20,8 +20,7 @@ import * as Weighed from "./iters.Weighed.ts"; import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ -export function adaptors(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { b0: { const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { @@ -83,7 +82,7 @@ export function adaptors(kind: rt.u8, dataData: Uint8Array, dataStart: number, d rt.byteVecPush(out, skipped.length & 0xff); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(mapped)); } else if (_4 === 4) { - const words: rt.ByteVec[] = chunksByZero$iters_ChunksByZero_slice_u8(data.data, data.start, data.length); + const words: rt.ByteVec[] = chunksByZero$iters_ChunksByZero_slice_u8(data); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); }), "next"))); @@ -161,10 +160,10 @@ export function adaptors(kind: rt.u8, dataData: Uint8Array, dataStart: number, d } /** The runs between zero bytes. */ -export function chunksByZero$iters_ChunksByZero_slice_u8(selfData: Uint8Array, selfStart: number, selfLen: number): rt.ByteVec[] { +export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt.ByteVec[] { const words: rt.ByteVec[] = []; let word: rt.ByteVec = new rt.ByteVec(); - for (const b of rt.byteSliceView(new rt.ByteSlice(selfData, selfStart, selfLen))) { + for (const b of rt.byteSliceView(self)) { if (!(b === 0)) { rt.byteVecPush(word, b); } else { @@ -178,8 +177,7 @@ export function chunksByZero$iters_ChunksByZero_slice_u8(selfData: Uint8Array, s } /** Consumers, and how far each reads: `log` records every item a closure sees. */ -export function consumers(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.ByteVec = new rt.ByteVec(); const _5: rt.u8 = rt.u8Rem(kind, 6); if (_5 === 0) { @@ -318,8 +316,7 @@ export function consumers(kind: rt.u8, dataData: Uint8Array, dataStart: number, * `reduce`, `max_by`, and `min_by`, whose comparators log each pair they see, and * `Peekable`'s `peek_mut` and `next_if_eq`. */ -export function reducers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.ByteVec = new rt.ByteVec(); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMaxBy(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8, _3: rt.u8): rt.Ordering => { const a: rt.u8 = _2; @@ -392,9 +389,9 @@ export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Qu return rt.u8Rem(self, 4) === rt.u8Rem(other._0, 4); } -export function eq$cmp_PartialEq_iters_Quarter_array2_u8(selfData: Uint8Array, selfStart: number, selfLen: number, other: Quarter.Quarter): boolean { +export function eq$cmp_PartialEq_iters_Quarter_array2_u8(self: rt.ByteSlice, other: Quarter.Quarter): boolean { rt.cellSet(other._1, rt.u8WrappingAdd(other._1.v, 64)); - return rt.iterSum(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(selfData, selfStart, selfLen))), rt.u8Add, 0) === other._0; + return rt.iterSum(rt.iterSlice(rt.byteSliceView(self)), rt.u8Add, 0) === other._0; } export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quarter.Quarter): boolean { @@ -407,8 +404,7 @@ export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quart * `PartialEq`: std's across strings and slices, and the crate's own. Each matches the * first item, and a mismatch keeps the item for the next `next`. */ -export function peekedOthers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { const _3: (a0: rt.u8) => string = (b: rt.u8): string => { const _42: rt.char = rt.u8Add(97, rt.u8Rem(b, 3)) as rt.char; return rt.fmtToString((f: rt.Formatter) => rt.fmtCharDisplay(_42, f)); @@ -550,9 +546,7 @@ export function peekedOthers(dataData: Uint8Array, dataStart: number, dataLen: n return p2[0]; })); rt.byteVecPush(out, option_mapOr$0sl5app(rt.peekableNextIfEq(it9, { _0: 1, _1: calls }, (a2: Uint8Array, b8: Quarter.Quarter): boolean => { - return ((a018: rt.ByteSlice, a114: Quarter.Quarter): boolean => { - return eq$cmp_PartialEq_iters_Quarter_array2_u8(a018.data, a018.start, a018.length, a114); - })(rt.byteSliceFrom(a2), b8); + return eq$cmp_PartialEq_iters_Quarter_array2_u8(rt.byteSliceFrom(a2), b8); }), 170, (p3: Uint8Array): rt.u8 => { return p3[0]; })); @@ -613,7 +607,7 @@ export function rotateFree$iters_RotateFree_u8(self: rt.u8): rt.u8 { * `nth` and `nth_back` through each adaptor, of a source whose reads `by_ref` or * `inspect` shows: each reads on past a `take`'s limit, or stops at it, as std's does. */ -export function skips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let item!: rt.u8 | undefined; let item2!: rt.u8 | undefined; let item3!: rt.u8 | undefined; @@ -642,7 +636,6 @@ export function skips(kind: rt.u8, dataData: Uint8Array, dataStart: number, data let item26!: rt.u8 | undefined; let item27!: [rt.u8, rt.u8] | undefined; let item28!: Uint8Array | undefined; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { return rt.usizeRem(_2 as rt.usize, 4); }); @@ -1026,8 +1019,7 @@ export function skips(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * `min_by_key` and `max_by_key` by keys that are tuples, `Reverse`s, `Option`s, and the * crate's own orders, `min` and `max` of such items, and `rposition` and `rfind`. */ -export function ranked(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function ranked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: (a0: rt.ByteVec, a1: [rt.usize, rt.u8] | undefined) => undefined = (out2: rt.ByteVec, found2: [rt.usize, rt.u8] | undefined): undefined => { rt.byteVecPush(out2, option_mapOr$06gg5x7(found2, 255, (_2: [rt.usize, rt.u8]): rt.u8 => { return _2[0] & 0xff; @@ -1155,8 +1147,7 @@ export function ranked(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } /** Ranges as values and as iterators. */ -export function ranges(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const range: rt.Range = new rt.Range(a, b); @@ -1242,16 +1233,15 @@ export function ranges(dataData: Uint8Array, dataStart: number, dataLen: number, for (const _295 of rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)), undefined, 4, true)) { rt.byteVecPush(out, _295 & 0xff); } - updates(a, b, data.data, data.start, data.length, out); + updates(a, b, data, out); } /** * Struct update syntax on std's ranges: the fields written run before the base, and * the rest are read from it. */ -export function updates(a: rt.u8, b: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _29!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const base: rt.Range = new rt.Range(a, b); rt.byteVecPush(out, 208); const _7: rt.u8 = rt.u8Div(b, 2); @@ -1296,8 +1286,7 @@ export function fullRange(out: rt.ByteVec): undefined { } /** Iterators of `Option`, which keep each `None` apart from their end. */ -export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function options(data: rt.ByteSlice, out: rt.ByteVec): void { const _83: (a0: rt.u8, a1: rt.ByteVec) => rt.u8 | undefined = (b2: rt.u8, calls2: rt.ByteVec): rt.u8 | undefined => { rt.byteVecPush(calls2, b2); return option_map$0cs071d(rt.u8CheckedSub(b2, 1), (b3: rt.u8): rt.u8 => { @@ -1397,12 +1386,11 @@ export function options(dataData: Uint8Array, dataStart: number, dataLen: number * each way JS holds `None`: `undefined`, `rt.None` where `Some` can be `undefined`, and * nested. */ -export function optionItems(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { let _44!: rt.u8; let _67!: boolean; let _87!: undefined | rt.None; let _138!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.u8) => rt.u8 | undefined = (b4: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b4, 3) === 0)) { return b4; @@ -1644,8 +1632,7 @@ export function second$iter_Map_slice_Iter_u8_iters_options_closure0(items: rt.I } /** The crate's own iterators, through `for`, adaptors, and `next`. */ -export function own(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const left: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const step: rt.u8 = rt.max(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 1), 1); const iter: iters_Countdown.Countdown = { left, step }; @@ -1696,22 +1683,21 @@ export function own(dataData: Uint8Array, dataStart: number, dataLen: number, ou * The last two bytes of `data`, as a `slice::Iter` made from the second argument: a * `for` must iterate it, not the first. */ -export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, dataData: Uint8Array, dataStart: number, dataLen: number): rt.Iter { - return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.usizeSaturatingSub(dataLen, 2)))); +export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, data: rt.ByteSlice): rt.Iter { + return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.usizeSaturatingSub(data.length, 2)))); } /** The odd bytes, from a function returning `impl Iterator`. */ -export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Iter { - return rt.iterFilter(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (b: rt.u8): boolean => { +export function odds(data: rt.ByteSlice): rt.Iter { + return rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): boolean => { return rt.u8Rem(b, 2) === 1; }); } /** Iterators as values: returned, stored, and printed. */ -export function values(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const _5: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); - const iter: rt.Iter = tail(_5.data, _5.start, _5.length, data.data, data.start, data.length); + const iter: rt.Iter = tail(_5.data, _5.start, _5.length, data); while (true) { const _8: rt.u8 | rt.Done = iter.next(); if (_8 === rt.DONE) { @@ -1721,7 +1707,7 @@ export function values(dataData: Uint8Array, dataStart: number, dataLen: number, } const held: iters_Held.Held = { it: rt.iterSlice(rt.byteSliceView(data)) }; rt.byteVecPush(out, iters_Held.skipOne(held)); - const iter2: rt.Iter = odds(data.data, data.start, data.length); + const iter2: rt.Iter = odds(data); while (true) { const _21: rt.u8 | rt.Done = iter2.next(); if (_21 === rt.DONE) { @@ -1774,8 +1760,7 @@ export function values(dataData: Uint8Array, dataStart: number, dataLen: number, * What std's `Option`-returning calls give, returned as is: an `Option`, whose `None` * stays apart from an item's own. */ -export function returned(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { const _3: (a0: rt.u8 | undefined, a1: rt.ByteVec) => undefined = (b: rt.u8 | undefined, out2: rt.ByteVec): undefined => { rt.byteVecPush(out2, option_mapOr$1surhce(b, 170, (b2: rt.u8): rt.u8 => { return b2; @@ -1834,13 +1819,13 @@ export function returned(dataData: Uint8Array, dataStart: number, dataLen: numbe _3(part12, out); const part13 = borrowed(it); _3(part13, out); - const part14 = secondOf(data.data, data.start, data.length); + const part14 = secondOf(data); _3(part14, out); const part15 = fromOne(n & 0xff); _3(part15, out); const part16 = peeked$iter_Copied_slice_Iter_u8(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data)))); _3(part16, out); - const part17 = at$u8(data.data, data.start, data.length, n); + const part17 = at$u8(data, n); _3(part17, out); const part18 = at$Option_u8(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b8: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b8, 3) === 0)) { @@ -1903,8 +1888,8 @@ export function borrowed(it: rt.Iter): rt.u8 | undefined { } /** Of a slice's iterator the function makes. */ -export function secondOf(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))); +export function secondOf(data: rt.ByteSlice): rt.u8 | undefined { + const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); it.next(); return rt.iterToOption(it.next()); } @@ -1923,8 +1908,8 @@ export function at$Option_u8(items: Array, i: rt.usize): rt.u return rt.sliceGet(items, i, rt.None); } -export function at$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: number, i: rt.usize): rt.u8 | undefined { - return rt.byteSliceGet(new rt.ByteSlice(itemsData, itemsStart, itemsLen), i); +export function at$u8(items: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { + return rt.byteSliceGet(items, i); } /** @@ -1933,7 +1918,7 @@ export function at$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: numbe * (`TrustedLen`, or only `TrustedRandomAccessNoCoerce`), and by `next` (neither), read by * each of std's consumers, and through adaptors that fold it or read it by `try_fold`. */ -export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _18!: [rt.ByteSlice, rt.ByteSlice]; const _40: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2: [rt.u8, rt.u8]): rt.u8 => { return _2[0] ^ _2[1]; @@ -1956,19 +1941,19 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _1101: (a0: [rt.u8, rt.u8]) => rt.u8 = (_221: [rt.u8, rt.u8]): rt.u8 => { return _221[0] ^ _221[1]; }; - const mid: number = rt.usizeRem(kind >> 5 as rt.usize, rt.usizeAdd(dataLen, 1)); - if (mid > dataLen) { + const mid: number = rt.usizeRem(kind >> 5 as rt.usize, rt.usizeAdd(data.length, 1)); + if (mid > data.length) { rt.panic("mid > len"); } if (!((kind & 8) === 0)) { - _18 = [new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), new rt.ByteSlice(dataData, dataStart, mid)] as [rt.ByteSlice, rt.ByteSlice]; + _18 = [new rt.ByteSlice(data.data, data.start + mid, data.length - mid), new rt.ByteSlice(data.data, data.start, mid)] as [rt.ByteSlice, rt.ByteSlice]; } else { - _18 = [new rt.ByteSlice(dataData, dataStart, mid), new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid)] as [rt.ByteSlice, rt.ByteSlice]; + _18 = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rt.ByteSlice, rt.ByteSlice]; } const a2: rt.ByteSlice = _18[0]; const b2: rt.ByteSlice = _18[1]; const other: boolean = (kind & 4) !== 0; - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0, (_223: rt.u8): rt.usize => { + const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_223: rt.u8): rt.usize => { return rt.usizeRem(_223 as rt.usize, 4); }); const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); @@ -1988,7 +1973,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL rt.refMutRelease(_6239); return x232; }), [true, true]); - const _41: rt.usize = rt.usizeRem(dataLen, 8); + const _41: rt.usize = rt.usizeRem(data.length, 8); if (_41 === 0) { rt.byteVecPush(out, rt.iterCount(z) & 0xff); } else if (_41 === 1) { @@ -2037,7 +2022,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _79: rt.usize = rt.usizeRem(dataLen, 8); + const _79: rt.usize = rt.usizeRem(data.length, 8); if (_79 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2287: rt.u8): rt.u8 => { const x228: rt.u8 = _2287; @@ -2177,7 +2162,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL rt.refMutRelease(_6219); return x201; }), "len"); - const _202: rt.usize = rt.usizeRem(dataLen, 8); + const _202: rt.usize = rt.usizeRem(data.length, 8); if (_202 === 0) { rt.byteVecPush(out, rt.iterCount(z3) & 0xff); } else if (_202 === 1) { @@ -2226,7 +2211,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _240: rt.usize = rt.usizeRem(dataLen, 8); + const _240: rt.usize = rt.usizeRem(data.length, 8); if (_240 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2256: rt.u8): rt.u8 => { const x197: rt.u8 = _2256; @@ -2364,7 +2349,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL rt.refMutRelease(_6199); return x170; }), "len"); - const _381: rt.usize = rt.usizeRem(dataLen, 8); + const _381: rt.usize = rt.usizeRem(data.length, 8); if (_381 === 0) { rt.byteVecPush(out, rt.iterCount(z5) & 0xff); } else if (_381 === 1) { @@ -2413,7 +2398,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _419: rt.usize = rt.usizeRem(dataLen, 8); + const _419: rt.usize = rt.usizeRem(data.length, 8); if (_419 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2225: rt.u8): rt.u8 => { const x166: rt.u8 = _2225; @@ -2551,7 +2536,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL rt.refMutRelease(_6179); return x139; }), "len"); - const _574: rt.usize = rt.usizeRem(dataLen, 8); + const _574: rt.usize = rt.usizeRem(data.length, 8); if (_574 === 0) { rt.byteVecPush(out, rt.iterCount(z7) & 0xff); } else if (_574 === 1) { @@ -2600,7 +2585,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _612: rt.usize = rt.usizeRem(dataLen, 8); + const _612: rt.usize = rt.usizeRem(data.length, 8); if (_612 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x135: rt.u8): rt.u8 => { const _6176: rt.RefCell = rt.refCellBorrowMut(log); @@ -2721,7 +2706,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL rt.refMutRelease(_6159); return x108; }), "len"); - const _751: rt.usize = rt.usizeRem(dataLen, 8); + const _751: rt.usize = rt.usizeRem(data.length, 8); if (_751 === 0) { rt.byteVecPush(out, rt.iterCount(z9) & 0xff); } else if (_751 === 1) { @@ -2770,7 +2755,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _789: rt.usize = rt.usizeRem(dataLen, 8); + const _789: rt.usize = rt.usizeRem(data.length, 8); if (_789 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x104: rt.u8): rt.u8 => { const _6156: rt.RefCell = rt.refCellBorrowMut(log); @@ -2903,7 +2888,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL rt.refMutRelease(_6139); return x77; })); - const _927: rt.usize = rt.usizeRem(dataLen, 8); + const _927: rt.usize = rt.usizeRem(data.length, 8); if (_927 === 0) { rt.byteVecPush(out, rt.iterCount(z11) & 0xff); } else if (_927 === 1) { @@ -2952,7 +2937,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _965: rt.usize = rt.usizeRem(dataLen, 8); + const _965: rt.usize = rt.usizeRem(data.length, 8); if (_965 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2157: rt.u8): rt.u8 => { const x73: rt.u8 = _2157; @@ -3114,7 +3099,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL }), "len"), (_2123: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { return [_2123[0][0] ^ _2123[1], _2123[0][1]] as [rt.u8, rt.u8]; }); - const _1102: rt.usize = rt.usizeRem(dataLen, 8); + const _1102: rt.usize = rt.usizeRem(data.length, 8); if (_1102 === 0) { rt.byteVecPush(out, rt.iterCount(z13) & 0xff); } else if (_1102 === 1) { @@ -3163,7 +3148,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL })); } } else { - const _1140: rt.usize = rt.usizeRem(dataLen, 8); + const _1140: rt.usize = rt.usizeRem(data.length, 8); if (_1140 === 0) { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2115: rt.u8): rt.u8 => { const x38: rt.u8 = _2115; @@ -3362,8 +3347,7 @@ export function zips(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * std trims the longer side on the first pair it reads from the back, and a by-index zip * reads no item it never yields from a side that does not log, nor through `nth` it skips. */ -export function zipsBack(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteSlice) => rt.u8 = (c: rt.ByteSlice): rt.u8 => { return c.length & 0xff; }; @@ -3692,73 +3676,73 @@ export function zipsBack(kind: rt.u8, dataData: Uint8Array, dataStart: number, d * takes and as its own, stepping up to its type's last value, past which std's debug * build panics, and ranges of `char` across the surrogates, which they skip. */ -export function rangeFroms(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0); +export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const near: rt.u8 = rt.u8Rem(a, 4); const how: rt.u8 = kind >> 6; const _12: rt.u8 = rt.u8Rem(kind, 16); if (_12 === 0) { - fromTop$u8_iters_range_froms_closure0(rt.u8Sub(255, near), dataData, dataStart, dataLen, how, out, (x14: rt.u8, out15: rt.ByteVec): undefined => { + fromTop$u8_iters_range_froms_closure0(rt.u8Sub(255, near), data, how, out, (x14: rt.u8, out15: rt.ByteVec): undefined => { rt.byteVecPush(out15, x14); }); } else if (_12 === 1) { - fromTop$u16_iters_range_froms_closure1(rt.u16Sub(65535, near as rt.u16), dataData, dataStart, dataLen, how, out, (x13: rt.u16, out14: rt.ByteVec): undefined => { + fromTop$u16_iters_range_froms_closure1(rt.u16Sub(65535, near as rt.u16), data, how, out, (x13: rt.u16, out14: rt.ByteVec): undefined => { rt.iterExtendBytes(out14, rt.iterSlice(rt.u16ToBeBytes(x13).reverse()), undefined, true); }); } else if (_12 === 2) { - fromTop$u32_iters_range_froms_closure2(rt.u32Sub(4294967295, near as rt.u32), dataData, dataStart, dataLen, how, out, (x12: rt.u32, out13: rt.ByteVec): undefined => { + fromTop$u32_iters_range_froms_closure2(rt.u32Sub(4294967295, near as rt.u32), data, how, out, (x12: rt.u32, out13: rt.ByteVec): undefined => { rt.iterExtendBytes(out13, rt.iterSlice(rt.u32ToBeBytes(x12).reverse()), undefined, true); }); } else if (_12 === 3) { - fromTop$u64_iters_range_froms_closure3(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, near as rt.u64), dataData, dataStart, dataLen, how, out, (x11: rt.u64, out12: rt.ByteVec): undefined => { + fromTop$u64_iters_range_froms_closure3(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, near as rt.u64), data, how, out, (x11: rt.u64, out12: rt.ByteVec): undefined => { rt.iterExtendBytes(out12, rt.iterSlice(rt.u64ToBeBytes(x11).reverse()), undefined, true); }); } else if (_12 === 4) { - fromTop$u128_iters_range_froms_closure4(rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, near as rt.u128), dataData, dataStart, dataLen, how, out, (x10: rt.u128, out11: rt.ByteVec): undefined => { + fromTop$u128_iters_range_froms_closure4(rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, near as rt.u128), data, how, out, (x10: rt.u128, out11: rt.ByteVec): undefined => { rt.iterExtendBytes(out11, rt.iterSlice(rt.u128ToBeBytes(x10).reverse()), undefined, true); }); } else if (_12 === 5) { - fromTop$usize_iters_range_froms_closure5(rt.usizeSub(4294967295, near as rt.usize), dataData, dataStart, dataLen, how, out, (x9: rt.usize, out10: rt.ByteVec): undefined => { + fromTop$usize_iters_range_froms_closure5(rt.usizeSub(4294967295, near as rt.usize), data, how, out, (x9: rt.usize, out10: rt.ByteVec): undefined => { rt.iterExtendBytes(out10, rt.iterSlice(rt.usizeToBeBytes(x9).reverse()), undefined, true); }); } else if (_12 === 6) { - fromTop$i8_iters_range_froms_closure6(rt.i8Sub(127, (near << 24) >> 24), dataData, dataStart, dataLen, how, out, (x8: rt.i8, out9: rt.ByteVec): undefined => { + fromTop$i8_iters_range_froms_closure6(rt.i8Sub(127, (near << 24) >> 24), data, how, out, (x8: rt.i8, out9: rt.ByteVec): undefined => { rt.iterExtendBytes(out9, rt.iterSlice(rt.i8ToBeBytes(x8).reverse()), undefined, true); }); } else if (_12 === 7) { - fromTop$i16_iters_range_froms_closure7(rt.i16Sub(32767, near as rt.i16), dataData, dataStart, dataLen, how, out, (x7: rt.i16, out8: rt.ByteVec): undefined => { + fromTop$i16_iters_range_froms_closure7(rt.i16Sub(32767, near as rt.i16), data, how, out, (x7: rt.i16, out8: rt.ByteVec): undefined => { rt.iterExtendBytes(out8, rt.iterSlice(rt.i16ToBeBytes(x7).reverse()), undefined, true); }); } else if (_12 === 8) { - fromTop$i32_iters_range_froms_closure8(rt.i32Sub(2147483647, near as rt.i32), dataData, dataStart, dataLen, how, out, (x6: rt.i32, out7: rt.ByteVec): undefined => { + fromTop$i32_iters_range_froms_closure8(rt.i32Sub(2147483647, near as rt.i32), data, how, out, (x6: rt.i32, out7: rt.ByteVec): undefined => { rt.iterExtendBytes(out7, rt.iterSlice(rt.i32ToBeBytes(x6).reverse()), undefined, true); }); } else if (_12 === 9) { - fromTop$i64_iters_range_froms_closure9(rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, near as rt.i64), dataData, dataStart, dataLen, how, out, (x5: rt.i64, out6: rt.ByteVec): undefined => { + fromTop$i64_iters_range_froms_closure9(rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, near as rt.i64), data, how, out, (x5: rt.i64, out6: rt.ByteVec): undefined => { rt.iterExtendBytes(out6, rt.iterSlice(rt.i64ToBeBytes(x5).reverse()), undefined, true); }); } else if (_12 === 10) { - fromTop$i128_iters_range_froms_closure10(rt.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, near as rt.i128), dataData, dataStart, dataLen, how, out, (x4: rt.i128, out5: rt.ByteVec): undefined => { + fromTop$i128_iters_range_froms_closure10(rt.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, near as rt.i128), data, how, out, (x4: rt.i128, out5: rt.ByteVec): undefined => { rt.iterExtendBytes(out5, rt.iterSlice(rt.i128ToBeBytes(x4).reverse()), undefined, true); }); } else if (_12 === 11) { - fromTop$isize_iters_range_froms_closure11(rt.isizeSub(2147483647, near as rt.isize), dataData, dataStart, dataLen, how, out, (x3: rt.isize, out4: rt.ByteVec): undefined => { + fromTop$isize_iters_range_froms_closure11(rt.isizeSub(2147483647, near as rt.isize), data, how, out, (x3: rt.isize, out4: rt.ByteVec): undefined => { rt.iterExtendBytes(out4, rt.iterSlice(rt.isizeToBeBytes(x3).reverse()), undefined, true); }); } else if (_12 === 12) { - fromTop$u64_iters_range_froms_closure12(rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), near as rt.u64), dataData, dataStart, dataLen, how, out, (x: rt.u64, out2: rt.ByteVec): undefined => { + fromTop$u64_iters_range_froms_closure12(rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), near as rt.u64), data, how, out, (x: rt.u64, out2: rt.ByteVec): undefined => { rt.iterExtendBytes(out2, rt.iterSlice(rt.u64ToBeBytes(x).reverse()), undefined, true); }); - fromTop$u128_iters_range_froms_closure13(rt.u128Add(rt.u128Sub(rt.u128Shl(1, 64), 2), near as rt.u128), dataData, dataStart, dataLen, how ^ 2, out, (x2: rt.u128, out3: rt.ByteVec): undefined => { + fromTop$u128_iters_range_froms_closure13(rt.u128Add(rt.u128Sub(rt.u128Shl(1, 64), 2), near as rt.u128), data, how ^ 2, out, (x2: rt.u128, out3: rt.ByteVec): undefined => { rt.iterExtendBytes(out3, rt.iterSlice(rt.u128ToBeBytes(x2).reverse()), undefined, true); }); rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(option_unwrapOr$00uis1j(rt.iterNth(new rt.RangeFrom(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 2), rt.i64Step), a as rt.usize), 0)).reverse()), undefined, true); } else if (_12 === 13) { - chars(a, dataData, dataStart, dataLen, how, out); + chars(a, data, how, out); } else if (_12 === 14) { - adapted(a, dataData, dataStart, dataLen, out); + adapted(a, data, out); } else { - overflowed(a, dataData, dataStart, dataLen, out); + overflowed(a, data.data, data.start, data.length, out); } } @@ -3768,11 +3752,11 @@ export function rangeFroms(kind: rt.u8, dataData: Uint8Array, dataStart: number, * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$char_iters_chars_closure0(start: rt.char, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.char, a1: rt.ByteVec) => undefined): void { +export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.char, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.char]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.charStep), "len"); + const iter: rt.Iter<[rt.u8, rt.char]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"); while (true) { const _13: [rt.u8, rt.char] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3785,7 +3769,7 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, dataData: Uint } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.charStep), "len"), (_26: [rt.u8, rt.char]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"), (_26: [rt.u8, rt.char]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.char = _26[1]; rt.byteVecPush(out, b4); @@ -3793,7 +3777,7 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, dataData: Uint }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.char, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3805,7 +3789,7 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, dataData: Uint rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.char, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.char, rt.u8]): undefined => { const x3: rt.char = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3821,11 +3805,11 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, dataData: Uint * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i128, a1: rt.ByteVec) => undefined): void { +export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i128, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i128Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"); while (true) { const _13: [rt.u8, rt.i128] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3838,7 +3822,7 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, dataDat } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i128Step), "len"), (_26: [rt.u8, rt.i128]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"), (_26: [rt.u8, rt.i128]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i128 = _26[1]; rt.byteVecPush(out, b4); @@ -3846,7 +3830,7 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, dataDat }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.i128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.i128, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3858,7 +3842,7 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, dataDat rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i128, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i128, rt.u8]): undefined => { const x3: rt.i128 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3874,11 +3858,11 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, dataDat * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i16, a1: rt.ByteVec) => undefined): void { +export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i16, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i16Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"); while (true) { const _13: [rt.u8, rt.i16] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3891,7 +3875,7 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i16Step), "len"), (_26: [rt.u8, rt.i16]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"), (_26: [rt.u8, rt.i16]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i16 = _26[1]; rt.byteVecPush(out, b4); @@ -3899,7 +3883,7 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.i16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.i16, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3911,7 +3895,7 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i16, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i16, rt.u8]): undefined => { const x3: rt.i16 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3927,11 +3911,11 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i32, a1: rt.ByteVec) => undefined): void { +export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i32, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i32Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"); while (true) { const _13: [rt.u8, rt.i32] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3944,7 +3928,7 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i32Step), "len"), (_26: [rt.u8, rt.i32]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"), (_26: [rt.u8, rt.i32]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i32 = _26[1]; rt.byteVecPush(out, b4); @@ -3952,7 +3936,7 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.i32, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -3964,7 +3948,7 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i32, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i32, rt.u8]): undefined => { const x3: rt.i32 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -3980,11 +3964,11 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i64, a1: rt.ByteVec) => undefined): void { +export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i64, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i64Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"); while (true) { const _13: [rt.u8, rt.i64] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -3997,7 +3981,7 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i64Step), "len"), (_26: [rt.u8, rt.i64]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"), (_26: [rt.u8, rt.i64]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i64 = _26[1]; rt.byteVecPush(out, b4); @@ -4005,7 +3989,7 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.i64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.i64, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4017,7 +4001,7 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i64, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i64, rt.u8]): undefined => { const x3: rt.i64 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4033,11 +4017,11 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i8, a1: rt.ByteVec) => undefined): void { +export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i8, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i8Step), "len"); + const iter: rt.Iter<[rt.u8, rt.i8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"); while (true) { const _13: [rt.u8, rt.i8] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4050,7 +4034,7 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, dataData: Ui } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.i8Step), "len"), (_26: [rt.u8, rt.i8]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"), (_26: [rt.u8, rt.i8]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.i8 = _26[1]; rt.byteVecPush(out, b4); @@ -4058,7 +4042,7 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, dataData: Ui }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.i8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.i8, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4070,7 +4054,7 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, dataData: Ui rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.i8, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i8, rt.u8]): undefined => { const x3: rt.i8 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4086,11 +4070,11 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, dataData: Ui * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.isize, a1: rt.ByteVec) => undefined): void { +export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.isize, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.isize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.isizeStep), "len"); + const iter: rt.Iter<[rt.u8, rt.isize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"); while (true) { const _13: [rt.u8, rt.isize] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4103,7 +4087,7 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, dataD } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.isizeStep), "len"), (_26: [rt.u8, rt.isize]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"), (_26: [rt.u8, rt.isize]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.isize = _26[1]; rt.byteVecPush(out, b4); @@ -4111,7 +4095,7 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, dataD }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.isize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.isize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.isize, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4123,7 +4107,7 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, dataD rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.isize, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.isize, rt.u8]): undefined => { const x3: rt.isize = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4139,11 +4123,11 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, dataD * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { +export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); while (true) { const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4156,7 +4140,7 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, dataDat } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u128 = _26[1]; rt.byteVecPush(out, b4); @@ -4164,7 +4148,7 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, dataDat }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4176,7 +4160,7 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, dataDat rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u128, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { const x3: rt.u128 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4192,11 +4176,11 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, dataDat * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { +export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); while (true) { const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4209,7 +4193,7 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, dataData } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u128 = _26[1]; rt.byteVecPush(out, b4); @@ -4217,7 +4201,7 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, dataData }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4229,7 +4213,7 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, dataData rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u128, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { const x3: rt.u128 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4245,11 +4229,11 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, dataData * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u16, a1: rt.ByteVec) => undefined): void { +export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u16, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u16Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"); while (true) { const _13: [rt.u8, rt.u16] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4262,7 +4246,7 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u16Step), "len"), (_26: [rt.u8, rt.u16]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"), (_26: [rt.u8, rt.u16]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u16 = _26[1]; rt.byteVecPush(out, b4); @@ -4270,7 +4254,7 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u16, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4282,7 +4266,7 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u16, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u16, rt.u8]): undefined => { const x3: rt.u16 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4298,11 +4282,11 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u32, a1: rt.ByteVec) => undefined): void { +export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u32, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u32Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"); while (true) { const _13: [rt.u8, rt.u32] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4315,7 +4299,7 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u32Step), "len"), (_26: [rt.u8, rt.u32]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"), (_26: [rt.u8, rt.u32]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u32 = _26[1]; rt.byteVecPush(out, b4); @@ -4323,7 +4307,7 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u32, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4335,7 +4319,7 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u32, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u32, rt.u8]): undefined => { const x3: rt.u32 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4351,11 +4335,11 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { +export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); while (true) { const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4368,7 +4352,7 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u64 = _26[1]; rt.byteVecPush(out, b4); @@ -4376,7 +4360,7 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4388,7 +4372,7 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u64, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { const x3: rt.u64 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4404,11 +4388,11 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { +export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); while (true) { const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4421,7 +4405,7 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, dataData: } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u64 = _26[1]; rt.byteVecPush(out, b4); @@ -4429,7 +4413,7 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, dataData: }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4441,7 +4425,7 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, dataData: rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u64, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { const x3: rt.u64 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4457,11 +4441,11 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, dataData: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u8, a1: rt.ByteVec) => undefined): void { +export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u8, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u8Step), "len"); + const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"); while (true) { const _13: [rt.u8, rt.u8] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4474,7 +4458,7 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, dataData: Ui } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.u8Step), "len"), (_26: [rt.u8, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"), (_26: [rt.u8, rt.u8]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.u8 = _26[1]; rt.byteVecPush(out, b4); @@ -4482,7 +4466,7 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, dataData: Ui }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.u8, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4494,7 +4478,7 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, dataData: Ui rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.u8, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u8, rt.u8]): undefined => { const x3: rt.u8 = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4510,11 +4494,11 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, dataData: Ui * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec, put: (a0: rt.usize, a1: rt.ByteVec) => undefined): void { +export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.usize, a1: rt.ByteVec) => undefined): void { b0: { const _6: rt.u8 = rt.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.usizeStep), "len"); + const iter: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"); while (true) { const _13: [rt.u8, rt.usize] | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -4527,7 +4511,7 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, dataDa } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), new rt.RangeFrom(start, rt.usizeStep), "len"), (_26: [rt.u8, rt.usize]): undefined => { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"), (_26: [rt.u8, rt.usize]): undefined => { const b4: rt.u8 = _26[0]; const x4: rt.usize = _26[1]; rt.byteVecPush(out, b4); @@ -4535,7 +4519,7 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, dataDa }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"); + const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); while (true) { const _31: [rt.usize, rt.u8] | rt.Done = iter2.next(); if (_31 === rt.DONE) { @@ -4547,7 +4531,7 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, dataDa rt.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), "len"), (_2: [rt.usize, rt.u8]): undefined => { + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.usize, rt.u8]): undefined => { const x3: rt.usize = _2[0]; const b3: rt.u8 = _2[1]; put(x3, out); @@ -4561,20 +4545,20 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, dataDa * `char` ranges of each kind across the surrogates, which std's `Step` skips, and up to * `char::MAX`, past which `start..` panics. */ -export function chars(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, how: rt.u8, out: rt.ByteVec): void { +export function chars(a: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec): void { const _8: (a0: rt.char, a1: rt.ByteVec) => undefined = (c2: rt.char, out2: rt.ByteVec): undefined => { rt.iterExtendBytes(out2, rt.iterSlice(rt.u32ToBeBytes(c2 as rt.u32).reverse()), undefined, true); }; const near: rt.u32 = rt.u8Rem(a, 4) as rt.u32; const gap: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(55293, near))); - fromTop$char_iters_chars_closure0(gap, dataData, dataStart, dataLen, how, out, (c3: rt.char, out3: rt.ByteVec): undefined => { + fromTop$char_iters_chars_closure0(gap, data, how, out, (c3: rt.char, out3: rt.ByteVec): undefined => { rt.iterExtendBytes(out3, rt.iterSlice(rt.u32ToBeBytes(c3 as rt.u32).reverse()), undefined, true); }); const top: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Sub(1114111 as rt.u32, near))); - fromTop$char_iters_chars_closure0(top, dataData, dataStart, dataLen, how, out, (c4: rt.char, out4: rt.ByteVec): undefined => { + fromTop$char_iters_chars_closure0(top, data, how, out, (c4: rt.char, out4: rt.ByteVec): undefined => { rt.iterExtendBytes(out4, rt.iterSlice(rt.u32ToBeBytes(c4 as rt.u32).reverse()), undefined, true); }); - const n: rt.usize = dataLen; + const n: rt.usize = data.length; const end: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(57344, near))); const iter: rt.Iter = rt.iterStepBy(rt.iterRev(new rt.Range(gap, end, rt.charStep)), 2); while (true) { @@ -4614,8 +4598,7 @@ export function chars(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLen * `start..` as what each adaptor and consumer taking an `IntoIterator` takes, and as its * own receiver. */ -export function adapted(a: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const lo: rt.u8 = rt.u8Rem(a, 64); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); const it: () => rt.Iter = (): rt.Iter => { @@ -4717,17 +4700,15 @@ export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, * width at their ends and past 2^53 and 2^64, `char`s at either side of the surrogates, * floats with NaN and the zeros, and unsigned `NonZero`s. */ -export function rangeMethods(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const at: rt.usize[] = rt.arrayMap([0, 1], (i: rt.usize): rt.usize => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0) as rt.usize; + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.usize; }); const past53: rt.u64 = rt.u64Add({ hi: 0x200000, lo: 0 } as rt.u64, 1); const past64: rt.u128 = rt.u128Add(rt.u128Shl(1, 64), 1); const _17: rt.u8 = rt.u8Rem(kind, 19); if (_17 === 0) { - const _19: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(0, 1, 2, 254, 255)); - stepped$u8(_19.data, _19.start, _19.length, at, out); + stepped$u8(rt.byteSliceFrom(Uint8Array.of(0, 1, 2, 254, 255)), at, out); } else if (_17 === 1) { 65535 - 1; stepped$u16([0, 1, 32767, 65534, 65535], at, out); @@ -5978,8 +5959,7 @@ export function bounded$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): [ * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u8(tableData: Uint8Array, tableStart: number, tableLen: number, at: rt.usize[], out: rt.ByteVec): [rt.u8, rt.u8] { - const table: rt.ByteSlice = new rt.ByteSlice(tableData, tableStart, tableLen); +export function bounded$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec): [rt.u8, rt.u8] { const _6: Uint8Array = rt.bytesMap(at, (i: rt.usize): rt.u8 => { const _3: rt.usize = rt.usizeRem(i, table.length); rt.idx(table, _3); @@ -8100,16 +8080,15 @@ export function stepped$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u8(tableData: Uint8Array, tableStart: number, tableLen: number, at: rt.usize[], out: rt.ByteVec): void { +export function stepped$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec): void { let _20!: rt.i32; let read!: rt.u8 | undefined; - const table: rt.ByteSlice = new rt.ByteSlice(tableData, tableStart, tableLen); const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { const h: rt.Hasher = rt.hasher(); value(h); return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); }; - const _6: [rt.u8, rt.u8] = bounded$u8(table.data, table.start, table.length, at, out); + const _6: [rt.u8, rt.u8] = bounded$u8(table, at, out); const a: rt.u8 = _6[0]; const b: rt.u8 = _6[1]; const part2 = (h2: rt.Hasher): undefined => { @@ -8292,7 +8271,7 @@ export function stepped$usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec * on after; of floats with NaN for 0xff, against a `Vec` by value; and of `start..`, which * never ends, and panics past its type's last value. */ -export function compares(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function compares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let r!: rt.u8; let r2!: rt.u8; let r3!: rt.u8; @@ -8300,7 +8279,6 @@ export function compares(kind: rt.u8, dataData: Uint8Array, dataStart: number, d let r5!: rt.u8; let r6!: rt.u8; let r7!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _23: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { return o2 & 0xff; diff --git a/ts/fixtures/lang/expected/joins.ts b/ts/fixtures/lang/expected/joins.ts index ebd82d681..c77dc6bc8 100644 --- a/ts/fixtures/lang/expected/joins.ts +++ b/ts/fixtures/lang/expected/joins.ts @@ -44,8 +44,7 @@ export function ids(v: joins_Logged.Logged[], log: rt.RefCell, out: * `concat` and `join` of what `kind` picks, each over the parts of `data` between its * zeros, as many as `kind`'s high bits pick, none and empty ones included. */ -export function joins(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const all: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceSplit(data, (_2: rt.u8): boolean => { return _2 === 0; }), "next", 8); @@ -188,10 +187,9 @@ export function joins(kind: rt.u8, dataData: Uint8Array, dataStart: number, data log[Symbol.dispose](); } else if (_26 === 4) { const owned2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (p3: rt.ByteSlice): string => { - const _35: rt.ByteSlice = p3; - return text(_35.data, _35.start, _35.length); + return text(p3); }), undefined, 12, true); - const sep4: string = text(seps.data, seps.start, seps.length); + const sep4: string = text(seps); fmt_put(out, rt.strsJoin(owned2, "")); fmt_put(out, rt.strsJoin(owned2, sep4)); const borrowed: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(owned2), (a02: string): string => { @@ -231,16 +229,14 @@ export function joins(kind: rt.u8, dataData: Uint8Array, dataStart: number, data if (rt.usizeRem(_214[0], 2) === 0) { return "ab"; } - const _93: rt.ByteSlice = _214[1]; - return text(_93.data, _93.start, _93.length); + return text(_214[1]); }), undefined, 12, true); fmt_put(out, rt.strsJoin(texts, "")); fmt_put(out, rt.strsJoin(texts, "--")); } else { const big: rt.ByteVec = rt.byteVecOf(1, 1 << 16); const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined); - const _508: rt.ByteSlice = rt.byteVecSlice(big); - const text_: string = text(_508.data, _508.start, _508.length); + const text_: string = text(rt.byteVecSlice(big)); const refs: (a0: rt.usize) => rt.ByteSlice[] = (n: rt.usize): rt.ByteSlice[] => { return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined); }; diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index d8066eca8..39b2e0b44 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -161,8 +161,8 @@ export function find$sync_Arc_str_str(keys: rt.Arc[], q: string): rt.u8 } /** The index of the first of `keys` that borrows as `q`. */ -export function find$u8_u8(keysData: Uint8Array, keysStart: number, keysLen: number, q: rt.u8): rt.u8 { - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(keysData, keysStart, keysLen)))); +export function find$u8_u8(keys: rt.ByteSlice, q: rt.u8): rt.u8 { + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(keys))); while (true) { const _7: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_7 === rt.DONE) { @@ -177,18 +177,18 @@ export function find$u8_u8(keysData: Uint8Array, keysStart: number, keysLen: num } /** Run one case. */ -export function keys(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 5); if (_4 === 0) { - options(dataData, dataStart, dataLen, out); + options(data.data, data.start, data.length, out); } else if (_4 === 1) { - arcs(dataData, dataStart, dataLen, out); + arcs(data, out); } else if (_4 === 2) { - borrows(dataData, dataStart, dataLen, out); + borrows(data.data, data.start, data.length, out); } else if (_4 === 3) { - defaults(dataData, dataStart, dataLen, out); + defaults(data, out); } else { - places(dataData, dataStart, dataLen, out); + places(data, out); } } @@ -307,9 +307,8 @@ export function compare$tuple2_u8_keys_Lopsided(l: [rt.u8, Lopsided.Lopsided], r * The comparisons a type's `PartialEq` and `PartialOrd` inherit: `!=` as `!eq`, and * the orderings from `partial_cmp`, false when it is `None`, whatever `eq` says. */ -export function defaults(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { let _7!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let iterStart: rt.usize = 1; const iterEnd: rt.usize = data.length; while ((_7 = iterStart++) < iterEnd) { @@ -389,9 +388,8 @@ export function defaults(dataData: Uint8Array, dataStart: number, dataLen: numbe * `clamp`, and sorts. A field before a tuple's last, and an `Option`, compare by * `partial_cmp`. The first three bytes clamp last, which panics unless `min <= max`. */ -export function overrides(_1: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function overrides(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _8!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let iterStart: rt.usize = 1; const iterEnd: rt.usize = data.length; while ((_8 = iterStart++) < iterEnd) { @@ -651,21 +649,17 @@ export function options(dataData: Uint8Array, dataStart: number, dataLen: number } /** `Arc`s compared, ordered, and hashed as what they hold, and borrowed as it. */ -export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { let _7!: rt.usize; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = dataLen; + const iterEnd: rt.usize = data.length; while ((_7 = iterStart++) < iterEnd) { const i: rt.usize = _7; const _16: rt.usize = rt.usizeSub(i, 1); - if (_16 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _16); - } - const _14: Name.Name = name(dataData[dataStart + _16]); - if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); - } - const _13: [Name.Name, Name.Name] = [_14, name(dataData[dataStart + i])]; + rt.idx(data, _16); + const _14: Name.Name = name(data.data[data.start + _16]); + rt.idx(data, i); + const _13: [Name.Name, Name.Name] = [_14, name(data.data[data.start + i])]; const a: Name.Name = _14; const b: Name.Name = _13[1]; rt.byteVecPush(out, order(rt.cmpArc(rt.cmpStr)(a.text, b.text)) | ((order(Name.cmp$cmp_Ord(a, b)) << 2) & 0xff)); @@ -676,10 +670,8 @@ export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, o rt.byteVecPush(out, (rt.u64Eq(hashOf$sync_Arc_str(a.text), hashOf$sync_Arc_str(b.text)) ? 1 : 0) | (((rt.u64Eq(hashOf$keys_Name(a), hashOf$keys_Name(b)) ? 1 : 0) << 1) & 0xff)); const text: string = a.text.value; rt.byteVecPush(out, text === b.text.value ? 1 : 0); - if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); - } - const _106: rt.usize = rt.usizeRem(dataData[dataStart + i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); + rt.idx(data, i); + const _106: rt.usize = rt.usizeRem(data.data[data.start + i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); if (!(_106 < 6)) { rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); } @@ -689,9 +681,9 @@ export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, o rt.byteVecPush(out, find$sync_Arc_str_str(_127, _105[_106])); rt.dropAll(_127); } - const _130: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); + const _130: rt.u8 | undefined = rt.byteSliceFirst(data); if (_130 !== undefined) { - rt.byteVecPush(out, find$u8_u8(dataData, dataStart, dataLen, _130)); + rt.byteVecPush(out, find$u8_u8(data, _130)); } const liar: rt.Arc = new rt.Arc({}); const never: rt.Arc = new rt.Arc({}); @@ -713,14 +705,14 @@ export function arcs(dataData: Uint8Array, dataStart: number, dataLen: number, o * give: numbers, a wide number, and a tuple, by keys JS compares and by keys found * through their hash. */ -export function places(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function places(data: rt.ByteSlice, out: rt.ByteVec): void { let _154!: rt.usize; let _257!: rt.u8; const counts: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const wide: rt.HashMap = rt.hashNew() as rt.HashMap; const hops: rt.HashMap = rt.hashNew(rt.hashing(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined, Hop.eq$cmp_PartialEq)) as rt.HashMap; const pairs: rt.BTreeMap = rt.btreeNew(Hop.cmp$cmp_Ord) as rt.BTreeMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _11: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_11 === rt.DONE) { @@ -805,16 +797,14 @@ export function places(dataData: Uint8Array, dataStart: number, dataLen: number, p[1] = p[1] ^ p[0]; } const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _150: rt.usize = rt.usizeMul(dataLen, 4); + const _150: rt.usize = rt.usizeMul(data.length, 4); let iterStart: rt.usize = 0; const iterEnd: rt.usize = _150; while ((_154 = iterStart++) < iterEnd) { const j: rt.usize = _154; - const _159: rt.usize = rt.usizeRem(j, dataLen); - if (_159 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _159); - } - const b2: rt.u8 = dataData[dataStart + _159]; + const _159: rt.usize = rt.usizeRem(j, data.length); + rt.idx(data, _159); + const b2: rt.u8 = data.data[data.start + _159]; const v: rt.Place = rt.entryOrInsertMut(rt.entry(tree, rt.u16Mul(j & 0xffff, 37) ^ b2 as rt.u16), j & 0xffff); v.v = rt.u16WrappingAdd(v.v, b2 as rt.u16); } @@ -828,12 +818,12 @@ export function places(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_179[1]))); } const touchy: rt.BTreeMap = rt.btreeNew(Touchy.cmp$cmp_Ord) as rt.BTreeMap; - const _195: rt.Place = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: dataLen & 0xff }), (): rt.u8 => { + const _195: rt.Place = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: data.length & 0xff }), (): rt.u8 => { return 7; }); _195.v = rt.u8Add(_195.v, 1); const hashy: rt.HashMap = rt.hashNew(rt.hashing(Touchy.hash$Hash_hash_DefaultHasher as (a0: Touchy.Touchy, a1: rt.Hasher) => undefined, Touchy.eq$cmp_PartialEq)) as rt.HashMap; - const _203: rt.Place = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: dataLen & 0xff }), (): rt.u8 => { + const _203: rt.Place = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: data.length & 0xff }), (): rt.u8 => { return 0; }); _203.v = rt.u8Add(_203.v, 2); @@ -844,7 +834,7 @@ export function places(dataData: Uint8Array, dataStart: number, dataLen: number, ((): undefined => { c2.v = rt.usizeAdd(c2.v, 1); })(); - const spare: rt.usize[] = [dataLen, 8]; + const spare: rt.usize[] = [data.length, 8]; const c3: rt.Place = rt.entryOrInsertMut(rt.entry(counts, 1), 3); const swapped = c3.v; c3.v = spare[0]; @@ -892,8 +882,7 @@ export function places(dataData: Uint8Array, dataStart: number, dataLen: number, * another form holding the same bytes, alone or in a tuple, an `Option`, or an `Arc`, * and a key found by a `&[u8]` it borrows as, in hash and B-tree collections alike. */ -export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const cut: rt.usize = rt.min(data.length, 6); const iter: rt.Iter = rt.byteSliceWindows(data, 2); while (true) { @@ -1086,8 +1075,7 @@ export function bytes(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * written, which leaves the collection's own as they were. A hash collection's order is * the runtime's, so what it yields is sorted first. */ -export function lentKeys(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), (w: rt.ByteSlice): Uint8Array => { rt.idx(w, 0); const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); @@ -1440,12 +1428,12 @@ export function lentKeys(kind: rt.u8, dataData: Uint8Array, dataStart: number, d * Values that are `[u8; 2]`, and the items of a deque and a heap, lent as keys are: a * `&` reads them and a `&mut` writes where the collection holds them. */ -export function lentValues(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const map: rt.HashMap = rt.hashNew() as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const iter: rt.Iter = rt.byteSliceWindows(new rt.ByteSlice(dataData, dataStart, dataLen), 2); + const iter: rt.Iter = rt.byteSliceWindows(data, 2); while (true) { const _11: rt.ByteSlice | rt.Done = iter.next(); if (_11 === rt.DONE) { @@ -1613,42 +1601,42 @@ export function lentValues(kind: rt.u8, dataData: Uint8Array, dataStart: number, * by their elements in turn, and ranged, walked, and edited through entries. A hash * collection's order is the runtime's, so what it yields is sorted first. */ -export function arrays(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 9); if (_4 === 0) { - keyed$u16_2_keys_arrays_closure0(dataData, dataStart, dataLen, (b8: rt.u8): rt.u16[] => { + keyed$u16_2_keys_arrays_closure0(data, (b8: rt.u8): rt.u16[] => { return [(((rt.u8Rem(b8, 4) as rt.u16)) << 8) & 0xffff, rt.u8Rem(b8, 3) as rt.u16]; }, out); } else if (_4 === 1) { - keyed$u64_2_keys_arrays_closure1(dataData, dataStart, dataLen, (b7: rt.u8): rt.u64[] => { + keyed$u64_2_keys_arrays_closure1(data, (b7: rt.u8): rt.u64[] => { return [rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u8Rem(b7, 4) as rt.u64), rt.u64Shl(1, rt.u8Mul(rt.u8Rem(b7, 3), 30))]; }, out); } else if (_4 === 2) { - keyed$i32_2_keys_arrays_closure2(dataData, dataStart, dataLen, (b6: rt.u8): rt.i32[] => { + keyed$i32_2_keys_arrays_closure2(data, (b6: rt.u8): rt.i32[] => { return [rt.i8Rem((b6 << 24) >> 24, 3) as rt.i32, rt.i32Neg(rt.u8Rem(b6, 2) as rt.i32)]; }, out); } else if (_4 === 3) { - keyed$char_2_keys_arrays_closure3(dataData, dataStart, dataLen, (b5: rt.u8): rt.char[] => { + keyed$char_2_keys_arrays_closure3(data, (b5: rt.u8): rt.char[] => { return [57344, rt.u8Add(rt.u8Rem(b5, 4), 97) as rt.char]; }, out); } else if (_4 === 4) { - keyed$bool_2_keys_arrays_closure4(dataData, dataStart, dataLen, (b4: rt.u8): boolean[] => { + keyed$bool_2_keys_arrays_closure4(data, (b4: rt.u8): boolean[] => { return [rt.u8Rem(b4, 2) === 0, rt.u8Rem(b4, 3) === 0]; }, out); } else if (_4 === 5) { - keyed$Option_u8_2_keys_arrays_closure5(dataData, dataStart, dataLen, (b3: rt.u8): Array => { + keyed$Option_u8_2_keys_arrays_closure5(data, (b3: rt.u8): Array => { return [small(b3), small(rt.u8Div(b3, 4))]; }, out); } else if (_4 === 6) { - keyed$keys_Hop_2_keys_arrays_closure6(dataData, dataStart, dataLen, (b2: rt.u8): Hop.Hop[] => { + keyed$keys_Hop_2_keys_arrays_closure6(data, (b2: rt.u8): Hop.Hop[] => { return [{ _0: rt.u64Shl(rt.u8Rem(b2, 3) as rt.u64, 53) }, { _0: rt.u8Rem(b2, 2) as rt.u64 }]; }, out); } else if (_4 === 7) { - keyed$u32_0_keys_arrays_closure7(dataData, dataStart, dataLen, (_2: rt.u8): rt.u32[] => { + keyed$u32_0_keys_arrays_closure7(data, (_2: rt.u8): rt.u32[] => { return []; }, out); } else { - keyed$u32_275_keys_arrays_closure8(dataData, dataStart, dataLen, (b: rt.u8): rt.u32[] => { + keyed$u32_275_keys_arrays_closure8(data, (b: rt.u8): rt.u32[] => { const _3: rt.u32 = rt.u8Rem(b, 4) as rt.u32; return Array.from({ length: 275 }, (): rt.u32 => { return _3; @@ -1658,11 +1646,10 @@ export function arrays(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$Option_u8_2_keys_arrays_closure5(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => Array, out: rt.ByteVec): void { +export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.u8) => Array, out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; const tree: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeMap, rt.u8>; const set: rt.HashSet> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashSet>; @@ -1915,11 +1902,10 @@ export function keyed$Option_u8_2_keys_arrays_closure5(dataData: Uint8Array, dat } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$bool_2_keys_arrays_closure4(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => boolean[], out: rt.ByteVec): void { +export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u8) => boolean[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2171,11 +2157,10 @@ export function keyed$bool_2_keys_arrays_closure4(dataData: Uint8Array, dataStar } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$char_2_keys_arrays_closure3(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.char[], out: rt.ByteVec): void { +export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u8) => rt.char[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2428,11 +2413,10 @@ export function keyed$char_2_keys_arrays_closure3(dataData: Uint8Array, dataStar } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$i32_2_keys_arrays_closure2(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.i32[], out: rt.ByteVec): void { +export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8) => rt.i32[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2684,11 +2668,10 @@ export function keyed$i32_2_keys_arrays_closure2(dataData: Uint8Array, dataStart } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$keys_Hop_2_keys_arrays_closure6(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => Hop.Hop[], out: rt.ByteVec): void { +export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8) => Hop.Hop[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$cmp_PartialEq))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(Hop.cmp$cmp_Ord)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$cmp_PartialEq))) as rt.HashSet; @@ -2941,11 +2924,10 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(dataData: Uint8Array, data } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u16_2_keys_arrays_closure0(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16[], out: rt.ByteVec): void { +export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3198,11 +3180,10 @@ export function keyed$u16_2_keys_arrays_closure0(dataData: Uint8Array, dataStart } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u32_0_keys_arrays_closure7(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { +export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3455,11 +3436,10 @@ export function keyed$u32_0_keys_arrays_closure7(dataData: Uint8Array, dataStart } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u32_275_keys_arrays_closure8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { +export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3712,11 +3692,10 @@ export function keyed$u32_275_keys_arrays_closure8(dataData: Uint8Array, dataSta } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u64_2_keys_arrays_closure1(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { +export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; let _572!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashSet; @@ -3973,24 +3952,24 @@ export function keyed$u64_2_keys_arrays_closure1(dataData: Uint8Array, dataStart * references to them, lent to an adaptor's closure as std lends the items it holds, and * held as `&[u8; N]` keys beside `[u8; N]` values. Of two bytes, and of none. */ -export function byteRefs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function byteRefs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (rt.u8Rem(kind, 2) === 0) { - taken$2_keys_byte_refs_closure0(dataData, dataStart, dataLen, (w: rt.ByteSlice): Uint8Array => { + taken$2_keys_byte_refs_closure0(data, (w: rt.ByteSlice): Uint8Array => { rt.idx(w, 0); const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); rt.idx(w, 1); return Uint8Array.of(_3, rt.u8Rem(w.data[w.start + 1], 4)); }, out); } else { - taken$0_keys_byte_refs_closure1(dataData, dataStart, dataLen, (_2: rt.ByteSlice): Uint8Array => { + taken$0_keys_byte_refs_closure1(data, (_2: rt.ByteSlice): Uint8Array => { return Uint8Array.of(); }, out); } } /** `byte_refs` of the arrays `make` makes of each window of two bytes. */ -export function taken$0_keys_byte_refs_closure1(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.ByteSlice) => Uint8Array, out: rt.ByteVec): void { - const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(new rt.ByteSlice(dataData, dataStart, dataLen), 2), make), undefined, 0, true); +export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: rt.ByteSlice) => Uint8Array, out: rt.ByteVec): void { + const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 0, true); const vec: Uint8Array[] = []; rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 0, true); const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; @@ -4290,8 +4269,8 @@ export function taken$0_keys_byte_refs_closure1(dataData: Uint8Array, dataStart: } /** `byte_refs` of the arrays `make` makes of each window of two bytes. */ -export function taken$2_keys_byte_refs_closure0(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.ByteSlice) => Uint8Array, out: rt.ByteVec): void { - const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(new rt.ByteSlice(dataData, dataStart, dataLen), 2), make), undefined, 2, true); +export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: rt.ByteSlice) => Uint8Array, out: rt.ByteVec): void { + const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 2, true); const vec: Uint8Array[] = []; rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; diff --git a/ts/fixtures/lang/expected/lengths.ts b/ts/fixtures/lang/expected/lengths.ts index 23ee04ade..83a3dd69f 100644 --- a/ts/fixtures/lang/expected/lengths.ts +++ b/ts/fixtures/lang/expected/lengths.ts @@ -6,21 +6,21 @@ import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; import * as lengths_Tagged from "./lengths.Tagged.ts"; /** Each case at the length `kind` picks. */ -export function lengths(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lengths(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { - each$0(dataData, dataStart, dataLen, out); + each$0(data, out); } else if (_4 === 1) { - each$1(dataData, dataStart, dataLen, out); + each$1(data, out); } else if (_4 === 2) { - each$3(dataData, dataStart, dataLen, out); + each$3(data, out); } else { - each$17(dataData, dataStart, dataLen, out); + each$17(data, out); } } -export function each$0(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(0, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$0(data: rt.ByteSlice, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(0, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -30,29 +30,29 @@ export function each$0(dataData: Uint8Array, dataStart: number, dataLen: number, return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 0, true); - joined$0(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); - joined$0(dataData, dataStart, dataLen, copy$array_array0_u8([rt.bytes(0).fill(165), rt.bytesFromFn(0, (i2: rt.usize): rt.u8 => { + joined$0(data, rows.map(copy$array_u8), out); + joined$0(data, copy$array_array0_u8([rt.bytes(0).fill(165), rt.bytesFromFn(0, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$0(rows, out); recloned$u32_0(wide, out); - filledBytes$0(dataData, dataStart, dataLen, rt.bytesFromFn(0, (i3: rt.usize): rt.u8 => { + filledBytes$0(data, rt.bytesFromFn(0, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$0(dataData, dataStart, dataLen, rt.arrayFromFn(0, (i4: rt.usize): rt.u32 => { + filledWords$0(data, rt.arrayFromFn(0, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$0(dataData, dataStart, dataLen, rt.arrayFromFn(0, (i5: rt.usize): Uint8Array => { + filledRows$0(data, rt.arrayFromFn(0, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(0, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 0), j) & 0xff; }); }), out); - swapped$u8_0(dataData, dataStart, dataLen, rows, out); - swapped$u32_0(dataData, dataStart, dataLen, wide, out); + swapped$u8_0(data, rows, out); + swapped$u32_0(data, wide, out); } -export function each$1(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(1, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$1(data: rt.ByteSlice, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(1, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -62,29 +62,29 @@ export function each$1(dataData: Uint8Array, dataStart: number, dataLen: number, return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 4, true); - joined$1(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); - joined$1(dataData, dataStart, dataLen, copy$array_array1_u8([rt.bytes(1).fill(165), rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { + joined$1(data, rows.map(copy$array_u8), out); + joined$1(data, copy$array_array1_u8([rt.bytes(1).fill(165), rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$1(rows, out); recloned$u32_1(wide, out); - filledBytes$1(dataData, dataStart, dataLen, rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { + filledBytes$1(data, rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$1(dataData, dataStart, dataLen, rt.arrayFromFn(1, (i4: rt.usize): rt.u32 => { + filledWords$1(data, rt.arrayFromFn(1, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$1(dataData, dataStart, dataLen, rt.arrayFromFn(1, (i5: rt.usize): Uint8Array => { + filledRows$1(data, rt.arrayFromFn(1, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(1, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 1), j) & 0xff; }); }), out); - swapped$u8_1(dataData, dataStart, dataLen, rows, out); - swapped$u32_1(dataData, dataStart, dataLen, wide, out); + swapped$u8_1(data, rows, out); + swapped$u32_1(data, wide, out); } -export function each$17(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(17, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$17(data: rt.ByteSlice, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(17, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(17, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -94,29 +94,29 @@ export function each$17(dataData: Uint8Array, dataStart: number, dataLen: number return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 68, true); - joined$17(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); - joined$17(dataData, dataStart, dataLen, copy$array_array17_u8([rt.bytes(17).fill(165), rt.bytesFromFn(17, (i2: rt.usize): rt.u8 => { + joined$17(data, rows.map(copy$array_u8), out); + joined$17(data, copy$array_array17_u8([rt.bytes(17).fill(165), rt.bytesFromFn(17, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$17(rows, out); recloned$u32_17(wide, out); - filledBytes$17(dataData, dataStart, dataLen, rt.bytesFromFn(17, (i3: rt.usize): rt.u8 => { + filledBytes$17(data, rt.bytesFromFn(17, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$17(dataData, dataStart, dataLen, rt.arrayFromFn(17, (i4: rt.usize): rt.u32 => { + filledWords$17(data, rt.arrayFromFn(17, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$17(dataData, dataStart, dataLen, rt.arrayFromFn(17, (i5: rt.usize): Uint8Array => { + filledRows$17(data, rt.arrayFromFn(17, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(17, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 17), j) & 0xff; }); }), out); - swapped$u8_17(dataData, dataStart, dataLen, rows, out); - swapped$u32_17(dataData, dataStart, dataLen, wide, out); + swapped$u8_17(data, rows, out); + swapped$u32_17(data, wide, out); } -export function each$3(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart, dataLen), rt.max(3, 1)), (c: rt.ByteSlice): Uint8Array => { +export function each$3(data: rt.ByteSlice, out: rt.ByteVec): void { + const rows: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, rt.max(3, 1)), (c: rt.ByteSlice): Uint8Array => { return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); }); @@ -126,45 +126,45 @@ export function each$3(dataData: Uint8Array, dataStart: number, dataLen: number, return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 12, true); - joined$3(dataData, dataStart, dataLen, rows.map(copy$array_u8), out); - joined$3(dataData, dataStart, dataLen, copy$array_array3_u8([rt.bytes(3).fill(165), rt.bytesFromFn(3, (i2: rt.usize): rt.u8 => { + joined$3(data, rows.map(copy$array_u8), out); + joined$3(data, copy$array_array3_u8([rt.bytes(3).fill(165), rt.bytesFromFn(3, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); retagged$3(rows, out); recloned$u32_3(wide, out); - filledBytes$3(dataData, dataStart, dataLen, rt.bytesFromFn(3, (i3: rt.usize): rt.u8 => { + filledBytes$3(data, rt.bytesFromFn(3, (i3: rt.usize): rt.u8 => { return i3 & 0xff; }), out); - filledWords$3(dataData, dataStart, dataLen, rt.arrayFromFn(3, (i4: rt.usize): rt.u32 => { + filledWords$3(data, rt.arrayFromFn(3, (i4: rt.usize): rt.u32 => { return rt.u32Mul(16909060, i4 as rt.u32); }), out); - filledRows$3(dataData, dataStart, dataLen, rt.arrayFromFn(3, (i5: rt.usize): Uint8Array => { + filledRows$3(data, rt.arrayFromFn(3, (i5: rt.usize): Uint8Array => { return rt.bytesFromFn(3, (j: rt.usize): rt.u8 => { return rt.usizeAdd(rt.usizeMul(i5, 3), j) & 0xff; }); }), out); - swapped$u8_3(dataData, dataStart, dataLen, rows, out); - swapped$u32_3(dataData, dataStart, dataLen, wide, out); + swapped$u8_3(data, rows, out); + swapped$u32_3(data, wide, out); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$0(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0)), undefined, true); +export function joined$0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$1(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 1)), undefined, true); +export function joined$1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 1)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$17(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 17)), undefined, true); +export function joined$17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 17)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$3(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 3)), undefined, true); +export function joined$3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 3)), undefined, true); } /** @@ -395,7 +395,7 @@ export function recloned$u32_3(rows: rt.u32[][], out: rt.ByteVec): void { } } -export function filledBytes$0(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$0(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(0), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_u8_tuple2_u8_u8(item); @@ -411,7 +411,7 @@ export function filledBytes$0(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -432,7 +432,7 @@ export function filledBytes$0(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledBytes$1(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$1(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(1), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_u8_tuple2_u8_u8(item); @@ -448,7 +448,7 @@ export function filledBytes$1(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -469,7 +469,7 @@ export function filledBytes$1(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledBytes$17(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$17(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(17), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_u8_tuple2_u8_u8(item); @@ -485,7 +485,7 @@ export function filledBytes$17(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -506,7 +506,7 @@ export function filledBytes$17(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledBytes$3(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array, out: rt.ByteVec): void { +export function filledBytes$3(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { const item = ([new Uint8Array(3), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8(item); @@ -522,7 +522,7 @@ export function filledBytes$3(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -543,7 +543,7 @@ export function filledBytes$3(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledWords$0(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$0(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(0), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_u32_tuple2_u8_u8(item); @@ -559,7 +559,7 @@ export function filledWords$0(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -580,7 +580,7 @@ export function filledWords$0(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledWords$1(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$1(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(1), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_u32_tuple2_u8_u8(item); @@ -596,7 +596,7 @@ export function filledWords$1(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -617,7 +617,7 @@ export function filledWords$1(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledWords$17(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$17(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(17), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_u32_tuple2_u8_u8(item); @@ -633,7 +633,7 @@ export function filledWords$17(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -654,7 +654,7 @@ export function filledWords$17(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledWords$3(dataData: Uint8Array, dataStart: number, dataLen: number, fill: rt.u32[], out: rt.ByteVec): void { +export function filledWords$3(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { const item = ([new Array(3), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u32_tuple2_u8_u8(item); @@ -670,7 +670,7 @@ export function filledWords$3(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -691,7 +691,7 @@ export function filledWords$3(dataData: Uint8Array, dataStart: number, dataLen: } } -export function filledRows$0(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$0(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 0 }, (): Uint8Array => { return (new Uint8Array(0) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -709,7 +709,7 @@ export function filledRows$0(dataData: Uint8Array, dataStart: number, dataLen: n rt.ptrWrite(uninit, [copy$array_array0_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -724,13 +724,13 @@ export function filledRows$0(dataData: Uint8Array, dataStart: number, dataLen: n for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array0_u8(v.data, v.start, v.length, out); + put$lengths_Put_array0_u8(v, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } } -export function filledRows$1(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$1(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 1 }, (): Uint8Array => { return (new Uint8Array(1) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -748,7 +748,7 @@ export function filledRows$1(dataData: Uint8Array, dataStart: number, dataLen: n rt.ptrWrite(uninit, [copy$array_array1_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -763,13 +763,13 @@ export function filledRows$1(dataData: Uint8Array, dataStart: number, dataLen: n for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array1_u8(v.data, v.start, v.length, out); + put$lengths_Put_array1_u8(v, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } } -export function filledRows$17(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$17(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 17 }, (): Uint8Array => { return (new Uint8Array(17) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -787,7 +787,7 @@ export function filledRows$17(dataData: Uint8Array, dataStart: number, dataLen: rt.ptrWrite(uninit, [copy$array_array17_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -802,13 +802,13 @@ export function filledRows$17(dataData: Uint8Array, dataStart: number, dataLen: for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array17_u8(v.data, v.start, v.length, out); + put$lengths_Put_array17_u8(v, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } } -export function filledRows$3(dataData: Uint8Array, dataStart: number, dataLen: number, fill: Uint8Array[], out: rt.ByteVec): void { +export function filledRows$3(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { const item = ([Array.from({ length: 3 }, (): Uint8Array => { return (new Uint8Array(3) as unknown) as Uint8Array; }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; @@ -826,7 +826,7 @@ export function filledRows$3(dataData: Uint8Array, dataStart: number, dataLen: n rt.ptrWrite(uninit, [copy$array_array3_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); uninit; } - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _29: rt.usize = rt.usizeRem(byte as rt.usize, 3); if (!(_29 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _29); @@ -841,7 +841,7 @@ export function filledRows$3(dataData: Uint8Array, dataStart: number, dataLen: n for (const _50 of slots) { const _57: [Uint8Array[], [rt.u8, rt.u8]] = _50; rt.iterForEach(rt.iterLend(rt.iterSlice(_57[0]), rt.byteSliceFrom), (v: rt.ByteSlice): undefined => { - put$lengths_Put_array3_u8(v.data, v.start, v.length, out); + put$lengths_Put_array3_u8(v, out); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_57[1][0], _57[1][1])), undefined, true); } @@ -855,27 +855,27 @@ export function put$lengths_Put_u32(self: rt.u32, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(self).reverse()), undefined, true); } -export function put$lengths_Put_array0_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); +export function put$lengths_Put_array0_u8(self: rt.ByteSlice, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, self); } -export function put$lengths_Put_array17_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); +export function put$lengths_Put_array17_u8(self: rt.ByteSlice, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, self); } -export function put$lengths_Put_array1_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); +export function put$lengths_Put_array1_u8(self: rt.ByteSlice, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, self); } -export function put$lengths_Put_array3_u8(selfData: Uint8Array, selfStart: number, selfLen: number, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(selfData, selfStart, selfLen)); +export function put$lengths_Put_array3_u8(self: rt.ByteSlice, out: rt.ByteVec): void { + rt.byteVecExtendFromSlice(out, self); } /** * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_0(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -888,7 +888,7 @@ export function swapped$u32_0(dataData: Uint8Array, dataStart: number, dataLen: const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -926,7 +926,7 @@ export function swapped$u32_0(dataData: Uint8Array, dataStart: number, dataLen: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_1(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -939,7 +939,7 @@ export function swapped$u32_1(dataData: Uint8Array, dataStart: number, dataLen: const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -977,7 +977,7 @@ export function swapped$u32_1(dataData: Uint8Array, dataStart: number, dataLen: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_17(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -990,7 +990,7 @@ export function swapped$u32_17(dataData: Uint8Array, dataStart: number, dataLen: const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1028,7 +1028,7 @@ export function swapped$u32_17(dataData: Uint8Array, dataStart: number, dataLen: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_3(dataData: Uint8Array, dataStart: number, dataLen: number, rows: rt.u32[][], out: rt.ByteVec): void { +export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { @@ -1041,7 +1041,7 @@ export function swapped$u32_3(dataData: Uint8Array, dataStart: number, dataLen: const next: rt.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1079,7 +1079,7 @@ export function swapped$u32_3(dataData: Uint8Array, dataStart: number, dataLen: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_0(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1094,7 +1094,7 @@ export function swapped$u8_0(dataData: Uint8Array, dataStart: number, dataLen: n const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1132,7 +1132,7 @@ export function swapped$u8_0(dataData: Uint8Array, dataStart: number, dataLen: n * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_1(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1147,7 +1147,7 @@ export function swapped$u8_1(dataData: Uint8Array, dataStart: number, dataLen: n const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1185,7 +1185,7 @@ export function swapped$u8_1(dataData: Uint8Array, dataStart: number, dataLen: n * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_17(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1200,7 +1200,7 @@ export function swapped$u8_17(dataData: Uint8Array, dataStart: number, dataLen: const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1238,7 +1238,7 @@ export function swapped$u8_17(dataData: Uint8Array, dataStart: number, dataLen: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_3(dataData: Uint8Array, dataStart: number, dataLen: number, rows: Uint8Array[], out: rt.ByteVec): void { +export function swapped$u8_3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); @@ -1253,7 +1253,7 @@ export function swapped$u8_3(dataData: Uint8Array, dataStart: number, dataLen: n const next: Uint8Array = rt.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; diff --git a/ts/fixtures/lang/expected/lists.ts b/ts/fixtures/lang/expected/lists.ts index 59a8e6b4e..c553e8c4b 100644 --- a/ts/fixtures/lang/expected/lists.ts +++ b/ts/fixtures/lang/expected/lists.ts @@ -27,13 +27,13 @@ export function items(l: rt.LinkedList, out: rt.ByteVec): void { * bytes, then how they compare, hash, iterate, and print. `kind` picks whether a split * past the end ends it, which panics. */ -export function lists(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _93!: rt.i32; let x2!: rt.u8 | undefined; let x3!: rt.Place | undefined; let l: rt.LinkedList = rt.listNew() as rt.LinkedList; let m: rt.LinkedList = rt.listNew() as rt.LinkedList; - l1: for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + l1: for (const b of rt.byteSliceView(data)) { const _13: rt.u8 = rt.u8Rem(b, 13); if (_13 === 0) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.listPopFront(l), 238)); @@ -150,9 +150,9 @@ export function lists(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.iterExtendBytes(out, rt.iterRev(it3), undefined, true); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.listIter(l)), 231)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.listIter(l), rt.usizeRem(kind as rt.usize, 4)), 230)); - edges(dataData, dataStart, dataLen, out); + edges(data, out); printed(l, m, out); - tallies(dataData, dataStart, dataLen, out); + tallies(data, out); if (rt.u8Rem(kind, 4) === 0) { rt.iterExtendBytes(out, rt.listIter(rt.listSplitOff(m, rt.usizeAdd(rt.usizeAdd(m.n, 1), rt.u8Rem(rt.u8Div(kind, 4), 2) as rt.usize))), undefined, true); } @@ -162,8 +162,7 @@ export function lists(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * `split_off` and `append` at 0, either side of the middle, and the end, and the list * `collect`, `From`, and `extend` make, empty ones included. */ -export function edges(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const whole: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _4); const len: rt.usize = whole.n; @@ -248,8 +247,8 @@ export function printed(l: rt.LinkedList, m: rt.LinkedList, out: r } /** A list of `Tally`s, which JS changes in place rather than through places. */ -export function tallies(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _4: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): lists_Tally.Tally => { +export function tallies(data: rt.ByteSlice, out: rt.ByteVec): void { + const _4: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): lists_Tally.Tally => { return { n: _2 as rt.u16 }; }); const l: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _4); diff --git a/ts/fixtures/lang/expected/locals.ts b/ts/fixtures/lang/expected/locals.ts index ce1083433..3ce07f5df 100644 --- a/ts/fixtures/lang/expected/locals.ts +++ b/ts/fixtures/lang/expected/locals.ts @@ -57,7 +57,7 @@ export function TALLY$init(_1: undefined): rt.RefCell { * Each byte an operation on the thread-locals; each puts what it read and what dropped. * First, what each holds, which only the value it starts with can be. */ -export function locals(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, ((a0: rt.Cell): rt.u32 => { return a0.v; })(COUNT.get()) & 0xff); @@ -87,7 +87,7 @@ export function locals(dataData: Uint8Array, dataStart: number, dataLen: number, rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26[0]._0 & 0xff, _26[0]._1 & 0xff, _26[1]._0 & 0xff, _26[1]._1 & 0xff)), undefined, true); rt.byteVecPush(out, serial(false)); const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _46: rt.u8 = rt.u8Rem(op, 9); if (_46 === 0) { ((c4: rt.Cell): undefined => { diff --git a/ts/fixtures/lang/expected/locks.ts b/ts/fixtures/lang/expected/locks.ts index e2b65e016..c9e17a433 100644 --- a/ts/fixtures/lang/expected/locks.ts +++ b/ts/fixtures/lang/expected/locks.ts @@ -7,14 +7,14 @@ import * as locks_Lock from "./locks.Lock.ts"; import * as locks_Tally from "./locks.Tally.ts"; /** Each byte an operation on the mutexes, its value the operand; each puts what it read. */ -export function locks(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function locks(data: rt.ByteSlice, out: rt.ByteVec): void { let _71!: boolean; const shared: rt.Arc> = new rt.Arc(new rt.Mutex(locks_Tally.default$Default())); const other: rt.Arc> = rt.arcClone(shared); const own: rt.Mutex = new rt.Mutex(new rt.ByteVec()); const number: rt.Mutex = new rt.Mutex(0); const lock: locks_Lock.Lock = { _0: new rt.Mutex(7) }; - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _17: rt.u8 = rt.u8Rem(op, 8); if (_17 === 0) { const tally: rt.Mutex = rt.mutexLock(shared.value); @@ -84,11 +84,11 @@ export function locks(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Locks a mutex while a guard of it is held, if the first byte is odd, which panics. */ -export function relock(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const mutex: rt.Mutex = new rt.Mutex(dataLen & 0xff); +export function relock(data: rt.ByteSlice, out: rt.ByteVec): void { + const mutex: rt.Mutex = new rt.Mutex(data.length & 0xff); const guard: rt.Mutex = rt.mutexLock(mutex); rt.byteVecPush(out, guard.value); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), (b: rt.u8): boolean => { + if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (b: rt.u8): boolean => { return rt.u8Rem(b, 2) === 1; })) { const _19: rt.Mutex = rt.mutexLock(mutex); @@ -105,12 +105,12 @@ export function relock(dataData: Uint8Array, dataStart: number, dataLen: number, * Each byte an operation on read-write locks, its value the operand; each puts what it * read. */ -export function rwlocks(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function rwlocks(data: rt.ByteSlice, out: rt.ByteVec): void { let _74!: boolean; let _90!: boolean; const lock: rt.Arc> = new rt.Arc(new rt.RefCell(locks_Tally.default$Default())); const number: rt.RefCell = new rt.RefCell(0); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const _12: rt.u8 = rt.u8Rem(op, 6); if (_12 === 0) { const tally: rt.RefCell = rt.rwLockWrite(lock.value); diff --git a/ts/fixtures/lang/expected/methods.ts b/ts/fixtures/lang/expected/methods.ts index 57db5a5c0..cc0b67850 100644 --- a/ts/fixtures/lang/expected/methods.ts +++ b/ts/fixtures/lang/expected/methods.ts @@ -4,7 +4,7 @@ import * as rt from "./rt.ts"; import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$18pd8cy as option_map$18pd8cy, map$0b7sac9 as option_map$0b7sac9, map$0x0f126 as option_map$0x0f126, map$02fxff7 as option_map$02fxff7, map$1u19ipa as option_map$1u19ipa, map$1rlqf9d as option_map$1rlqf9d, map$1fszu7p as option_map$1fszu7p, map$12xrbxt as option_map$12xrbxt, map$0xz4pvf as option_map$0xz4pvf, map$1rxjg4m as option_map$1rxjg4m, map$03bv7br as option_map$03bv7br, map$08v2q5m as option_map$08v2q5m } from "./core/option.ts"; /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v4: rt.u8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u8ToBeBytes(v4))); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v4)) === v4 ? 1 : 0); @@ -12,9 +12,8 @@ export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.u8 = rt.u8FromBeBytes(rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -435,7 +434,7 @@ export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v4: rt.u16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(v4))); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v4)) === v4 ? 1 : 0); @@ -443,9 +442,8 @@ export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.u16 = rt.u16FromBeBytes(rt.bytesFromFn(2, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -866,7 +864,7 @@ export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v4: rt.u32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(v4))); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v4)) === v4 ? 1 : 0); @@ -874,9 +872,8 @@ export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -1297,7 +1294,7 @@ export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v4: rt.u64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(v4))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v4)), v4) ? 1 : 0); @@ -1305,9 +1302,8 @@ export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.u64 = rt.u64FromBeBytes(rt.bytesFromFn(8, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -1728,7 +1724,7 @@ export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v4: rt.u128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v4))); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v4)), v4) ? 1 : 0); @@ -1736,9 +1732,8 @@ export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.u128 = rt.u128FromBeBytes(rt.bytesFromFn(16, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -2159,7 +2154,7 @@ export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v4: rt.usize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.usizeToBeBytes(v4))); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v4)) === v4 ? 1 : 0); @@ -2167,9 +2162,8 @@ export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.usize = rt.usizeFromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -2590,7 +2584,7 @@ export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v8: rt.i8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i8ToBeBytes(v8))); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v8)) === v8 ? 1 : 0); @@ -2598,9 +2592,8 @@ export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.i8 = rt.i8FromBeBytes(rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -3016,7 +3009,7 @@ export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v8: rt.i16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i16ToBeBytes(v8))); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v8)) === v8 ? 1 : 0); @@ -3024,9 +3017,8 @@ export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.i16 = rt.i16FromBeBytes(rt.bytesFromFn(2, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -3442,7 +3434,7 @@ export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v8: rt.i32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i32ToBeBytes(v8))); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v8)) === v8 ? 1 : 0); @@ -3450,9 +3442,8 @@ export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.i32 = rt.i32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -3868,7 +3859,7 @@ export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v8: rt.i64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i64ToBeBytes(v8))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v8)), v8) ? 1 : 0); @@ -3876,9 +3867,8 @@ export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.i64 = rt.i64FromBeBytes(rt.bytesFromFn(8, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -4294,7 +4284,7 @@ export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v8: rt.i128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v8))); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v8)), v8) ? 1 : 0); @@ -4302,9 +4292,8 @@ export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.i128 = rt.i128FromBeBytes(rt.bytesFromFn(16, (i2: rt.usize): rt.u8 => { return byte(i2); @@ -4720,7 +4709,7 @@ export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function isizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v8: rt.isize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.isizeToBeBytes(v8))); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v8)) === v8 ? 1 : 0); @@ -4728,9 +4717,8 @@ export function isizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const a: rt.isize = rt.isizeFromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { return byte(i2); diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index 2b6d208e8..d0dbb0d74 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -13,24 +13,24 @@ import * as nested_Unit from "./nested.Unit.ts"; * Run case `kind % 8` over `data`, whose bytes pick each `None`, `Some(None)`, or * `Some(Some(_))`. */ -export function nested(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function nested(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { - made(dataData, dataStart, dataLen, out); + made(data, out); } else if (_4 === 1) { - keys(dataData, dataStart, dataLen, out); + keys(data.data, data.start, data.length, out); } else if (_4 === 2) { - iters(dataData, dataStart, dataLen, out); + iters(data, out); } else if (_4 === 3) { - consumers(dataData, dataStart, dataLen, out); + consumers(data, out); } else if (_4 === 4) { - panics(dataData, dataStart, dataLen, out); + panics(data, out); } else if (_4 === 5) { - closures(dataData, dataStart, dataLen, out); + closures(data, out); } else if (_4 === 6) { - elements(dataData, dataStart, dataLen, out); + elements(data, out); } else { - units(dataData, dataStart, dataLen, out); + units(data, out); } } @@ -76,8 +76,8 @@ export function tried(a: undefined | rt.None, b: rt.u8 | undefined | rt.None): r return rt.None; } -export function made(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function made(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const b of rt.byteSliceView(data)) { const o: rt.u8 | undefined | rt.None = pick(b); const u: undefined | rt.None = unit(b); rt.byteVecPush(out, code(o)); @@ -201,8 +201,7 @@ export function halve(n: rt.u8): rt.u8 | undefined | rt.None { return thenSome$0d5am30(rt.u8Rem(n, 2) === 0, rt.u8Div(n, 2)); } -export function iters(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const items: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { const b: rt.u8 = _2; return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); @@ -255,8 +254,7 @@ export function iters(dataData: Uint8Array, dataStart: number, dataLen: number, * Each consumer that returns an `Option` of the item, over items that are each `None` * for an odd byte: its `None` apart from its `Some(None)`. */ -export function consumers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function consumers(data: rt.ByteSlice, out: rt.ByteVec): void { const items: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { const b: rt.u8 = _2; return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); @@ -352,8 +350,7 @@ export function consumers(dataData: Uint8Array, dataStart: number, dataLen: numb * `Option<()>`: its `None` ends or skips, where its `Some(None)` is an item. Each count is * of the closure's calls. */ -export function closures(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { let called: rt.u8 = 0; const _6: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const _8: rt.Place = rt.place(() => called, (value) => called = value); @@ -484,8 +481,7 @@ export function closures(dataData: Uint8Array, dataStart: number, dataLen: numbe * then a map keyed by them: an empty collection's and an out-of-range `None` apart from a * `Some(None)`. The first byte is also the index. */ -export function elements(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { const _8: (a0: rt.Place) => undefined = (o8: rt.Place): undefined => { o8.v = option_mapOr$06rr3sb(o8.v, 66, (_2: rt.u8): rt.u8 | undefined => { return undefined; @@ -703,8 +699,8 @@ export function elements(dataData: Uint8Array, dataStart: number, dataLen: numbe weak[Symbol.dispose](); } -export function panics(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function panics(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const b of rt.byteSliceView(data)) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.optionExpect(pick(b), "picked none", rt.None), 225)); rt.byteVecPush(out, code(rt.optionUnwrap(pick(b), rt.None))); rt.optionUnwrap(unit(b ^ 1), rt.None); @@ -719,27 +715,27 @@ export function half(b: rt.u8): rt.u8 { } /** Each of `data` through `f`, read from its parameter: a function item too. */ -export function each$u8_nested_half(dataData: Uint8Array, dataStart: number, dataLen: number, _: (a0: rt.u8) => rt.u8): rt.ByteVec { - return rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), half), undefined, true); +export function each$u8_nested_half(data: rt.ByteSlice, _: (a0: rt.u8) => rt.u8): rt.ByteVec { + return rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), half), undefined, true); } /** Each of `data` through `f`, read from its parameter: a function item too. */ -export function each$unit_nested_ignore(dataData: Uint8Array, dataStart: number, dataLen: number, _: (a0: rt.u8) => undefined): undefined[] { - return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), ignore as (a0: rt.u8) => undefined), undefined, 0, true); +export function each$unit_nested_ignore(data: rt.ByteSlice, _: (a0: rt.u8) => undefined): undefined[] { + return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), ignore as (a0: rt.u8) => undefined), undefined, 0, true); } /** Each of `data` through `f`, read from its parameter: a function item too. */ -export function each$unit_nested_units_closure3(dataData: Uint8Array, dataStart: number, dataLen: number, f: (a0: rt.u8) => undefined): undefined[] { - return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), f), undefined, 0, true); +export function each$unit_nested_units_closure3(data: rt.ByteSlice, f: (a0: rt.u8) => undefined): undefined[] { + return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), f), undefined, 0, true); } /** Each of `data` through a pointer. */ -export function pointed(dataData: Uint8Array, dataStart: number, dataLen: number, f: (a0: rt.u8) => undefined): undefined[] { - return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), f), undefined, 0, true); +export function pointed(data: rt.ByteSlice, f: (a0: rt.u8) => undefined): undefined[] { + return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), f), undefined, 0, true); } -export function madeAll$nested_Unit(m: nested_Unit.Unit, dataData: Uint8Array, dataStart: number, dataLen: number): undefined[] { - return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): undefined => { +export function madeAll$nested_Unit(m: nested_Unit.Unit, data: rt.ByteSlice): undefined[] { + return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => { nested_Unit.made$nested_Made(m, _2); }), undefined, 0, true); } @@ -748,9 +744,8 @@ export function madeAll$nested_Unit(m: nested_Unit.Unit, dataData: Uint8Array, d * The `()` results of closures, functions, pointers, a `dyn Fn`, and a method returning an * associated type, as the items of a `Vec`, a `VecDeque`, an `Option`, and a `Result`. */ -export function units(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function units(data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.u8) => undefined; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const units: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => {}), undefined, 0, true); const _7: rt.Iter = rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}); const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _7, undefined, 0, true); @@ -765,11 +760,11 @@ export function units(dataData: Uint8Array, dataStart: number, dataLen: number, } f = (_24: rt.u8): undefined => {}; } - const byPointer: undefined[] = pointed(data.data, data.start, data.length, f); - const generic: undefined[] = each$unit_nested_units_closure3(data.data, data.start, data.length, (_25: rt.u8): undefined => {}); - const byName: undefined[] = each$unit_nested_ignore(data.data, data.start, data.length, ignore as (a0: rt.u8) => undefined); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(each$u8_nested_half(data.data, data.start, data.length, half))), undefined, true); - const methods: undefined[] = madeAll$nested_Unit({}, data.data, data.start, data.length); + const byPointer: undefined[] = pointed(data, f); + const generic: undefined[] = each$unit_nested_units_closure3(data, (_25: rt.u8): undefined => {}); + const byName: undefined[] = each$unit_nested_ignore(data, ignore as (a0: rt.u8) => undefined); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(each$u8_nested_half(data, half))), undefined, true); + const methods: undefined[] = madeAll$nested_Unit({}, data); const dynamic: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), rt.lent(ignore as (a0: rt.u8) => undefined)), undefined, 0, true); const iter: rt.Iter = rt.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); while (true) { diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index cc47862b4..dd236aa1c 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -218,9 +218,8 @@ export function counts(out: rt.ByteVec, arcs: rt.Arc[], items: rt.Arc = new rt.Arc(by); const two: rt.Arc = new rt.Arc(rt.u8WrappingAdd(by, 1)); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index ad62af82d..c9074b7fe 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -38,16 +38,16 @@ export function item(tag: rt.usize, key: rt.u8): orders_Item.Item { } /** Run one case. */ -export function orders(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function orders(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _5: rt.u8 = rt.u8Rem(kind, 4); if (_5 === 0) { - cmps(dataData, dataStart, dataLen, out); + cmps(data.data, data.start, data.length, out); } else if (_5 === 1) { - sorted(dataData, dataStart, dataLen, out); + sorted(data, out); } else if (_5 === 2) { - heaps(dataData, dataStart, dataLen, out); + heaps(data, out); } else { - values(dataData, dataStart, dataLen, out); + values(data, out); } flush(out); } @@ -126,8 +126,7 @@ export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, o * The `is_sorted` family of slices and iterators of items, bytes, and strings, as given * and sorted: each test std makes, and each item or key it drops. */ -export function sorted(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { const _77: () => orders_Item.Item = (): orders_Item.Item => { return item(200, 0); }; @@ -238,8 +237,7 @@ export function sorted(dataData: Uint8Array, dataStart: number, dataLen: number, * A heap of items changed by each pair of bytes, an operation and its operand: each * comparison its sifts make, which of equal items it gives back, and when each drops. */ -export function heaps(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { let _127: boolean = false; let _128: boolean = false; let heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; @@ -380,8 +378,7 @@ export function heaps(dataData: Uint8Array, dataStart: number, dataLen: number, * Heaps of values with no comparison of their own: bytes, a min-heap of them, strings, * and tuples, built every way, and their vectors, slices, clones, and debug form. */ -export function values(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteSliceToByteVec(data))), rt.le, rt.ge, rt.lt); rt.heapPush(bytes, data.length & 0xff, rt.le); rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes.d)))), undefined, true); @@ -457,8 +454,7 @@ export function values(dataData: Uint8Array, dataStart: number, dataLen: number, * orders them, by their bytes and then by length: directly, through `Ord`'s defaults, as * keys and items, and in tuples, owned and borrowed. */ -export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { const iter: rt.Iter = rt.byteSliceWindows(data, 2); while (true) { const _6: rt.ByteSlice | rt.Done = iter.next(); @@ -593,8 +589,7 @@ export function part(tag: rt.usize, key: rt.u8): Part.Part { * `min`, `clamp`, and their `_by` forms, and as `sort_by` orders them, whose comparisons * are the runtime's own. */ -export function tuples(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function tuples(data: rt.ByteSlice, out: rt.ByteVec): void { const _3: (a0: rt.u8) => rt.f64 = (b: rt.u8): rt.f64 => { if (!(rt.u8Rem(b, 5) === 0)) { return rt.u8Rem(b, 4) as rt.f64; @@ -868,10 +863,9 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, * ring buffer wraps: of parts, which log where std stops, and of floats, whose NaN orders * as nothing. Then each as a B-tree key. */ -export function held(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function held(data: rt.ByteSlice, out: rt.ByteVec): void { let _342!: Uint8Array; let key!: rt.Result, rt.Poll>; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.usize, a1: rt.u8) => rt.Result = (i5: rt.usize, b2: rt.u8): rt.Result => { if ((b2 & 128) === 0) { return rt.Ok(part(i5, b2)); @@ -1123,8 +1117,7 @@ export function torn(tag: rt.usize, key: rt.u8, mode: rt.u8): Torn.Torn { * the set operators, which build as `collect` does from what they yield, of sets that * `insert` built. Then zero-sized keys, which std's sort leaves as they are. */ -export function btrees(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const mode: rt.u8 = rt.u8Rem(kind, 5); const keys: (a0: rt.ByteSlice) => Torn.Torn[] = (bytes: rt.ByteSlice): Torn.Torn[] => { return rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(bytes))), (_2: [rt.usize, rt.u8]): Torn.Torn => { diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index 7d6fb112b..b0b06adc2 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -167,7 +167,7 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, * Pointers to numbers, to a field, and to a whole struct: read, written, swapped, * replaced, compared, and null. */ -export function places(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function places(data: rt.ByteSlice, out: rt.ByteVec): void { let _29!: rt.Place; let _42!: rt.u8; let x: rt.u32 = 0; @@ -178,7 +178,7 @@ export function places(dataData: Uint8Array, dataStart: number, dataLen: number, const pa: rt.Place = rt.place(() => pair.a, (value3) => pair.a = value3); const pp: pointers_Pair.Pair = pair; let held: rt.Place = rt.NULL; - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const v: rt.u32 = byte as rt.u32; const _19: rt.u8 = rt.u8Rem(byte, 9); if (_19 === 0) { @@ -226,7 +226,7 @@ export function places(dataData: Uint8Array, dataStart: number, dataLen: number, * Unchecked indexing, a boxed number behind a pointer, a `MaybeUninit` number, and a * value dropped in place. */ -export function unchecked(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function unchecked(data: rt.ByteSlice, out: rt.ByteVec): void { const counts: rt.u32[] = Array.from({ length: 4 }, (): rt.u32 => { return 0; }); @@ -237,7 +237,7 @@ export function unchecked(dataData: Uint8Array, dataStart: number, dataLen: numb uninit; const held: rt.Arc = new rt.Arc(0); const dropped: rt.Arc = rt.arcClone(held); - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const at: rt.usize = rt.u8Rem(byte, 4) as rt.usize; const _23: rt.u32[] = counts; const at2 = rt.idx(_23, at); @@ -261,7 +261,7 @@ export function unchecked(dataData: Uint8Array, dataStart: number, dataLen: numb * Pointers to the parts of a struct kept as objects: initialized one by one from nothing, * written through the struct's pointer and their own, and read out before a write. */ -export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function nested(data: rt.ByteSlice, out: rt.ByteVec): void { const slot: Outer.Outer = ({ inner: { a: undefined, b: undefined }, pair: [undefined, undefined], n: undefined } as unknown) as Outer.Outer; const p: Outer.Outer = slot; const _8: [Inner.Inner, [rt.u32, rt.u32]] = [p.inner, p.pair]; @@ -270,7 +270,7 @@ export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, rt.ptrWrite(inner, { a: 1, b: 2 }); rt.ptrWrite(pair, [3, 4] as [rt.u32, rt.u32]); p.n = 5; - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const v: rt.u32 = byte as rt.u32; const _25: rt.u8 = rt.u8Rem(byte, 6); if (_25 === 0) { @@ -301,8 +301,8 @@ export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, * Copies of a `MaybeUninit` and of a union holding arrays, each changed after, and values * read out through pointers before what they point at changes. */ -export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const _5 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const _5 of rt.byteSliceView(data)) { const v: rt.u32 = _5 as rt.u32; const x: rt.u32[] = copy$mem_MaybeUninit_array_u32(Array.from({ length: 4 }, (): rt.u32 => { return v; @@ -347,10 +347,10 @@ export function snapshot(v: rt.u32): [rt.u8, rt.u8] { * `as_ref`, and `()` written through a dangling pointer; and values of no bytes read * through dangling pointers. */ -export function sentinels(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function sentinels(data: rt.ByteSlice, out: rt.ByteVec): void { let p!: rt.Place; let _19!: rt.u8; - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { let some: rt.u32 | undefined = filter$0tnmmii(byte as rt.u32, (v: rt.u32): boolean => { return rt.u32Rem(v, 2) === 0; }); @@ -383,13 +383,13 @@ export function sentinels(dataData: Uint8Array, dataStart: number, dataLen: numb * through `get` and `get_mut`, read through another `get` and before a write, assigned * through `get`, which drops what each held, replaced whole, and their values taken out. */ -export function cells(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { const count: rt.Arc = new rt.Arc(undefined); let num: rt.Cell = new rt.Cell(4294967295 - 1); const pair: rt.Cell = new rt.Cell({ _0: 0, _1: 255 }); let text: rt.Cell = new rt.Cell(""); const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new pointers_Held.Held(0, rt.arcClone(count))); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(op, 8); const _23: rt.u8 = rt.u8Rem(op, 8); if (_23 === 0) { @@ -495,8 +495,8 @@ export function renewNum(cell: rt.Cell, value: rt.u32): rt.u32 { * one to a part a `&mut` given as `mem::replace`'s value borrows, which it leaves be; * and one through a reference `mem::replace` pointed elsewhere first. */ -export function rebound(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function rebound(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(n, 7); if (_10 === 0) { rt.iterExtendBytes(out, rt.iterSlice(replacedBefore(n)), undefined, true); @@ -622,12 +622,12 @@ export function pointerOf(d: Duo.Duo): Duo.Duo { * iteration of a loop that assigns the variable after, one an arm makes where another * arm replaces its variable, and ones nested loops make. */ -export function lapsed(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { let _54!: rt.u8; let pair: Duo.Duo = { _0: 0, _1: 255 }; let log: Log.Log = { bytes: new rt.ByteVec() }; let window: Uint8Array = rt.bytes(3); - for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const n of rt.byteSliceView(data)) { const p: Duo.Duo = pair; p._0 = rt.u8WrappingAdd(p._0, n); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(p._0, p._1)), undefined, true); @@ -690,9 +690,9 @@ export function resetter$pointers_ByClosure(slot: ByClosure.ByClosure): () => un * Each byte a copy of one of them, the original written whole after by its generic body, * and both put. Each is a function of its own, as a loop assigns its variables again. */ -export function writers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function writers(data: rt.ByteSlice, out: rt.ByteVec): void { let _12!: Uint8Array; - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(byte, 3); const _13: rt.u8 = rt.u8Rem(byte, 3); if (_13 === 0) { @@ -741,8 +741,8 @@ export function nudge(g: pointers_Gauge.Gauge, n: rt.u8): void { * `MaybeUninit::as_mut_ptr` and `as_ptr`. Each is a function of its own, as a loop assigns * its variables again. */ -export function made(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const _5 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function made(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const _5 of rt.byteSliceView(data)) { rt.iterExtendBytes(out, rt.iterSlice(madeParts(_5)), undefined, true); } } @@ -764,10 +764,10 @@ export function madeParts(n: rt.u8): Uint8Array { * Entries pushed into segments of slots that each fill whole first, read back, and * changed in place through the pointer each slot's cell lends. */ -export function segments(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { const log: Segment.Segment[] = []; let len: rt.usize = 0; - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const _12: rt.u8 = rt.u8Rem(byte, 4); if (_12 === 0) { if (!(rt.usizeRem(len, 8) === 0)) { @@ -819,9 +819,8 @@ export function segments(dataData: Uint8Array, dataStart: number, dataLen: numbe * A `MaybeUninit` array and a `MaybeUninit` variable, each slot written whole before any * pointer into it is taken, then changed through pointers to a part of each and read back. */ -export function uninitRuns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function uninitRuns(data: rt.ByteSlice, out: rt.ByteVec): void { let _7!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const runs: pointers_Run.Run[] = Array.from({ length: 3 }, (): pointers_Run.Run => { return ({ span: [undefined, undefined], n: undefined } as unknown) as pointers_Run.Run; }); @@ -864,8 +863,7 @@ export function uninitRuns(dataData: Uint8Array, dataStart: number, dataLen: num * `chunks_exact_mut`, and a `zip` with an index range; then changed through pointers to * a part of each and read back. */ -export function iteratedRuns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function iteratedRuns(data: rt.ByteSlice, out: rt.ByteVec): void { const byte: (a0: rt.usize) => rt.u8 = (at3: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, at3), 0); }; @@ -964,10 +962,10 @@ export function stableCell(stable: Stable.Stable): rt.Place { * A pointer to a cell beside a field a generic body writes whole, which leaves the cell's * struct be. */ -export function besideWritten(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function besideWritten(data: rt.ByteSlice, out: rt.ByteVec): void { const pair: [rt.u16, Stable.Stable] = [0, { _0: new rt.Cell(0) }]; const cell: rt.Place = stableCell(pair[1]); - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { firstSet$u16(pair, byte as rt.u16); cell.v = rt.u8WrappingAdd(cell.v, byte); rt.byteVecPush(out, cell.v ^ (pair[0] & 0xff)); @@ -986,12 +984,12 @@ export function slotOf(waiter: Waiter.Waiter): [rt.u8, rt.u8] { * Waiters linked and unlinked, each changed and read through the pointer into its cell * taken when it was made, which nothing writing a waiter whole leaves stale. */ -export function waiters(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function waiters(data: rt.ByteSlice, out: rt.ByteVec): void { let _80!: rt.usize; const nodes: Waiter.Waiter[] = [waiter(0), waiter(1), waiter(2), waiter(3)]; const slots: [rt.u8, rt.u8][] = [slotOf(nodes[0]), slotOf(nodes[1]), slotOf(nodes[2]), slotOf(nodes[3])]; const list: Waiters.Waiters = { head: new rt.Atomic(rt.NULL), last: rt.NULL }; - for (const byte of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const byte of rt.byteSliceView(data)) { const at: rt.usize = rt.usizeRem(byte >> 2 as rt.usize, 4); const _42: rt.u8 = rt.u8Rem(byte, 4); if (_42 === 0) { @@ -1042,8 +1040,8 @@ export function waiters(dataData: Uint8Array, dataStart: number, dataLen: number * points at another variable, whose first is assigned after, and ones a callee gives back * only as a reference, through a borrow a closure keeps. */ -export function taken(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(n, 4); if (_10 === 0) { rt.iterExtendBytes(out, rt.iterSlice(readBefore(n)), undefined, true); @@ -1126,24 +1124,13 @@ export function viewed(n: rt.u8): Uint8Array { * `UnsafeCell`, and `AtomicPtr` make and take them. Pointers to one array are equal however they were made, and to arrays of equal * bytes, or to parts at other offsets, are not. */ -export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(data)) { const a: Uint8Array = Uint8Array.of(n, n ^ 1, n ^ 2, n ^ 3); const b: Uint8Array = copy$array_u8(a); const fromRef: rt.ByteSlice = rt.byteSliceFrom(a); const fromRaw: rt.ByteSlice = rt.byteSliceFrom(a); - const _19: rt.u8 = rt.byteSliceSame(fromRef, rt.byteSliceFrom(a)) ? 1 : 0; - const _23: rt.u8 = rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0; - const _25: rt.u8 = rt.byteSliceSame(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0; - const _31: rt.u8 = rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0; - const _33: rt.u8 = !rt.byteSliceSame(fromRef, rt.byteSliceFrom(b)) ? 1 : 0; - const _36: rt.u8 = rt.byteSliceSame(fromRef, rt.NULL) ? 1 : 0; - const _41: rt.ByteSlice = rt.byteSliceFrom(a); - const _43: rt.ByteSlice = rt.byteSliceFrom(a); - const _39: rt.u8 = sameBytes(_41, _43.data, _43.start, _43.length) ? 1 : 0; - const _46: rt.ByteSlice = rt.byteSliceFrom(a); - const _48: rt.ByteSlice = rt.byteSliceFrom(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_19, _23, _25, _31, _33, _36, _39, sameBytes(_46, _48.data, _48.start, _48.length) ? 1 : 0)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.byteSliceSame(fromRef, rt.byteSliceFrom(a)) ? 1 : 0, rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0, rt.byteSliceSame(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0, rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0, !rt.byteSliceSame(fromRef, rt.byteSliceFrom(b)) ? 1 : 0, rt.byteSliceSame(fromRef, rt.NULL) ? 1 : 0, sameBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(a)) ? 1 : 0, sameBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(held(n)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(parts(rt.byteSliceFrom(a))), undefined, true); const _55: rt.u8 = rt.u8Rem(n, 4); @@ -1160,8 +1147,8 @@ export function bytes(dataData: Uint8Array, dataStart: number, dataLen: number, } } -export function sameBytes(p: rt.ByteSlice, qData: Uint8Array, qStart: number, qLen: number): boolean { - return rt.byteSliceSame(p, new rt.ByteSlice(qData, qStart, qLen)); +export function sameBytes(p: rt.ByteSlice, q: rt.ByteSlice): boolean { + return rt.byteSliceSame(p, q); } /** @@ -1298,8 +1285,8 @@ export function exchanged(n: rt.u8): Uint8Array { * none of those pointers: each read out over a type parameter, as smallvec's `Drain` * reads its items, and kept past its array's next value. */ -export function loaded(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function loaded(data: rt.ByteSlice, out: rt.ByteVec): void { + for (const n of rt.byteSliceView(data)) { let pair: Loaded.Loaded[] = [{ _0: n, _1: 1 }, { _0: 2, _1: ~n & 0xff }]; const first: Loaded.Loaded = option_unwrapOr$0mkoact(nextRead$pointers_Loaded(rt.iterSlice(pair)), { _0: 0, _1: 0 }); pair = [{ _0: first._1, _1: n ^ 90 }, { _0: first._0, _1: n }]; @@ -1319,14 +1306,14 @@ export function nextRead$pointers_Loaded(items: rt.Iter): Loaded. * read, as zlib's stream takes its window each round, by a callee over a type parameter: * one into an array and one into a struct. */ -export function reattached(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function reattached(data: rt.ByteSlice, out: rt.ByteVec): void { const window: pointers_Window.Window = { at: rt.NULL }; let buf: rt.u16[] = Array.from({ length: 4 }, (): rt.u16 => { return 0; }); const slot: pointers_Slot.Slot = { at: rt.NULL }; let pair: Reattached.Reattached = { _0: 0, _1: 0 }; - for (const n of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const n of rt.byteSliceView(data)) { const _17: rt.u16[] = buf; attach$array4_u16(rt.place(() => window.at, (value) => window.at = value), _17); const _18: rt.u16 = (((n as rt.u16)) << 7) & 0xffff; diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index b9402c9a1..132d76a47 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -62,9 +62,9 @@ export function rename(name: rt.Place, b: rt.u8): string | u } /** A `&mut Option` passed on from inside a closure std calls. */ -export function largestOf(seen: rt.Place, itemsData: Uint8Array, itemsStart: number, itemsLen: number): rt.u8 { +export function largestOf(seen: rt.Place, items: rt.ByteSlice): rt.u8 { let taken: rt.u8 = 0; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(itemsData, itemsStart, itemsLen))), (_2: rt.u8): undefined => { + rt.iterForEach(rt.iterSlice(rt.byteSliceView(items)), (_2: rt.u8): undefined => { if (takeLargest(seen, _2) !== undefined) { taken = rt.u8WrappingAdd(taken, 1); } @@ -123,9 +123,9 @@ export function pushTo(s: rt.Place, c: rt.char): void { } } -export function skip(remaining: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): rt.usize { +export function skip(remaining: rt.Place, data: rt.ByteSlice): rt.usize { let skipped: rt.usize = 0; - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _6: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -167,9 +167,8 @@ export function fill(seen: rt.Place, s: rt.Place, nex return rt.u8WrappingAdd(option_unwrapOr$0r2bmpr(seen.v, 238), rt.stringLen(s.v) & 0xff); } -export function refs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { let _170!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _117: (a0: rt.u8 | undefined | rt.None) => rt.u8 = (o: rt.u8 | undefined | rt.None): rt.u8 => { return option_mapOr$1xztl8h(o, 221, (o2: rt.u8 | undefined): rt.u8 => { return option_unwrapOr$0r2bmpr(o2, 238); @@ -220,7 +219,7 @@ export function refs(dataData: Uint8Array, dataStart: number, dataLen: number, o shiftWide(rt.place(() => wide, (value4) => wide = value4), by); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(wide))); let seen: rt.u8 | undefined = undefined; - rt.byteVecPush(out, largestOf(rt.place(() => seen, (value5) => seen = value5), data.data, data.start, data.length)); + rt.byteVecPush(out, largestOf(rt.place(() => seen, (value5) => seen = value5), data)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(seen, 238)); let slot: rt.u8 | undefined = by; if (slot !== undefined) { @@ -290,7 +289,7 @@ export function refs(dataData: Uint8Array, dataStart: number, dataLen: number, o rt.byteVecPush(out, sum); rt.byteVecPush(out, at & 0xff); let remaining: rt.usize = rt.u8Rem(by, 5) as rt.usize; - rt.byteVecPush(out, skip(rt.place(() => remaining, (value16) => remaining = value16), data.data, data.start, data.length) & 0xff); + rt.byteVecPush(out, skip(rt.place(() => remaining, (value16) => remaining = value16), data) & 0xff); rt.byteVecPush(out, remaining & 0xff); const _214: [refs_Pair.Pair, refs_Pair.Pair] = [{ n: 1 }, { n: 2 }]; const a: refs_Pair.Pair = _214[0]; @@ -340,16 +339,15 @@ export function refs(dataData: Uint8Array, dataStart: number, dataLen: number, o const _314: rt.u8 = total & 0xff; derefBox(rt.place(() => boxed2, (value21) => boxed2 = value21), _314); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(boxed2, 238)); - lent(data.data, data.start, data.length, out); + lent(data, out); } /** * What std lends of an `Option` a `&mut` borrows: its payload, written through in place, * passed on, and kept. */ -export function lent(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { let at!: rt.Place; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let seen: rt.u32 | undefined = undefined; let last = undefined as [rt.u8, rt.u8] | undefined; let text = undefined as string | undefined; @@ -486,16 +484,16 @@ export function lent(dataData: Uint8Array, dataStart: number, dataLen: number, o } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(_154, 61166)))); } - defaulted(data.data, data.start, data.length, out); - taken(data.data, data.start, data.length, out); - elements(data.data, data.start, data.length, out); - kept(data.data, data.start, data.length, out); + defaulted(data, out); + taken(data, out); + elements(data, out); + kept(data, out); } /** Filled in place by its default, through a `&mut` and from a closure, then reset. */ -export function defaulted(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function defaulted(data: rt.ByteSlice, out: rt.ByteVec): void { let listing: Listing.Listing | undefined = undefined; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const _11: rt.u8 = rt.u8Rem(b, 5); if (_11 === 0) { listing = undefined; @@ -555,13 +553,12 @@ export function restock(listing: Listing.Listing, b: rt.u8): rt.ByteVec | undefi * moq-net's front: a `Vec` a closure captured by reference, taken, replaced, and * refilled on each call, read after by the caller. */ -export function taken(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { let held: rt.ByteVec = rt.byteSliceToByteVec(data); let wide: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return rt.u32Mul(_2 as rt.u32, 1000); }), undefined, 4, true); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(poll$taken_refs_taken_closure1(data.data, data.start, data.length, (b4: rt.u8): boolean => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(poll$taken_refs_taken_closure1(data, (b4: rt.u8): boolean => { const taken = held; held = new rt.ByteVec(); for (const x of rt.byteVecView(taken)) { @@ -617,8 +614,8 @@ export function taken(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); } -export function poll$taken_refs_taken_closure1(dataData: Uint8Array, dataStart: number, dataLen: number, f: (a0: rt.u8) => boolean): rt.usize { - return rt.iterCount(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): boolean => { +export function poll$taken_refs_taken_closure1(data: rt.ByteSlice, f: (a0: rt.u8) => boolean): rt.usize { + return rt.iterCount(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): boolean => { return !f(_2); })); } @@ -627,9 +624,8 @@ export function poll$taken_refs_taken_closure1(dataData: Uint8Array, dataStart: * What std lends of the elements and values of slices and collections, which JS copies: * one, each in turn, or each to a closure. */ -export function elements(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { let _326!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const v: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; }), undefined, 4, true); @@ -852,7 +848,7 @@ export function elements(dataData: Uint8Array, dataStart: number, dataLen: numbe _326 = nested; } rt.byteVecPush(out, _326); - const iter19: rt.Iter = rt.iterSlice([seenOf(data.data, data.start, data.length), undefined]); + const iter19: rt.Iter = rt.iterSlice([seenOf(data), undefined]); while (true) { const _335: rt.u8 | undefined | rt.Done = iter19.next(); if (_335 === rt.DONE) { @@ -870,7 +866,7 @@ export function elements(dataData: Uint8Array, dataStart: number, dataLen: numbe rt.byteVecPush(out, rt.iterCount(rt.iterOption(rt.optionAsMut(rt.place(() => o2, (value5) => o2 = value5)))) & 0xff); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(o2, 238)); } - const iter21: rt.Iter<[rt.u8, rt.u8] | undefined> = rt.iterSlice([copy$Option_tuple2_u8_u8(option_map$1fmzefe(seenOf(data.data, data.start, data.length), (b9: rt.u8): [rt.u8, rt.u8] => { + const iter21: rt.Iter<[rt.u8, rt.u8] | undefined> = rt.iterSlice([copy$Option_tuple2_u8_u8(option_map$1fmzefe(seenOf(data), (b9: rt.u8): [rt.u8, rt.u8] => { return [b9, 1] as [rt.u8, rt.u8]; })), undefined]); while (true) { @@ -892,7 +888,7 @@ export function elements(dataData: Uint8Array, dataStart: number, dataLen: numbe return p[0]; })); } - let n: rt.u8 = option_unwrapOr$0r2bmpr(seenOf(data.data, data.start, data.length), 0); + let n: rt.u8 = option_unwrapOr$0r2bmpr(seenOf(data), 0); const iter23: rt.Iter | undefined> = rt.iterSlice([rt.place(() => n, (value8) => n = value8), undefined]); while (true) { const _391: rt.Place | undefined | rt.Done = iter23.next(); @@ -903,7 +899,7 @@ export function elements(dataData: Uint8Array, dataStart: number, dataLen: numbe rt.byteVecPush(out, rt.iterCount(rt.iterOption(rt.optionAsMut(rt.place(() => o6, (value9) => o6 = value9)))) & 0xff); } rt.byteVecPush(out, n); - let _406: rt.u8 | undefined = seenOf(data.data, data.start, data.length); + let _406: rt.u8 | undefined = seenOf(data); const iter24: rt.Iter> = rt.iterOption(_406 === undefined ? undefined : rt.place(() => _406 as rt.u8, (value10) => _406 = value10)); while (true) { const _408: rt.Place | rt.Done = iter24.next(); @@ -1057,8 +1053,7 @@ export function elements(dataData: Uint8Array, dataStart: number, dataLen: numbe * References kept in a tuple, read after the index or reference they were borrowed * through changes: each part reads what it borrowed when the tuple was made. */ -export function kept(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function kept(data: rt.ByteSlice, out: rt.ByteVec): void { const by: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 4); const v: Uint8Array = Uint8Array.of(1, 2, 3, 4); const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(v))), rt.iterSlice(rt.byteSliceView(data)), [false, false]); @@ -1096,8 +1091,8 @@ export function kept(dataData: Uint8Array, dataStart: number, dataLen: number, o rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_73, v[_77], r.pair.n, held.at.pair.n))); } -export function seenOf(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { - return rt.byteSliceGet(new rt.ByteSlice(dataData, dataStart, dataLen), 2); +export function seenOf(data: rt.ByteSlice): rt.u8 | undefined { + return rt.byteSliceGet(data, 2); } export function bumpSlot(c: rt.Place, b: rt.u8): void { @@ -1150,22 +1145,22 @@ export function total$refs_Tally_mut_u32(self: rt.Place): rt.u32 { return total$refs_Tally_u32(self.v); } -export function tallyAll$mut_mut_u32(t: rt.Place>>, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 { - for (const _5 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function tallyAll$mut_mut_u32(t: rt.Place>>, data: rt.ByteSlice): rt.u32 { + for (const _5 of rt.byteSliceView(data)) { tally$refs_Tally_mut_mut_u32(t, _5); } return total$refs_Tally_mut_mut_mut_u32(t); } -export function tallyAll$mut_refs_Pair(t: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 { - for (const _5 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function tallyAll$mut_refs_Pair(t: rt.Place, data: rt.ByteSlice): rt.u32 { + for (const _5 of rt.byteSliceView(data)) { refs_Pair.tally$refs_Tally_mut(t, _5); } return refs_Pair.total$refs_Tally_mut_mut(t); } -export function tallyAll$mut_u32(t: rt.Place>, dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 { - for (const _5 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { +export function tallyAll$mut_u32(t: rt.Place>, data: rt.ByteSlice): rt.u32 { + for (const _5 of rt.byteSliceView(data)) { tally$refs_Tally_mut_u32(t, _5); } return total$refs_Tally_mut_mut_u32(t); @@ -1241,12 +1236,11 @@ export function callOnce$mut_refs_to_refs_closure3(f: (a0: rt.u8) => rt.u8): rt. * A `&mut` to a reference: replaced, read, and written through, held, passed on, swapped, * and through an impl that forwards a trait through `&mut T`. */ -export function toRefs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - if (dataLen >= 1) { - const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const n: rt.usize = dataData[dataStart] as rt.usize; - let bytes: rt.ByteSlice = rest; - const _12: rt.usize = rt.usizeRem(n, rt.usizeAdd(rest.length, 2)); +export function toRefs(data: rt.ByteSlice, out: rt.ByteVec): void { + if (data.length >= 1) { + const n: rt.usize = data.data[data.start] as rt.usize; + let bytes: rt.ByteSlice = rt.byteSliceRange(data, 1); + const _12: rt.usize = rt.usizeRem(n, rt.usizeAdd(rt.byteSliceRange(data, 1).length, 2)); rt.byteVecExtendFromSlice(out, takeFront(rt.place(() => bytes, (value) => bytes = value), _12)); rt.byteVecPush(out, bytes.length & 0xff); const reader: Reader.Reader = { rest: rt.place(() => bytes, (value2) => bytes = value2) }; @@ -1265,7 +1259,7 @@ export function toRefs(dataData: Uint8Array, dataStart: number, dataLen: number, } } rt.byteVecPush(out, bytes.length & 0xff); - let tail2: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rest)), (_2: rt.u8): rt.u32 => { + let tail2: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))), (_2: rt.u8): rt.u32 => { return (((_2 as rt.u32)) << 8) >>> 0; }), undefined, 4, true); while (tail2.length >= 1) { @@ -1273,15 +1267,16 @@ export function toRefs(dataData: Uint8Array, dataStart: number, dataLen: number, tail2 = tail2.slice(1, tail2.length - 0); } let text: string = ""; - for (const _59 of rt.byteSliceView(rest)) { + for (const _59 of rt.byteSliceView(rt.byteSliceRange(data, 1))) { text = text + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(_59, 26)) as rt.char); } let s: string = text; const part = rt.min(rt.usizeRem(n, 3), rt.stringLen(s)); s = rt.strSlice(s, part); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - const _85: rt.ByteSlice = rt.byteSliceRange(rest, rt.usizeDiv(rest.length, 2)); - let a: rt.ByteSlice = rest; + const part2 = rt.usizeDiv(rt.byteSliceRange(data, 1).length, 2); + const _85: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceRange(data, 1), part2); + let a: rt.ByteSlice = rt.byteSliceRange(data, 1); let b3: rt.ByteSlice = _85; const swapped = a; a = b3; @@ -1292,7 +1287,7 @@ export function toRefs(dataData: Uint8Array, dataStart: number, dataLen: number, const taken2 = a; a = rt.byteSliceFrom(new Uint8Array(0)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.length & 0xff, taken2.length & 0xff))); - let left: rt.ByteSlice = rest; + let left: rt.ByteSlice = rt.byteSliceRange(data, 1); const skip: (a0: rt.usize) => rt.usize = (n2: rt.usize): rt.usize => { const at: rt.usize = rt.min(n2, left.length); left = rt.byteSliceRange(left, at); @@ -1301,7 +1296,7 @@ export function toRefs(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecPush(out, skip(rt.usizeRem(n, 3)) & 0xff); rt.byteVecPush(out, skip(1) & 0xff); rt.byteVecPush(out, left.length & 0xff); - const pairs: refs_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rest)), (_22: rt.u8): refs_Pair.Pair => { + const pairs: refs_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))), (_22: rt.u8): refs_Pair.Pair => { return { n: _22 }; }), undefined, 1, true); const first: refs_Pair.Pair = { n: 0 }; @@ -1320,14 +1315,14 @@ export function toRefs(dataData: Uint8Array, dataStart: number, dataLen: number, let count: rt.u32 = 0; const pair: refs_Pair.Pair = { n: 1 }; let _182: rt.Place = rt.place(() => count, (value7) => count = value7); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_u32(rt.place(() => _182, (value8) => _182 = value8), rest.data, rest.start, rest.length)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_u32(rt.place(() => _182, (value8) => _182 = value8), rt.byteSliceRange(data, 1))))); let _189: refs_Pair.Pair = pair; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_refs_Pair(rt.place(() => _189, (value9) => _189 = value9), rest.data, rest.start, rest.length)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_refs_Pair(rt.place(() => _189, (value9) => _189 = value9), rt.byteSliceRange(data, 1))))); let _197: rt.Place = rt.place(() => count, (value10) => count = value10); let _196: rt.Place> = rt.place(() => _197, (value11) => _197 = value11); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_mut_u32(rt.place(() => _196, (value12) => _196 = value12), rest.data, rest.start, rest.length)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_mut_u32(rt.place(() => _196, (value12) => _196 = value12), rt.byteSliceRange(data, 1))))); rt.byteVecPush(out, pair.n); - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(rest)); + const it: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))); rt.byteVecPush(out, nextTwo$mut_iter_Copied_slice_Iter_u8(it)); let _208: rt.Iter = it; rt.byteVecPush(out, nextTwo$mut_mut_iter_Copied_slice_Iter_u8(rt.place(() => _208, (value13) => _208 = value13))); diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts index 0003d8ff8..10ae05232 100644 --- a/ts/fixtures/lang/expected/returns.ts +++ b/ts/fixtures/lang/expected/returns.ts @@ -26,11 +26,9 @@ export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n export const takeOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; /** The same slice type through another function, which shares its slot. */ -export function tail(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { - const _4: boolean = n <= dataLen; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); - const _0: rt.Result = option_okOr$12p77jh(then$0w2ymju(_4, (): rt.ByteSlice => { - return rt.byteSliceRange(captured, n); +export function tail(data: rt.ByteSlice, n: rt.usize): returns_Error.Error | undefined { + const _0: rt.Result = option_okOr$12p77jh(then$0w2ymju(n <= data.length, (): rt.ByteSlice => { + return rt.byteSliceRange(data, n); }), { tag: "Short", _0: n } as returns_Error.Error); if (!_0.ok) { return _0.error; @@ -148,7 +146,7 @@ export function both(dataData: Uint8Array, dataStart: number, dataLen: number): const part8: number = wideOut.p_1Len; if (err2 === undefined) { const b: rt.u64 = part5 as rt.u64; - const err3: returns_Error.Error | undefined = tail(part6, part7, part8, rt.u64Low(rt.u64Rem(a, 3))); + const err3: returns_Error.Error | undefined = tail(new rt.ByteSlice(part6, part7, part8), rt.u64Low(rt.u64Rem(a, 3))); const part9: Uint8Array = takeOut.pData; const part10: number = takeOut.pStart; const part11: number = takeOut.pLen; @@ -177,13 +175,13 @@ export function both(dataData: Uint8Array, dataStart: number, dataLen: number): export const bothOut: { err: unknown; p_1: rt.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; -export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, otherData: Uint8Array, otherStart: number, otherLen: number): rt.u64 | undefined { +export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, other: rt.ByteSlice): rt.u64 | undefined { const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; const part2: Uint8Array = wideOut.p_1Data; const part3: number = wideOut.p_1Start; const part4: number = wideOut.p_1Len; - new Guard.Guard(new rt.ByteSlice(otherData, otherStart, otherLen), dataLen & 0xff)[Symbol.dispose](); + new Guard.Guard(other, dataLen & 0xff)[Symbol.dispose](); if (err !== undefined) { wideOut.err = err as returns_Error.Error; return undefined; @@ -201,8 +199,8 @@ export function unitErr(dataData: Uint8Array, dataStart: number, dataLen: number }), undefined); } -export function noneErr(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result { - const _2: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); +export function noneErr(data: rt.ByteSlice): rt.Result { + const _2: rt.u8 | undefined = rt.byteSliceFirst(data); if (_2 !== undefined) { if (_2 === 0) { return rt.ERR; @@ -211,7 +209,7 @@ export function noneErr(dataData: Uint8Array, dataStart: number, dataLen: number return rt.Err(_2); } } - return option_okOr$0gtm15y(option_map$1yogfym((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return option_okOr$0gtm15y(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { return _22[1]; }), undefined as rt.u8 | undefined); } @@ -266,9 +264,8 @@ export function pushNumber(out: rt.ByteVec, r: rt.Result<[rt.u64, rt.ByteSlice], } } -export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.ByteSlice) => rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); b0: { const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { @@ -282,7 +279,7 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const part62: number = takeOut.pStart; const part63: number = takeOut.pLen; push(out, (err15 !== undefined ? rt.Err(err15 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part61, part62, part63))) as rt.Result); - const err16: returns_Error.Error | undefined = tail(data.data, data.start, data.length, 3); + const err16: returns_Error.Error | undefined = tail(data, 3); const part64: Uint8Array = takeOut.pData; const part65: number = takeOut.pStart; const part66: number = takeOut.pLen; @@ -304,7 +301,7 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const err11 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); return err11 !== undefined ? rt.Err(err11 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); }), undefined, 12, true); - const err12: returns_Error.Error | undefined = tail(data.data, data.start, data.length, 1); + const err12: returns_Error.Error | undefined = tail(data, 1); const part50: Uint8Array = takeOut.pData; const part51: number = takeOut.pStart; const part52: number = takeOut.pLen; @@ -350,7 +347,7 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { return _22[1]; }), (s: rt.ByteSlice): rt.u8 => { - const err10: returns_Error.Error | undefined = tail(s.data, s.start, s.length, 2); + const err10: returns_Error.Error | undefined = tail(s, 2); const part47: Uint8Array = takeOut.pData; const part48: number = takeOut.pStart; const part49: number = takeOut.pLen; @@ -376,14 +373,14 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } const other: Uint8Array = Uint8Array.of(255, 1, 2); const _96: rt.ByteSlice = rt.byteSliceFrom(other); - const part35: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96.data, _96.start, _96.length); + const part35: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96); const err8: returns_Error.Error | undefined = part35 === undefined ? wideOut.err as returns_Error.Error : undefined; const part36: Uint8Array = wideOut.p_1Data; const part37: number = wideOut.p_1Start; const part38: number = wideOut.p_1Len; pushNumber(out, (err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part35 as rt.u64, new rt.ByteSlice(part36, part37, part38)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); - const part39: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100.data, _100.start, _100.length); + const part39: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100); const err9: returns_Error.Error | undefined = part39 === undefined ? wideOut.err as returns_Error.Error : undefined; const part40: Uint8Array = wideOut.p_1Data; const part41: number = wideOut.p_1Start; @@ -396,7 +393,7 @@ export function returns(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } else { rt.byteVecPush(out, 238); } - const _110: rt.Result = noneErr(data.data, data.start, data.length); + const _110: rt.Result = noneErr(data); if (_110.ok) { rt.byteVecPush(out, _110.value.length & 0xff); } else { diff --git a/ts/fixtures/lang/expected/saturates.ts b/ts/fixtures/lang/expected/saturates.ts index 040e79902..26aef8402 100644 --- a/ts/fixtures/lang/expected/saturates.ts +++ b/ts/fixtures/lang/expected/saturates.ts @@ -222,11 +222,10 @@ export function hashed$usize(v: rt.usize): rt.u64 { } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v: rt.u8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u8ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.u8 = (at: rt.usize): rt.u8 => { const buf: Uint8Array = Uint8Array.of(0); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -235,7 +234,7 @@ export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.u8FromBeBytes(buf); }; @@ -421,11 +420,10 @@ export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v: rt.u16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { const buf: Uint8Array = rt.bytes(2); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -434,7 +432,7 @@ export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.u16FromBeBytes(buf); }; @@ -620,11 +618,10 @@ export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v: rt.u32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.u32 = (at: rt.usize): rt.u32 => { const buf: Uint8Array = rt.bytes(4); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -633,7 +630,7 @@ export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.u32FromBeBytes(buf); }; @@ -819,11 +816,10 @@ export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v: rt.u64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.u64 = (at: rt.usize): rt.u64 => { const buf: Uint8Array = rt.bytes(8); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -832,7 +828,7 @@ export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.u64FromBeBytes(buf); }; @@ -1018,11 +1014,10 @@ export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v: rt.u128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.u128 = (at: rt.usize): rt.u128 => { const buf: Uint8Array = rt.bytes(16); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -1031,7 +1026,7 @@ export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.u128FromBeBytes(buf); }; @@ -1217,11 +1212,10 @@ export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v: rt.usize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.usizeToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.usize = (at: rt.usize): rt.usize => { const buf: Uint8Array = rt.bytes(4); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -1230,7 +1224,7 @@ export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.usizeFromBeBytes(buf); }; @@ -1416,11 +1410,10 @@ export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v: rt.i8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i8ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.i8 = (at: rt.usize): rt.i8 => { const buf: Uint8Array = Uint8Array.of(0); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -1429,7 +1422,7 @@ export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.i8FromBeBytes(buf); }; @@ -1611,11 +1604,10 @@ export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v: rt.i16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i16ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.i16 = (at: rt.usize): rt.i16 => { const buf: Uint8Array = rt.bytes(2); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -1624,7 +1616,7 @@ export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.i16FromBeBytes(buf); }; @@ -1806,11 +1798,10 @@ export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v: rt.i32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i32ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.i32 = (at: rt.usize): rt.i32 => { const buf: Uint8Array = rt.bytes(4); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -1819,7 +1810,7 @@ export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.i32FromBeBytes(buf); }; @@ -2001,11 +1992,10 @@ export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v: rt.i64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i64ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.i64 = (at: rt.usize): rt.i64 => { const buf: Uint8Array = rt.bytes(8); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -2014,7 +2004,7 @@ export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.i64FromBeBytes(buf); }; @@ -2196,11 +2186,10 @@ export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v: rt.i128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.i128 = (at: rt.usize): rt.i128 => { const buf: Uint8Array = rt.bytes(16); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -2209,7 +2198,7 @@ export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.i128FromBeBytes(buf); }; @@ -2391,11 +2380,10 @@ export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function isizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _20: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v: rt.isize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.isizeToBeBytes(v))); }; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const take: (a0: rt.usize) => rt.isize = (at: rt.usize): rt.isize => { const buf: Uint8Array = rt.bytes(4); const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); @@ -2404,7 +2392,7 @@ export function isizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_10 === rt.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); } return rt.isizeFromBeBytes(buf); }; diff --git a/ts/fixtures/lang/expected/separated.ts b/ts/fixtures/lang/expected/separated.ts index bd5a272ec..7b6c4c347 100644 --- a/ts/fixtures/lang/expected/separated.ts +++ b/ts/fixtures/lang/expected/separated.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { map$1r7pvtd as option_map$1r7pvtd, map$14orwce as option_map$14orwce, map$02o7iu2 as option_map$02o7iu2, map$0vryjg8 as option_map$0vryjg8, map$13xzfv2 as option_map$13xzfv2, mapOr$0j8cgo8 as option_mapOr$0j8cgo8, mapOr$0wkl4zm as option_mapOr$0wkl4zm, mapOr$15c63lv as option_mapOr$15c63lv, mapOr$1qu2moz as option_mapOr$1qu2moz, mapOr$0eu6gsi as option_mapOr$0eu6gsi, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; +import { map$1r7pvtd as option_map$1r7pvtd, map$14orwce as option_map$14orwce, map$02o7iu2 as option_map$02o7iu2, map$0vryjg8 as option_map$0vryjg8, map$1uuzv15 as option_map$1uuzv15, mapOr$0j8cgo8 as option_mapOr$0j8cgo8, mapOr$0wkl4zm as option_mapOr$0wkl4zm, mapOr$15c63lv as option_mapOr$15c63lv, mapOr$1qu2moz as option_mapOr$1qu2moz, mapOr$18m1ie6 as option_mapOr$18m1ie6, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; import * as Below from "./separated.Below.ts"; import * as separated_Pair from "./separated.Pair.ts"; @@ -23,8 +23,8 @@ export function hint(_1: [rt.usize, rt.usize | undefined], out: rt.ByteVec): voi } /** A sum of a part, which tells parts of different lengths or contents apart. */ -export function sum(partData: Uint8Array, partStart: number, partLen: number): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(partData, partStart, partLen))), partLen & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { +export function sum(part: rt.ByteSlice): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(part)), part.length & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { return rt.u8WrappingAdd(rt.u8WrappingMul(acc, 31), _32); }); } @@ -123,7 +123,7 @@ export function scribblePairs(i: rt.usize, part: separated_Pair.Pair[]): void { * predicate that logs each call, with each bound that makes no, some, or every element a * separator. */ -export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function separated(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _52!: rt.ByteSlice | undefined; let _83!: rt.i32; let p2!: rt.ByteSlice | undefined; @@ -175,7 +175,6 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, let p31!: rt.u16[] | undefined; let _1928!: rt.usize; let p33!: separated_Pair.Pair[] | undefined; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); const steps: rt.u8 = kind >> 3; const iter: rt.Iter = rt.iterSlice([0, 1, 128, 256]); @@ -247,8 +246,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, _52 = rt.iterToOption(it.nextBack()); } if (_52 !== undefined) { - const p: rt.ByteSlice = _52; - rt.byteVecPush(out, sum(p.data, p.start, p.length)); + rt.byteVecPush(out, sum(_52)); hint(it.sizeHint(), out); flush(log, out); } else { @@ -267,29 +265,19 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, } else { p2 = rt.iterToOption(it2.nextBack()); } - rt.byteVecPush(out, option_mapOr$0eu6gsi(p2, 252, (a042: rt.ByteSlice): rt.u8 => { - return sum(a042.data, a042.start, a042.length); - })); + rt.byteVecPush(out, option_mapOr$18m1ie6(p2, 252, sum)); hint(it2.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterNth(rt.byteSliceSplit(data, test), 1), (a043: rt.ByteSlice): rt.u8 => { - return sum(a043.data, a043.start, a043.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNth(rt.byteSliceSplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterNthBack(rt.byteSliceSplit(data, test), 1), (a044: rt.ByteSlice): rt.u8 => { - return sum(a044.data, a044.start, a044.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNthBack(rt.byteSliceSplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterLast(rt.byteSliceSplit(data, test)), (a045: rt.ByteSlice): rt.u8 => { - return sum(a045.data, a045.start, a045.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterLast(rt.byteSliceSplit(data, test)), sum)), undefined, true); flush(log, out); rt.byteVecPush(out, rt.iterCount(rt.byteSliceSplit(data, test)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceSplit(data, test)), 1), (a046: rt.ByteSlice): rt.u8 => { - return sum(a046.data, a046.start, a046.length); - }), "next"); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceSplit(data, test)), 1), sum), "next"); flush(log, out); const iter4: rt.Iter = rt.iterSlice([false, true]); l154: while (true) { @@ -395,31 +383,20 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, let iterStart4: rt.i32 = 0; const iterEnd4: rt.i32 = 4; while ((_360 = iterStart4++) < iterEnd4) { - const _366: rt.ByteSlice = rt.splitAsSlice(it7); const i4: rt.i32 = _360; - rt.byteVecPush(out, sum(_366.data, _366.start, _366.length)); + rt.byteVecPush(out, sum(rt.splitAsSlice(it7))); if (rt.i32Rem(i4, 2) === 0) { - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterToOption(it7.next()), (a058: rt.ByteSlice): rt.u8 => { - return sum(a058.data, a058.start, a058.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it7.next()), sum)), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterToOption(it7.nextBack()), (a057: rt.ByteSlice): rt.u8 => { - return sum(a057.data, a057.start, a057.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it7.nextBack()), sum)), undefined, true); } flush(log, out); } const copy: rt.Iter = it7.clone(); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterToOption(copy.nextBack()), (a059: rt.ByteSlice): rt.u8 => { - return sum(a059.data, a059.start, a059.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterToOption(it7.next()), (a060: rt.ByteSlice): rt.u8 => { - return sum(a060.data, a060.start, a060.length); - })), undefined, true); - const _393: rt.ByteSlice = rt.splitAsSlice(copy); - rt.byteVecPush(out, sum(_393.data, _393.start, _393.length)); - const _397: rt.ByteSlice = rt.splitAsSlice(it7); - rt.byteVecPush(out, sum(_397.data, _397.start, _397.length)); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(copy.nextBack()), sum)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it7.next()), sum)), undefined, true); + rt.byteVecPush(out, sum(rt.splitAsSlice(copy))); + rt.byteVecPush(out, sum(rt.splitAsSlice(it7))); flush(log, out); const it8: rt.Iter = rt.sliceSplit(pairs, testPairs); rt.iterToOption(it8.nextBack()); @@ -443,8 +420,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, _425 = rt.iterToOption(it9.nextBack()); } if (_425 !== undefined) { - const p7: rt.ByteSlice = _425; - rt.byteVecPush(out, sum(p7.data, p7.start, p7.length)); + rt.byteVecPush(out, sum(_425)); hint(it9.sizeHint(), out); flush(log, out); } else { @@ -463,29 +439,19 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, } else { p8 = rt.iterToOption(it10.nextBack()); } - rt.byteVecPush(out, option_mapOr$0eu6gsi(p8, 252, (a017: rt.ByteSlice): rt.u8 => { - return sum(a017.data, a017.start, a017.length); - })); + rt.byteVecPush(out, option_mapOr$18m1ie6(p8, 252, sum)); hint(it10.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterNth(rt.byteSliceRsplit(data, test), 1), (a018: rt.ByteSlice): rt.u8 => { - return sum(a018.data, a018.start, a018.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNth(rt.byteSliceRsplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterNthBack(rt.byteSliceRsplit(data, test), 1), (a019: rt.ByteSlice): rt.u8 => { - return sum(a019.data, a019.start, a019.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNthBack(rt.byteSliceRsplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterLast(rt.byteSliceRsplit(data, test)), (a020: rt.ByteSlice): rt.u8 => { - return sum(a020.data, a020.start, a020.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterLast(rt.byteSliceRsplit(data, test)), sum)), undefined, true); flush(log, out); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRsplit(data, test)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceRsplit(data, test)), 1), (a021: rt.ByteSlice): rt.u8 => { - return sum(a021.data, a021.start, a021.length); - }), "next"); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceRsplit(data, test)), 1), sum), "next"); flush(log, out); const iter11: rt.Iter = rt.iterSlice([false, true]); l119: while (true) { @@ -717,8 +683,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, _971 = rt.iterToOption(it19.nextBack()); } if (_971 !== undefined) { - const p17: rt.ByteSlice = _971; - rt.byteVecPush(out, sum(p17.data, p17.start, p17.length)); + rt.byteVecPush(out, sum(_971)); hint(it19.sizeHint(), out); flush(log, out); } else { @@ -737,29 +702,19 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, } else { p18 = rt.iterToOption(it20.nextBack()); } - rt.byteVecPush(out, option_mapOr$0eu6gsi(p18, 252, (a02: rt.ByteSlice): rt.u8 => { - return sum(a02.data, a02.start, a02.length); - })); + rt.byteVecPush(out, option_mapOr$18m1ie6(p18, 252, sum)); hint(it20.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterNth(rt.byteSliceSplitInclusive(data, test), 1), (a03: rt.ByteSlice): rt.u8 => { - return sum(a03.data, a03.start, a03.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNth(rt.byteSliceSplitInclusive(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterNthBack(rt.byteSliceSplitInclusive(data, test), 1), (a04: rt.ByteSlice): rt.u8 => { - return sum(a04.data, a04.start, a04.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNthBack(rt.byteSliceSplitInclusive(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterLast(rt.byteSliceSplitInclusive(data, test)), (a05: rt.ByteSlice): rt.u8 => { - return sum(a05.data, a05.start, a05.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterLast(rt.byteSliceSplitInclusive(data, test)), sum)), undefined, true); flush(log, out); rt.byteVecPush(out, rt.iterCount(rt.byteSliceSplitInclusive(data, test)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceSplitInclusive(data, test)), 1), (a06: rt.ByteSlice): rt.u8 => { - return sum(a06.data, a06.start, a06.length); - }), "next"); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceSplitInclusive(data, test)), 1), sum), "next"); flush(log, out); const iter21: rt.Iter = rt.iterSlice([false, true]); l98: while (true) { @@ -873,7 +828,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, while (true) { const _1292: rt.ByteSlice | rt.Done = it25.next(); if (_1292 !== rt.DONE) { - rt.byteVecPush(out, sum(_1292.data, _1292.start, _1292.length)); + rt.byteVecPush(out, sum(_1292)); hint(it25.sizeHint(), out); flush(log, out); } else { @@ -894,7 +849,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, while (true) { const _1330: rt.ByteSlice | rt.Done = it26.next(); if (_1330 !== rt.DONE) { - rt.byteVecPush(out, sum(_1330.data, _1330.start, _1330.length)); + rt.byteVecPush(out, sum(_1330)); hint(it26.sizeHint(), out); flush(log, out); } else { @@ -982,8 +937,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(_1489[0], _1489[1]); } flush(log, out); - const _1498: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1498.data, _1498.start, _1498.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const held: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceSplit(rt.byteVecSlice(bytes), test), "next", 8); const iter31: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held))); while (true) { @@ -994,12 +948,10 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(rt.usizeAdd(_1511[0], 7), _1511[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held), (p44: rt.ByteSlice): rt.u8 => { - const _419: rt.ByteSlice = p44; - return sum(_419.data, _419.start, _419.length); + return sum(p44); }), undefined, true); flush(log, out); - const _1527: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1527.data, _1527.start, _1527.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const iter32: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRsplitMut(words, testWords)); while (true) { const _1538: [rt.usize, rt.u16[]] | rt.Done = iter32.next(); @@ -1065,8 +1017,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, } flush(log, out); } - const _1654: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1654.data, _1654.start, _1654.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const it31: rt.Iter = rt.sliceSplitMut(words, testWords); let iterStart19: rt.usize = 0; const iterEnd19: rt.usize = 12; @@ -1113,8 +1064,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(_1723[0], _1723[1]); } flush(log, out); - const _1732: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1732.data, _1732.start, _1732.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const held4: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceSplitInclusive(rt.byteVecSlice(bytes), test), "next", 8); const iter40: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held4))); while (true) { @@ -1125,12 +1075,10 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(rt.usizeAdd(_1745[0], 7), _1745[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held4), (p41: rt.ByteSlice): rt.u8 => { - const _415: rt.ByteSlice = p41; - return sum(_415.data, _415.start, _415.length); + return sum(p41); }), undefined, true); flush(log, out); - const _1761: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1761.data, _1761.start, _1761.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const iter41: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceSplitInclusiveMut(words, testWords)); while (true) { const _1772: [rt.usize, rt.u16[]] | rt.Done = iter41.next(); @@ -1196,8 +1144,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, } flush(log, out); } - const _1888: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1888.data, _1888.start, _1888.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const it34: rt.Iter = rt.sliceSplitInclusiveMut(words, testWords); let iterStart22: rt.usize = 0; const iterEnd22: rt.usize = 12; @@ -1245,8 +1192,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(_1963[0], _1963[1]); } flush(log, out); - const _1972: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_1972.data, _1972.start, _1972.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const held7: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceSplitn(rt.byteVecSlice(bytes), n6, test), "next", 8); const iter49: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held7))); while (true) { @@ -1257,12 +1203,10 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(rt.usizeAdd(_1985[0], 7), _1985[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held7), (p37: rt.ByteSlice): rt.u8 => { - const _47: rt.ByteSlice = p37; - return sum(_47.data, _47.start, _47.length); + return sum(p37); }), undefined, true); flush(log, out); - const _2001: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_2001.data, _2001.start, _2001.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const iter50: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRsplitnMut(words, n6, testWords)); while (true) { const _2012: [rt.usize, rt.u16[]] | rt.Done = iter50.next(); @@ -1320,8 +1264,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(_2110[0], _2110[1]); } flush(log, out); - const _2119: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_2119.data, _2119.start, _2119.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); const held10: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRsplitn(rt.byteVecSlice(bytes), n6, test), "next", 8); const iter55: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held10))); while (true) { @@ -1332,12 +1275,10 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, scribble(rt.usizeAdd(_2132[0], 7), _2132[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held10), (p40: rt.ByteSlice): rt.u8 => { - const _411: rt.ByteSlice = p40; - return sum(_411.data, _411.start, _411.length); + return sum(p40); }), undefined, true); flush(log, out); - const _2148: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_2148.data, _2148.start, _2148.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); } else { const below: (a0: rt.u8) => Below.Below = (tag: rt.u8): Below.Below => { return new Below.Below(tag, bound, log); @@ -1348,9 +1289,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, }, (): void => { captured[Symbol.dispose](); })); - rt.iterExtendBytes(out, rt.iterOption(option_map$13xzfv2(rt.iterToOption(it36.next()), (a0: rt.ByteSlice): rt.u8 => { - return sum(a0.data, a0.start, a0.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it36.next()), sum)), undefined, true); flush(log, out); rt.drop(it36); flush(log, out); @@ -1365,7 +1304,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, if (_2172 === rt.DONE) { break; } - rt.byteVecPush(out, sum(_2172.data, _2172.start, _2172.length)); + rt.byteVecPush(out, sum(_2172)); flush(log, out); } rt.drop(iter56); @@ -1378,8 +1317,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, })), "next", 8); flush(log, out); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(all), (p36: rt.ByteSlice): rt.u8 => { - const _32: rt.ByteSlice = p36; - return sum(_32.data, _32.start, _32.length); + return sum(p36); }), undefined, true); const captured4 = below(227); rt.byteVecPush(out, rt.ownedCount(rt.byteSliceSplitn(data, 2, rt.closure((_215: rt.u8): boolean => { @@ -1405,8 +1343,7 @@ export function separated(kind: rt.u8, dataData: Uint8Array, dataStart: number, } rt.drop(iter57); flush(log, out); - const _2218: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, sum(_2218.data, _2218.start, _2218.length)); + rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); } } } diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index fbf93b744..25348fb65 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -97,11 +97,11 @@ export function shape(dataData: Uint8Array, dataStart: number, dataLen: number): } /** `Copy` aggregates: a copy changes apart from its original. */ -export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { let _265!: Uint8Array; let poll!: rt.Poll; let _300!: rt.u8; - const p: Point.Point = Point.new(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0) as rt.i32, 7); + const p: Point.Point = Point.new(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.i32, 7); const q: Point.Point = copy$shapes_Point(p); q.x = rt.i32Add(q.x, 100); Point.bump(q); @@ -137,12 +137,12 @@ export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, const old2 = a; a = _66; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.x & 0xff, b.x & 0xff, old2.x & 0xff))); - const boxed: Moved.Moved = { _0: dataLen & 0xff, _1: 0 }; + const boxed: Moved.Moved = { _0: data.length & 0xff, _1: 0 }; boxed._1 = rt.u16Add(boxed._1, 1); boxed._1 = rt.u16Add(boxed._1, 2); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed._0))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(boxed._1))); - let n: rt.u32 = dataLen as rt.u32; + let n: rt.u32 = data.length as rt.u32; const both: [rt.u32, rt.u32] = [n, n]; n = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n)))); @@ -150,10 +150,10 @@ export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, let t: string = "cde"; let x: Point.Point = p; let y: Point.Point = q; - const _120: [rt.u8, rt.u8] = [dataLen & 0xff, 1]; + const _120: [rt.u8, rt.u8] = [data.length & 0xff, 1]; let i: rt.u8 = _120[0]; let j: rt.u8 = 1; - const _125: rt.usize = rt.usizeRem(dataLen, 3); + const _125: rt.usize = rt.usizeRem(data.length, 3); let iterStart: rt.usize = 0; const iterEnd: rt.usize = _125; while (iterStart++ < iterEnd) { @@ -174,17 +174,17 @@ export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecPush(out, (x.x & 0xff) ^ i); } rt.byteVecPush(out, (rt.stringLen(t) & 0xff) ^ (y.y & 0xff) ^ j); - const word: Uint8Array = Uint8Array.of(0, 0, 0, dataLen & 0xff); + const word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); const converted: rt.u32 = rt.u32FromBeBytes(word); word[0] = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32)))); - const cell: Uint8Array = Uint8Array.of(dataLen & 0xff); + const cell: Uint8Array = Uint8Array.of(data.length & 0xff); rt.byteVecPush(out, writeThenRead(copy$array_u8(cell), rt.byteSliceFrom(cell))); - const source: Uint8Array = Uint8Array.of(dataLen & 0xff); + const source: Uint8Array = Uint8Array.of(data.length & 0xff); const returned: Uint8Array = same(copy$array_u8(source)); source[0] = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(returned[0], source[0]))); - rt.byteVecPush(out, copyThenWrite([dataLen & 0xff, 0] as [rt.u8, rt.u8])); + rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); const marked: boolean = mark(out, 1) === 0; mark(out, 2); rt.byteVecPush(out, marked ? 1 : 0); @@ -203,7 +203,7 @@ export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, const err: Point.Point = copy$shapes_Point(rt.resultUnwrapErr(fail, rt.u8Debug)); err.y = 3; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Debug).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Debug).y & 0xff))); - const shape_: shapes_Shape.Shape = copy$shapes_Shape(shape(dataData, dataStart, dataLen)); + const shape_: shapes_Shape.Shape = copy$shapes_Shape(shape(data.data, data.start, data.length)); const before: shapes_Shape.Shape = copy$shapes_Shape(shape_); if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { @@ -232,10 +232,10 @@ export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_265)); } - if (rt.usizeRem(dataLen, 2) === 0) { + if (rt.usizeRem(data.length, 2) === 0) { poll = rt.Pending as rt.Poll; } else { - poll = Uint8Array.of(dataLen & 0xff) as rt.Poll; + poll = Uint8Array.of(data.length & 0xff) as rt.Poll; } const polled: rt.Poll = copy$task_Poll_array1_u8(poll); if (poll !== rt.Pending) { @@ -257,8 +257,8 @@ export function copies(dataData: Uint8Array, dataStart: number, dataLen: number, } rt.byteVecPush(out, _300); } - shares(dataData, dataStart, dataLen, out); - unwritten(dataData, dataStart, dataLen, out); + shares(data, out); + unwritten(data.data, data.start, data.length, out); } /** @@ -304,11 +304,10 @@ export function bump(slot: rt.Mutex): void { * `Copy` aggregates holding shared references: a copy has its own values, and shares * what its references point at with the original's. */ -export function shares(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { let res!: rt.Result<[rt.Mutex, rt.u8], rt.u8>; let n!: rt.u8; let flow!: rt.Result>; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); const slot: rt.Mutex = new rt.Mutex(a); const other: rt.Mutex = new rt.Mutex(0); @@ -553,12 +552,11 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { * Aggregates written with their fields out of declaration order evaluate them as * written: each field logs as it runs. */ -export function order(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function order(data: rt.ByteSlice, out: rt.ByteVec): void { let taken!: shapes_Shape.Shape; let _75!: rt.usize; - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i2), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), 0); }; const _5: rt.u16 = mark(out, at(0)) & 0xffff; const _10: rt.u16 = mark(out, at(1)) & 0xffff; @@ -590,8 +588,8 @@ export function order(dataData: Uint8Array, dataStart: number, dataLen: number, while ((_75 = iterStart++) < iterEnd) { sum = rt.usizeAdd(sum, _75); } - const len: rt.usize = dataLen; - const _83: rt.ByteSlice = logged(dataData, dataStart, dataLen, out); + const len: rt.usize = data.length; + const _83: rt.ByteSlice = logged(data, out); const _85: rt.usize = rt.min(mark(out, 14), len); const _87: rt.usize = rt.usizeDiv(rt.min(mark(out, 15), len), 2); const _103: rt.usize = sum; @@ -606,7 +604,7 @@ export function order(dataData: Uint8Array, dataStart: number, dataLen: number, const _143: [rt.usize, rt.usize] = [mark(out, 18), mark(out, 19)]; rt.byteVecPush(out, part & 0xff); rt.byteVecPush(out, _143[0] & 0xff); - indexed(dataData, dataStart, dataLen, out); + indexed(data, out); } /** @@ -614,10 +612,9 @@ export function order(dataData: Uint8Array, dataStart: number, dataLen: number, * evaluate what comes before those first: each logs as it runs, or changes what an * earlier operand read. */ -export function indexed(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const captured = new rt.ByteSlice(dataData, dataStart, dataLen); +export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(captured, i), 0); + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; const _7: rt.ByteVec = listed(out, at(0)); rt.byteVecPush(out, 225); @@ -632,8 +629,7 @@ export function indexed(dataData: Uint8Array, dataStart: number, dataLen: number rt.byteSliceCopyWithin(_30, 2, _30.length, 1); const _36: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); rt.byteSliceCopyWithin(_36, 3, _36.length, 0); - const _42: rt.ByteSlice = rt.byteSliceFrom(bytes); - const _41: rt.ByteSlice = logged(_42.data, _42.start, _42.length, out); + const _41: rt.ByteSlice = logged(rt.byteSliceFrom(bytes), out); rt.byteVecPush(out, 230); rt.idx(_41, 1); const second: rt.u8 = _41.data[_41.start + 1]; @@ -651,11 +647,11 @@ export function indexed(dataData: Uint8Array, dataStart: number, dataLen: number 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 mid: number = rt.usizeDiv(dataLen, 2); - if (mid > dataLen) { + const mid: number = rt.usizeDiv(data.length, 2); + if (mid > data.length) { rt.panic("mid > len"); } - ends([new rt.ByteSlice(dataData, dataStart, mid), new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid)], out); + 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]; @@ -694,9 +690,9 @@ export function twice(b: rt.u8): rt.u8 { } /** `data`, logging that it was read. */ -export function logged(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): rt.ByteSlice { +export function logged(data: rt.ByteSlice, out: rt.ByteVec): rt.ByteSlice { rt.byteVecPush(out, 238); - return new rt.ByteSlice(dataData, dataStart, dataLen); + return data; } /** `n`'s byte, incremented. */ @@ -713,10 +709,10 @@ export function reset(m: Moved.Moved): rt.u16 { } /** Fieldless enums cast to every width, past their discriminant's range and sign. */ -export function discriminants(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { let wide!: shapes_Wide.Wide; let signed!: Signed.Signed; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(b, 3); if (_10 === 0) { wide = "Low" as shapes_Wide.Wide; @@ -749,7 +745,7 @@ export function discriminants(dataData: Uint8Array, dataStart: number, dataLen: * Loops: labeled, `while let`, ranges, values out of `break`, loops that end a function, * and values of type `!`. */ -export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { let _24!: rt.usize; let _34!: rt.usize; let steps!: rt.u8; @@ -765,7 +761,7 @@ export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, } } }; - const stack: rt.ByteVec = rt.byteSliceToByteVec(new rt.ByteSlice(dataData, dataStart, dataLen)); + const stack: rt.ByteVec = rt.byteSliceToByteVec(data); let popped: rt.u32 = 0; while (true) { const _5: rt.u8 | undefined = rt.byteVecPop(stack); @@ -784,28 +780,22 @@ export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(popped))); let found = undefined as [rt.usize, rt.usize] | undefined; let iterStart: rt.usize = 0; - const iterEnd: rt.usize = dataLen; + const iterEnd: rt.usize = data.length; l3: while ((_24 = iterStart++) < iterEnd) { const i: rt.usize = _24; let iterStart2: rt.usize = rt.usizeAdd(i, 1); - const iterEnd2: rt.usize = dataLen; + const iterEnd2: rt.usize = data.length; while (true) { if (!((_34 = iterStart2++) < iterEnd2)) { continue l3; } const j: rt.usize = _34; - if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); - } - const _39: rt.u8 = dataData[dataStart + i]; - if (j >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + j); - } - if (!(_39 === dataData[dataStart + j])) { - if (j >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + j); - } - if (dataData[dataStart + j] === 0) { + rt.idx(data, i); + const _39: rt.u8 = data.data[data.start + i]; + rt.idx(data, j); + if (!(_39 === data.data[data.start + j])) { + rt.idx(data, j); + if (data.data[data.start + j] === 0) { continue l3; } } else { @@ -819,7 +809,7 @@ export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, } else { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(found[0] & 0xff, found[1] & 0xff))); } - let n: rt.u64 = dataLen as rt.u64; + let n: rt.u64 = data.length as rt.u64; b6: { while (!rt.u64Le(n, 1)) { if (!(rt.u64Rem(n, 2) === 0)) { @@ -847,7 +837,7 @@ export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, count = rt.u8Add(count, 1); } rt.byteVecPush(out, count); - const lo: rt.i32 = rt.i32Neg(rt.usizeRem(dataLen, 4) | 0); + const lo: rt.i32 = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); const r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); const first: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; r.end = r.start; @@ -868,22 +858,22 @@ export function loops(dataData: Uint8Array, dataStart: number, dataLen: number, while ((_136 = iterStart4++) < iterEnd4) { rt.byteVecPush(out, _136 & 0xff); } - rt.byteVecPush(out, firstRepeat(dataData, dataStart, dataLen)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(dataData, dataStart, dataLen)))); - rt.byteVecPush(out, armLoop(dataData, dataStart, dataLen)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(dataData, dataStart, dataLen, 0) as rt.u32))); - rt.byteVecPush(out, _158(rt.u8Mul(dataLen & 0xff, 7))); - drain(dataData, dataStart, dataLen, out); - rt.byteVecPush(out, returnedLoop(dataData, dataStart, dataLen)); - branchLoops(dataData, dataStart, dataLen, out); - diverging(dataData, dataStart, dataLen, out); + rt.byteVecPush(out, firstRepeat(data.data, data.start, data.length)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(data)))); + rt.byteVecPush(out, armLoop(data)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(data.data, data.start, data.length, 0) as rt.u32))); + rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); + drain(data.data, data.start, data.length, out); + rt.byteVecPush(out, returnedLoop(data)); + branchLoops(data, out); + diverging(data, out); } /** * Values of type `!` where a value goes, triggered by the first two bytes so most * inputs run every case to its end. */ -export function diverging(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { const _15: (a0: rt.u8) => rt.u8 = (b2: rt.u8): rt.u8 => { if (!(b2 === 253)) { return rt.u8Div(b2, 3); @@ -891,15 +881,15 @@ export function diverging(dataData: Uint8Array, dataStart: number, dataLen: numb const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b2, f)]; rt.panicFmt(["closure ", args2[0]]); }; - const head: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.min(dataLen, 2)); + const head: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(head), 0); - rt.byteVecPush(out, returnedNever(b, dataLen)); + rt.byteVecPush(out, returnedNever(b, data.length)); rt.byteVecPush(out, brokenNever(head.data, head.start, head.length)); rt.byteVecPush(out, _15(b)); rt.byteVecPush(out, guardedReturn(head.data, head.start, head.length)); rt.byteVecPush(out, boundNever(head.data, head.start, head.length, out)); rt.byteVecPush(out, closureNever(b)); - genericNever(b, dataLen); + genericNever(b, data.length); } /** @@ -1099,8 +1089,7 @@ export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: num } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ -export function branchLoops(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function branchLoops(data: rt.ByteSlice, out: rt.ByteVec): void { let i: rt.usize = 0; l1: while (rt.usizeAdd(i, 1) < data.length) { const w: rt.ByteSlice = rt.byteSliceRange(data, i, rt.usizeAdd(i, 2)); @@ -1142,8 +1131,7 @@ export function branchLoops(dataData: Uint8Array, dataStart: number, dataLen: nu } /** A loop that only `return` leaves, returned itself, around loops that `break`. */ -export function returnedLoop(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function returnedLoop(data: rt.ByteSlice): rt.u8 { let i: rt.usize = 0; while (!(i >= data.length)) { for (const b of rt.byteSliceView(rt.byteSliceRange(data, i))) { @@ -1200,8 +1188,7 @@ export function firstRepeat(dataData: Uint8Array, dataStart: number, dataLen: nu } /** A loop that ends the function, left by `break` with a value from nested scopes. */ -export function tailBreak(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u16 { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function tailBreak(data: rt.ByteSlice): rt.u16 { let i: rt.usize = 0; l2: while (true) { if (!(i >= data.length)) { @@ -1250,27 +1237,23 @@ export function tailBreak(dataData: Uint8Array, dataStart: number, dataLen: numb } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ -export function armLoop(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { +export function armLoop(data: rt.ByteSlice): rt.u8 { let k: rt.usize = 0; - const _3: rt.u8 | undefined = rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)); + const _3: rt.u8 | undefined = rt.byteSliceFirst(data); if (_3 !== undefined) { if (_3 >= 128) { return rt.u8Div(_3, 2); } } - while (!(k >= dataLen)) { + while (!(k >= data.length)) { const _13: rt.usize = k; - if (_13 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _13); - } - if (!(dataData[dataStart + _13] >= 128)) { + rt.idx(data, _13); + if (!(data.data[data.start + _13] >= 128)) { k = rt.usizeAdd(k, 1); } else { const _17: rt.usize = k; - if (_17 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _17); - } - return rt.u8Sub(dataData[dataStart + _17], 128); + rt.idx(data, _17); + return rt.u8Sub(data.data[data.start + _17], 128); } } return 238; @@ -1310,28 +1293,28 @@ export function drain(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ -export function patterns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { let class_!: rt.u8; let area!: rt.i64; let either!: rt.Result; let v!: rt.u8; - if (!(dataLen === 0)) { - if (!(dataLen === 1)) { - if (!(dataLen >= 2)) { + if (!(data.length === 0)) { + if (!(data.length === 1)) { + if (!(data.length >= 2)) { rt.unreachable(undefined); - } else if (!((dataData[dataStart] === dataData[dataStart + (dataLen - 1)]))) { - rt.byteVecPush(out, dataData[dataStart] ^ dataData[dataStart + 1]); - rt.byteVecPush(out, (dataLen - 2) & 0xff); + } 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, (data.length - 2) & 0xff); } else { rt.byteVecPush(out, 2); } } else { - rt.byteVecPush(out, dataData[dataStart]); + rt.byteVecPush(out, data.data[data.start]); } } else { rt.byteVecPush(out, 0); } - for (const _33 of rt.byteSliceView(rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.min(dataLen, 4)))) { + for (const _33 of rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 4)))) { b3: { const b: rt.u8 = _33; if (b === 0) { @@ -1363,11 +1346,11 @@ export function patterns(dataData: Uint8Array, dataStart: number, dataLen: numbe rt.byteVecPush(out, class_); } b6: { - if (dataLen >= 2) { - const _56: shapes_Dir.Dir | undefined = dir(dataData[dataStart]); + if (data.length >= 2) { + const _56: shapes_Dir.Dir | undefined = dir(data.data[data.start]); if (_56 !== undefined) { const d: shapes_Dir.Dir = _56; - if (dataData[dataStart + 1] > 10) { + if (data.data[data.start + 1] > 10) { rt.byteVecPush(out, from$convert_From_shapes_Dir_u8(d)); break b6; } @@ -1375,7 +1358,7 @@ export function patterns(dataData: Uint8Array, dataStart: number, dataLen: numbe } rt.byteVecPush(out, 238); } - const shape_: shapes_Shape.Shape = shape(dataData, dataStart, dataLen); + const shape_: shapes_Shape.Shape = shape(data.data, data.start, data.length); b8: { if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { @@ -1396,10 +1379,10 @@ export function patterns(dataData: Uint8Array, dataStart: number, dataLen: numbe area = 0; } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(area))); - if (!(rt.usizeRem(dataLen, 2) === 0)) { + if (!(rt.usizeRem(data.length, 2) === 0)) { either = rt.Err(160); } else { - either = rt.Ok(dataLen & 0xff); + either = rt.Ok(data.length & 0xff); } if (either.ok) { v = either.value; @@ -1408,19 +1391,19 @@ export function patterns(dataData: Uint8Array, dataStart: number, dataLen: numbe } rt.byteVecPush(out, v); rt.byteVecPush(out, rt.u8Add(rt.byteSliceFrom(Uint8Array.of()).length & 0xff, rt.iterSum(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of()))), rt.u8Add, 0))); - const bytes: Uint8Array = Uint8Array.of(dataLen & 0xff, 1, 2); - const slice2 = rt.byteSliceRange(rt.byteSliceFrom(bytes), 1, 3); - slice2.data[slice2.start] = 9; + const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); + const slice = rt.byteSliceRange(rt.byteSliceFrom(bytes), 1, 3); + slice.data[slice.start] = 9; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Add(total$shapes_Shape([shape_, { tag: "Dot" } as shapes_Shape.Shape], out), total$shapes_Meters([{ _0: 3 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }], out))))); - const parsed: rt.Result = rt.Ok(dataLen & 0xff); + const parsed: rt.Result = rt.Ok(data.length & 0xff); const a2: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rt.u8 }).value, (parsed as { ok: true; value: rt.u8 }).value, early(a2)))); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(parsed, f, rt.u8Debug, (value: Void.Void, f: rt.Formatter) => Void.fmt$fmt_Debug(value, f))]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - payloads(dataData, dataStart, dataLen, out); - known(dataData, dataStart, dataLen, out); - rematched(dataData, dataStart, dataLen, out); + payloads(data.data, data.start, data.length, out); + known(data.data, data.start, data.length, out); + rematched(data, out); } /** `n`'s result: `Ok` for an even `n`. */ @@ -1667,7 +1650,7 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } /** Enums matched again where an enclosing match decided their variant. */ -export function rematched(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { let _5!: rt.u8; let _15!: rt.u8; let _19!: rt.u8; @@ -1686,7 +1669,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb let lift!: rt.u8; let _206!: rt.u8; let _226!: rt.u8; - const s: shapes_Shape.Shape = shape(dataData, dataStart, dataLen); + const s: shapes_Shape.Shape = shape(data.data, data.start, data.length); if (s.tag === "Dot") { _5 = 2; } else if (s.tag === "Line") { @@ -1709,7 +1692,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb _19 = s.width & 0xff; } rt.byteVecPush(out, _19); - const d: shapes_Dir.Dir | undefined = dir(dataLen & 0xff); + const d: shapes_Dir.Dir | undefined = dir(data.length & 0xff); if (d === undefined) { _29 = 15; } else if (d === "North") { @@ -1718,7 +1701,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb _29 = { North: 1, East: 2, South: 4, West: 8 }[d] & 0xff; } rt.byteVecPush(out, _29); - const order: rt.Ordering = rt.cmp(dataLen & 0xff, 2); + const order: rt.Ordering = rt.cmp(data.length & 0xff, 2); if (order === -1) { _43 = 17; } else { @@ -1728,7 +1711,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb if (order === -1) { rt.byteVecPush(out, 32); } - if (!(dataLen > 1)) { + if (!(data.length > 1)) { r = rt.Err(2); } else { r = rt.Ok(1); @@ -1742,13 +1725,13 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb rt.byteVecPush(out, _58); } let assigned = -1 as rt.Ordering; - if (dataLen > 3) { + if (data.length > 3) { assigned = 1; } if (assigned === 0) { rt.byteVecPush(out, 34); } - const flow: rt.Result = step(0, dataLen & 0xff); + const flow: rt.Result = step(0, data.length & 0xff); if (!flow.ok) { if ((flow as rt.Result).ok) { _76 = ((flow as rt.Result) as { ok: true; value: rt.u16 }).value & 0xff; @@ -1758,10 +1741,10 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb rt.byteVecPush(out, _76); } const counts: rt.HashMap = rt.hashNew() as rt.HashMap; - if (rt.usizeRem(dataLen, 2) === 0) { - rt.hashInsert(counts, dataLen & 0xff, 35); + if (rt.usizeRem(data.length, 2) === 0) { + rt.hashInsert(counts, data.length & 0xff, 35); } - const entry: rt.Entry | undefined = rt.entry(counts, dataLen & 0xff); + const entry: rt.Entry | undefined = rt.entry(counts, data.length & 0xff); if (entry !== undefined) { if ((entry as rt.Entry | undefined) === undefined) { _97 = 37; @@ -1774,7 +1757,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb } let m: shapes_Shape.Shape = s; if (m.tag === "Dot") { - const _110: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.min(dataLen, 1)); + const _110: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); m = shape(_110.data, _110.start, _110.length); if (m.tag === "Line") { _107 = 18; @@ -1822,9 +1805,9 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb let iterStart2: rt.i32 = 0; const iterEnd2: rt.i32 = 4; while (iterStart2++ < iterEnd2) { - rt.byteVecPush(out, Machine.run(machine, dataLen & 0xff)); + rt.byteVecPush(out, Machine.run(machine, data.length & 0xff)); } - const filled: Filled.Filled = { shape: copy$Option_shapes_Shape(option_map$0600mq0(dir(dataLen & 0xff), (_2: shapes_Dir.Dir): shapes_Shape.Shape => { + const filled: Filled.Filled = { shape: copy$Option_shapes_Shape(option_map$0600mq0(dir(data.length & 0xff), (_2: shapes_Dir.Dir): shapes_Shape.Shape => { return copy$shapes_Shape(s); })) }; let iterStart3: rt.i32 = 0; @@ -1832,7 +1815,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb while (iterStart3++ < iterEnd3) { rt.byteVecPush(out, Filled.run(filled)); } - let original: shapes_Shape.Shape = shape(dataData, dataStart, dataLen); + let original: shapes_Shape.Shape = shape(data.data, data.start, data.length); if (original.tag === "Dot") { const _183: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); original = shape(_183.data, _183.start, _183.length); @@ -1846,7 +1829,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb } if (s.tag === "Line") { const from3: Point.Point = s._0; - if (!(dataLen > 2)) { + if (!(data.length > 2)) { lift = 2; } else { lift = 1; @@ -1858,7 +1841,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb rt.byteVecPush(out, _192); b29: { if (s.tag === "Dot") { - if (!(dataLen > 1)) { + if (!(data.length > 1)) { _206 = 53; break b29; } @@ -1879,7 +1862,7 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb if (w.tag === "Dot") { let i2: rt.usize = 0; while (true) { - if (!(i2 < rt.min(dataLen, 3))) { + if (!(i2 < rt.min(data.length, 3))) { break b31; } if (w.tag === "Dot") { @@ -1896,12 +1879,12 @@ export function rematched(dataData: Uint8Array, dataStart: number, dataLen: numb } } } - reseated(dataData, dataStart, dataLen, out); - decidedByBool(dataData, dataStart, dataLen, out); + reseated(data.data, data.start, data.length, out); + decidedByBool(data, out); } /** A match a `bool` already decided: `matches!`, and `==` of a derived `PartialEq`. */ -export function decidedByBool(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { let _4!: boolean; let _9!: boolean; let _12!: rt.u8; @@ -1918,7 +1901,7 @@ export function decidedByBool(dataData: Uint8Array, dataStart: number, dataLen: let _105!: rt.u8; let _111!: rt.u8; let _113!: boolean; - const s: shapes_Shape.Shape = shape(dataData, dataStart, dataLen); + const s: shapes_Shape.Shape = shape(data.data, data.start, data.length); if (s.tag === "Dot") { _4 = true; } else { @@ -1948,7 +1931,7 @@ export function decidedByBool(dataData: Uint8Array, dataStart: number, dataLen: if (!_17) { rt.byteVecPush(out, 63); } - if (!(dataLen > 2)) { + if (!(data.length > 2)) { wide = false; } else if (s.tag === "Rect") { wide = true; @@ -1983,7 +1966,7 @@ export function decidedByBool(dataData: Uint8Array, dataStart: number, dataLen: } rt.byteVecPush(out, _61); } - const _64: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), rt.min(dataLen, 1)); + const _64: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); const t: shapes_Shape.Shape = shape(_64.data, _64.start, _64.length); if (t.tag === "Rect") { if (shapes_Shape.eq$cmp_PartialEq(s, t)) { @@ -2010,7 +1993,7 @@ export function decidedByBool(dataData: Uint8Array, dataStart: number, dataLen: } else { dot2 = false; } - if (dataLen > 3) { + if (data.length > 3) { dot2 = !dot2; } if (dot2) { @@ -2030,7 +2013,7 @@ export function decidedByBool(dataData: Uint8Array, dataStart: number, dataLen: if (!seen) { rt.byteVecPush(out, 85); } else { - at.v = dataLen > 4; + at.v = data.length > 4; if (!seen) { _99 = 84; } else { @@ -2177,8 +2160,7 @@ export function counted(calls: rt.Place, b: rt.u8): rt.Result undefined = (v: rt.u8): undefined => { sum = rt.u32Add(sum, v as rt.u32); @@ -2269,9 +2250,8 @@ export function apply$shapes_closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt. } /** Options, results, `?`, and strings. */ -export function library(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function library(data: rt.ByteSlice, out: rt.ByteVec): void { let parsed!: rt.Result; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _3: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { const _4: rt.u8 | undefined = rt.u8CheckedAdd(a2, b2); if (_4 !== undefined) { @@ -2421,12 +2401,11 @@ export function polled(x: rt.u8): rt.Poll; let option!: rt.u8 | undefined; let _116!: rt.u8; let _132!: boolean; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); let total: rt.u16 = 0; for (const x of rt.byteSliceView(data)) { const flow: rt.Result = step(total, x); diff --git a/ts/fixtures/lang/expected/singles.ts b/ts/fixtures/lang/expected/singles.ts index 403893603..c3d72728c 100644 --- a/ts/fixtures/lang/expected/singles.ts +++ b/ts/fixtures/lang/expected/singles.ts @@ -7,8 +7,7 @@ import * as singles_Gauge from "./singles.Gauge.ts"; import * as singles_Reading from "./singles.Reading.ts"; /** The bits of an `f32` from the front of `data`, big-endian and zero-padded. */ -export function takeBits(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u32, rt.ByteSlice] { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function takeBits(data: rt.ByteSlice): [rt.u32, rt.ByteSlice] { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); @@ -16,8 +15,8 @@ export function takeBits(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** An `f32` from the front of `data`. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.f32, rt.ByteSlice] { - const _4: [rt.u32, rt.ByteSlice] = takeBits(dataData, dataStart, dataLen); +export function take(data: rt.ByteSlice): [rt.f32, rt.ByteSlice] { + const _4: [rt.u32, rt.ByteSlice] = takeBits(data); return [rt.f32FromBits(_4[0]), _4[1]] as [rt.f32, rt.ByteSlice]; } @@ -64,12 +63,12 @@ export function raise(level: rt.Place, by: rt.f32): void { level.v = Math.fround(level.v * 2.0); } -export function singles(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function singles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let zeros!: boolean; let _300!: rt.f32; - const _6: [rt.f32, rt.ByteSlice] = take(dataData, dataStart, dataLen); + const _6: [rt.f32, rt.ByteSlice] = take(data); const a: rt.f32 = _6[0]; - const _9: [rt.f32, rt.ByteSlice] = take(_6[1].data, _6[1].start, _6[1].length); + const _9: [rt.f32, rt.ByteSlice] = take(_6[1]); const b: rt.f32 = _9[0]; const _10: rt.u8 = rt.u8Rem(kind, 10); if (_10 === 0) { @@ -139,8 +138,8 @@ export function singles(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(rt.isizeFromF64(a as rt.f64)))); } else if (_10 === 2) { const wide: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(dataLen, 16); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, n), rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, n)); + const n: rt.usize = rt.min(data.length, 16); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, n), rt.byteSliceRange(data, 0, n)); const v: rt.u128 = rt.u128FromBeBytes(wide); const w: rt.f64 = rt.f64FromBits(rt.u64Cast(v)); const iter5: rt.Iter = rt.iterSlice([Math.fround(rt.u128Low(v) & 0xff), Math.fround(rt.u128Low(v) & 0xffff), Math.fround(rt.u128Low(v)), rt.u64ToF32(rt.u64Cast(v)), rt.u128ToF32(v), Math.fround(rt.u128Low(v)), Math.fround((rt.u128Low(v) << 24) >> 24), Math.fround((rt.u128Low(v) << 16) >> 16), Math.fround(rt.u128Low(v) | 0), rt.i64ToF32(rt.i64Cast(v)), rt.i128ToF32(rt.i128Cast(v)), Math.fround(rt.u128Low(v) | 0), rt.u64ToF32(rt.u64Cast(rt.u128Shr(v, 64))), rt.i64ToF32(rt.i64Cast(rt.u128Shr(v, 64))), Math.fround(rt.u128Low(v) & 0xffff), Math.fround((rt.u128Low(v) << 16) >> 16), rt.u128And(v, 1) === 1 ? 1.0 : 0.0, Math.fround(rt.u128Low(v) & 0xff), Math.fround(w), 1.8446744073709552e19, -9.223372036854776e18, Infinity, 2147483648.0]); @@ -217,7 +216,7 @@ export function singles(kind: rt.u8, dataData: Uint8Array, dataStart: number, da return o & 0xff; })); } else if (_10 === 6) { - const bits2: rt.u32 = takeBits(dataData, dataStart, dataLen)[0]; + const bits2: rt.u32 = takeBits(data)[0]; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32FromBits(bits2))))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f32ToBeBytes(rt.f32FromBits(bits2)))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f32ToLeBytes(rt.f32FromBits(bits2)))); @@ -306,7 +305,7 @@ export function singles(kind: rt.u8, dataData: Uint8Array, dataStart: number, da * exactly halfway between two singles, plus a tiny addend, subnormal sums, products past * `f32::MAX` that the sum brings back, and half the product's last place. */ -export function mulAdds(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function mulAdds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _53!: [rt.f32, rt.f32, rt.f32]; let _95!: rt.f32; const _63: (a0: rt.f32) => rt.f32 = (x: rt.f32): rt.f32 => { @@ -314,7 +313,7 @@ export function mulAdds(kind: rt.u8, dataData: Uint8Array, dataStart: number, da }; b0: { if (!(rt.u8Rem(kind, 2) === 0)) { - let state: rt.u32 = (takeBits(dataData, dataStart, dataLen)[0] | 1) >>> 0; + let state: rt.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rt.i32 = 0; const iterEnd: rt.i32 = 32; while (true) { @@ -366,10 +365,10 @@ export function mulAdds(kind: rt.u8, dataData: Uint8Array, dataStart: number, da putF32(out, rt.f32MulAdd(_53[0], _53[1], _53[2])); } } - const _9: [rt.f32, rt.ByteSlice] = take(dataData, dataStart, dataLen); + const _9: [rt.f32, rt.ByteSlice] = take(data); const a: rt.f32 = _9[0]; - const _12: [rt.f32, rt.ByteSlice] = take(_9[1].data, _9[1].start, _9[1].length); - putF32(out, rt.f32MulAdd(a, _12[0], take(_12[1].data, _12[1].start, _12[1].length)[0])); + const _12: [rt.f32, rt.ByteSlice] = take(_9[1]); + putF32(out, rt.f32MulAdd(a, _12[0], take(_12[1])[0])); } } @@ -390,8 +389,8 @@ export function step(state: rt.Place): rt.u32 { * `f32`'s `Display`, `Debug`, `LowerExp`, and `UpperExp`, with a precision from the byte * after the single, and every other option. */ -export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _6: [rt.f32, rt.ByteSlice] = take(dataData, dataStart, dataLen); +export function formats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _6: [rt.f32, rt.ByteSlice] = take(data); const a: rt.f32 = _6[0]; const p: rt.usize = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_6[1]), 0) as rt.usize; b0: { @@ -407,9 +406,9 @@ export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Display(a, f), (f: rt.Formatter) => rt.f32LowerExp(a, f), (f: rt.Formatter) => rt.f32Debug(a, f)]; fmt_put(out, rt.fmtFormat([rt.fmtSpec({ precision: 160 }, args6[0]), " ", rt.fmtSpec({ precision: 120 }, args6[1]), " ", rt.fmtSpec({ precision: 160 }, args6[2])])); } else if (_13 === 2) { - const _72: [rt.f32, rt.ByteSlice] = take(_6[1].data, _6[1].start, _6[1].length); + const _72: [rt.f32, rt.ByteSlice] = take(_6[1]); const b: rt.f32 = _72[0]; - const c: rt.f32 = take(_72[1].data, _72[1].start, _72[1].length)[0]; + const c: rt.f32 = take(_72[1])[0]; putF32(out, rt.f32Clamp(a, b, c)); } else if (_13 === 3) { const _78: rt.f32[] = [Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]; @@ -417,7 +416,7 @@ export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, da const args8: rt.Fmt[] = [(f: rt.Formatter) => singles_Reading.fmt$fmt_Debug(part, f)]; fmt_put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ precision: 2 }, args8[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); } else { - let state: rt.u32 = (takeBits(dataData, dataStart, dataLen)[0] | 1) >>> 0; + let state: rt.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rt.i32 = 0; const iterEnd: rt.i32 = 64; while (iterStart++ < iterEnd) { @@ -444,18 +443,18 @@ export function formats(kind: rt.u8, dataData: Uint8Array, dataStart: number, da * `str::parse::`, with its errors, of the input as text, of bytes mapped into the * grammar's alphabet, or of decimals made from a seed. */ -export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _108!: rt.usize; b0: { const _4: rt.u8 = rt.u8Rem(kind, 3); if (_4 === 0) { - const _6: rt.Result = rt.strFromUtf8(new rt.ByteSlice(dataData, dataStart, dataLen)); + const _6: rt.Result = rt.strFromUtf8(data); if (_6.ok) { one(_6.value, out); } } else if (_4 === 1) { let s: string = ""; - for (const b of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const b of rt.byteSliceView(data)) { const _21: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); const _22: rt.usize = rt.usizeRem(b as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); rt.idx(_21, _22); @@ -463,7 +462,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } one(s, out); } else { - let state: rt.u32 = (takeBits(dataData, dataStart, dataLen)[0] | 1) >>> 0; + let state: rt.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rt.i32 = 0; const iterEnd: rt.i32 = 16; while (iterStart++ < iterEnd) { diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index e5ff7bf28..c1505a94d 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import { copy$slices_Pair } from "./lib.ts"; -import { map$1wqzuhy as option_map$1wqzuhy, map$0c2keyb as option_map$0c2keyb, map$11y9s7r as option_map$11y9s7r, map$0qyyft9 as option_map$0qyyft9, map$1uvq0gl as option_map$1uvq0gl, map$003seos as option_map$003seos, map$0a57co2 as option_map$0a57co2, mapOr$189goit as option_mapOr$189goit, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; +import { map$1wqzuhy as option_map$1wqzuhy, map$0c2keyb as option_map$0c2keyb, map$11y9s7r as option_map$11y9s7r, map$0qyyft9 as option_map$0qyyft9, map$1xk4yz1 as option_map$1xk4yz1, map$003seos as option_map$003seos, map$0a57co2 as option_map$0a57co2, mapOr$189goit as option_mapOr$189goit, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; import * as slices_Counted from "./slices.Counted.ts"; import * as slices_Item from "./slices.Item.ts"; import * as slices_Noisy from "./slices.Noisy.ts"; @@ -23,8 +23,8 @@ export function flush(out: rt.ByteVec): void { } /** A digest of a part, which tells parts of different lengths or contents apart. */ -export function digest(partData: Uint8Array, partStart: number, partLen: number): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(partData, partStart, partLen))), partLen & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { +export function digest(part: rt.ByteSlice): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(part)), part.length & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { return rt.u8WrappingAdd(rt.u8WrappingMul(acc, 31), _32); }); } @@ -39,44 +39,25 @@ export function digestWords(part: rt.u16[]): rt.u8 { * `windows` or `chunks`, as `kind` picks, of a size it picks too, which is 0 one time in * six, which panics. */ -export function parts(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 2), 6) as rt.usize; const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); if (rt.u8Rem(kind, 2) === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), (a019: rt.ByteSlice): rt.u8 => { - return digest(a019.data, a019.start, a019.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), (a020: rt.ByteSlice): rt.u8 => { - return digest(a020.data, a020.start, a020.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), digest), undefined, true); const it: rt.Iter = rt.byteSliceWindows(data, size); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.next()), (a021: rt.ByteSlice): rt.u8 => { - return digest(a021.data, a021.start, a021.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.nextBack()), (a022: rt.ByteSlice): rt.u8 => { - return digest(a022.data, a022.start, a022.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it, 1), (a023: rt.ByteSlice): rt.u8 => { - return digest(a023.data, a023.start, a023.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it, 1), (a024: rt.ByteSlice): rt.u8 => { - return digest(a024.data, a024.start, a024.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, (a025: rt.ByteSlice): rt.u8 => { - return digest(a025.data, a025.start, a025.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceWindows(data, size)), (a026: rt.ByteSlice): rt.u8 => { - return digest(a026.data, a026.start, a026.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceWindows(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceWindows(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), (a027: rt.ByteSlice): rt.u8 => { - return digest(a027.data, a027.start, a027.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), digest), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceWindows(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceWindows(words, size)), digestWords), undefined, true); const it2: rt.Iter = rt.sliceWindows(words, size); @@ -105,37 +86,19 @@ export function parts(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } } } else { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), (a0: rt.ByteSlice): rt.u8 => { - return digest(a0.data, a0.start, a0.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), (a02: rt.ByteSlice): rt.u8 => { - return digest(a02.data, a02.start, a02.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), digest), undefined, true); const it3: rt.Iter = rt.byteSliceChunks(data, size); rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it3.next()), (a03: rt.ByteSlice): rt.u8 => { - return digest(a03.data, a03.start, a03.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it3.nextBack()), (a04: rt.ByteSlice): rt.u8 => { - return digest(a04.data, a04.start, a04.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it3, 1), (a05: rt.ByteSlice): rt.u8 => { - return digest(a05.data, a05.start, a05.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it3, 1), (a06: rt.ByteSlice): rt.u8 => { - return digest(a06.data, a06.start, a06.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it3.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it3.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it3, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it3, 1), digest)), undefined, true); rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it3, (a07: rt.ByteSlice): rt.u8 => { - return digest(a07.data, a07.start, a07.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceChunks(data, size)), (a08: rt.ByteSlice): rt.u8 => { - return digest(a08.data, a08.start, a08.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it3, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceChunks(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), (a09: rt.ByteSlice): rt.u8 => { - return digest(a09.data, a09.start, a09.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), digest), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunks(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunks(words, size)), digestWords), undefined, true); const it4: rt.Iter = rt.sliceChunks(words, size); @@ -240,8 +203,7 @@ export function digestPairs(part: slices_Pair.Pair[]): rt.u8 { * `chunks`, as `kind` picks, of a size it picks too, which is 0 one time in six, which * panics. */ -export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 8), 6) as rt.usize; const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { @@ -254,37 +216,19 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da b0: { const _16: rt.u8 = rt.u8Rem(kind, 8); if (_16 === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), (a037: rt.ByteSlice): rt.u8 => { - return digest(a037.data, a037.start, a037.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), (a038: rt.ByteSlice): rt.u8 => { - return digest(a038.data, a038.start, a038.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), digest), undefined, true); const it: rt.Iter = rt.byteSliceChunksExact(data, size); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.next()), (a039: rt.ByteSlice): rt.u8 => { - return digest(a039.data, a039.start, a039.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it.nextBack()), (a040: rt.ByteSlice): rt.u8 => { - return digest(a040.data, a040.start, a040.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it, 1), (a041: rt.ByteSlice): rt.u8 => { - return digest(a041.data, a041.start, a041.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it, 1), (a042: rt.ByteSlice): rt.u8 => { - return digest(a042.data, a042.start, a042.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, (a043: rt.ByteSlice): rt.u8 => { - return digest(a043.data, a043.start, a043.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceChunksExact(data, size)), (a044: rt.ByteSlice): rt.u8 => { - return digest(a044.data, a044.start, a044.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceChunksExact(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), (a045: rt.ByteSlice): rt.u8 => { - return digest(a045.data, a045.start, a045.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), digest), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunksExact(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunksExact(words, size)), digestWords), undefined, true); const it2: rt.Iter = rt.sliceChunksExact(words, size); @@ -299,45 +243,25 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.byteVecPush(out, rt.iterCount(rt.sliceChunksExact(words, size)) & 0xff); rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunksExact(words, size), 2), 2), digestWords), undefined, true); const it3: rt.Iter = rt.byteSliceChunksExact(data, size); - const _129: rt.ByteSlice = rt.partsRemainder(it3); - rt.byteVecPush(out, digest(_129.data, _129.start, _129.length)); + rt.byteVecPush(out, digest(rt.partsRemainder(it3))); it3.next(); rt.iterToOption(it3.nextBack()); - const _137: rt.ByteSlice = rt.partsRemainder(it3); - rt.byteVecPush(out, digest(_137.data, _137.start, _137.length)); + rt.byteVecPush(out, digest(rt.partsRemainder(it3))); rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceChunksExact(words, size)))); } else if (_16 === 1) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), (a019: rt.ByteSlice): rt.u8 => { - return digest(a019.data, a019.start, a019.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), (a020: rt.ByteSlice): rt.u8 => { - return digest(a020.data, a020.start, a020.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), digest), undefined, true); const it4: rt.Iter = rt.byteSliceRchunks(data, size); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it4.next()), (a021: rt.ByteSlice): rt.u8 => { - return digest(a021.data, a021.start, a021.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it4.nextBack()), (a022: rt.ByteSlice): rt.u8 => { - return digest(a022.data, a022.start, a022.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it4, 1), (a023: rt.ByteSlice): rt.u8 => { - return digest(a023.data, a023.start, a023.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it4, 1), (a024: rt.ByteSlice): rt.u8 => { - return digest(a024.data, a024.start, a024.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it4.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it4.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it4, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it4, 1), digest)), undefined, true); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it4, (a025: rt.ByteSlice): rt.u8 => { - return digest(a025.data, a025.start, a025.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceRchunks(data, size)), (a026: rt.ByteSlice): rt.u8 => { - return digest(a026.data, a026.start, a026.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it4, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceRchunks(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), (a027: rt.ByteSlice): rt.u8 => { - return digest(a027.data, a027.start, a027.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), digest), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunks(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunks(words, size)), digestWords), undefined, true); const it5: rt.Iter = rt.sliceRchunks(words, size); @@ -355,37 +279,19 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da return c13.length & 0xff; })), undefined, true); } else if (_16 === 2) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), (a0: rt.ByteSlice): rt.u8 => { - return digest(a0.data, a0.start, a0.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), (a02: rt.ByteSlice): rt.u8 => { - return digest(a02.data, a02.start, a02.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), digest), undefined, true); const it6: rt.Iter = rt.byteSliceRchunksExact(data, size); rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it6.next()), (a03: rt.ByteSlice): rt.u8 => { - return digest(a03.data, a03.start, a03.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterToOption(it6.nextBack()), (a04: rt.ByteSlice): rt.u8 => { - return digest(a04.data, a04.start, a04.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNth(it6, 1), (a05: rt.ByteSlice): rt.u8 => { - return digest(a05.data, a05.start, a05.length); - })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterNthBack(it6, 1), (a06: rt.ByteSlice): rt.u8 => { - return digest(a06.data, a06.start, a06.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it6.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it6.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it6, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it6, 1), digest)), undefined, true); rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it6, (a07: rt.ByteSlice): rt.u8 => { - return digest(a07.data, a07.start, a07.length); - }), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uvq0gl(rt.iterLast(rt.byteSliceRchunksExact(data, size)), (a08: rt.ByteSlice): rt.u8 => { - return digest(a08.data, a08.start, a08.length); - })), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(it6, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceRchunksExact(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), (a09: rt.ByteSlice): rt.u8 => { - return digest(a09.data, a09.start, a09.length); - }), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), digest), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunksExact(words, size), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunksExact(words, size)), digestWords), undefined, true); const it7: rt.Iter = rt.sliceRchunksExact(words, size); @@ -400,11 +306,9 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksExact(words, size)) & 0xff); rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunksExact(words, size), 2), 2), digestWords), undefined, true); const it8: rt.Iter = rt.byteSliceRchunksExact(data, size); - const _370: rt.ByteSlice = rt.partsRemainder(it8); - rt.byteVecPush(out, digest(_370.data, _370.start, _370.length)); + rt.byteVecPush(out, digest(rt.partsRemainder(it8))); rt.iterNth(it8, 1); - const _376: rt.ByteSlice = rt.partsRemainder(it8); - rt.byteVecPush(out, digest(_376.data, _376.start, _376.length)); + rt.byteVecPush(out, digest(rt.partsRemainder(it8))); rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceRchunksExact(words, size)))); } else if (_16 === 3) { const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)); @@ -415,8 +319,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } scribble(_391[0], _391[1]); } - const _399: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_399.data, _399.start, _399.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const held: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter2: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held))); while (true) { @@ -427,8 +330,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(rt.usizeAdd(_412[0], 7), _412[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held), (c10: rt.ByteSlice): rt.u8 => { - const _417: rt.ByteSlice = c10; - return digest(_417.data, _417.start, _417.length); + return digest(c10); }), undefined, true); const it9: rt.Iter = rt.byteSliceChunks(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it9.len() & 0xff); @@ -450,8 +352,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(4, _451); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)) & 0xff); - const _464: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_464.data, _464.start, _464.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const iter3: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksMut(words, size)); while (true) { const _472: [rt.usize, rt.u16[]] | rt.Done = iter3.next(); @@ -545,8 +446,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } scribble(_634[0], _634[1]); } - const _642: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_642.data, _642.start, _642.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const held4: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter8: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held4))); while (true) { @@ -557,8 +457,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(rt.usizeAdd(_655[0], 7), _655[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held4), (c7: rt.ByteSlice): rt.u8 => { - const _414: rt.ByteSlice = c7; - return digest(_414.data, _414.start, _414.length); + return digest(c7); }), undefined, true); const it12: rt.Iter = rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it12.len() & 0xff); @@ -580,8 +479,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(4, _694); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size)) & 0xff); - const _707: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_707.data, _707.start, _707.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const iter9: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksExactMut(words, size)); while (true) { const _715: [rt.usize, rt.u16[]] | rt.Done = iter9.next(); @@ -692,8 +590,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } scribble(_908[0], _908[1]); } - const _916: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_916.data, _916.start, _916.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const held7: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter15: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held7))); while (true) { @@ -704,8 +601,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(rt.usizeAdd(_929[0], 7), _929[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held7), (c4: rt.ByteSlice): rt.u8 => { - const _410: rt.ByteSlice = c4; - return digest(_410.data, _410.start, _410.length); + return digest(c4); }), undefined, true); const it17: rt.Iter = rt.byteSliceRchunks(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it17.len() & 0xff); @@ -727,8 +623,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(4, _968); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size)) & 0xff); - const _981: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_981.data, _981.start, _981.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const iter16: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRchunksMut(words, size)); while (true) { const _989: [rt.usize, rt.u16[]] | rt.Done = iter16.next(); @@ -822,8 +717,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da } scribble(_1151[0], _1151[1]); } - const _1159: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_1159.data, _1159.start, _1159.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const held10: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter21: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held10))); while (true) { @@ -834,8 +728,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(rt.usizeAdd(_1172[0], 7), _1172[1].v); } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held10), (c: rt.ByteSlice): rt.u8 => { - const _45: rt.ByteSlice = c; - return digest(_45.data, _45.start, _45.length); + return digest(c); }), undefined, true); const it20: rt.Iter = rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it20.len() & 0xff); @@ -857,8 +750,7 @@ export function chunked(kind: rt.u8, dataData: Uint8Array, dataStart: number, da scribble(4, _1211); } rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size)) & 0xff); - const _1224: rt.ByteSlice = rt.byteVecSlice(bytes); - rt.byteVecPush(out, digest(_1224.data, _1224.start, _1224.length)); + rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); const iter22: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRchunksExactMut(words, size)); while (true) { const _1232: [rt.usize, rt.u16[]] | rt.Done = iter22.next(); @@ -1056,25 +948,24 @@ export function pokeArray(s: rt.u32[]): void { * bounds from the first two bytes, which may be out of bounds or backwards, which * panics; with what is written through each part landing in what it came from. */ -export function subslices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - if (dataLen >= 2) { - const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); - const reach: rt.usize = rt.usizeAdd(data2.length, 2); - const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 1] as rt.usize, reach)]; +export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + if (data.length >= 2) { + const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); + const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach)]; const a: rt.usize = _14[0]; const b: rt.usize = _14[1]; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); - const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); + const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); - const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): slices_Pair.Pair => { + const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): slices_Pair.Pair => { const b4: rt.u8 = _23; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; }), undefined, 4, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(data2)), [false, false]); + const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), [false, false]); while (true) { const _37: [rt.Place, rt.u8] | rt.Done = iter.next(); if (_37 === rt.DONE) { @@ -1254,18 +1145,17 @@ export function subslices(kind: rt.u8, dataData: Uint8Array, dataStart: number, * backwards, which panics, of the rest as items, bytes, and integers: what it yields, and * what each drops and keeps as the drain drops, or as it is forgotten. */ -export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - if (dataLen >= 2) { - const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); - const reach: rt.usize = rt.usizeAdd(data2.length, 2); - const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 1] as rt.usize, reach)]; +export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + if (data.length >= 2) { + const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); + const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach)]; const a: rt.usize = _14[0]; const b: rt.usize = _14[1]; - const items: slices_Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): slices_Item.Item => { + const items: slices_Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): slices_Item.Item => { return new slices_Item.Item(_2); }), undefined, 1, true); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); - const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): rt.u32 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); + const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): rt.u32 => { return rt.u32Add(_23 as rt.u32, 1000); }), undefined, 4, true); const _31: rt.u8 = rt.u8Rem(kind, 8); @@ -1398,7 +1288,7 @@ export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * backwards, which panics or gives `None`; with what is written through each mutable * part landing in what it came from. */ -export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _104!: rt.u8; let _112!: rt.u8; let _120!: rt.u8; @@ -1433,30 +1323,29 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } return { tag: "Unbounded" } as rt.RangeBound; }; - if (dataLen >= 2) { - const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2); - const reach: rt.usize = rt.usizeAdd(data2.length, 2); + if (data.length >= 2) { + const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); const at: (a0: rt.u8) => rt.usize = (x3: rt.u8): rt.usize => { if (!(x3 === 255)) { return rt.usizeRem(x3 as rt.usize, reach); } return 4294967295; }; - const _16: [rt.usize, rt.usize] = [at(dataData[dataStart]), at(dataData[dataStart + 1])]; + const _16: [rt.usize, rt.usize] = [at(data.data[data.start]), at(data.data[data.start + 1])]; const a: rt.usize = _16[0]; const b: rt.usize = _16[1]; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); - const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); + const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); - const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): slices_Pair.Pair => { + const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_22: rt.u8): slices_Pair.Pair => { const b4: rt.u8 = _22; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; }), undefined, 4, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(data2)), [false, false]); + const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), [false, false]); while (true) { const _39: [rt.Place, rt.u8] | rt.Done = iter.next(); if (_39 === rt.DONE) { @@ -1467,25 +1356,24 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const _47: rt.u8 = rt.u8Rem(kind, 8); if (_47 === 0) { const _53: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const slice5 = rt.byteVecSlice(bytes); - const bounds26 = rt.sliceIndexBounds(_53, slice5.length); - const _51: rt.ByteSlice = rt.byteSliceRange(slice5, bounds26[0], bounds26[1]); - rt.byteVecPush(out, digest(_51.data, _51.start, _51.length)); + const slice7 = rt.byteVecSlice(bytes); + const bounds26 = rt.sliceIndexBounds(_53, slice7.length); + rt.byteVecPush(out, digest(rt.byteSliceRange(slice7, bounds26[0], bounds26[1]))); const bounds27 = rt.sliceIndexBounds(new rt.RangeInclusive(a, b, rt.usizeStep), words.length); rt.byteVecPush(out, digestWords(rt.sliceRange(words, bounds27[0], bounds27[1]))); const bounds28 = rt.sliceIndexBounds({ end: b, inclusive: true }, pairs.length); rt.byteVecPush(out, digestPairs(rt.sliceRange(pairs, bounds28[0], bounds28[1]))); const bounds29 = rt.sliceIndexBounds(new rt.RangeInclusive(rt.min(a, 4), rt.min(b, 4), rt.usizeStep), array.length); - const part5 = rt.sliceRange(array, bounds29[0], bounds29[1]); - rt.byteVecPush(out, _46(part5)); - const bounds30 = rt.sliceIndexBounds({ end: b, inclusive: true }, data2.length); - const _75: rt.ByteSlice = rt.byteSliceRange(data2, bounds30[0], bounds30[1]); - rt.byteVecPush(out, digest(_75.data, _75.start, _75.length)); + const part6 = rt.sliceRange(array, bounds29[0], bounds29[1]); + rt.byteVecPush(out, _46(part6)); + const slice8 = rt.byteSliceRange(data, 2); + const bounds30 = rt.sliceIndexBounds({ end: b, inclusive: true }, slice8.length); + rt.byteVecPush(out, digest(rt.byteSliceRange(slice8, bounds30[0], bounds30[1]))); } else if (_47 === 1) { const _79: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const slice4 = rt.byteVecSlice(bytes); - const bounds21 = rt.sliceIndexBounds(_79, slice4.length); - const part: rt.ByteSlice = rt.byteSliceRange(slice4, bounds21[0], bounds21[1]); + const slice6 = rt.byteVecSlice(bytes); + const bounds21 = rt.sliceIndexBounds(_79, slice6.length); + const part: rt.ByteSlice = rt.byteSliceRange(slice6, bounds21[0], bounds21[1]); rt.byteSliceView(part).reverse(); rt.idx(part, 0); part.data[part.start] = part.data[part.start] ^ 90; @@ -1503,7 +1391,7 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_105 === undefined) { _104 = 238; } else { - _104 = digest(_105.data, _105.start, _105.length); + _104 = digest(_105); } rt.byteVecPush(out, _104); const _114: rt.ByteSlice = rt.byteVecSlice(bytes); @@ -1512,14 +1400,14 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_113 === undefined) { _112 = 238; } else { - _112 = digest(_113.data, _113.start, _113.length); + _112 = digest(_113); } rt.byteVecPush(out, _112); const _121: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, b); if (_121 === undefined) { _120 = 238; } else { - _120 = digest(_121.data, _121.start, _121.length); + _120 = digest(_121); } rt.byteVecPush(out, _120); const _130: rt.ByteSlice = rt.byteVecSlice(bytes); @@ -1528,28 +1416,28 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_129 === undefined) { _128 = 238; } else { - _128 = digest(_129.data, _129.start, _129.length); + _128 = digest(_129); } rt.byteVecPush(out, _128); const _137: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), a); if (_137 === undefined) { _136 = 238; } else { - _136 = digest(_137.data, _137.start, _137.length); + _136 = digest(_137); } rt.byteVecPush(out, _136); const _145: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0); if (_145 === undefined) { _144 = 238; } else { - _144 = digest(_145.data, _145.start, _145.length); + _144 = digest(_145); } rt.byteVecPush(out, _144); - const _152: rt.ByteSlice | undefined = rt.byteSliceGetRange(data2, a, b); + const _152: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceRange(data, 2), a, b); if (_152 === undefined) { _151 = 238; } else { - _151 = digest(_152.data, _152.start, _152.length); + _151 = digest(_152); } rt.byteVecPush(out, _151); const _158: rt.u16[] | undefined = rt.sliceGetRange(words, a, b); @@ -1673,7 +1561,7 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_297 === undefined) { _296 = 238; } else { - _296 = digest(_297.data, _297.start, _297.length); + _296 = digest(_297); } rt.byteVecPush(out, _296); const _307: slices_Pair.Pair[] = pairs; @@ -1692,13 +1580,14 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const _324: rt.RangeInclusive = stepped; const slice3 = rt.byteVecSlice(bytes); const bounds10 = rt.sliceIndexBounds(_324, slice3.length); - const _322: rt.ByteSlice = rt.byteSliceRange(slice3, bounds10[0], bounds10[1]); - rt.byteVecPush(out, digest(_322.data, _322.start, _322.length)); - const bounds11 = rt.sliceIndexBounds(folded, data2.length); - const _327: rt.ByteSlice = rt.byteSliceRange(data2, bounds11[0], bounds11[1]); - rt.byteVecPush(out, digest(_327.data, _327.start, _327.length)); + rt.byteVecPush(out, digest(rt.byteSliceRange(slice3, bounds10[0], bounds10[1]))); + const _328: rt.RangeInclusive = folded; + const slice4 = rt.byteSliceRange(data, 2); + const bounds11 = rt.sliceIndexBounds(_328, slice4.length); + rt.byteVecPush(out, digest(rt.byteSliceRange(slice4, bounds11[0], bounds11[1]))); } else if (_47 === 5) { - const _333: rt.RangeBound = _329(a, data2.length & 0xff); + const part4 = rt.byteSliceRange(data, 2).length & 0xff; + const _333: rt.RangeBound = _329(a, part4); const _332: [rt.RangeBound, rt.RangeBound] = [_333, _329(b, rt.u8Div(kind, 8))]; const lo: rt.RangeBound = _333; const hi: rt.RangeBound = _332[1]; @@ -1708,7 +1597,7 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (_345 === undefined) { _344 = 238; } else { - _344 = digest(_345.data, _345.start, _345.length); + _344 = digest(_345); } rt.byteVecPush(out, _344); const _354: slices_Pair.Pair[] = pairs; @@ -1730,24 +1619,19 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat pokePairs(9, rt.sliceRangeMut(pairs, bounds4[0], bounds4[1])); const slice2 = rt.byteVecSlice(bytes); const bounds5 = rt.sliceIndexBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], slice2.length); - const _372: rt.ByteSlice = rt.byteSliceRange(slice2, bounds5[0], bounds5[1]); - rt.byteVecPush(out, digest(_372.data, _372.start, _372.length)); + rt.byteVecPush(out, digest(rt.byteSliceRange(slice2, bounds5[0], bounds5[1]))); } else if (_47 === 6) { rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 0), (c2: rt.ByteSlice): rt.u8 => { - const _38: rt.ByteSlice = c2; - return digest(_38.data, _38.start, _38.length); + return digest(c2); })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 3), (c3: rt.ByteSlice): rt.u8 => { - const _310: rt.ByteSlice = c3; - return digest(_310.data, _310.start, _310.length); + return digest(c3); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(data2, 1), (c4: rt.ByteSlice): rt.u8 => { - const _311: rt.ByteSlice = c4; - return digest(_311.data, _311.start, _311.length); + rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 1), (c4: rt.ByteSlice): rt.u8 => { + return digest(c4); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(data2, 4), (c5: rt.ByteSlice): rt.u8 => { - const _312: rt.ByteSlice = c5; - return digest(_312.data, _312.start, _312.length); + rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 4), (c5: rt.ByteSlice): rt.u8 => { + return digest(c5); })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$1wqzuhy(rt.sliceGetRange(words, 0, 4), (c6: rt.u16[]): rt.u8 => { return digestWords(c6); @@ -1760,13 +1644,11 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat })), undefined, true); const slice: rt.ByteSlice = rt.byteVecSlice(bytes); if (slice.length >= 1) { - const _415: rt.ByteSlice = new rt.ByteSlice(slice.data, slice.start, 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_415.data, _415.start, _415.length), digest(slice.data, slice.start + 1, slice.length - 1))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(new rt.ByteSlice(slice.data, slice.start, 1)), digest(new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1)))), undefined, true); } const _417: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitLastChunk(rt.byteVecSlice(bytes), 4); if (_417 !== undefined) { - const _427: rt.ByteSlice = _417[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0].data, _417[0].start, _417[0].length), digest(_427.data, _427.start, _427.length))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1]))), undefined, true); } const _428: [rt.u16[], rt.u16[]] | undefined = rt.sliceSplitAtChecked(words, 0); if (_428 !== undefined) { @@ -1854,33 +1736,32 @@ export function ranges(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * options of them, on the whole slice and on mutable parts and chunks of it, at bounds * from the first three bytes, which may be out of bounds or backwards, which panics. */ -export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - if (dataLen >= 3) { - const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3); - const reach: rt.usize = rt.usizeAdd(data2.length, 2); - const _16: [rt.usize, rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 1] as rt.usize, reach), rt.usizeRem(dataData[dataStart + 2] as rt.usize, reach)]; +export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + if (data.length >= 3) { + const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 3).length, 2); + const _16: [rt.usize, rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach), rt.usizeRem(data.data[data.start + 2] as rt.usize, reach)]; const a: rt.usize = _16[0]; const b: rt.usize = _16[1]; const c: rt.usize = _16[2]; const size: rt.usize = rt.usizeAdd(rt.usizeRem(c, 3), 1); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data2); - const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { + const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 3)); + const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); }), undefined, 2, true); - const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_29: rt.u8): slices_Pair.Pair => { + const pairs: slices_Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_29: rt.u8): slices_Pair.Pair => { const b4: rt.u8 = _29; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; }), undefined, 4, true); - const counted: slices_Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_211: rt.u8): slices_Counted.Counted => { + const counted: slices_Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_211: rt.u8): slices_Counted.Counted => { return { n: _211 }; }), undefined, 1, true); - const items: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_212: rt.u8): slices_Noisy.Noisy => { + const items: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_212: rt.u8): slices_Noisy.Noisy => { return new slices_Noisy.Noisy(_212); }), undefined, 1, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(data2)), [false, false]); + const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), [false, false]); while (true) { const _53: [rt.Place, rt.u8] | rt.Done = iter.next(); if (_53 === rt.DONE) { @@ -1915,7 +1796,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.sliceFill(items, new slices_Noisy.Noisy(c & 0xff), slices_Noisy.clone$Clone, rt.drop); flush(out); rt.sliceRangeMut(array, rt.min(a, 5)).fill(c as rt.u32); - const opts: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_224: rt.u8): slices_Noisy.Noisy | undefined => { + const opts: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_224: rt.u8): slices_Noisy.Noisy | undefined => { return new slices_Noisy.Noisy(_224); }), undefined, 2, true); rt.sliceFill(rt.sliceRangeMut(opts, a), undefined as slices_Noisy.Noisy | undefined, option_clone$1omlcob, rt.drop); @@ -2001,7 +1882,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data rt.sliceRotateLeft(_246[1], n2); rt.sliceRotateRight(_246[1], rt.min(b, n2)); flush(out); - const _258: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(rt.byteVecSlice(bytes), rt.min(b, data2.length)); + const _258: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(rt.byteVecSlice(bytes), rt.min(b, rt.byteSliceRange(data, 3).length)); rt.byteSliceRotateLeft(_258[0], _258[0].length); rt.byteSliceRotateRight(_258[1], rt.usizeDiv(_258[1].length, 2)); rt.sliceRotateLeft(rt.sliceRangeMut(array, 1), c); @@ -2043,7 +1924,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data _350.b = 48879; } const _357: slices_Counted.Counted[] = rt.sliceRangeMut(counted, a); - const part8 = rt.usizeSub(data2.length, a); + const part8 = rt.usizeSub(rt.byteSliceRange(data, 3).length, a); rt.sliceCopyFromSlice(_357, rt.sliceRange(rt.iterToArray(rt.iterMap(new rt.Range(0, c), (n9: rt.usize): slices_Counted.Counted => { return { n: n9 & 0xff }; }), undefined, 1, true), 0, part8)); @@ -2059,7 +1940,7 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data const source2: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(new rt.Range(0, c), (tag3: rt.usize): slices_Noisy.Noisy => { return new slices_Noisy.Noisy((tag3 & 0xff) | 80); }), undefined, 1, true); - const n5: rt.usize = rt.min(data2.length, c); + const n5: rt.usize = rt.min(rt.byteSliceRange(data, 3).length, c); rt.sliceCloneFromSlice(rt.sliceRangeMut(items, 0, n5), rt.sliceRange(source2, 0, n5), slices_Noisy.clone$Clone, rt.drop); flush(out); const _403: [slices_Counted.Counted[], slices_Counted.Counted[]] = rt.sliceSplitAtMut(counted, a); diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index 756bc8a6f..271f3df78 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -61,8 +61,8 @@ export function second(dataData: Uint8Array, dataStart: number, dataLen: number, } /** A use that needs the slice itself. */ -export function opaque(sData: Uint8Array, sStart: number, sLen: number): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, sLen))), sLen & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { +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); }); } @@ -73,15 +73,15 @@ export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { return n; } -export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _58!: rt.u8; let _169!: rt.u8; let err!: Short.Short; const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { - let restData: Uint8Array = dataData; - let restStart: number = dataStart; - let restLen: number = dataLen; + 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; @@ -103,14 +103,14 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, sum); rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData, restStart, restLen)); } else if (_4 === 1) { - const mid4: number = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0), 8) as rt.usize; - if (mid4 > dataLen) { + const mid4: number = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8) as rt.usize; + if (mid4 > data.length) { rt.panic("mid > len"); } rt.byteVecPush(out, mid4 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(dataData, dataStart + mid4, dataLen - mid4)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(data.data, data.start + mid4, data.length - mid4)); } else if (_4 === 2) { - const part7: rt.u8 | undefined = header(dataData, dataStart, dataLen); + const part7: rt.u8 | undefined = header(data.data, data.start, data.length); const err3: Short.Short | undefined = part7 === undefined ? headerOut.err as Short.Short : undefined; const part8: rt.u16 = headerOut.p_1; const part9: Uint8Array = headerOut.p_2Data; @@ -121,35 +121,36 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const b3: rt.u16 = part8; rt.byteVecPush(out, a2); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(b3))); - rt.byteVecPush(out, opaque(part9, part10, part11)); + rt.byteVecPush(out, opaque(new rt.ByteSlice(part9, part10, part11))); } else if ((err3 as Short.Short).tag === "Empty") { rt.byteVecPush(out, 240); } else { rt.byteVecPush(out, 241 ^ (((err3 as Short.Short) as { tag: "Need"; _0: rt.usize })._0 & 0xff)); } } else if (_4 === 3) { - const mid3: number = rt.usizeDiv(dataLen, 2); - if (mid3 > dataLen) { + const mid3: number = rt.usizeDiv(data.length, 2); + if (mid3 > data.length) { rt.panic("mid > len"); } + const head: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid3); let iterStart: rt.u8 = 0; const iterEnd: rt.u8 = 3; while ((_58 = iterStart++) < iterEnd) { - rt.byteVecPush(out, opaque(dataData, dataStart, mid3) ^ _58); + rt.byteVecPush(out, opaque(head) ^ _58); } - rt.byteVecPush(out, opaque(dataData, dataStart + mid3, dataLen - mid3)); + rt.byteVecPush(out, opaque(new rt.ByteSlice(data.data, data.start + mid3, data.length - mid3))); } else if (_4 === 4) { - const mid: number = rt.usizeDiv(dataLen, 3); - if (mid > dataLen) { + const mid: number = rt.usizeDiv(data.length, 3); + if (mid > data.length) { rt.panic("mid > len"); } - let pair_0Data: Uint8Array = dataData; - let pair_0Start: number = dataStart; + let pair_0Data: Uint8Array = data.data; + let pair_0Start: number = data.start; let pair_0Len: number = mid; - let pair_1Data: Uint8Array = dataData; - let pair_1Start: number = dataStart + mid; - let pair_1Len: number = dataLen - mid; - const _73: rt.usize = rt.usizeRem(dataLen, 3); + 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) { @@ -175,55 +176,39 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecPush(out, pair_1Data[pair_1Start]); } rt.byteVecExtendFromSlice(out, new rt.ByteSlice(pair_0Data, pair_0Start, pair_0Len)); - const mid2: number = rt.usizeDiv(dataLen, 2); - if (mid2 > dataLen) { + const mid2: number = rt.usizeDiv(data.length, 2); + if (mid2 > data.length) { rt.panic("mid > len"); } - let aData2: Uint8Array = dataData; - let aStart2: number = dataStart; - let aLen2: number = mid2; - let bData2: Uint8Array = dataData; - let bStart2: number = dataStart + mid2; - let bLen2: number = dataLen - mid2; - const _101: rt.usize = rt.usizeRem(dataLen, 3); + let a3: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid2); + let b4: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2); + const _101: rt.usize = rt.usizeRem(data.length, 3); let iterStart3: rt.usize = 0; const iterEnd3: rt.usize = _101; while (iterStart3++ < iterEnd3) { - const _111Data: Uint8Array = bData2; - const _111Start: number = bStart2; - const _111Len: number = bLen2; - const _112Data: Uint8Array = aData2; - const _112Start: number = aStart2; - const _112Len: number = aLen2; - aData2 = _111Data; - aStart2 = _111Start; - aLen2 = _111Len; - bData2 = _112Data; - bStart2 = _112Start; - bLen2 = _112Len; - rt.byteVecPush(out, opaque(aData2, aStart2, aLen2)); + const _111: rt.ByteSlice = b4; + const _112: rt.ByteSlice = a3; + a3 = _111; + b4 = _112; + rt.byteVecPush(out, opaque(a3)); } - rt.byteVecPush(out, aLen2 & 0xff); - rt.byteVecPush(out, opaque(bData2, bStart2, bLen2)); + rt.byteVecPush(out, a3.length & 0xff); + rt.byteVecPush(out, opaque(b4)); } else if (_4 === 5) { - let restData3: Uint8Array = dataData; - let restStart3: number = dataStart; - let restLen3: number = dataLen; + let rest3: rt.ByteSlice = data; while (true) { - const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(restData3, restStart3, restLen3); + const _125: rt.ByteSlice = rest3; + const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(_125.data, _125.start, _125.length); if (_124 !== undefined) { rt.byteVecPush(out, _124[0] ^ _124[1]); - const slice: rt.ByteSlice = _124[2]; - restData3 = slice.data; - restStart3 = slice.start; - restLen3 = slice.length; + rest3 = _124[2]; } else { break; } } - rt.byteVecPush(out, restLen3 & 0xff); + rt.byteVecPush(out, rest3.length & 0xff); } else if (_4 === 6) { - const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(new rt.ByteSlice(dataData, dataStart, dataLen), 4); + const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(data, 4); b5: { if (split !== undefined) { const _227: rt.ByteSlice = split[0]; @@ -237,13 +222,13 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } - const err2: Short.Short | undefined = take(dataData, dataStart, dataLen, 3); + const err2: Short.Short | undefined = take(data.data, data.start, data.length, 3); const part: Uint8Array = At.splitOut$returns_Split.p_0Data; const part2: number = At.splitOut$returns_Split.p_0Start; const part3: number = At.splitOut$returns_Split.p_0Len; const part6: number = At.splitOut$returns_Split.p_1Len; if (err2 === undefined) { - rt.byteVecPush(out, opaque(part, part2, part3)); + rt.byteVecPush(out, opaque(new rt.ByteSlice(part, part2, part3))); rt.byteVecPush(out, part6 & 0xff); } else { const e: Short.Short = err2 as Short.Short; @@ -256,26 +241,26 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else { const first2: rt.u8 = code(out, 7); - if (dataLen !== 0) { - rt.byteVecPush(out, dataData[dataStart]); - rt.byteVecPush(out, (dataLen - 1) & 0xff); + 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(dataLen, 2) === 0) { + if (rt.usizeRem(data.length, 2) === 0) { err = { tag: "Empty" } as Short.Short; } else { - err = { tag: "Need", _0: dataLen } as Short.Short; + err = { tag: "Need", _0: data.length } as Short.Short; } const _1902: Short.Short = err; - if (dataLen !== 0) { - rt.byteVecPush(out, dataData[dataStart]); + if (data.length !== 0) { + rt.byteVecPush(out, data.data[data.start]); } else if (_1902.tag === "Empty") { rt.byteVecPush(out, 224); } else { rt.byteVecPush(out, 225 ^ (_1902._0 & 0xff)); } - const _200: rt.Result = second(dataData, dataStart, dataLen, rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen))); + const _200: rt.Result = second(data.data, data.start, data.length, rt.byteSliceFirst(data)); if (_200.ok) { rt.byteVecPush(out, _200.value); } else if (_200.error === undefined) { @@ -283,8 +268,8 @@ export function splits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { rt.byteVecPush(out, _200.error ^ 85); } - if (2 <= dataLen) { - rt.byteVecPush(out, dataData[dataStart + 1] ^ ((dataLen - 2) & 0xff)); + if (2 <= data.length) { + rt.byteVecPush(out, data.data[data.start + 1] ^ ((data.length - 2) & 0xff)); } } } diff --git a/ts/fixtures/lang/expected/statics.ts b/ts/fixtures/lang/expected/statics.ts index b91c1f440..ce829adac 100644 --- a/ts/fixtures/lang/expected/statics.ts +++ b/ts/fixtures/lang/expected/statics.ts @@ -25,13 +25,13 @@ export const TABLE: rt.ByteSlice = /* @__PURE__ */ rt.byteSliceFrom(Uint8Array.o * Each byte an operation on the statics; each puts what it read. First, what each holds, * which only the value it starts with can be. */ -export function statics(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function statics(data: rt.ByteSlice, out: rt.ByteVec): void { let _68!: rt.u8; rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicLoad(COUNT, 0)).reverse()), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicLoad(WIDE, 0)).reverse()), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicLoad(SIGNED, 0) & 0xff, rt.atomicLoad(FLAG, 0) ? 1 : 0, rt.atomicLoad(SIZE, 0) & 0xff)), undefined, true); rt.byteVecPush(out, next(false)); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(op, 6); const _38: rt.u8 = rt.u8Rem(op, 6); if (_38 === 0) { @@ -123,7 +123,7 @@ export function first(): rt.ByteVec { export const FORCED: rt.Atomic = /* @__PURE__ */ new rt.Atomic(0); /** Each byte an operation on statics and constants read from memory; each puts what it read. */ -export function cells(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(COUNTER.name))), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(COUNTER.steps), undefined, true); const _10: Counter.Counter = COUNTER; @@ -148,7 +148,7 @@ export function cells(dataData: Uint8Array, dataStart: number, dataLen: number, rt.cellSet(tally, _40); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tally.v, new rt.Cell(250).v, new rt.Cell([1, 2] as [rt.u8, rt.u8]).v[1])), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(new rt.Cell(new rt.Cell(3)).v.v, new rt.Cell(new rt.Cell(4)).v.v)), undefined, true); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const n2: rt.u8 = rt.u8Div(op, 8); const _68: rt.u8 = rt.u8Rem(op, 8); if (_68 === 0) { @@ -243,10 +243,10 @@ export const STARTED: rt.Once = /* @__PURE__ */ new rt.OnceLock(undefined); * Each byte an operation on a `Once`, its own or a static's; each puts what it saw. One * whose function runs again from within it panics, as wasm32's does, if its byte is odd. */ -export function onces(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function onces(data: rt.ByteSlice, out: rt.ByteVec): void { const once: rt.Once = new rt.OnceLock(undefined); const owned: rt.Arc = new rt.Arc(undefined); - for (const op of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))) { + for (const op of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(op, 6); const _13: rt.u8 = rt.u8Rem(op, 6); if (_13 === 0) { diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index d05a05cee..9c8642c4b 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -2,18 +2,18 @@ import * as rt from "./rt.ts"; import { then$0havnzo } from "./core/bool.ts"; -import { fromStr$1cr4vnw as nonzero_fromStr$1cr4vnw, fromStrRadix$14i0wt8 as nonzero_fromStrRadix$14i0wt8, fromStr$0lgcgfz as nonzero_fromStr$0lgcgfz, fromStrRadix$1lxegnk as nonzero_fromStrRadix$1lxegnk, fromStr$0nnqa9n as nonzero_fromStr$0nnqa9n, fromStrRadix$1d9m2yx as nonzero_fromStrRadix$1d9m2yx, fromStr$1oqlbkr as nonzero_fromStr$1oqlbkr, fromStrRadix$1jz5doi as nonzero_fromStrRadix$1jz5doi, fromStr$0tkab53 as nonzero_fromStr$0tkab53, fromStrRadix$1d0ksj7 as nonzero_fromStrRadix$1d0ksj7, fromStr$1q8byvk as nonzero_fromStr$1q8byvk, fromStrRadix$07g34i1 as nonzero_fromStrRadix$07g34i1, fromStr$0ujk11v as nonzero_fromStr$0ujk11v, fromStrRadix$17bacti as nonzero_fromStrRadix$17bacti, fromStr$0rlmwxp as nonzero_fromStr$0rlmwxp, fromStrRadix$059mp1l as nonzero_fromStrRadix$059mp1l, fromStr$06ydblo as nonzero_fromStr$06ydblo, fromStrRadix$0kf0g60 as nonzero_fromStrRadix$0kf0g60, fromStr$1oeehgy as nonzero_fromStr$1oeehgy, fromStrRadix$0ynvtyj as nonzero_fromStrRadix$0ynvtyj, fromStr$1b9wkfh as nonzero_fromStr$1b9wkfh, fromStrRadix$0cet6d1 as nonzero_fromStrRadix$0cet6d1, fromStr$1hl5h4e as nonzero_fromStr$1hl5h4e, fromStrRadix$1bz0mya as nonzero_fromStrRadix$1bz0mya } from "./core/num/nonzero.ts"; -import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1a4gm66 as option_unwrapOr$1a4gm66, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0gl6wke as option_map$0gl6wke, mapOr$16umieg as option_mapOr$16umieg, mapOr$147z9gi as option_mapOr$147z9gi } from "./core/option.ts"; -import { parse$0vh4cry, parse$1gx0slj, parse$19hh5l5, parse$1wk8j8i, parse$0zmco93, parse$1t9x185, parse$1jrkp2i, parse$1qgvwsg, parse$1osnhn3, parse$1gszg8m, parse$06gw7w3, parse$1srq5rw, parse$15q33cp } from "./core/str.ts"; +import { fromStr$0evev4b as nonzero_fromStr$0evev4b, fromStrRadix$1dc3cul as nonzero_fromStrRadix$1dc3cul, fromStr$1lm2uzl as nonzero_fromStr$1lm2uzl, fromStrRadix$1cv6o7i as nonzero_fromStrRadix$1cv6o7i, fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3, fromStrRadix$18imw6k as nonzero_fromStrRadix$18imw6k, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStrRadix$1u3fi38 as nonzero_fromStrRadix$1u3fi38, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStrRadix$0yvapq5 as nonzero_fromStrRadix$0yvapq5, fromStr$06k4xxy as nonzero_fromStr$06k4xxy, fromStrRadix$0rmwudb as nonzero_fromStrRadix$0rmwudb, fromStr$0xht6mx as nonzero_fromStr$0xht6mx, fromStrRadix$0qjnxek as nonzero_fromStrRadix$0qjnxek, fromStr$021o7ki as nonzero_fromStr$021o7ki, fromStrRadix$0dk3w71 as nonzero_fromStrRadix$0dk3w71, fromStr$1myv2t6 as nonzero_fromStr$1myv2t6, fromStrRadix$0o6ntrm as nonzero_fromStrRadix$0o6ntrm, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStrRadix$0ebk8xe as nonzero_fromStrRadix$0ebk8xe, fromStr$081k88g as nonzero_fromStr$081k88g, fromStrRadix$17xzbib as nonzero_fromStrRadix$17xzbib, fromStr$1gsgexo as nonzero_fromStr$1gsgexo, fromStrRadix$0k1ynqn as nonzero_fromStrRadix$0k1ynqn } from "./core/num/nonzero.ts"; +import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0gl6wke as option_map$0gl6wke, mapOr$16umieg as option_mapOr$16umieg, mapOr$147z9gi as option_mapOr$147z9gi } from "./core/option.ts"; +import { parse$0vh4cry, parse$1bh1yup, parse$034rhh2, parse$1wp6z3o, parse$00wf0ig, parse$1bfudtm, parse$16jvjal, parse$0y8gj7z, parse$0y6waa4, parse$1s5pqso, parse$129b0a7, parse$150tkxc, parse$02m155k } from "./core/str.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "./core/str/traits.ts"; import { put as fmt_put } from "./fmt.ts"; import * as strs_Counted from "./strs.Counted.ts"; import * as strs_Named from "./strs.Named.ts"; /** A char of the alphabet for each byte, by its low bits. */ -export function text(dataData: Uint8Array, dataStart: number, dataLen: number): string { +export function text(data: rt.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen)); + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -29,8 +29,8 @@ export function text(dataData: Uint8Array, dataStart: number, dataLen: number): } /** Whether the `i`th step reads from the back: by the byte's high bit. */ -export function fromBack(dataData: Uint8Array, dataStart: number, dataLen: number, i: rt.usize): boolean { - const _3: rt.u8 | undefined = rt.byteSliceGet(new rt.ByteSlice(dataData, dataStart, dataLen), i); +export function fromBack(data: rt.ByteSlice, i: rt.usize): boolean { + const _3: rt.u8 | undefined = rt.byteSliceGet(data, i); if (_3 !== undefined) { if ((_3 & 128) !== 0) { return true; @@ -63,13 +63,13 @@ export function putSeen(out: rt.ByteVec, seen: rt.char[]): void { rt.byteVecPush(out, 253); } -export function strs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let c!: rt.char | undefined; let part!: string | undefined; let part3!: string | undefined; let item!: [rt.usize, string] | undefined; let _236!: rt.char; - const s: string = text(dataData, dataStart, dataLen); + const s: string = text(data); const _7: rt.usize = rt.u8Rem(rt.u8Div(kind, 8), 16) as rt.usize; if (!(_7 < 16)) { rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _7); @@ -81,7 +81,7 @@ export function strs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const it: rt.Iter = rt.strChars(s); let i: rt.usize = 0; while (true) { - if (!fromBack(dataData, dataStart, dataLen, i)) { + if (!fromBack(data, i)) { c = rt.iterToOption(it.next()); } else { c = rt.iterToOption(it.nextBack()); @@ -109,7 +109,7 @@ export function strs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const parts: rt.Iter = rt.strSplit(s, String.fromCodePoint(sep)); let i2: rt.usize = 0; while (true) { - if (!fromBack(dataData, dataStart, dataLen, i2)) { + if (!fromBack(data, i2)) { part = rt.iterToOption(parts.next()); } else { part = rt.iterToOption(parts.nextBack()); @@ -137,7 +137,7 @@ export function strs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL }); let i3: rt.usize = 0; while (true) { - if (!fromBack(dataData, dataStart, dataLen, i3)) { + if (!fromBack(data, i3)) { part3 = rt.iterToOption(parts2.next()); } else { part3 = rt.iterToOption(parts2.nextBack()); @@ -183,7 +183,7 @@ export function strs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL const found2: rt.Iter<[rt.usize, string]> = rt.strMatchIndices(s, String.fromCodePoint(sep)); let i4: rt.usize = 0; while (true) { - if (!fromBack(dataData, dataStart, dataLen, i4)) { + if (!fromBack(data, i4)) { item = rt.iterToOption(found2.next()); } else { item = rt.iterToOption(found2.nextBack()); @@ -278,10 +278,10 @@ export function pattern(kind: rt.u8, s: string): string { * `&s[a..b]` by byte offsets, and the `str` methods by a `&str` pattern, which an empty * one matches before each char and after the last. */ -export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _209!: [rt.usize, rt.usize]; let sliced!: string; - const s: string = text(dataData, dataStart, dataLen); + const s: string = text(data); const p: string = pattern(kind, s); b0: { const _8: rt.u8 = rt.u8Rem(kind, 8); @@ -369,10 +369,10 @@ export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } return rt.usizeSaturatingSub(rt.usizeAdd(rt.stringLen(s), 1), rt.usizeRem(b2 as rt.usize, 4)); }; - if (!(dataLen >= 2)) { + if (!(data.length >= 2)) { _209 = [0, 0] as [rt.usize, rt.usize]; } else { - _209 = [at2(dataData[dataStart]), at2(dataData[dataStart + 1])] as [rt.usize, rt.usize]; + _209 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rt.usize, rt.usize]; } const a: rt.usize = _209[0]; const b: rt.usize = _209[1]; @@ -515,8 +515,7 @@ export function odd(c: rt.char): boolean { export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt.ByteVec): void { let capacity!: rt.usize; const part = rt.u8Rem(a, 4) as rt.usize; - const _7: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, part); - const piece: string = text(_7.data, _7.start, _7.length); + const piece: string = text(rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, part)); const _17: [rt.usize, rt.usize] = [offset(s.v, a), offset(s.v, b)]; const i: rt.usize = _17[0]; const j: rt.usize = _17[1]; @@ -638,8 +637,9 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data if (mid > dataLen) { rt.panic("mid > len"); } - let s: string = text(dataData, dataStart, mid); - const named: strs_Named.Named = { name: text(dataData, dataStart, mid) }; + const head: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); + let s: string = text(head); + const named: strs_Named.Named = { name: text(head) }; const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), 3); while (true) { const _18: rt.ByteSlice | rt.Done = iter.next(); @@ -689,16 +689,15 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * of every edge, of text of chars of every UTF-8 width, or of bytes mapped into an * alphabet of signs, digits, and the letters of `true` and `false`. */ -export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let one!: string | undefined; let all!: string[]; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const radix: rt.u32 = rt.u32Add(2, rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.u32, 35)); const _13: rt.u8 = rt.u8Rem(rt.u8Div(kind, 14), 3); if (_13 === 0) { one = undefined; } else if (_13 === 1) { - one = text(data.data, data.start, data.length); + one = text(data); } else { let s: string = ""; for (const b of rt.byteSliceView(data)) { @@ -757,7 +756,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.charFromStr(_49); } else if (_53 === 2) { const radix2: rt.u32 = radix; - const iter5: rt.Iter> = rt.iterSlice([parse$1srq5rw(_49), nonzero_fromStr$1cr4vnw(_49)]); + const iter5: rt.Iter> = rt.iterSlice([parse$150tkxc(_49), nonzero_fromStr$0evev4b(_49)]); while (true) { const _149: rt.Result | rt.Done = iter5.next(); if (_149 === rt.DONE) { @@ -774,13 +773,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rt.fmtSpec({ alternate: true }, args12[1])])); } } - const _139: rt.Result = parse$1srq5rw(_49); + const _139: rt.Result = parse$150tkxc(_49); if (!_139.ok) { const part12 = _139.error.kind; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part12)]; fmt_put(out, rt.fmtFormat([args14[0]])); } - const _195: rt.Result = nonzero_fromStrRadix$14i0wt8(_49, radix2); + const _195: rt.Result = nonzero_fromStrRadix$1dc3cul(_49, radix2); if (_195.ok) { const arg24 = _195.value; const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg24, f)]; @@ -792,7 +791,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 3) { const radix3: rt.u32 = radix; - const iter6: rt.Iter> = rt.iterSlice([parse$1osnhn3(_49), nonzero_fromStr$0lgcgfz(_49)]); + const iter6: rt.Iter> = rt.iterSlice([parse$0y6waa4(_49), nonzero_fromStr$1lm2uzl(_49)]); while (true) { const _236: rt.Result | rt.Done = iter6.next(); if (_236 === rt.DONE) { @@ -809,13 +808,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args22[0], "|", args22[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rt.fmtSpec({ alternate: true }, args22[1])])); } } - const _226: rt.Result = parse$1osnhn3(_49); + const _226: rt.Result = parse$0y6waa4(_49); if (!_226.ok) { const part11 = _226.error.kind; const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part11)]; fmt_put(out, rt.fmtFormat([args24[0]])); } - const _282: rt.Result = nonzero_fromStrRadix$1lxegnk(_49, radix3); + const _282: rt.Result = nonzero_fromStrRadix$1cv6o7i(_49, radix3); if (_282.ok) { const arg22 = _282.value; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg22, f)]; @@ -827,7 +826,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 4) { const radix4: rt.u32 = radix; - const iter7: rt.Iter> = rt.iterSlice([parse$1gszg8m(_49), nonzero_fromStr$0nnqa9n(_49)]); + const iter7: rt.Iter> = rt.iterSlice([parse$1s5pqso(_49), nonzero_fromStr$0gvyqp3(_49)]); while (true) { const _323: rt.Result | rt.Done = iter7.next(); if (_323 === rt.DONE) { @@ -844,13 +843,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rt.fmtSpec({ alternate: true }, args32[1])])); } } - const _313: rt.Result = parse$1gszg8m(_49); + const _313: rt.Result = parse$1s5pqso(_49); if (!_313.ok) { const part10 = _313.error.kind; const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part10)]; fmt_put(out, rt.fmtFormat([args34[0]])); } - const _369: rt.Result = nonzero_fromStrRadix$1d9m2yx(_49, radix4); + const _369: rt.Result = nonzero_fromStrRadix$18imw6k(_49, radix4); if (_369.ok) { const arg20 = _369.value; const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg20, f)]; @@ -862,7 +861,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 5) { const radix5: rt.u32 = radix; - const iter8: rt.Iter> = rt.iterSlice([parse$06gw7w3(_49), nonzero_fromStr$1oqlbkr(_49)]); + const iter8: rt.Iter> = rt.iterSlice([parse$129b0a7(_49), nonzero_fromStr$19lq810(_49)]); while (true) { const _410: rt.Result | rt.Done = iter8.next(); if (_410 === rt.DONE) { @@ -879,13 +878,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args42[0], "|", args42[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rt.fmtSpec({ alternate: true }, args42[1])])); } } - const _400: rt.Result = parse$06gw7w3(_49); + const _400: rt.Result = parse$129b0a7(_49); if (!_400.ok) { const part9 = _400.error.kind; const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part9)]; fmt_put(out, rt.fmtFormat([args44[0]])); } - const _456: rt.Result = nonzero_fromStrRadix$1jz5doi(_49, radix5); + const _456: rt.Result = nonzero_fromStrRadix$1u3fi38(_49, radix5); if (_456.ok) { const arg18 = _456.value; const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg18, f)]; @@ -897,7 +896,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 6) { const radix6: rt.u32 = radix; - const iter9: rt.Iter> = rt.iterSlice([parse$1qgvwsg(_49), nonzero_fromStr$0tkab53(_49)]); + const iter9: rt.Iter> = rt.iterSlice([parse$0y8gj7z(_49), nonzero_fromStr$1lyc2jq(_49)]); while (true) { const _497: rt.Result | rt.Done = iter9.next(); if (_497 === rt.DONE) { @@ -914,13 +913,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args52[0], "|", args52[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rt.fmtSpec({ alternate: true }, args52[1])])); } } - const _487: rt.Result = parse$1qgvwsg(_49); + const _487: rt.Result = parse$0y8gj7z(_49); if (!_487.ok) { const part8 = _487.error.kind; const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part8)]; fmt_put(out, rt.fmtFormat([args54[0]])); } - const _543: rt.Result = nonzero_fromStrRadix$1d0ksj7(_49, radix6); + const _543: rt.Result = nonzero_fromStrRadix$0yvapq5(_49, radix6); if (_543.ok) { const arg16 = _543.value; const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg16, f)]; @@ -932,7 +931,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 7) { const radix7: rt.u32 = radix; - const iter10: rt.Iter> = rt.iterSlice([parse$15q33cp(_49), nonzero_fromStr$1q8byvk(_49)]); + const iter10: rt.Iter> = rt.iterSlice([parse$02m155k(_49), nonzero_fromStr$06k4xxy(_49)]); while (true) { const _584: rt.Result | rt.Done = iter10.next(); if (_584 === rt.DONE) { @@ -949,13 +948,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args62[0], "|", args62[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rt.fmtSpec({ alternate: true }, args62[1])])); } } - const _574: rt.Result = parse$15q33cp(_49); + const _574: rt.Result = parse$02m155k(_49); if (!_574.ok) { const part7 = _574.error.kind; const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part7)]; fmt_put(out, rt.fmtFormat([args64[0]])); } - const _630: rt.Result = nonzero_fromStrRadix$07g34i1(_49, radix7); + const _630: rt.Result = nonzero_fromStrRadix$0rmwudb(_49, radix7); if (_630.ok) { const arg14 = _630.value; const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg14, f)]; @@ -967,7 +966,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 8) { const radix8: rt.u32 = radix; - const iter11: rt.Iter> = rt.iterSlice([parse$1t9x185(_49), nonzero_fromStr$0ujk11v(_49)]); + const iter11: rt.Iter> = rt.iterSlice([parse$1bfudtm(_49), nonzero_fromStr$0xht6mx(_49)]); while (true) { const _671: rt.Result | rt.Done = iter11.next(); if (_671 === rt.DONE) { @@ -984,13 +983,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rt.fmtSpec({ alternate: true }, args72[1])])); } } - const _661: rt.Result = parse$1t9x185(_49); + const _661: rt.Result = parse$1bfudtm(_49); if (!_661.ok) { const part6 = _661.error.kind; const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part6)]; fmt_put(out, rt.fmtFormat([args74[0]])); } - const _717: rt.Result = nonzero_fromStrRadix$17bacti(_49, radix8); + const _717: rt.Result = nonzero_fromStrRadix$0qjnxek(_49, radix8); if (_717.ok) { const arg12 = _717.value; const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg12, f)]; @@ -1002,7 +1001,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 9) { const radix9: rt.u32 = radix; - const iter12: rt.Iter> = rt.iterSlice([parse$19hh5l5(_49), nonzero_fromStr$0rlmwxp(_49)]); + const iter12: rt.Iter> = rt.iterSlice([parse$034rhh2(_49), nonzero_fromStr$021o7ki(_49)]); while (true) { const _758: rt.Result | rt.Done = iter12.next(); if (_758 === rt.DONE) { @@ -1019,13 +1018,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args82[0], "|", args82[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rt.fmtSpec({ alternate: true }, args82[1])])); } } - const _748: rt.Result = parse$19hh5l5(_49); + const _748: rt.Result = parse$034rhh2(_49); if (!_748.ok) { const part5 = _748.error.kind; const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part5)]; fmt_put(out, rt.fmtFormat([args84[0]])); } - const _804: rt.Result = nonzero_fromStrRadix$059mp1l(_49, radix9); + const _804: rt.Result = nonzero_fromStrRadix$0dk3w71(_49, radix9); if (_804.ok) { const arg10 = _804.value; const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg10, f)]; @@ -1037,7 +1036,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 10) { const radix10: rt.u32 = radix; - const iter13: rt.Iter> = rt.iterSlice([parse$1wk8j8i(_49), nonzero_fromStr$06ydblo(_49)]); + const iter13: rt.Iter> = rt.iterSlice([parse$1wp6z3o(_49), nonzero_fromStr$1myv2t6(_49)]); while (true) { const _845: rt.Result | rt.Done = iter13.next(); if (_845 === rt.DONE) { @@ -1054,13 +1053,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rt.fmtSpec({ alternate: true }, args92[1])])); } } - const _835: rt.Result = parse$1wk8j8i(_49); + const _835: rt.Result = parse$1wp6z3o(_49); if (!_835.ok) { const part4 = _835.error.kind; const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part4)]; fmt_put(out, rt.fmtFormat([args94[0]])); } - const _891: rt.Result = nonzero_fromStrRadix$0kf0g60(_49, radix10); + const _891: rt.Result = nonzero_fromStrRadix$0o6ntrm(_49, radix10); if (_891.ok) { const arg8 = _891.value; const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg8, f)]; @@ -1072,7 +1071,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 11) { const radix11: rt.u32 = radix; - const iter14: rt.Iter> = rt.iterSlice([parse$0zmco93(_49), nonzero_fromStr$1oeehgy(_49)]); + const iter14: rt.Iter> = rt.iterSlice([parse$00wf0ig(_49), nonzero_fromStr$10p52cj(_49)]); while (true) { const _932: rt.Result | rt.Done = iter14.next(); if (_932 === rt.DONE) { @@ -1089,13 +1088,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args102[0], "|", args102[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rt.fmtSpec({ alternate: true }, args102[1])])); } } - const _922: rt.Result = parse$0zmco93(_49); + const _922: rt.Result = parse$00wf0ig(_49); if (!_922.ok) { const part3 = _922.error.kind; const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part3)]; fmt_put(out, rt.fmtFormat([args104[0]])); } - const _978: rt.Result = nonzero_fromStrRadix$0ynvtyj(_49, radix11); + const _978: rt.Result = nonzero_fromStrRadix$0ebk8xe(_49, radix11); if (_978.ok) { const arg6 = _978.value; const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg6, f)]; @@ -1107,7 +1106,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else if (_53 === 12) { const radix12: rt.u32 = radix; - const iter15: rt.Iter> = rt.iterSlice([parse$1gx0slj(_49), nonzero_fromStr$1b9wkfh(_49)]); + const iter15: rt.Iter> = rt.iterSlice([parse$1bh1yup(_49), nonzero_fromStr$081k88g(_49)]); while (true) { const _1019: rt.Result | rt.Done = iter15.next(); if (_1019 === rt.DONE) { @@ -1124,13 +1123,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rt.fmtSpec({ alternate: true }, args112[1])])); } } - const _1009: rt.Result = parse$1gx0slj(_49); + const _1009: rt.Result = parse$1bh1yup(_49); if (!_1009.ok) { const part2 = _1009.error.kind; const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part2)]; fmt_put(out, rt.fmtFormat([args114[0]])); } - const _1065: rt.Result = nonzero_fromStrRadix$0cet6d1(_49, radix12); + const _1065: rt.Result = nonzero_fromStrRadix$17xzbib(_49, radix12); if (_1065.ok) { const arg4 = _1065.value; const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg4, f)]; @@ -1142,7 +1141,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } } else { const radix13: rt.u32 = radix; - const iter16: rt.Iter> = rt.iterSlice([parse$1jrkp2i(_49), nonzero_fromStr$1hl5h4e(_49)]); + const iter16: rt.Iter> = rt.iterSlice([parse$16jvjal(_49), nonzero_fromStr$1gsgexo(_49)]); while (true) { const _1106: rt.Result | rt.Done = iter16.next(); if (_1106 === rt.DONE) { @@ -1159,13 +1158,13 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat fmt_put(out, rt.fmtFormat([args122[0], "|", args122[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rt.fmtSpec({ alternate: true }, args122[1])])); } } - const _1096: rt.Result = parse$1jrkp2i(_49); + const _1096: rt.Result = parse$16jvjal(_49); if (!_1096.ok) { const part = _1096.error.kind; const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part)]; fmt_put(out, rt.fmtFormat([args124[0]])); } - const _1152: rt.Result = nonzero_fromStrRadix$1bz0mya(_49, radix13); + const _1152: rt.Result = nonzero_fromStrRadix$0k1ynqn(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; @@ -1183,13 +1182,12 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * `String` made from and extended by iterators of chars and of strings, each the kind * picks, from text of chars of every UTF-8 width and its parts between `/`s. */ -export function iters(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const s: string = text(dataData, dataStart, dataLen); +export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const s: string = text(data); const chars: rt.char[] = rt.iterToArray(rt.strChars(s), "next", 4); const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), "next", 8); const nexts: rt.Cell = new rt.Cell(0); - const _16: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.usizeDiv(dataLen, 2)); - const named: strs_Named.Named = { name: text(_16.data, _16.start, _16.length) }; + const named: strs_Named.Named = { name: text(rt.byteSliceRange(data, 0, rt.usizeDiv(data.length, 2))) }; const _21: rt.u8 = rt.u8Rem(kind, 4); if (_21 === 0) { fmt_put(out, rt.stringExtendChars("", rt.strChars(s))); @@ -1363,8 +1361,9 @@ export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat if (mid > dataLen) { rt.panic("mid > len"); } - let s: string = text(dataData, dataStart, mid); - const named: strs_Named.Named = { name: text(dataData, dataStart, mid) }; + const head: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); + let s: string = text(head); + const named: strs_Named.Named = { name: text(head) }; const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), 4); while (true) { const _18: rt.ByteSlice | rt.Done = iter.next(); @@ -1408,9 +1407,8 @@ export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * hint's lower bound first, which panics past `isize::MAX` before it reads a char, and * else the chars panic with `consumed` past the eighth. */ -export function hinted(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function hinted(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _70!: rt.usize; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const pick: (a0: rt.usize) => rt.u32 = (i: rt.usize): rt.u32 => { const _4: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.usize, [0, 5, 8, 9, 2147483645, 2147483648, 4294967295].length); if (!(_4 < 7)) { @@ -1424,10 +1422,7 @@ export function hinted(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const sub: rt.usize = rt.usizeDiv(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, [0, 5, 8, 9, 2147483645, 2147483648, 4294967295].length); let t: string = "aé"; const _25: rt.Place = rt.place(() => t, (value) => t = value); - const _30: rt.ByteSlice | undefined = rt.byteSliceGetRange(data, 2); - const _32: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of()); - const _29: rt.ByteSlice = option_unwrapOr$1a4gm66(_30, _32.data, _32.start, _32.length); - const _26: string = text(_29.data, _29.start, _29.length); + const _26: string = text(option_unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 2), rt.byteSliceFrom(Uint8Array.of()))); _25.v = _25.v + _26; const calls: rt.Cell = new rt.Cell(0); const f: (a0: rt.u32) => rt.char = (_2: rt.u32): rt.char => { diff --git a/ts/fixtures/lang/expected/tuples.ts b/ts/fixtures/lang/expected/tuples.ts index acc562662..571290dd1 100644 --- a/ts/fixtures/lang/expected/tuples.ts +++ b/ts/fixtures/lang/expected/tuples.ts @@ -33,29 +33,29 @@ export function entries(map: rt.HashMap, out: rt.ByteVec): void { } /** Collected, unzipped, or extended as `kind` picks, from at most 24 bytes of `data`. */ -export function tuples(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(dataData, dataStart, dataLen), 0, rt.min(dataLen, 24)); +export function tuples(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 24)); const _8: rt.u8 = rt.u8Rem(kind, 10); if (_8 === 0) { - ones(data2.data, data2.start, data2.length, out); + ones(data2, out); } else if (_8 === 1) { - pairs(data2.data, data2.start, data2.length, out); + pairs(data2, out); } else if (_8 === 2) { - triples(data2.data, data2.start, data2.length, out); + triples(data2, out); } else if (_8 === 3) { - twelves(data2.data, data2.start, data2.length, out); + twelves(data2, out); } else if (_8 === 4) { - extended(data2.data, data2.start, data2.length, out); + extended(data2, out); } else if (_8 === 5) { - borrowed(data2.data, data2.start, data2.length, out); + borrowed(data2, out); } else if (_8 === 6) { - dropped(data2.data, data2.start, data2.length, out); + dropped(data2, out); } else if (_8 === 7) { - panicked(data2.data, data2.start, data2.length, out); + panicked(data2, out); } else if (_8 === 8) { - reserved(data2.data, data2.start, data2.length, out); + reserved(data2, out); } else { - shunted(data2.data, data2.start, data2.length, out); + shunted(data2, out); } } @@ -63,8 +63,7 @@ export function tuples(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * 1-tuples, each by its collection's own `extend`: a heap's rebuilds once, where a longer * tuple's pushes each item. */ -export function ones(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(rt.tupleExtendOne([[]] as [rt.u16[]], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u16] => { return [(((_2 as rt.u16)) << 4) & 0xffff] as [rt.u16]; }), (c, items) => rt.iterExtend(c, items, undefined, 2, true))[0]), (n: rt.u16): Uint8Array => { @@ -128,8 +127,7 @@ export function ones(dataData: Uint8Array, dataStart: number, dataLen: number, o } /** Pairs, by `collect` and `unzip`, of `()` too. */ -export function pairs(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _6: rt.Iter<[rt.u8, rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char] => { const b: rt.u8 = _2; return [b ^ 90, b as rt.char] as [rt.u8, rt.char]; @@ -179,8 +177,7 @@ export function pairs(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Triples, of mixed collections, and tuples of collections within one. */ -export function triples(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const _7: rt.Iter<[rt.u8, rt.u16, rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u16, rt.char] => { const b: rt.u8 = _2; return [b, (((b as rt.u16)) << 8) & 0xffff, rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char] as [rt.u8, rt.u16, rt.char]; @@ -232,8 +229,8 @@ export function triples(dataData: Uint8Array, dataStart: number, dataLen: number } /** The longest tuple std's impls take, of every collection the runtime extends. */ -export function twelves(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _16: rt.Iter<[rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): [rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]] => { +export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { + const _16: rt.Iter<[rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]] => { const b: rt.u8 = _2; const _8: rt.usize = rt.u8Rem(b, 3) as rt.usize; if (!(_8 < 3)) { @@ -288,8 +285,7 @@ export function twelves(dataData: Uint8Array, dataStart: number, dataLen: number * `extend` onto collections that hold some already: a heap sifts each item up past them, * and a map or set keeps an equal key already there. */ -export function extended(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([1]), undefined, 2, true), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rt.Iter<[rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8] => { const b: rt.u8 = _2; @@ -321,8 +317,7 @@ export function extended(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** `Extend<&T>` and `Extend<(&K, &V)>`, which store copies of what the items borrow. */ -export function borrowed(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { const points: Spot.Spot[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Spot.Spot => { const b: rt.u8 = _2; return { x: b, y: (((b as rt.u16)) << 2) & 0xffff }; @@ -367,8 +362,7 @@ export function borrowed(dataData: Uint8Array, dataStart: number, dataLen: numbe * to one it holds, as each item's fields extend in order, and what an iterator still * holds drops once the tuple extended by it is done. */ -export function dropped(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); const logged: (a0: rt.u8, a1: rt.u8) => tuples_Logged.Logged = (id: rt.u8, key: rt.u8): tuples_Logged.Logged => { return new tuples_Logged.Logged(id, key, rt.arcClone(log)); @@ -441,8 +435,7 @@ export function dropped(dataData: Uint8Array, dataStart: number, dataLen: number } /** A panic midway, from what makes the items. */ -export function panicked(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { const at: rt.usize = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8) as rt.usize; const _13: rt.Iter<[rt.u8, rt.char, rt.u16]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): [rt.u8, rt.char, rt.u16] => { const i: rt.usize = _2[0]; @@ -470,9 +463,9 @@ export function panicked(dataData: Uint8Array, dataStart: number, dataLen: numbe * A size hint past what a collection may hold, which the first to reserve for it panics * at, in field order, before any item is made. */ -export function reserved(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function reserved(data: rt.ByteSlice, out: rt.ByteVec): void { const items: rt.Range = new rt.Range(0, 4294967295); - const _4: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart, dataLen)), 0), 6); + const _4: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 6); if (_4 === 0) { rt.byteVecPush(out, rt.tupleExtend([undefined, []] as [undefined, rt.u32[]], rt.iterMap(items, (i5: rt.u32): [undefined, rt.u32] => { return [undefined, i5] as [undefined, rt.u32]; @@ -514,8 +507,7 @@ export function reserved(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** `collect` of `Result`s and `Option`s of pairs, into one of a tuple, which std's docs show. */ -export function shunted(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { const parsed: rt.Result<[rt.ByteVec, string], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result<[rt.u8, rt.char], rt.u8> => { const b: rt.u8 = _2; if (!(b === 0)) { diff --git a/ts/fixtures/lang/expected/utf8.ts b/ts/fixtures/lang/expected/utf8.ts index 559ea3fa4..ecf804f91 100644 --- a/ts/fixtures/lang/expected/utf8.ts +++ b/ts/fixtures/lang/expected/utf8.ts @@ -4,12 +4,12 @@ import * as rt from "./rt.ts"; import { mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; import { put as fmt_put } from "./fmt.ts"; -export function decodes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function decodes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let bytes!: rt.ByteVec; if (rt.u8Rem(kind, 2) === 0) { - bytes = rt.byteSliceToByteVec(new rt.ByteSlice(dataData, dataStart, dataLen)); + bytes = rt.byteSliceToByteVec(data); } else { - bytes = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): rt.u8 => { + bytes = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { const _54: rt.usize = rt.u8Rem(_2, 32) as rt.usize; if (!(_54 < 32)) { rt.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 38a27951d..5ddae29d1 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -244,10 +244,9 @@ export function boundOf(kind: rt.u8, a: rt.u64): rt.RangeBound { return { tag: "Unbounded" } as rt.RangeBound; } -export function wrappers(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let scale!: wrappers_Scale.Scale; let name!: string; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _5: (a0: rt.u8) => rt.u64 = (b3: rt.u8): rt.u64 => { const _3: rt.u8 = rt.u8Rem(b3, 4); if (_3 === 0) { diff --git a/ts/fixtures/lang/expected/wraps.ts b/ts/fixtures/lang/expected/wraps.ts index 0f0dbc749..1d9ef6473 100644 --- a/ts/fixtures/lang/expected/wraps.ts +++ b/ts/fixtures/lang/expected/wraps.ts @@ -225,8 +225,7 @@ export function hashed$wraps_Tick_usize(v: Tick.Tick): rt.u64 { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v: rt.u8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u8ToBeBytes(v))); }; @@ -409,8 +408,7 @@ export function u8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v: rt.u16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(v))); }; @@ -593,8 +591,7 @@ export function u16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v: rt.u32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(v))); }; @@ -777,8 +774,7 @@ export function u32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v: rt.u64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(v))); }; @@ -961,8 +957,7 @@ export function u64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v: rt.u128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v))); }; @@ -1145,8 +1140,7 @@ export function u128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v: rt.usize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.usizeToBeBytes(v))); }; @@ -1329,8 +1323,7 @@ export function usizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v: rt.i8): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i8ToBeBytes(v))); }; @@ -1515,8 +1508,7 @@ export function i8s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLe * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v: rt.i16): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i16ToBeBytes(v))); }; @@ -1701,8 +1693,7 @@ export function i16s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v: rt.i32): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i32ToBeBytes(v))); }; @@ -1887,8 +1878,7 @@ export function i32s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v: rt.i64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i64ToBeBytes(v))); }; @@ -2073,8 +2063,7 @@ export function i64s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v: rt.i128): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v))); }; @@ -2259,8 +2248,7 @@ export function i128s(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function isizes(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _30: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v: rt.isize): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.isizeToBeBytes(v))); }; diff --git a/ts/fixtures/lang/expected/zeros.ts b/ts/fixtures/lang/expected/zeros.ts index a81132e1f..ab922d66c 100644 --- a/ts/fixtures/lang/expected/zeros.ts +++ b/ts/fixtures/lang/expected/zeros.ts @@ -66,8 +66,7 @@ export function made$zeros_Unit(): zeros_Unit.Unit { } /** The case `kind` picks, on `data`; each puts what it read. */ -export function zeros(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function zeros(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _72: (a0: rt.u8) => One.One = (_2: rt.u8): One.One => { return "Only" as One.One; }; @@ -272,8 +271,8 @@ export function digest$zeros_Tagged_String(value: zeros_Tagged.Tagged, o } /** The impls `#[derive]` calls on `PhantomData`, `PhantomPinned`, and `()` fields. */ -export function impls(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const tags: zeros_Tagged.Tagged[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_2: rt.u8): zeros_Tagged.Tagged => { +export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const tags: zeros_Tagged.Tagged[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): zeros_Tagged.Tagged => { const n: rt.u8 = _2; zeros_Tagged.default$Default_String(); return { n, of: undefined, pin: undefined, unit: undefined }; @@ -342,15 +341,15 @@ export function impls(kind: rt.u8, dataData: Uint8Array, dataStart: number, data } /** `Some(())` if every byte of `data` is below 0x80. */ -export function small(dataData: Uint8Array, dataStart: number, dataLen: number): undefined | rt.None { - return rt.iterCollectOption(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_22: rt.u8): undefined | rt.None => { +export function small(data: rt.ByteSlice): undefined | rt.None { + return rt.iterCollectOption(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): undefined | rt.None => { return thenSome$1j8foe9(_22 < 128, undefined); }), (values: rt.Iter) => rt.iterFold(values, undefined, () => undefined), undefined, rt.None, rt.None); } /** `Ok(())`, or the first byte of `data` that is 0xff. */ -export function checked(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result { - return rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart, dataLen))), (_22: rt.u8): rt.Result => { +export function checked(data: rt.ByteSlice): rt.Result { + return rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.Result => { const b: rt.u8 = _22; if (!(b === 255)) { return rt.OK; @@ -360,9 +359,8 @@ export function checked(dataData: Uint8Array, dataStart: number, dataLen: number } /** `()` as a hash and B-tree key and as `collect::>`'s item. */ -export function keys(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _148!: rt.u8; - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); const _4: rt.u8 = rt.u8Rem(kind, 3); if (_4 === 0) { const hash: rt.HashSet = rt.hashNew() as rt.HashSet; @@ -410,8 +408,8 @@ export function keys(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL }), (_27: undefined | rt.None): undefined => { rt.byteVecPush(out, 9); }), (values: rt.Iter) => rt.iterToArray(values, "next", 0), undefined, rt.None) !== undefined ? 1 : 0); - rt.byteVecPush(out, small(data.data, data.start, data.length) !== rt.None ? 1 : 0); - const _149: rt.Result = checked(data.data, data.start, data.length); + rt.byteVecPush(out, small(data) !== rt.None ? 1 : 0); + const _149: rt.Result = checked(data); if (_149.ok) { _148 = 0; } else { @@ -460,8 +458,7 @@ export function flattened(_value: undefined, xs: rt.ByteVec[]): rt.u8 { * Functions, closures, and locals whose every read lowers to nothing: a drop of what * drops nothing, and a comparison of what holds nothing. */ -export function unread(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const data: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, dataLen); +export function unread(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.atomicStore(LOG, 0, 0); const n: rt.u8 = data.length & 0xff; const _9: rt.u8 = rt.u8Rem(kind, 3); diff --git a/ts/fixtures/lang/src/args.rs b/ts/fixtures/lang/src/args.rs index 1912a9ebb..a462f7ce0 100644 --- a/ts/fixtures/lang/src/args.rs +++ b/ts/fixtures/lang/src/args.rs @@ -1,4 +1,5 @@ -//! Byte slices passed to the crate's own functions, which take them as their parts. +//! Byte slices passed to the crate's own functions, which take them as their parts unless +//! their bodies make them whole all the same. /// A use that needs the slice itself. #[inline(never)] @@ -21,7 +22,7 @@ fn len(data: &[u8]) -> usize { data.len() } -/// A parameter borrowed, which makes it whole on entry. +/// A parameter borrowed, which takes it whole. fn by_ref(data: &[u8]) -> usize { let r = &data; len_of(r) @@ -31,7 +32,7 @@ fn len_of(data: &&[u8]) -> usize { data.len() } -/// A parameter made whole in a loop, which makes it whole on entry. +/// A parameter made whole in a loop, which takes it whole. fn kept(data: &[u8], n: u8) -> Vec<&[u8]> { let mut all = Vec::new(); for _ in 0..n % 4 { @@ -58,6 +59,54 @@ fn depth(data: &[u8]) -> u8 { } } +/// Passed along to one that takes it whole, so taken whole too. +fn relay(data: &[u8]) -> u8 { + opaque(data) +} + +/// Passed along to one that takes its parts, so taken as parts too. +fn relay_sum(data: &[u8]) -> u8 { + sum(data) +} + +/// Recursive, and made whole at the bottom, so taken whole all the way down. +fn last_run(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) if b != 0 => last_run(rest), + _ => opaque(data), + } +} + +/// Mutually recursive, each reading bytes, so both take parts. +fn evens(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) => b.wrapping_add(odds(rest)), + None => 0, + } +} + +fn odds(data: &[u8]) -> u8 { + match data.split_first() { + Some((_, rest)) => evens(rest), + None => 0, + } +} + +/// Mutually recursive, where `ping` makes its slice whole and `pong` only splits its own. +fn ping(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) if b % 3 != 0 => pong(rest), + _ => opaque(data), + } +} + +fn pong(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) => b ^ ping(rest), + None => 0, + } +} + /// A slice chosen by a call that does something. fn pick<'a>(out: &mut Vec, data: &'a [u8]) -> &'a [u8] { out.push(0xbb); @@ -90,7 +139,7 @@ fn weigh(w: &W, data: &[u8]) -> u8 { } pub fn args(kind: u8, data: &[u8], out: &mut Vec) { - match kind % 6 { + match kind % 8 { 0 => { out.push(sum(data)); out.push(len(data) as u8); @@ -126,6 +175,25 @@ pub fn args(kind: u8, data: &[u8], out: &mut Vec) { } out.extend_from_slice(&seen); } + 6 => { + let data = &data[..data.len().min(64)]; + out.push(relay(data)); + out.push(relay_sum(data)); + out.push(last_run(data)); + out.push(evens(data)); + out.push(ping(data)); + out.push(pong(data)); + } + 7 => { + // Callers holding the slice whole, and ones holding its parts, of one callee. + let halves = [data.split_at(data.len() / 2).0, data.split_at(data.len() / 2).1]; + for half in halves.iter() { + out.push(sum(half)); + out.push(relay(half)); + } + out.push(relay_sum(halves[1])); + out.push(sum(data)); + } _ => { out.push(weigh(&Scale(kind), data)); out.push(Scale(3).weigh(&data[data.len().min(2)..])); diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index e3abcf93f..5b3f996cb 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -12,9 +12,9 @@ import { then$1y5f3ge } from "./core/bool.ts"; * A `BytesMut` split, frozen, grown, and written, ending with every piece's bytes: a * write to one that reached another would show. */ -export function bytesMut(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { let _80!: rt.usize; - const ops: Ops.Ops = { _0: new rt.ByteSlice(dataData, dataStart, dataLen) }; + const ops: Ops.Ops = { _0: data }; const buf: rt.BytesMut = rt.bytesMutWithCapacity(rt.usizeRem(Ops.byte(ops) as rt.usize, 24)); const pieces: rt.BytesMut[] = []; const frozen: rt.ByteSlice[] = []; @@ -435,28 +435,28 @@ export function reads(dataData: Uint8Array, dataStart: number, dataLen: number, const _22: rt.u8 = rt.u8Rem(dataData[dataStart], 8); if (_22 === 0) { let _24: rt.ByteSlice = rt.bytesCopyFromSlice(input); - rest = readAll$bytes_Bytes(rt.place(() => _24, (value7) => _24 = value7), dataData, dataStart + 2, mid, read$bytes_Bytes, out); + rest = readAll$bytes_Bytes(rt.place(() => _24, (value7) => _24 = value7), new rt.ByteSlice(dataData, dataStart + 2, mid), read$bytes_Bytes, out); } else if (_22 === 1) { - rest = readAll$bytes_BytesMut(rt.bytesMutFrom(input), dataData, dataStart + 2, mid, read$bytes_BytesMut, out); + rest = readAll$bytes_BytesMut(rt.bytesMutFrom(input), new rt.ByteSlice(dataData, dataStart + 2, mid), read$bytes_BytesMut, out); } else if (_22 === 2) { - rest = readAll$buf_Pieces(Pieces.new(input.data, input.start, input.length, cut), dataData, dataStart + 2, mid, readPieces$buf_Pieces, out); + rest = readAll$buf_Pieces(Pieces.new(input.data, input.start, input.length, cut), new rt.ByteSlice(dataData, dataStart + 2, mid), readPieces$buf_Pieces, out); } else if (_22 === 3) { let _33: rt.ByteSlice = rt.byteSliceRange(input, 0); - rest = readAll$ref_slice_u8(rt.place(() => _33, (value6) => _33 = value6), dataData, dataStart + 2, mid, read$ref_slice_u8, out); + rest = readAll$ref_slice_u8(rt.place(() => _33, (value6) => _33 = value6), new rt.ByteSlice(dataData, dataStart + 2, mid), read$ref_slice_u8, out); } else if (_22 === 4) { const _37: Provided.Provided = { _0: Pieces.new(input.data, input.start, input.length, cut) }; - rest = readAll$buf_Provided(_37, dataData, dataStart + 2, mid, readPieces$buf_Provided, out); + rest = readAll$buf_Provided(_37, new rt.ByteSlice(dataData, dataStart + 2, mid), readPieces$buf_Provided, out); } else if (_22 === 5) { let _42: rt.ByteSlice = rt.bytesCopyFromSlice(input); let _41: rt.Place = rt.place(() => _42, (value4) => _42 = value4); - rest = readAll$mut_bytes_Bytes(rt.place(() => _41, (value5) => _41 = value5), dataData, dataStart + 2, mid, read$mut_bytes_Bytes, out); + rest = readAll$mut_bytes_Bytes(rt.place(() => _41, (value5) => _41 = value5), new rt.ByteSlice(dataData, dataStart + 2, mid), read$mut_bytes_Bytes, out); } else if (_22 === 6) { let _46: rt.ByteSlice = rt.byteSliceRange(input, 0); let _45: rt.Place = rt.place(() => _46, (value2) => _46 = value2); - rest = readAll$mut_ref_slice_u8(rt.place(() => _45, (value3) => _45 = value3), dataData, dataStart + 2, mid, read$mut_ref_slice_u8, out); + rest = readAll$mut_ref_slice_u8(rt.place(() => _45, (value3) => _45 = value3), new rt.ByteSlice(dataData, dataStart + 2, mid), read$mut_ref_slice_u8, out); } else { let _50: Pieces.Pieces = Pieces.new(input.data, input.start, input.length, cut); - rest = readAll$mut_buf_Pieces(rt.place(() => _50, (value) => _50 = value), dataData, dataStart + 2, mid, readPieces$mut_buf_Pieces, out); + rest = readAll$mut_buf_Pieces(rt.place(() => _50, (value) => _50 = value), new rt.ByteSlice(dataData, dataStart + 2, mid), readPieces$mut_buf_Pieces, out); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rest)); const vec: rt.ByteVec = new rt.ByteVec(); @@ -513,8 +513,8 @@ export function readPieces$mut_buf_Pieces(buf: rt.Place, n: rt.us } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$buf_Pieces(buf: Pieces.Pieces, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: Pieces.Pieces, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$buf_Pieces(buf: Pieces.Pieces, ops: rt.ByteSlice, read: (a0: Pieces.Pieces, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, Pieces.hasRemaining$bytes_Buf_mut(buf) ? 1 : 0); @@ -527,8 +527,8 @@ export function readAll$buf_Pieces(buf: Pieces.Pieces, opsData: Uint8Array, opsS } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$buf_Provided(buf: Provided.Provided, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: Provided.Provided, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$buf_Provided(buf: Provided.Provided, ops: rt.ByteSlice, read: (a0: Provided.Provided, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, Provided.hasRemaining$bytes_Buf_mut(buf) ? 1 : 0); @@ -541,8 +541,8 @@ export function readAll$buf_Provided(buf: Provided.Provided, opsData: Uint8Array } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_Bytes(buf: rt.Place, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: rt.Place, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$bytes_Bytes(buf: rt.Place, ops: rt.ByteSlice, read: (a0: rt.Place, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_bytes_Bytes(buf) ? 1 : 0); @@ -555,8 +555,8 @@ export function readAll$bytes_Bytes(buf: rt.Place, opsData: Uint8A } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_BytesMut(buf: rt.BytesMut, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: rt.BytesMut, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$bytes_BytesMut(buf: rt.BytesMut, ops: rt.ByteSlice, read: (a0: rt.BytesMut, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_bytes_BytesMut(buf) ? 1 : 0); @@ -569,8 +569,8 @@ export function readAll$bytes_BytesMut(buf: rt.BytesMut, opsData: Uint8Array, op } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_buf_Pieces(buf: rt.Place, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: rt.Place, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$mut_buf_Pieces(buf: rt.Place, ops: rt.ByteSlice, read: (a0: rt.Place, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, Pieces.hasRemaining$bytes_Buf_mut_mut(buf) ? 1 : 0); @@ -583,8 +583,8 @@ export function readAll$mut_buf_Pieces(buf: rt.Place, opsData: Ui } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_bytes_Bytes(buf: rt.Place>, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: rt.Place>, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$mut_bytes_Bytes(buf: rt.Place>, ops: rt.ByteSlice, read: (a0: rt.Place>, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_bytes_Bytes(buf) ? 1 : 0); @@ -597,8 +597,8 @@ export function readAll$mut_bytes_Bytes(buf: rt.Place>, o } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_ref_slice_u8(buf: rt.Place>, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: rt.Place>, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$mut_ref_slice_u8(buf: rt.Place>, ops: rt.ByteSlice, read: (a0: rt.Place>, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(buf) ? 1 : 0); @@ -611,8 +611,8 @@ export function readAll$mut_ref_slice_u8(buf: rt.Place>, } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$ref_slice_u8(buf: rt.Place, opsData: Uint8Array, opsStart: number, opsLen: number, read: (a0: rt.Place, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(new rt.ByteSlice(opsData, opsStart, opsLen))) { +export function readAll$ref_slice_u8(buf: rt.Place, ops: rt.ByteSlice, read: (a0: rt.Place, a1: rt.usize) => rt.u128, out: rt.ByteVec): rt.ByteVec { + for (const op of rt.byteSliceView(ops)) { if (!(op === 255)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read(buf, op as rt.usize)))); rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_ref_slice_u8(buf) ? 1 : 0); @@ -794,8 +794,7 @@ export function writeThrough$mut_Vec_u8(buf: rt.Place, dataData: Uin } else if (_18 === 4) { putU64$bytes_BufMut_mut_Vec_u8(buf, v); } else if (_18 === 5) { - const _23: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2)); - putSlice$bytes_BufMut_mut_Vec_u8(buf, _23.data, _23.start, _23.length); + putSlice$bytes_BufMut_mut_Vec_u8(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 6) { putI128Le$bytes_BufMut_mut_Vec_u8(buf, rt.i128Shl(rt.i128Cast(v), 40)); } else if (_18 === 7) { @@ -839,8 +838,7 @@ export function writeThrough$mut_bytes_BytesMut(buf: rt.Place, data } else if (_18 === 4) { putU64$bytes_BufMut_mut_bytes_BytesMut(buf, v); } else if (_18 === 5) { - const _23: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2)); - putSlice$bytes_BufMut_mut_bytes_BytesMut(buf, _23.data, _23.start, _23.length); + putSlice$bytes_BufMut_mut_bytes_BytesMut(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 6) { putI128Le$bytes_BufMut_mut_bytes_BytesMut(buf, rt.i128Shl(rt.i128Cast(v), 40)); } else if (_18 === 7) { diff --git a/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts b/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts index 6ce8d44cf..99ea78655 100644 --- a/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts +++ b/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts @@ -71,8 +71,7 @@ export function hasRemainingMut$bytes_BufMut_mut_mut_bytes_BytesMut(self: rt.Pla * `self`. */ export function putI128Le$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt.i128): void { - const _3: rt.ByteSlice = rt.byteSliceFrom(rt.i128ToBeBytes(n).reverse()); - putSlice$bytes_BufMut_mut_Vec_u8(self, _3.data, _3.start, _3.length); + putSlice$bytes_BufMut_mut_Vec_u8(self, rt.byteSliceFrom(rt.i128ToBeBytes(n).reverse())); } /** @@ -96,8 +95,7 @@ export function putI128Le$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: * `self`. */ export function putI128Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i128): void { - const _3: rt.ByteSlice = rt.byteSliceFrom(rt.i128ToBeBytes(n).reverse()); - putSlice$bytes_BufMut_mut_bytes_BytesMut(self, _3.data, _3.start, _3.length); + putSlice$bytes_BufMut_mut_bytes_BytesMut(self, rt.byteSliceFrom(rt.i128ToBeBytes(n).reverse())); } /** @@ -267,8 +265,8 @@ export function putI8$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, srcData: Uint8Array, srcStart: number, srcLen: number): void { - rt.byteVecExtendFromSlice(self.v, new rt.ByteSlice(srcData, srcStart, srcLen)); +export function putSlice$bytes_BufMut_mut_Vec_u8(self: rt.Place, src: rt.ByteSlice): void { + rt.byteVecExtendFromSlice(self.v, src); } /** @@ -292,8 +290,8 @@ export function putSlice$bytes_BufMut_mut_Vec_u8(self: rt.Place, src * assert_eq!(b"hello\0", &dst); * ``` */ -export function putSlice$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, srcData: Uint8Array, srcStart: number, srcLen: number): void { - rt.bytesMutExtend(self.v, new rt.ByteSlice(srcData, srcStart, srcLen)); +export function putSlice$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, src: rt.ByteSlice): void { + rt.bytesMutExtend(self.v, src); } /** diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 52cc8dafa..4209af111 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -13,13 +13,9 @@ export function cases(): [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefine slices(a0.data, a0.start, a0.length, a1); }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["made", (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { made(a02.data, a02.start, a02.length, a12); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { - events(a03.data, a03.start, a03.length, a13); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", events as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { random(a04.data, a04.start, a04.length, a14); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { - bytesMut(a05.data, a05.start, a05.length, a15); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", bytesMut as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { reads(a06.data, a06.start, a06.length, a16); }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::writes", (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { writes(a07.data, a07.start, a07.length, a17); @@ -144,8 +140,8 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o * `tracing`'s events, which evaluate nothing without a subscriber: no field marks `out`, * one in a branch included. */ -export function events(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - rt.byteVecPush(out, dataLen & 0xff); +export function events(data: rt.ByteSlice, out: rt.ByteVec): void { + rt.byteVecPush(out, data.length & 0xff); } /** diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 8df3e6c74..1af37b33c 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -382,6 +382,8 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { /// Those not held as their parts, each made from its parts on entry: its name, then /// its parts'. rebuilt: Vec<(Local, String, [String; 3])>, + /// Those held as their parts whose object some read makes from them all the same. + remade: FxHashSet, /// The names of the parameters that are parts. part_params: Vec, /// Where this function hands back its `Ok`'s parts, if it does. @@ -462,6 +464,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { scalar_binds: Vec::new(), parted, rebuilt: Vec::new(), + remade: FxHashSet::default(), part_params: Vec::new(), slot, slotted_calls: FxHashMap::default(), diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 03b01445b..39d2533e4 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -8,7 +8,9 @@ //! 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. A function that hands back a `Result` in a slot holds its -//! result so, to hand back the `Ok`'s parts, and its callers read them back as parts. +//! result so, to hand back the `Ok`'s parts, and its callers read them back as parts. A +//! byte slice parameter is passed as its parts when its body holds it so and never makes +//! its object. use rustc_abi::VariantIdx; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -220,16 +222,85 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { /// Which of `instance`'s parameters it takes as a byte slice's parts, its `data`, /// `start`, and `length`, rather than an `rt.ByteSlice`: each `&[u8]` or `&[u8; N]` of a - /// function only translated code calls directly. Empty if none. - pub(crate) fn parted(&self, instance: ty::Instance<'tcx>) -> Vec { + /// function only translated code calls directly, that its body holds as its parts and + /// never makes the object of. One it would make takes the object its caller has, or + /// makes once. Empty if none. + /// + /// A body holding a slice as parts depends on whether its callees take theirs so, so + /// each instance a call reaches while this settles starts at every slice and drops those + /// its body would make, until none changes: the most parts every body agrees on, through + /// recursion too. + pub(crate) fn parted(&mut self, instance: ty::Instance<'tcx>) -> Vec { + if let Some(parted) = self.parted.get(&instance) { + return parted.clone(); + } let Some(did) = self.inside(instance) else { return Vec::new(); }; - let parted: Vec = self.inside_sig(did, instance).0.into_iter().map(slice_ref).collect(); - match parted.contains(&true) { - true => parted, - false => Vec::new(), + let slices: Vec = self.inside_sig(did, instance).0.into_iter().map(slice_ref).collect(); + if !slices.contains(&true) { + self.parted.insert(instance, Vec::new()); + return Vec::new(); + } + if let Some(parting) = &mut self.parting { + return parting.entry(instance).or_insert(slices).clone(); + } + self.parting = Some([(instance, slices)].into_iter().collect()); + let mut i = 0; + let mut changed = false; + loop { + let parting = self.parting.as_ref().expect("settling"); + if i == parting.len() { + if !std::mem::take(&mut changed) { + break; + } + i = 0; + continue; + } + let (&at, guess) = parting.get_index(i).expect("in range"); + let guess = guess.clone(); + let held = self.held_parts(at, &guess); + if held != guess { + self.parting.as_mut().expect("settling")[i] = held; + changed = true; + } + i += 1; + } + for (at, parted) in self.parting.take().expect("settling") { + let parted = if parted.contains(&true) { parted } else { Vec::new() }; + self.parted.insert(at, parted); + } + self.parted[&instance].clone() + } + + /// Which of the slices `guess` passes `instance` as parts its body holds as parts and + /// never makes the object of, given its callees take theirs as [`Self::parted`] guesses + /// now. What lowering it refuses is left to its lowering to report. + fn held_parts(&mut self, instance: ty::Instance<'tcx>, guess: &[bool]) -> Vec { + let span = self.tcx.def_span(instance.def_id()); + let refusals = self.refusals.replace(Vec::new()); + let failed = self.failed; + let lowered = self.lowered.contains(&instance); + let held = match super::instance_mir(self, instance, span) { + Some(mir) => { + let slotted = self.slotted(instance); + let mut b = crate::lower::body::Body::new(self); + b.parted = guess.to_vec(); + b.slotted = slotted; + let fx = Fx::new(&mut b, &mir, super::Env::Plain, span); + mir.args_iter() + .zip(guess) + .map(|(local, &parted)| parted && fx.scalars.contains_key(&local) && !fx.remade.contains(&local)) + .collect() + } + None => guess.to_vec(), + }; + self.refusals = refusals; + self.failed = failed; + if !lowered { + self.lowered.remove(&instance); } + held } /// Where `instance` hands back its `Ok`'s parts, if it does: a function of the crate's @@ -814,7 +885,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// Which arguments a call of `func` takes as a byte slice's parts, as /// [`Translator::parted`](crate::lower::Translator::parted) says. - pub(super) fn parted_call(&self, func: &Operand<'tcx>) -> Vec { + pub(super) fn parted_call(&mut self, func: &Operand<'tcx>) -> Vec { let ty::FnDef(def_id, args) = *func.ty(&self.mir.local_decls, self.tcx).kind() else { return Vec::new(); }; @@ -888,9 +959,16 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { shapes.insert(local, shape); } } + let mut parted_calls: FxHashMap> = FxHashMap::default(); + for (bb, data) in mir.basic_blocks.iter_enumerated() { + if let TerminatorKind::Call { func, .. } = &data.terminator().kind { + parted_calls.insert(bb, self.parted_call(func)); + } + } while !shapes.is_empty() { - let bad = self.unheld(&shapes); + let (bad, remade) = self.unheld(&shapes, &parted_calls); if bad.is_empty() { + self.remade = remade; break; } shapes.retain(|l, _| !bad.contains(l)); @@ -912,8 +990,13 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// The locals of `shapes` that can't be held as their parts, given the others are: one /// assigned other than by what makes its parts, or written into, or whose object would - /// be made more often than now. - fn unheld(&self, shapes: &FxHashMap>) -> FxHashSet { + /// be made more often than now. Then the parameters passed as parts whose object some + /// read makes. `parted_calls` holds which arguments each call takes as parts. + fn unheld( + &self, + shapes: &FxHashMap>, + parted_calls: &FxHashMap>, + ) -> (FxHashSet, FxHashSet) { let mir = self.mir; let tcx = self.tcx; let mut bad = FxHashSet::default(); @@ -997,7 +1080,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } // A slice passed as its parts. - for (arg, parted) in args.iter().zip(self.parted_call(func)) { + for (arg, &parted) in args.iter().zip(&parted_calls[&bb]) { if let (Operand::Copy(p) | Operand::Move(p), true) = (&arg.node, parted) && let Some(shape) = shapes.get(&p.local) && let (node, n) = walk(shape, p.projection) @@ -1150,7 +1233,12 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } - bad + let remade = made + .iter() + .flat_map(|(_, objects)| objects.iter().map(|&(l, _)| l)) + .filter(|l| self.parted.contains(l)) + .collect(); + (bad, remade) } /// For each part of `local` that its definition `rvalue` copies from another local held diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index f1c7358e5..01386e905 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -254,6 +254,10 @@ pub struct Translator<'a, 'tcx> { bindings: bind::Bindings<'tcx>, /// The instances the config's roots name, which the outside calls. roots: rustc_data_structures::fx::FxHashSet>, + /// Which parameters each instance takes as a byte slice's parts, by [`Self::parted`]. + parted: rustc_data_structures::fx::FxHashMap, Vec>, + /// While [`Self::parted`] settles, each instance it reached, with its guess so far. + parting: Option, Vec>>, /// Where each instance hands back its `Ok`'s parts, if it does, by [`Self::slotted`]. slotted: rustc_data_structures::fx::FxHashMap, Option>>, /// The slot of each `Ok` payload type, which every function returning one shares. @@ -466,6 +470,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { site: None, bindings: Default::default(), roots: Default::default(), + parted: Default::default(), + parting: None, slotted: Default::default(), slots: Default::default(), }) diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index c30847b09..41e37c162 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -205,8 +205,9 @@ fn codec() { /// A caller of two functions of a type, through its module, as moq's TypeScript calls /// the codec. const SHAKE: &str = r#"import * as Decoder from "./coding/decode.Decoder.ts"; +import * as rt from "./rt.ts"; -export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(buf, 0, buf.length, { tag: "Quic" })); +export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(rt.byteSliceFrom(buf), { tag: "Quic" })); "#; /// Bun's and esbuild's tree-shaken bundles of [`SHAKE`] keep the functions it calls and @@ -254,6 +255,7 @@ fn shake(out: &Path) { "ByteSlice", "Ok", "Panic", + "byteSliceFrom", "checked", "max", "panic", From bfa1dbbc9e0848f2c674241cf76e7a8342b6c5e6 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 20:19:58 -0700 Subject: [PATCH 26/26] fix(ts): take apart a slotted call of no arguments, and a held residual's whole error A slotted producer copies none of its arguments, and may take none, so reading its first argument panicked. `?` on a residual held as its parts passed `From::from` only the error's first part; it now makes the whole `Err` from that variant's parts. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/pointers.ts | 18 +- ts/fixtures/lang/expected/returns.Wrapped.ts | 17 + ts/fixtures/lang/expected/returns.ts | 313 ++++++++++++------- ts/fixtures/lang/src/returns.rs | 45 ++- ts/src/lower/mir/scalar.rs | 24 +- 5 files changed, 291 insertions(+), 126 deletions(-) create mode 100644 ts/fixtures/lang/expected/returns.Wrapped.ts diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index b0b06adc2..23c5636bc 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -33,7 +33,7 @@ import type * as Viewed from "./pointers.Viewed.ts"; import type * as Waiter from "./pointers.Waiter.ts"; import * as Waiters from "./pointers.Waiters.ts"; import type * as pointers_Window from "./pointers.Window.ts"; -import * as Wrapped from "./pointers.Wrapped.ts"; +import * as pointers_Wrapped from "./pointers.Wrapped.ts"; import type * as Written from "./pointers.Written.ts"; /** Put `node` in the list just before `at`. */ @@ -388,7 +388,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { let num: rt.Cell = new rt.Cell(4294967295 - 1); const pair: rt.Cell = new rt.Cell({ _0: 0, _1: 255 }); let text: rt.Cell = new rt.Cell(""); - const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new pointers_Held.Held(0, rt.arcClone(count))); + const held: pointers_Wrapped.Wrapped = pointers_Wrapped.new$pointers_Held(new pointers_Held.Held(0, rt.arcClone(count))); for (const op of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(op, 8); const _23: rt.u8 = rt.u8Rem(op, 8); @@ -423,7 +423,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { const fresh: pointers_Held.Held = new pointers_Held.Held(n, _99); if (rt.u8Rem(n, 2) === 0) { const captured2 = fresh; - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure0(held, rt.closure((p6: pointers_Held.Held): undefined => { + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure0(held, rt.closure((p6: pointers_Held.Held): undefined => { const _311: pointers_Held.Held = captured2; p6[Symbol.dispose](); rt.ptrWrite(p6, _311); @@ -432,22 +432,22 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { })); } else { const captured = fresh; - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure1(held, rt.closure((p5: pointers_Held.Held): undefined => { + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure1(held, rt.closure((p5: pointers_Held.Held): undefined => { rt.ptrWrite(p5, captured); }, (): void => { captured[Symbol.dispose](); })); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Wrapped.with$pointers_Held_u8_pointers_cells_closure2(held, (p7: pointers_Held.Held): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pointers_Wrapped.with$pointers_Held_u8_pointers_cells_closure2(held, (p7: pointers_Held.Held): rt.u8 => { return p7.n; }), count.strong & 0xff)), undefined, true); } else if (_23 === 5) { - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure3(held, (p3: pointers_Held.Held): undefined => { + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure3(held, (p3: pointers_Held.Held): undefined => { p3.n = rt.u8WrappingAdd(p3.n, n); }); const _119: pointers_Held.Held = held._0.v; _119.n = _119.n ^ 1; - rt.byteVecPush(out, Wrapped.with$pointers_Held_u8_pointers_cells_closure4(held, (p4: pointers_Held.Held): rt.u8 => { + rt.byteVecPush(out, pointers_Wrapped.with$pointers_Held_u8_pointers_cells_closure4(held, (p4: pointers_Held.Held): rt.u8 => { return p4.n; })); } else if (_23 === 6) { @@ -463,8 +463,8 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { Object.assign(pair.v, _140); } else { const _146: rt.Arc = rt.arcClone(count); - const made: Wrapped.Wrapped = Wrapped.new$pointers_Held(new pointers_Held.Held(n, _146)); - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure5(made, (p2: pointers_Held.Held): undefined => { + const made: pointers_Wrapped.Wrapped = pointers_Wrapped.new$pointers_Held(new pointers_Held.Held(n, _146)); + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure5(made, (p2: pointers_Held.Held): undefined => { p2.n = p2.n ^ 85; }); rt.byteVecPush(out, count.strong & 0xff); diff --git a/ts/fixtures/lang/expected/returns.Wrapped.ts b/ts/fixtures/lang/expected/returns.Wrapped.ts new file mode 100644 index 000000000..44694a899 --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Wrapped.ts @@ -0,0 +1,17 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; + +/** An error converted from a residual of a slice and a byte. */ +export interface Wrapped { + _0: rt.u8; + _1: rt.u8; +} + +export function from$convert_From_tuple2_ref_slice_u8_u8(_1: [rt.ByteSlice, rt.u8]): Wrapped { + const n: rt.u8 = _1[1]; + return { _0: (_1[0].length & 0xff) ^ option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_1[0]), 90), _1: n }; +} + +//# sourceMappingURL=returns.Wrapped.ts.map diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts index 10ae05232..27cb7b559 100644 --- a/ts/fixtures/lang/expected/returns.ts +++ b/ts/fixtures/lang/expected/returns.ts @@ -8,6 +8,7 @@ import * as At from "./returns.At.ts"; import * as returns_Error from "./returns.Error.ts"; import * as Guard from "./returns.Guard.ts"; import * as Split from "./returns.Split.ts"; +import * as returns_Wrapped from "./returns.Wrapped.ts"; /** A slice alone, with returns from several places. */ export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { @@ -264,128 +265,198 @@ export function pushNumber(out: rt.ByteVec, r: rt.Result<[rt.u64, rt.ByteSlice], } } +/** A slice that takes no argument. */ +export function fixed(): returns_Error.Error | undefined { + const slice: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); + takeOut.pData = slice.data; + takeOut.pStart = slice.start; + takeOut.pLen = slice.length; + return undefined; +} + +/** Takes `fixed`'s result apart, so it is held as parts. */ +export function afterFixed(_dataData: Uint8Array, _dataStart: number, dataLen: number): returns_Error.Error | undefined { + const err: returns_Error.Error | undefined = fixed(); + const part: Uint8Array = takeOut.pData; + const part2: number = takeOut.pStart; + const part3: number = takeOut.pLen; + if (err === undefined) { + const slice2: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(part, part2, part3), 0, rt.min(dataLen, part3)); + takeOut.pData = slice2.data; + takeOut.pStart = slice2.start; + takeOut.pLen = slice2.length; + return undefined; + } + return err as returns_Error.Error; +} + +/** `?` on a residual whose error is a slice and a byte, converted. */ +export function wrapped(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + let rErr!: boolean; + let r2!: rt.u8; + let r_0Data!: Uint8Array; + let r_0Start!: number; + let r_0Len!: number; + let r_1!: rt.u8; + if (dataLen === 0) { + rErr = true; + r_0Data = dataData; + r_0Start = dataStart; + r_0Len = dataLen; + r_1 = 0; + } else if (!(rt.u8Rem(dataData[dataStart], 2) === 0)) { + const _12_1: rt.u8 = dataData[dataStart]; + rErr = true; + r_0Data = dataData; + r_0Start = dataStart + 1; + r_0Len = dataLen - 1; + r_1 = _12_1; + } else { + const b: rt.u8 = dataData[dataStart]; + rErr = false; + r2 = b; + } + const _15Err: boolean = rErr; + const _152: rt.u8 = r2; + const _15_0Data: Uint8Array = r_0Data; + const _15_0Start: number = r_0Start; + const _15_0Len: number = r_0Len; + const _15_1: rt.u8 = r_1; + if (!_15Err) { + const _19_0: rt.u8 = _152; + wrappedOut.p_1Data = dataData; + wrappedOut.p_1Start = dataStart; + wrappedOut.p_1Len = dataLen; + return _19_0; + } + wrappedOut.err = returns_Wrapped.from$convert_From_tuple2_ref_slice_u8_u8([new rt.ByteSlice(_15_0Data, _15_0Start, _15_0Len), _15_1]); + return undefined; +} + +export const wrappedOut: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.ByteSlice) => rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>; b0: { - const _4: rt.u8 = rt.u8Rem(kind, 6); + const _4: rt.u8 = rt.u8Rem(kind, 7); if (_4 === 0) { - const err14: returns_Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); - const part58: Uint8Array = takeOut.pData; - const part59: number = takeOut.pStart; - const part60: number = takeOut.pLen; - push(out, (err14 !== undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part58, part59, part60))) as rt.Result); - const err15: returns_Error.Error | undefined = take(data.data, data.start, data.length, 201); - const part61: Uint8Array = takeOut.pData; - const part62: number = takeOut.pStart; - const part63: number = takeOut.pLen; - push(out, (err15 !== undefined ? rt.Err(err15 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part61, part62, part63))) as rt.Result); - const err16: returns_Error.Error | undefined = tail(data, 3); - const part64: Uint8Array = takeOut.pData; - const part65: number = takeOut.pStart; - const part66: number = takeOut.pLen; - push(out, (err16 !== undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part64, part65, part66))) as rt.Result); - const part67: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); - const err17: returns_Error.Error | undefined = part67 === undefined ? wideOut.err as returns_Error.Error : undefined; - const part68: Uint8Array = wideOut.p_1Data; - const part69: number = wideOut.p_1Start; - const part70: number = wideOut.p_1Len; - pushNumber(out, (err17 !== undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok([part67 as rt.u64, new rt.ByteSlice(part68, part69, part70)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); - const part71: rt.u64 | undefined = count(data.data, data.start, data.length); - const err18: returns_Error.Error | undefined = part71 === undefined ? wideOut.err as returns_Error.Error : undefined; - const part72: Uint8Array = wideOut.p_1Data; - const part73: number = wideOut.p_1Start; - const part74: number = wideOut.p_1Len; - pushNumber(out, (err18 !== undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok([part71 as rt.u64, new rt.ByteSlice(part72, part73, part74)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const err16: returns_Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); + const part65: Uint8Array = takeOut.pData; + const part66: number = takeOut.pStart; + const part67: number = takeOut.pLen; + push(out, (err16 !== undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part65, part66, part67))) as rt.Result); + const err17: returns_Error.Error | undefined = take(data.data, data.start, data.length, 201); + const part68: Uint8Array = takeOut.pData; + const part69: number = takeOut.pStart; + const part70: number = takeOut.pLen; + push(out, (err17 !== undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part68, part69, part70))) as rt.Result); + const err18: returns_Error.Error | undefined = tail(data, 3); + const part71: Uint8Array = takeOut.pData; + const part72: number = takeOut.pStart; + const part73: number = takeOut.pLen; + push(out, (err18 !== undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part71, part72, part73))) as rt.Result); + const part74: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + const err19: returns_Error.Error | undefined = part74 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part75: Uint8Array = wideOut.p_1Data; + const part76: number = wideOut.p_1Start; + const part77: number = wideOut.p_1Len; + pushNumber(out, (err19 !== undefined ? rt.Err(err19 as returns_Error.Error) : rt.Ok([part74 as rt.u64, new rt.ByteSlice(part75, part76, part77)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part78: rt.u64 | undefined = count(data.data, data.start, data.length); + const err20: returns_Error.Error | undefined = part78 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part79: Uint8Array = wideOut.p_1Data; + const part80: number = wideOut.p_1Start; + const part81: number = wideOut.p_1Len; + pushNumber(out, (err20 !== undefined ? rt.Err(err20 as returns_Error.Error) : rt.Ok([part78 as rt.u64, new rt.ByteSlice(part79, part80, part81)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 1) { const kept: rt.Result[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { - const err11 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); - return err11 !== undefined ? rt.Err(err11 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); + const err13 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); + return err13 !== undefined ? rt.Err(err13 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); }), undefined, 12, true); - const err12: returns_Error.Error | undefined = tail(data, 1); - const part50: Uint8Array = takeOut.pData; - const part51: number = takeOut.pStart; - const part52: number = takeOut.pLen; + const err14: returns_Error.Error | undefined = tail(data, 1); + const part57: Uint8Array = takeOut.pData; + const part58: number = takeOut.pStart; + const part59: number = takeOut.pLen; for (const _29 of kept) { push(out, _29); } - push(out, (err12 !== undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part50, part51, part52))) as rt.Result); - const part53: rt.u64 | undefined = both(data.data, data.start, data.length); - const err13: returns_Error.Error | undefined = part53 === undefined ? bothOut.err as returns_Error.Error : undefined; - const part54: rt.u64 = bothOut.p_1; - const part57: number = bothOut.p_2Len; - if (err13 === undefined) { - const a: rt.u64 = part53 as rt.u64; - const b: rt.u64 = part54; + push(out, (err14 !== undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part57, part58, part59))) as rt.Result); + const part60: rt.u64 | undefined = both(data.data, data.start, data.length); + const err15: returns_Error.Error | undefined = part60 === undefined ? bothOut.err as returns_Error.Error : undefined; + const part61: rt.u64 = bothOut.p_1; + const part64: number = bothOut.p_2Len; + if (err15 === undefined) { + const a: rt.u64 = part60 as rt.u64; + const b: rt.u64 = part61; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); - rt.byteVecPush(out, part57 & 0xff); + rt.byteVecPush(out, part64 & 0xff); } else { - rt.byteVecPush(out, returns_Error.code(err13 as returns_Error.Error)); + rt.byteVecPush(out, returns_Error.code(err15 as returns_Error.Error)); } } else if (_4 === 2) { if (!(rt.usizeRem(data.length, 2) === 0)) { f = (a02: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const part44 = narrow(a02.data, a02.start, a02.length); - const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part44 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part44, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + const part51 = narrow(a02.data, a02.start, a02.length); + const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part51 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part51, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result3; }; } else { f = (a0: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const part43 = wide(a0.data, a0.start, a0.length); - const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part43 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part43, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + const part50 = wide(a0.data, a0.start, a0.length); + const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part50 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part50, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result2; }; } pushNumber(out, f(data)); for (const _71 of rt.iterToArray(rt.iterMap(rt.iterSlice([data, rt.byteSliceRange(data, rt.min(data.length, 3))]), (a03: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { - const part46 = count(a03.data, a03.start, a03.length); - const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part46 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part46, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + const part53 = count(a03.data, a03.start, a03.length); + const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part53 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part53, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); return result4; }), undefined, 16, true)) { pushNumber(out, _71); } rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { return _22[1]; - }), (s: rt.ByteSlice): rt.u8 => { - const err10: returns_Error.Error | undefined = tail(s, 2); - const part47: Uint8Array = takeOut.pData; - const part48: number = takeOut.pStart; - const part49: number = takeOut.pLen; - return result_mapOr$0fbyajt((err10 !== undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part47, part48, part49))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { + }), (s2: rt.ByteSlice): rt.u8 => { + const err12: returns_Error.Error | undefined = tail(s2, 2); + const part54: Uint8Array = takeOut.pData; + const part55: number = takeOut.pStart; + const part56: number = takeOut.pLen; + return result_mapOr$0fbyajt((err12 !== undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part54, part55, part56))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { return a04.length; }) & 0xff; })), undefined, true); } else if (_4 === 3) { - const err7: rt.u8 | undefined = halves(data.data, data.start, data.length); - const part28: number = halvesOut.p_0Len; - const part29: Uint8Array = halvesOut.p_1Data; - const part30: number = halvesOut.p_1Start; - const part31: number = halvesOut.p_1Len; - const part32: Uint8Array = halvesOut.p_2Data; - const part33: number = halvesOut.p_2Start; - const part34: number = halvesOut.p_2Len; - if (err7 === undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part29, part30, part31)); - rt.byteVecPush(out, part28 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part32, part33, part34)); + const err9: rt.u8 | undefined = halves(data.data, data.start, data.length); + const part35: number = halvesOut.p_0Len; + const part36: Uint8Array = halvesOut.p_1Data; + const part37: number = halvesOut.p_1Start; + const part38: number = halvesOut.p_1Len; + const part39: Uint8Array = halvesOut.p_2Data; + const part40: number = halvesOut.p_2Start; + const part41: number = halvesOut.p_2Len; + if (err9 === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part36, part37, part38)); + rt.byteVecPush(out, part35 & 0xff); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part39, part40, part41)); } else { - rt.byteVecPush(out, err7 as rt.u8); + rt.byteVecPush(out, err9 as rt.u8); } const other: Uint8Array = Uint8Array.of(255, 1, 2); const _96: rt.ByteSlice = rt.byteSliceFrom(other); - const part35: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96); - const err8: returns_Error.Error | undefined = part35 === undefined ? wideOut.err as returns_Error.Error : undefined; - const part36: Uint8Array = wideOut.p_1Data; - const part37: number = wideOut.p_1Start; - const part38: number = wideOut.p_1Len; - pushNumber(out, (err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part35 as rt.u64, new rt.ByteSlice(part36, part37, part38)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part42: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96); + const err10: returns_Error.Error | undefined = part42 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part43: Uint8Array = wideOut.p_1Data; + const part44: number = wideOut.p_1Start; + const part45: number = wideOut.p_1Len; + pushNumber(out, (err10 !== undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok([part42 as rt.u64, new rt.ByteSlice(part43, part44, part45)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); - const part39: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100); - const err9: returns_Error.Error | undefined = part39 === undefined ? wideOut.err as returns_Error.Error : undefined; - const part40: Uint8Array = wideOut.p_1Data; - const part41: number = wideOut.p_1Start; - const part42: number = wideOut.p_1Len; - pushNumber(out, (err9 !== undefined ? rt.Err(err9 as returns_Error.Error) : rt.Ok([part39 as rt.u64, new rt.ByteSlice(part40, part41, part42)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part46: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100); + const err11: returns_Error.Error | undefined = part46 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part47: Uint8Array = wideOut.p_1Data; + const part48: number = wideOut.p_1Start; + const part49: number = wideOut.p_1Len; + pushNumber(out, (err11 !== undefined ? rt.Err(err11 as returns_Error.Error) : rt.Ok([part46 as rt.u64, new rt.ByteSlice(part47, part48, part49)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); } else if (_4 === 4) { const _104: rt.Result = unitErr(data.data, data.start, data.length); if (_104.ok) { @@ -399,28 +470,46 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$0r2bmpr(_110.error, 0)))); } - const part17: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); - const err5: returns_Error.Error | undefined = part17 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; - const part18: Uint8Array = leadOut$u16.p_1Data; - const part19: number = leadOut$u16.p_1Start; - const part20: number = leadOut$u16.p_1Len; + const part24: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); + const err7: returns_Error.Error | undefined = part24 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; + const part25: Uint8Array = leadOut$u16.p_1Data; + const part26: number = leadOut$u16.p_1Start; + const part27: number = leadOut$u16.p_1Len; const _123: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); - const part22: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); - const err6: returns_Error.Error | undefined = part22 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; - const part23: Uint8Array = leadOut$u32.p_1Data; - const part24: number = leadOut$u32.p_1Start; - const part25: number = leadOut$u32.p_1Len; - if (err5 === undefined) { - if (err6 === undefined) { - const a3: rt.u16 = part17 as rt.u16; - const b3: rt.u32 = part22 as rt.u32; + const part29: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); + const err8: returns_Error.Error | undefined = part29 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; + const part30: Uint8Array = leadOut$u32.p_1Data; + const part31: number = leadOut$u32.p_1Start; + const part32: number = leadOut$u32.p_1Len; + if (err7 === undefined) { + if (err8 === undefined) { + const a3: rt.u16 = part24 as rt.u16; + const b3: rt.u32 = part29 as rt.u32; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a3))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(b3))); - rt.byteVecPush(out, part25 & 0xff); + rt.byteVecPush(out, part32 & 0xff); break b0; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err5 !== undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok([part17 as rt.u16, new rt.ByteSlice(part18, part19, part20)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err6 !== undefined ? rt.Err(err6 as returns_Error.Error) : rt.Ok([part22 as rt.u32, new rt.ByteSlice(part23, part24, part25)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err7 !== undefined ? rt.Err(err7 as returns_Error.Error) : rt.Ok([part24 as rt.u16, new rt.ByteSlice(part25, part26, part27)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part29 as rt.u32, new rt.ByteSlice(part30, part31, part32)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + } else if (_4 === 5) { + const err5: returns_Error.Error | undefined = afterFixed(data.data, data.start, data.length); + const part17: Uint8Array = takeOut.pData; + const part18: number = takeOut.pStart; + const part19: number = takeOut.pLen; + if (err5 === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part17, part18, part19)); + } else { + rt.byteVecPush(out, returns_Error.code(err5 as returns_Error.Error)); + } + const part20: rt.u8 | undefined = wrapped(data.data, data.start, data.length); + const err6: returns_Wrapped.Wrapped | undefined = part20 === undefined ? wrappedOut.err as returns_Wrapped.Wrapped : undefined; + const part23: number = wrappedOut.p_1Len; + if (err6 === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part20 as rt.u8, part23 & 0xff))); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, (err6 as returns_Wrapped.Wrapped)._0, (err6 as returns_Wrapped.Wrapped)._1))); + } } else { const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; const err: returns_Error.Error | undefined = splitWith$returns_At(at, data.data, data.start, data.length); @@ -431,11 +520,11 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else { rt.byteVecPush(out, returns_Error.code(err as returns_Error.Error)); } - const _176: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = new Split.of$returns_At(at).split$Split(data); - if (_176.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_176.value[1].length & 0xff, _176.value[0].length & 0xff))); + const _196: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = new Split.of$returns_At(at).split$Split(data); + if (_196.ok) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_196.value[1].length & 0xff, _196.value[0].length & 0xff))); } else { - rt.byteVecPush(out, returns_Error.code(_176.error)); + rt.byteVecPush(out, returns_Error.code(_196.error)); } const err2: returns_Error.Error | undefined = At.split$returns_Split(at, data.data, data.start, data.length); const part7: Uint8Array = At.splitOut$returns_Split.p_0Data; @@ -444,30 +533,30 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const part10: Uint8Array = At.splitOut$returns_Split.p_1Data; const part11: number = At.splitOut$returns_Split.p_1Start; const part12: number = At.splitOut$returns_Split.p_1Len; - const _190: rt.Result = result_andThen$1yropo4((err2 !== undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { + const _210: rt.Result = result_andThen$1yropo4((err2 !== undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { const err3 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); return err3 !== undefined ? rt.Err(err3 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); }); - if (_190.ok) { - rt.byteVecPush(out, _190.value.length & 0xff); + if (_210.ok) { + rt.byteVecPush(out, _210.value.length & 0xff); } else { - rt.byteVecPush(out, returns_Error.code(_190.error)); + rt.byteVecPush(out, returns_Error.code(_210.error)); } - let restData3: Uint8Array = data.data; - let restStart3: number = data.start; - let restLen3: number = data.length; + let restData4: Uint8Array = data.data; + let restStart4: number = data.start; + let restLen4: number = data.length; let sum: rt.u64 = 0; while (true) { - const part13: rt.u64 | undefined = narrow(restData3, restStart3, restLen3); + const part13: rt.u64 | undefined = narrow(restData4, restStart4, restLen4); const err4: returns_Error.Error | undefined = part13 === undefined ? wideOut.err as returns_Error.Error : undefined; const part14: Uint8Array = wideOut.p_1Data; const part15: number = wideOut.p_1Start; const part16: number = wideOut.p_1Len; if (err4 === undefined) { sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13 as rt.u64); - restData3 = part14; - restStart3 = part15; - restLen3 = part16; + restData4 = part14; + restStart4 = part15; + restLen4 = part16; } else { break; } diff --git a/ts/fixtures/lang/src/returns.rs b/ts/fixtures/lang/src/returns.rs index 12658778a..0d2c92d4c 100644 --- a/ts/fixtures/lang/src/returns.rs +++ b/ts/fixtures/lang/src/returns.rs @@ -151,8 +151,41 @@ fn push_number(out: &mut Vec, r: Result<(u64, &[u8]), Error>) { } } +/// A slice that takes no argument. +#[inline(never)] +fn fixed() -> Result<&'static [u8], Error> { + Ok(b"abc") +} + +/// Takes `fixed`'s result apart, so it is held as parts. +fn after_fixed(data: &[u8]) -> Result<&[u8], Error> { + let s = fixed()?; + Ok(&s[..data.len().min(s.len())]) +} + +/// An error converted from a residual of a slice and a byte. +#[derive(Debug, Clone, Copy, PartialEq)] +struct Wrapped(u8, u8); + +impl From<(&[u8], u8)> for Wrapped { + fn from((s, n): (&[u8], u8)) -> Self { + Wrapped(s.len() as u8 ^ s.first().copied().unwrap_or(0x5a), n) + } +} + +/// `?` on a residual whose error is a slice and a byte, converted. +fn wrapped(data: &[u8]) -> Result<(u8, &[u8]), Wrapped> { + let r: Result = match data.split_first() { + Some((&b, _)) if b % 2 == 0 => Ok(b), + Some((&b, rest)) => Err((rest, b)), + None => Err((data, 0)), + }; + let v = r?; + Ok((v, data)) +} + pub fn returns(kind: u8, data: &[u8], out: &mut Vec) { - match kind % 6 { + match kind % 7 { 0 => { push(out, take(data, kind as usize % 7)); push(out, take(data, 201)); @@ -222,6 +255,16 @@ pub fn returns(kind: u8, data: &[u8], out: &mut Vec) { (a, b) => out.extend_from_slice(&[a.is_ok() as u8, b.is_ok() as u8]), } } + 5 => { + match after_fixed(data) { + Ok(s) => out.extend_from_slice(s), + Err(e) => out.push(e.code()), + } + match wrapped(data) { + Ok((v, rest)) => out.extend_from_slice(&[v, rest.len() as u8]), + Err(Wrapped(a, b)) => out.extend_from_slice(&[0xee, a, b]), + } + } _ => { let at = At(kind as usize % 5); match split_with(&at, data) { diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 39d2533e4..b3eea8221 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -1071,7 +1071,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { parted.insert(local); let size = shapes[&local].size(); for part in 0..size { - copies.push((local, part, self.produced_copy(producer, part, &args[0].node, shapes))); + copies.push((local, part, self.produced_copy(producer, part, args, shapes))); } } None => { @@ -1304,10 +1304,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { &self, producer: Producer, part: usize, - arg: &Operand<'tcx>, + args: &[Spanned>], shapes: &FxHashMap>, ) -> Option<(Local, usize)> { - let (Operand::Copy(p) | Operand::Move(p)) = arg else { + // A slotted call may take no argument, and copies none. + let (Operand::Copy(p) | Operand::Move(p)) = &args.first()?.node else { return None; }; let (node, _) = walk(shapes.get(&p.local)?, p.projection); @@ -1673,8 +1674,23 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { }; let (from, to) = (from.type_at(1), to.type_at(1)); let error = match &args[0].node { + // Held as its parts: its `Err`'s, made whole. Operand::Copy(p) | Operand::Move(p) if self.scalar_enum(*p) => { - self.held_arg(&args[0].node, span, out).remove(0).0 + let shape = self.scalars[&p.local].shape.clone(); + let node = walk(&shape, p.projection).0.shape; + let Shape::Enum(_, [_, Some(fields)]) = node else { + unreachable!("checked by producer") + }; + let [field] = fields.as_slice() else { + unreachable!("a residual holds one error") + }; + let at = node.variant_at(1); + let parts: Vec = self + .held_arg(&args[0].node, span, out) + .into_iter() + .map(|(e, _)| e) + .collect(); + self.build(field, None, &parts[at..at + field.size()], span) } op => match self.operand(op, span, out) { // Held back, and read here, where folding it would read it.