From 76c95a6bd3d4898a7e462d2991b582cc1fb1d51f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 16:21:46 -0700 Subject: [PATCH 01/17] chore(quest): claim quest/m2/ts-mir.md Quest-Claim: 13f5cafd4d89a95e From 4340fb1a6df39d09d3f58615da2b0dfe5ee9ddc2 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 16:41:45 -0700 Subject: [PATCH 02/17] feat(ts)!: lower every body from MIR, deleting the THIR lowering Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- driver/src/cargo.rs | 16 +- ffi/src/cli.rs | 2 +- ts/fixtures/codec/expected/bench.ts | 563 +- .../expected/coding/decode.DecodeError.ts | 150 +- .../codec/expected/coding/decode.Decoder.ts | 208 +- .../expected/coding/encode.EncodeError.ts | 38 +- .../codec/expected/coding/encode.Encoder.ts | 198 +- .../codec/expected/coding/varint.Form.ts | 12 +- ts/fixtures/codec/expected/coding/varint.ts | 600 ++- .../codec/expected/coding/version.Version.ts | 42 +- .../codec/expected/coding/version.Versions.ts | 135 +- ts/fixtures/codec/expected/harness.ts | 1035 ++-- .../codec/expected/lib.SessionError.ts | 29 +- .../codec/expected/lite/group.Group.ts | 153 +- ts/fixtures/codec/expected/lite/message.ts | 124 +- .../codec/expected/lite/probe.Probe.ts | 172 +- .../codec/expected/lite/version.Version.ts | 20 +- ts/fixtures/lang/expected/fmt.Fails.ts | 22 +- ts/fixtures/lang/expected/fmt.Fault.ts | 88 +- ts/fixtures/lang/expected/fmt.Hex.ts | 14 +- ts/fixtures/lang/expected/fmt.Kind.ts | 33 +- ts/fixtures/lang/expected/fmt.Manual.ts | 4 +- ts/fixtures/lang/expected/fmt.Nested.ts | 40 +- ts/fixtures/lang/expected/fmt.Padded.ts | 17 +- ts/fixtures/lang/expected/fmt.Pair.ts | 18 +- ts/fixtures/lang/expected/fmt.Seq.ts | 6 +- ts/fixtures/lang/expected/fmt.Six.ts | 21 +- ts/fixtures/lang/expected/fmt.Tup.ts | 12 +- ts/fixtures/lang/expected/fmt.Wide.ts | 24 +- ts/fixtures/lang/expected/fmt.ts | 953 ++-- ts/fixtures/lang/expected/generics.Either.ts | 103 +- ts/fixtures/lang/expected/generics.Tagged.ts | 18 +- ts/fixtures/lang/expected/generics.Wrap.ts | 164 +- ts/fixtures/lang/expected/generics.ts | 129 +- ts/fixtures/lang/expected/harness.ts | 197 +- ts/fixtures/lang/expected/ints.ts | 4639 +++++++++++------ ts/fixtures/lang/expected/iters.Countdown.ts | 13 +- ts/fixtures/lang/expected/iters.Doubled.ts | 11 +- ts/fixtures/lang/expected/iters.Evens.ts | 23 +- ts/fixtures/lang/expected/iters.Gaps.ts | 26 +- ts/fixtures/lang/expected/iters.Halving.ts | 12 +- ts/fixtures/lang/expected/iters.Held.ts | 4 +- ts/fixtures/lang/expected/iters.ts | 1407 ++--- ts/fixtures/lang/expected/shapes.Meters.ts | 7 +- ts/fixtures/lang/expected/shapes.Moved.ts | 10 +- ts/fixtures/lang/expected/shapes.Point.ts | 32 +- ts/fixtures/lang/expected/shapes.Shape.ts | 56 +- ts/fixtures/lang/expected/shapes.Void.ts | 4 +- ts/fixtures/lang/expected/shapes.ts | 2075 +++++--- ts/fixtures/reject/census.md | 334 +- ts/fixtures/reject/expected-mir.txt | 62 - ts/fixtures/reject/expected.txt | 90 +- ts/fixtures/task/expected/kio.Consumer.ts | 43 +- ts/fixtures/task/expected/kio.Park.ts | 14 +- ts/fixtures/task/expected/kio.Pending.ts | 6 +- ts/fixtures/task/expected/kio.Producer.ts | 48 +- ts/fixtures/task/expected/kio.Waiter.ts | 23 +- ts/fixtures/task/expected/kio.WaiterList.ts | 138 +- ts/fixtures/task/expected/kio.ts | 84 +- ts/fixtures/task/expected/log.Log.ts | 30 +- ts/fixtures/task/expected/model.Channel.ts | 111 +- ts/fixtures/task/expected/model.Guard.ts | 36 +- ts/fixtures/task/expected/model.ts | 2659 ++++++++-- ts/runtime/rt/task.ts | 76 +- ts/src/cli.rs | 17 +- ts/src/config.rs | 2 - ts/src/driver.rs | 21 +- ts/src/lower/body.rs | 3078 +---------- ts/src/lower/consts.rs | 123 +- ts/src/lower/drop.rs | 140 +- ts/src/lower/fmt.rs | 182 +- ts/src/lower/iter.rs | 21 +- ts/src/lower/library.rs | 447 +- ts/src/lower/mir/call.rs | 23 +- ts/src/lower/mir/cfg.rs | 10 +- ts/src/lower/mir/coroutine.rs | 6 +- ts/src/lower/mir/glue.rs | 3 +- ts/src/lower/mir/mod.rs | 33 +- ts/src/lower/mod.rs | 99 +- ts/src/lower/num.rs | 2 +- ts/src/lower/pat.rs | 305 -- ts/src/lower/task.rs | 59 +- ts/src/print.rs | 133 +- ts/src/ts.rs | 90 +- ts/tests/fixtures.rs | 58 +- 85 files changed, 11848 insertions(+), 10437 deletions(-) delete mode 100644 ts/fixtures/reject/expected-mir.txt delete mode 100644 ts/src/lower/pat.rs diff --git a/driver/src/cargo.rs b/driver/src/cargo.rs index 0002eb8df..1a889aa8d 100644 --- a/driver/src/cargo.rs +++ b/driver/src/cargo.rs @@ -15,8 +15,6 @@ pub struct Args { pub manifest: PathBuf, /// Passed on to `cargo check`. pub cargo: Vec, - /// The driver's own options, each with its value. - pub options: Vec<(String, String)>, } /// What a driver writes, absolute. @@ -29,11 +27,9 @@ pub enum Output { impl Args { /// Parse `args`, without the program name, or `None` after printing `usage` for - /// `--help`. `options` are the driver's own, each taking a value. An error ends with - /// `usage`. - pub fn parse(args: &[String], usage: &str, options: &[&str]) -> Result, String> { + /// `--help`. An error ends with `usage`. + pub fn parse(args: &[String], usage: &str) -> Result, String> { let mut config = None; - let mut own = Vec::new(); let mut out = None; let mut census = None; let mut manifest = None; @@ -55,13 +51,6 @@ impl Args { }; *slot = Some(absolute(Path::new(value))?); } - option if options.contains(&option) => { - let [value, tail @ ..] = rest else { - return Err(format!("{arg} needs a value\n\n{usage}")); - }; - rest = tail; - own.push((option.to_string(), value.clone())); - } "--" => { cargo = rest; break; @@ -91,7 +80,6 @@ impl Args { output, manifest, cargo: cargo.to_vec(), - options: own, })) } } diff --git a/ffi/src/cli.rs b/ffi/src/cli.rs index d209854d0..8ffa09670 100644 --- a/ffi/src/cli.rs +++ b/ffi/src/cli.rs @@ -27,7 +27,7 @@ pub fn run(args: &[String]) -> ExitCode { } fn try_run(args: &[String]) -> Result { - let Some(args) = Args::parse(args, USAGE, &[])? else { + let Some(args) = Args::parse(args, USAGE)? else { return Ok(ExitCode::SUCCESS); }; let config = Config::load(&args.config)?; diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 2c44ef839..da1d3006d 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -13,84 +13,139 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one workload. */ export function run(input: Uint8Array): rt.ByteVec { - let out: rt.ByteVec = new rt.ByteVec(); - const splitFirst = rt.sliceSplitFirst(input); - if (splitFirst === undefined) { - return out; - } - const op = splitFirst[0]; - const data = splitFirst[1]; - const splitFirst2 = rt.sliceSplitFirst(data); - if (splitFirst2 === undefined) { - return out; - } - const selector = splitFirst2[0]; - const data2 = splitFirst2[1]; - if (op === 0) { - encoded(encodeVarints(data2, form(selector), out), out); - } else if (op === 1) { - decoded(decodeVarints(data2, form(selector), out), out); - } else if (op === 2) { - encoded(encodeFrames(data2, liteVersion(selector), out), out); - } else if (op === 3) { - decoded(decodeFrames(data2, liteVersion(selector), out), out); - } else if (op === 4) { - encoded(encodeGroup(data2, liteVersion(selector), out), out); - } else if (op === 6) { - iterate(selector, data2, out); - } else if (op === 7) { - decoded(decodeSplit(data2, liteVersion(selector), out), out); + let _0!: rt.ByteVec; + let out!: rt.ByteVec; + let op!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let selector!: rt.u8; + let _9!: [rt.u8, Uint8Array] | undefined; + let _13!: Form.Form; + let _17!: Form.Form; + let _21!: Version.Version; + let _25!: Version.Version; + let _29!: Version.Version; + let _34!: Version.Version; + let _38!: Version.Version; + out = new rt.ByteVec(); + _5 = rt.sliceSplitFirst(input); + if (_5 !== undefined) { + op = _5[0]; + _9 = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + selector = _9[0]; + if (op === 0) { + _13 = form(selector); + encoded(encodeVarints(_9[1], _13, out), out); + } else if (op === 1) { + _17 = form(selector); + decoded(decodeVarints(_9[1], _17, out), out); + } else if (op === 2) { + _21 = liteVersion(selector); + encoded(encodeFrames(_9[1], _21, out), out); + } else if (op === 3) { + _25 = liteVersion(selector); + decoded(decodeFrames(_9[1], _25, out), out); + } else if (op === 4) { + _29 = liteVersion(selector); + encoded(encodeGroup(_9[1], _29, out), out); + } else if (op === 6) { + iterate(selector, _9[1], out); + } else if (op === 7) { + _34 = liteVersion(selector); + decoded(decodeSplit(_9[1], _34, out), out); + } else { + _38 = liteVersion(selector); + decoded(decodeGroup(_9[1], _38, out), out); + } + _0 = out; + } else { + _0 = out; + } } else { - decoded(decodeGroup(data2, liteVersion(selector), out), out); + _0 = out; } - return out; + return _0; } export function encoded(result: rt.Result, out: rt.ByteVec): void { + let err!: EncodeError.EncodeError; if (!result.ok) { - const err = result.error; + err = result.error; encodeError(out, err); } + return; } export function decoded(result: rt.Result, out: rt.ByteVec): void { + let err!: DecodeError.DecodeError; if (!result.ok) { - const err = result.error; + err = result.error; decodeError(out, err); } + return; } /** The same value, `count` times. */ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - const [count, data2] = takeU64(data); - const [value, ] = takeU64(data2); - let w: Encoder.Encoder = Encoder.new(out, form_); - const end = rt.u64Low(count); - for (let _ = 0; _ < end; _++) { - const varint = Encoder.varint(w, value); - if (!varint.ok) { - return rt.Err(varint.error); + let _0!: rt.Result; + let count!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let value!: rt.u64; + let w!: Encoder.Encoder; + let iter!: rt.Range; + let _17!: rt.Result; + let _14Some!: boolean; + _6 = takeU64(data); + count = _6[0]; + value = takeU64(_6[1])[0]; + w = Encoder.new(out, form_); + iter = new rt.Range(0, rt.u64Low(count)); + l0: while (true) { + _14Some = iter.start < iter.end; + if (_14Some) { + iter.start++; } + if (!_14Some) { + _0 = rt.Ok(undefined); + } else { + _17 = Encoder.varint(w, value); + if (_17.ok) { + continue l0; + } else { + _0 = _17; + } + } + return _0; } - return rt.Ok(undefined); } /** Every varint on the wire: how many, and the last. */ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - let r: Decoder.Decoder = Decoder.new(wire, form_); - let count: rt.usize = 0; - let last: rt.u64 = 0; - while (!Decoder.isEmpty(r)) { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); + let _0!: rt.Result; + let r!: Decoder.Decoder; + let count!: rt.usize; + let last!: rt.u64; + let _9!: rt.Result; + r = Decoder.new(wire, form_); + count = 0; + last = 0; + l0: while (true) { + if (!Decoder.isEmpty(r)) { + _9 = Decoder.varint(r); + if (_9.ok) { + last = _9.value; + count = rt.usizeAdd(count, 1); + continue l0; + } else { + _0 = _9; + } + } else { + putUsize(out, count); + putU64(out, last); + _0 = rt.Ok(undefined); } - last = varint.value; - count = rt.usizeAdd(count, 1); + return _0; } - putUsize(out, count); - putU64(out, last); - return rt.Ok(undefined); } /** @@ -99,65 +154,128 @@ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVe * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const [count, data2] = takeU64(data); - const [delta, data3] = takeU64(data2); - const [first, data4] = takeU64(data3); - const [size, data5] = takeU64(data4); - const [keyEvery, data6] = takeU64(data5); - const [keySize, ] = takeU64(data6); - const [delta2, keyEvery2] = [rt.i64Cast(delta), rt.u64Low(keyEvery)] as [rt.i64, rt.usize]; - let w: Encoder.Encoder = Encoder.new(out, Form.from$From_Version(version)); - const end = rt.u64Low(count); - for (let n = 0; n < end; n++) { - let value: [rt.i64, rt.u64]; - arms: { - if (n === 0) { - value = [0, first]; - break arms; + let _0!: rt.Result; + let count!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let delta!: rt.u64; + let _9!: [rt.u64, Uint8Array]; + let first!: rt.u64; + let _12!: [rt.u64, Uint8Array]; + let size!: rt.u64; + let _15!: [rt.u64, Uint8Array]; + let keyEvery!: rt.u64; + let _18!: [rt.u64, Uint8Array]; + let keySize!: rt.u64; + let delta2!: rt.i64; + let keyEvery2!: rt.usize; + let _23!: [rt.i64, rt.usize]; + let _24!: rt.i64; + let w!: Encoder.Encoder; + let iter!: rt.Range; + let _32!: rt.usize; + let n!: rt.usize; + let delta3!: rt.i64; + let size2!: rt.u64; + let _38!: [rt.i64, rt.u64]; + let _45!: rt.Result; + let _48!: rt.u64; + let _51!: rt.Result; + let _32Some!: boolean; + _6 = takeU64(data); + count = _6[0]; + _9 = takeU64(_6[1]); + delta = _9[0]; + _12 = takeU64(_9[1]); + first = _12[0]; + _15 = takeU64(_12[1]); + size = _15[0]; + _18 = takeU64(_15[1]); + keyEvery = _18[0]; + keySize = takeU64(_18[1])[0]; + _24 = rt.i64Cast(delta); + _23 = [_24, rt.u64Low(keyEvery)] as [rt.i64, rt.usize]; + delta2 = _24; + keyEvery2 = _23[1]; + w = Encoder.new(out, Form.from$From_Version(version)); + iter = new rt.Range(0, rt.u64Low(count)); + l0: while (true) { + _32Some = iter.start < iter.end; + if (_32Some) { + _32 = iter.start++; + } + if (!_32Some) { + _0 = rt.Ok(undefined); + } else { + b2: { + n = _32; + if (n === 0) { + _38 = [0, first] as [rt.i64, rt.u64]; + } else { + if (keyEvery2 !== 0) { + if (rt.usizeRem(n, keyEvery2) === 0) { + _38 = [delta2, keySize] as [rt.i64, rt.u64]; + break b2; + } + } + _38 = [delta2, size] as [rt.i64, rt.u64]; + } } - const n2 = n; - if (keyEvery2 !== 0 && rt.usizeRem(n2, keyEvery2) === 0) { - value = [delta2, keySize]; - break arms; + delta3 = _38[0]; + size2 = _38[1]; + _48 = zigzag(delta3); + _45 = Encoder.varint(w, _48); + if (_45.ok) { + _51 = Encoder.varint(w, size2); + if (_51.ok) { + continue l0; + } else { + _0 = _51; + } + } else { + _0 = _45; } - value = [delta2, size]; - } - const [delta3, size2] = value; - const varint = Encoder.varint(w, zigzag(delta3)); - if (!varint.ok) { - return rt.Err(varint.error); - } - const varint2 = Encoder.varint(w, size2); - if (!varint2.ok) { - return rt.Err(varint2.error); } + return _0; } - return rt.Ok(undefined); } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - let r: Decoder.Decoder = Decoder.new(wire, Form.from$From_Version(version)); - let count: rt.usize = 0; - let total: rt.u64 = 0; - let last: rt.i64 = 0; - while (!Decoder.isEmpty(r)) { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - last = unzigzag(varint.value); - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); + let _0!: rt.Result; + let r!: Decoder.Decoder; + let count!: rt.usize; + let total!: rt.u64; + let last!: rt.i64; + let _12!: rt.Result; + let _18!: rt.Result; + r = Decoder.new(wire, Form.from$From_Version(version)); + count = 0; + total = 0; + last = 0; + l0: while (true) { + if (!Decoder.isEmpty(r)) { + _12 = Decoder.varint(r); + if (_12.ok) { + last = unzigzag(_12.value); + _18 = Decoder.varint(r); + if (_18.ok) { + total = rt.u64Add(total, _18.value); + count = rt.usizeAdd(count, 1); + continue l0; + } else { + _0 = _18; + } + } else { + _0 = _12; + } + } else { + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + _0 = rt.Ok(undefined); } - total = rt.u64Add(total, varint2.value); - count = rt.usizeAdd(count, 1); + return _0; } - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - return rt.Ok(undefined); } /** @@ -168,66 +286,100 @@ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt * and how many decodes came up short. */ export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const [read, wire] = takeU64(data); - const read2 = rt.max(rt.u64Low(read), 1); - let start: rt.usize = 0; - let end: rt.usize = 0; - let count: rt.usize = 0; - let total: rt.u64 = 0; - let last: rt.i64 = 0; - let short: rt.usize = 0; - while (end < wire.length) { - end = rt.min(wire.length, rt.usizeAdd(end, read2)); - while (start < end) { - let r: Decoder.Decoder = Decoder.new(rt.sliceRange(wire, start, end), Form.from$From_Version(version)); - const frameHeader_ = frameHeader(r); - if (frameHeader_.ok) { - const delta = frameHeader_.value[0]; - const size = frameHeader_.value[1]; - start = rt.usizeSub(end, Decoder.remaining(r)); - last = delta; - total = rt.u64Add(total, size); - count = rt.usizeAdd(count, 1); - } else if (!frameHeader_.ok && frameHeader_.error.tag === "Short") { - short = rt.usizeAdd(short, 1); - break; + let _0!: rt.Result; + let _6!: [rt.u64, Uint8Array]; + let read2!: rt.usize; + let start!: rt.usize; + let end!: rt.usize; + let count!: rt.usize; + let total!: rt.u64; + let last!: rt.i64; + let short!: rt.usize; + let r!: Decoder.Decoder; + let _32!: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError>; + let delta!: rt.i64; + let size!: rt.u64; + _6 = takeU64(data); + read2 = rt.max(rt.u64Low(_6[0]), 1); + start = 0; + end = 0; + count = 0; + total = 0; + last = 0; + short = 0; + l0: while (true) { + b1: { + if (!(end < _6[1].length)) { + if (!(start < end)) { + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + putUsize(out, short); + _0 = rt.Ok(undefined); + } else { + _0 = rt.Err({ tag: "Short" } as DecodeError.DecodeError); + } } else { - const err = frameHeader_.error; - return rt.Err(err); + end = rt.min(_6[1].length, rt.usizeAdd(end, read2)); + while (true) { + if (!(start < end)) { + continue l0; + } else { + const slice = _6[1]; + r = Decoder.new(rt.sliceRange(slice, start, end), Form.from$From_Version(version)); + _32 = frameHeader(r); + if (_32.ok) { + delta = _32.value[0]; + size = _32.value[1]; + start = rt.usizeSub(end, Decoder.remaining(r)); + last = delta; + total = rt.u64Add(total, size); + count = rt.usizeAdd(count, 1); + } else if (_32.error.tag === "Short") { + short = rt.usizeAdd(short, 1); + continue l0; + } else { + _0 = rt.Err(_32.error); + break b1; + } + } + } } } + return _0; } - if (start < end) { - return rt.Err({ tag: "Short" }); - } - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - putUsize(out, short); - return rt.Ok(undefined); } /** One FRAME header: the zigzag timestamp delta, then the size. */ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError> { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const delta = unzigzag(varint.value); - const arg = delta; - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); + let _0!: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError>; + let delta!: rt.i64; + let _3!: rt.Result; + let _9!: rt.Result; + _3 = Decoder.varint(r); + if (_3.ok) { + delta = unzigzag(_3.value); + _9 = Decoder.varint(r); + if (_9.ok) { + _0 = rt.Ok([delta, _9.value] as [rt.i64, rt.u64]); + } else { + _0 = _9; + } + } else { + _0 = _3; } - return rt.Ok([arg, varint2.value]); + return _0; } /** One size-prefixed GROUP header, starting at the first frame. */ export function encodeGroup(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const [subscribe, data2] = takeU64(data); - const [sequence, ] = takeU64(data2); - const group = { subscribe, sequence, frameStart: 0 }; - return Group.encode$Encode_Version(group, Encoder.new(out, Form.from$From_Version(version)), version); + let _6!: [rt.u64, Uint8Array]; + let group!: Group.Group; + let _12!: Encoder.Encoder; + _6 = takeU64(data); + group = { subscribe: _6[0], sequence: takeU64(_6[1])[0], frameStart: 0 }; + _12 = Encoder.new(out, Form.from$From_Version(version)); + return Group.encode$Encode_Version(group, _12, version); } /** @@ -235,64 +387,77 @@ export function encodeGroup(data: Uint8Array, version: Version.Version, out: rt. * next to the iterator protocol they run through. */ export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - if (chain === 0) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (arg: rt.u8): rt.u8 => { - const b = arg; - return b >> 1; - }), (arg2: rt.u8): boolean => { - const b2 = arg2; - return (b2 & 1) === 0; - }))); - } else if (chain === 1) { - rt.byteVecPush(out, rt.iterAny(rt.iterSlice(data), (arg3: rt.u8): boolean => { - const b3 = arg3; - return b3 === 0xff; - }) ? 1 : 0); - } else if (chain === 2) { - const odd = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (arg4: rt.u8): boolean => { - const b4 = arg4; - return (b4 & 1) === 1; - })); - putUsize(out, odd.length); - } else if (chain === 3) { - putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (arg5: rt.u8): rt.u32 => { - const b5 = arg5; - return b5 as rt.u32; - }), rt.u32Add, 0) as rt.u64); - } else if (chain === 4) { - putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, arg6: rt.u8): rt.u32 => { - const b6 = arg6; - return (acc ^ b6 as rt.u32) >>> 0; - }) as rt.u64); - } else { - let last: rt.usize = 0; - const iter = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const i = item[0]; - const b7 = item[1]; - if (b7 === 0x80) { - last = i; + let _11!: rt.Iter; + let odd!: rt.ByteVec; + let last!: rt.usize; + let iter!: rt.Iter<[rt.usize, rt.u8]>; + let _33!: [rt.usize, rt.u8] | rt.Done; + let i!: rt.usize; + b0: { + if (chain === 0) { + putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_211: rt.u8): rt.u8 => { + return _211 >> 1; + }), (_212: rt.u8): boolean => { + return (_212 & 1) === 0; + }))); + } else if (chain === 1) { + _11 = rt.iterSlice(data); + rt.byteVecPush(out, rt.iterAny(_11, (_210: rt.u8): boolean => { + return _210 === 255; + }) ? 1 : 0); + } else if (chain === 2) { + odd = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (_28: rt.u8): boolean => { + return (_28 & 1) === 1; + })); + putUsize(out, odd.length); + } else if (chain === 3) { + putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u32 => { + return _2 as rt.u32; + }), rt.u32Add, 0) as rt.u64); + } else if (chain === 4) { + putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { + return (acc ^ _3 as rt.u32) >>> 0; + }) as rt.u64); + } else { + last = 0; + iter = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + _33 = iter.next(); + if (_33 === rt.DONE) { + putUsize(out, last); + break b0; + } else { + i = _33[0]; + if (_33[1] === 128) { + last = i; + } + } } } - putUsize(out, last); } + return; } export function decodeGroup(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const decodeSlice = Group.decodeSlice$Decode_Version(wire, version); - if (!decodeSlice.ok) { - return rt.Err(decodeSlice.error); + let _0!: rt.Result; + let group!: Group.Group; + let used!: rt.usize; + let _6!: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError>; + let val!: [Group.Group, rt.usize]; + _6 = Group.decodeSlice$Decode_Version(wire, version); + if (_6.ok) { + val = _6.value; + group = val[0]; + used = val[1]; + putU64(out, group.subscribe); + putU64(out, group.sequence); + putU64(out, group.frameStart); + putUsize(out, used); + _0 = rt.Ok(undefined); + } else { + _0 = _6; } - const [group, used] = decodeSlice.value; - putU64(out, group.subscribe); - putU64(out, group.sequence); - putU64(out, group.frameStart); - putUsize(out, used); - return rt.Ok(undefined); + return _0; } //# sourceMappingURL=bench.ts.map diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index 118e4d74a..be4e2246a 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -5,105 +5,138 @@ import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import * as SessionError from "../lib.SessionError.ts"; export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __field0!: rt.u64; + let args!: [rt.u64]; + let size!: rt.usize; + let max!: rt.usize; + let __displaySize!: rt.usize; + let __displayMax!: rt.usize; if (self.tag === "Short") { - return rt.fmtWriteStr(__formatter, "short buffer"); + _0 = rt.fmtWriteStr(__formatter, "short buffer"); } else if (self.tag === "Long") { - return rt.fmtWriteStr(__formatter, "long buffer"); + _0 = rt.fmtWriteStr(__formatter, "long buffer"); } else if (self.tag === "InvalidString") { - return rt.fmtWriteStr(__formatter, "invalid string"); + _0 = rt.fmtWriteStr(__formatter, "invalid string"); } else if (self.tag === "InvalidMessage") { - const _0 = self._0; - const value = [_0] as [rt.u64]; - const __field0 = value[0]; - return rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(__field0, f)]); + __field0 = ([self._0] as [rt.u64])[0]; + args = [__field0] as [rt.u64]; + const arg = args[0]; + _0 = rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(arg, f)]); } else if (self.tag === "InvalidSubscribeLocation") { - return rt.fmtWriteStr(__formatter, "invalid subscribe location"); + _0 = rt.fmtWriteStr(__formatter, "invalid subscribe location"); } else if (self.tag === "InvalidValue") { - return rt.fmtWriteStr(__formatter, "invalid value"); + _0 = rt.fmtWriteStr(__formatter, "invalid value"); } else if (self.tag === "TooMany") { - return rt.fmtWriteStr(__formatter, "too many"); + _0 = rt.fmtWriteStr(__formatter, "too many"); } else if (self.tag === "BoundsExceeded") { - return rt.fmtWriteStr(__formatter, "bounds exceeded"); + _0 = rt.fmtWriteStr(__formatter, "bounds exceeded"); } else if (self.tag === "ExpectedEnd") { - return rt.fmtWriteStr(__formatter, "expected end"); + _0 = rt.fmtWriteStr(__formatter, "expected end"); } else if (self.tag === "MessageTooLarge") { - const size = self.size; - const max = self.max; - const value2 = [size, max] as [rt.usize, rt.usize]; - const __displaySize = value2[0]; - const __displayMax = value2[1]; - return rt.fmtWriteFmt(__formatter, ["message too large: ", (f: rt.Formatter) => rt.usizeDisplay(__displaySize, f), " bytes exceeds ", (f: rt.Formatter) => rt.usizeDisplay(__displayMax, f), " byte limit"]); + size = self.size; + max = self.max; + __displaySize = size; + __displayMax = max; + _0 = rt.fmtWriteFmt(__formatter, ["message too large: ", (f: rt.Formatter) => rt.usizeDisplay(__displaySize, f), " bytes exceeds ", (f: rt.Formatter) => rt.usizeDisplay(__displayMax, f), " byte limit"]); } else if (self.tag === "ExpectedData") { - return rt.fmtWriteStr(__formatter, "expected data"); + _0 = rt.fmtWriteStr(__formatter, "expected data"); } else if (self.tag === "Duplicate") { - return rt.fmtWriteStr(__formatter, "duplicate"); + _0 = rt.fmtWriteStr(__formatter, "duplicate"); } else if (self.tag === "Missing") { - return rt.fmtWriteStr(__formatter, "missing"); + _0 = rt.fmtWriteStr(__formatter, "missing"); } else if (self.tag === "Unsupported") { - return rt.fmtWriteStr(__formatter, "unsupported"); + _0 = rt.fmtWriteStr(__formatter, "unsupported"); } else if (self.tag === "TrailingBytes") { - return rt.fmtWriteStr(__formatter, "trailing bytes"); + _0 = rt.fmtWriteStr(__formatter, "trailing bytes"); } else if (self.tag === "Version") { - return rt.fmtWriteStr(__formatter, "unsupported version"); + _0 = rt.fmtWriteStr(__formatter, "unsupported version"); } else if (self.tag === "Session") { - const _02 = self._0; - return SessionError.fmt$Display(_02, __formatter); + _0 = SessionError.fmt$Display(self._0, __formatter); } else if (self.tag === "MalformedAuthToken") { - return rt.fmtWriteStr(__formatter, "malformed authorization token"); + _0 = rt.fmtWriteStr(__formatter, "malformed authorization token"); } else { - return rt.fmtWriteStr(__formatter, "multiple authorization tokens"); + _0 = rt.fmtWriteStr(__formatter, "multiple authorization tokens"); } + return _0; } export function from$From_FromUtf8Error(source: rt.FromUtf8Error): DecodeError { - return { tag: "InvalidString", _0: source }; + return { tag: "InvalidString", _0: source } as DecodeError; } export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: rt.FromUtf8Error; + let _7!: string; + let _8!: rt.Fmt; + let __self02!: rt.u64; + let _11!: string; + let _12!: rt.Fmt; + let __self1!: rt.usize; + let _21!: string; + let _22!: string; + let _23!: rt.Fmt; + let _24!: string; + let _25!: rt.Fmt; + let __self03!: SessionError.SessionError; + let _34!: string; + let _35!: rt.Fmt; if (self.tag === "Short") { - return rt.fmtWriteStr(f, "Short"); + _0 = rt.fmtWriteStr(f, "Short"); } else if (self.tag === "Long") { - return rt.fmtWriteStr(f, "Long"); + _0 = rt.fmtWriteStr(f, "Long"); } else if (self.tag === "InvalidString") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "InvalidString"), (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(__self0, f))); + __self0 = self._0; + _7 = "InvalidString"; + _8 = (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8)); } else if (self.tag === "InvalidMessage") { - const __self02 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "InvalidMessage"), (f: rt.Formatter) => rt.u64Display(__self02, f))); + __self02 = self._0; + _11 = "InvalidMessage"; + _12 = (f: rt.Formatter) => rt.u64Display(__self02, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _11), _12)); } else if (self.tag === "InvalidSubscribeLocation") { - return rt.fmtWriteStr(f, "InvalidSubscribeLocation"); + _0 = rt.fmtWriteStr(f, "InvalidSubscribeLocation"); } else if (self.tag === "InvalidValue") { - return rt.fmtWriteStr(f, "InvalidValue"); + _0 = rt.fmtWriteStr(f, "InvalidValue"); } else if (self.tag === "TooMany") { - return rt.fmtWriteStr(f, "TooMany"); + _0 = rt.fmtWriteStr(f, "TooMany"); } else if (self.tag === "BoundsExceeded") { - return rt.fmtWriteStr(f, "BoundsExceeded"); + _0 = rt.fmtWriteStr(f, "BoundsExceeded"); } else if (self.tag === "ExpectedEnd") { - return rt.fmtWriteStr(f, "ExpectedEnd"); + _0 = rt.fmtWriteStr(f, "ExpectedEnd"); } else if (self.tag === "MessageTooLarge") { - const __self03 = self.size; - const __self1 = self.max; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "MessageTooLarge"), "size", (f: rt.Formatter) => rt.usizeDisplay(__self03, f)), "max", (f: rt.Formatter) => rt.usizeDisplay(__self1, f))); + __self1 = self.max; + _21 = "MessageTooLarge"; + _22 = "size"; + _23 = (f: rt.Formatter) => rt.usizeDisplay(self.size, f); + _24 = "max"; + _25 = (f: rt.Formatter) => rt.usizeDisplay(__self1, f); + _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _21), _22, _23), _24, _25)); } else if (self.tag === "ExpectedData") { - return rt.fmtWriteStr(f, "ExpectedData"); + _0 = rt.fmtWriteStr(f, "ExpectedData"); } else if (self.tag === "Duplicate") { - return rt.fmtWriteStr(f, "Duplicate"); + _0 = rt.fmtWriteStr(f, "Duplicate"); } else if (self.tag === "Missing") { - return rt.fmtWriteStr(f, "Missing"); + _0 = rt.fmtWriteStr(f, "Missing"); } else if (self.tag === "Unsupported") { - return rt.fmtWriteStr(f, "Unsupported"); + _0 = rt.fmtWriteStr(f, "Unsupported"); } else if (self.tag === "TrailingBytes") { - return rt.fmtWriteStr(f, "TrailingBytes"); + _0 = rt.fmtWriteStr(f, "TrailingBytes"); } else if (self.tag === "Version") { - return rt.fmtWriteStr(f, "Version"); + _0 = rt.fmtWriteStr(f, "Version"); } else if (self.tag === "Session") { - const __self04 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Session"), (f: rt.Formatter) => SessionError.fmt$Debug(__self04, f))); + __self03 = self._0; + _34 = "Session"; + _35 = (f: rt.Formatter) => SessionError.fmt$Debug(__self03, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _34), _35)); } else if (self.tag === "MalformedAuthToken") { - return rt.fmtWriteStr(f, "MalformedAuthToken"); + _0 = rt.fmtWriteStr(f, "MalformedAuthToken"); } else { - return rt.fmtWriteStr(f, "MultipleAuthTokens"); + _0 = rt.fmtWriteStr(f, "MultipleAuthTokens"); } + return _0; } /** A decode error. */ @@ -130,16 +163,17 @@ export type DecodeError = /** A complete frame cannot be extended by reading more stream bytes. */ export function complete(self: DecodeError): DecodeError { + let _0!: DecodeError; if (self.tag === "Short") { - return { tag: "InvalidValue" }; + _0 = { tag: "InvalidValue" } as DecodeError; } else { - const other = self; - return other; + _0 = self; } + return _0; } -export function from$From_BoundsExceeded(_: BoundsExceeded.BoundsExceeded): DecodeError { - return { tag: "BoundsExceeded" }; +export function from$From_BoundsExceeded(_1: BoundsExceeded.BoundsExceeded): DecodeError { + return { tag: "BoundsExceeded" } as DecodeError; } //# sourceMappingURL=decode.DecodeError.ts.map diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 5ac1b88ce..5443ae050 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -44,9 +44,14 @@ export function need(self: Decoder): rt.usize { /** Record that a read wanted `more` bytes past the current position. */ export function short(self: Decoder, more: rt.usize): DecodeError.DecodeError { - const need_ = rt.usizeSaturatingAdd(rt.usizeSub(self.len, self.buf.length), more); - self.need = rt.max(self.need, need_); - return { tag: "Short" }; + let need_!: rt.usize; + let _8!: rt.usize; + let _9!: rt.usize; + need_ = rt.usizeSaturatingAdd(rt.usizeSub(self.len, self.buf.length), more); + _9 = self.need; + _8 = rt.max(_9, need_); + self.need = _8; + return { tag: "Short" } as DecodeError.DecodeError; } /** The number of unread bytes. */ @@ -61,14 +66,16 @@ export function isEmpty(self: Decoder): boolean { /** Read `len` raw bytes. */ export function slice(self: Decoder, len: rt.usize): rt.Result { - const splitAtChecked = rt.sliceSplitAtChecked(self.buf, len); - if (splitAtChecked === undefined) { - return rt.Err(short(self, len)); + let _0!: rt.Result; + let _6!: [Uint8Array, Uint8Array] | undefined; + _6 = rt.sliceSplitAtChecked(self.buf, len); + if (_6 !== undefined) { + self.buf = _6[1]; + _0 = rt.Ok(_6[0]); + } else { + _0 = rt.Err(short(self, len)); } - const head = splitAtChecked[0]; - const rest_ = splitAtChecked[1]; - self.buf = rest_; - return rt.Ok(head); + return _0; } /** Read every remaining byte. */ @@ -80,102 +87,167 @@ export function rest(self: Decoder): Uint8Array { /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ export function sub(self: Decoder, len: rt.usize): rt.Result { - const slice_ = slice(self, len); - if (!slice_.ok) { - return rt.Err(slice_.error); + let _0!: rt.Result; + let _4!: rt.Result; + _4 = slice(self, len); + if (_4.ok) { + _0 = rt.Ok(new_(_4.value, self.form)); + } else { + _0 = _4; } - return rt.Ok(new_(slice_.value, self.form)); + return _0; } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - const slice_ = slice(self, 1); - if (!slice_.ok) { - return rt.Err(slice_.error); + let _0!: rt.Result; + let _3!: rt.Result; + let _8!: rt.usize; + let _9!: rt.usize; + _3 = slice(self, 1); + if (_3.ok) { + _8 = 0; + _9 = _3.value.length; + if (!(_8 < _9)) { + rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); + } + _0 = rt.Ok(_3.value[_8]); + } else { + _0 = _3; } - return rt.Ok(rt.at(slice_.value, 0)); + return _0; } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const slice_ = slice(self, 2); - if (!slice_.ok) { - return rt.Err(slice_.error); + let _0!: rt.Result; + let _2!: rt.Result; + let _9!: rt.u8; + let _10!: rt.usize; + let _11!: rt.usize; + let _14!: rt.usize; + let _15!: rt.usize; + _2 = slice(self, 2); + if (_2.ok) { + _10 = 0; + _11 = _2.value.length; + if (!(_10 < _11)) { + rt.panic("index out of bounds: the len is " + _11 + " but the index is " + _10); + } + _9 = _2.value[_10]; + _14 = 1; + _15 = _2.value.length; + if (!(_14 < _15)) { + rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); + } + _0 = rt.Ok((_9 << 8) | _2.value[_14]); + } else { + _0 = _2; } - const b = slice_.value; - return rt.Ok((rt.at(b, 0) << 8) | rt.at(b, 1)); + return _0; } /** Read a byte that must be 0 or 1. */ export function bool(self: Decoder): rt.Result { - const u8_ = u8(self); - if (!u8_.ok) { - return rt.Err(u8_.error); - } - if (u8_.value === 0) { - return rt.Ok(false); - } else if (u8_.value === 1) { - return rt.Ok(true); + let _0!: rt.Result; + let _2!: rt.Result; + let val!: rt.u8; + _2 = u8(self); + if (_2.ok) { + val = _2.value; + if (val === 0) { + _0 = rt.Ok(false); + } else if (val === 1) { + _0 = rt.Ok(true); + } else { + _0 = rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + } } else { - return rt.Err({ tag: "InvalidValue" }); + _0 = _2; } + return _0; } /** Read a varint. */ export function varint(self: Decoder): rt.Result { - const read_ = read(self.buf, self.form); - if (read_.ok) { - const value = read_.value[0]; - const rest_ = read_.value[1]; - self.buf = rest_; - return rt.Ok(value); - } else if (!read_.ok && read_.error.tag === "Short") { - return rt.Err(short(self, rt.usizeAdd(self.buf.length, 1))); + let _0!: rt.Result; + let _2!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; + let _3!: Form.Form; + let value!: rt.u64; + let _13!: Uint8Array; + _13 = self.buf; + _3 = self.form; + _2 = read(_13, _3); + if (_2.ok) { + value = _2.value[0]; + self.buf = _2.value[1]; + _0 = rt.Ok(value); + } else if (_2.error.tag === "Short") { + _0 = rt.Err(short(self, rt.usizeAdd(self.buf.length, 1))); } else { - const err = read_.error; - return rt.Err(err); + _0 = rt.Err(_2.error); } + return _0; } /** Read an optional varint: 0 is `None`, and `n + 1` is `Some(n)`. */ export function varintOpt(self: Decoder): rt.Result { - const varint_ = varint(self); - if (!varint_.ok) { - return rt.Err(varint_.error); + let _0!: rt.Result; + let _3!: rt.Result; + _3 = varint(self); + if (_3.ok) { + _0 = rt.Ok(rt.u64CheckedSub(_3.value, 1)); + } else { + _0 = _3; } - return rt.Ok(rt.u64CheckedSub(varint_.value, 1)); + return _0; } /** Read a varint length, then that many raw bytes. */ export function bytes(self: Decoder): rt.Result { - const start = self.buf; - const varint_ = varint(self); - if (!varint_.ok) { - return rt.Err(varint_.error); - } - const mapErr = rt.resultMapErr(rt.usizeTryFrom(varint_.value), (_: rt.TryFromIntError): DecodeError.DecodeError => { - return { tag: "BoundsExceeded" }; - }); - if (!mapErr.ok) { - return rt.Err(mapErr.error); + let _0!: rt.Result; + let start!: Uint8Array; + let _3!: rt.Result; + let _6!: rt.Result; + start = self.buf; + _6 = varint(self); + if (_6.ok) { + _3 = rt.resultMapErr(rt.usizeTryFrom(_6.value), (_2: rt.TryFromIntError): DecodeError.DecodeError => { + return { tag: "BoundsExceeded" } as DecodeError.DecodeError; + }); + if (_3.ok) { + _0 = rt.resultInspectErr(slice(self, _3.value), (_22: DecodeError.DecodeError): void => { + self.buf = start; + return; + }); + } else { + _0 = _3; + } + } else { + _0 = _6; } - const len = mapErr.value; - return rt.resultInspectErr(slice(self, len), (_2: DecodeError.DecodeError): void => { - self.buf = start; - }); + return _0; } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - const bytes_ = bytes(self); - if (!bytes_.ok) { - return rt.Err(bytes_.error); - } - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(bytes_.value)); - if (!fromUtf8.ok) { - return rt.Err(DecodeError.from$From_FromUtf8Error(fromUtf8.error)); + let _0!: rt.Result; + let _2!: rt.Result; + let _5!: rt.Result; + let residual2!: rt.Result; + _5 = bytes(self); + if (_5.ok) { + _2 = rt.stringFromUtf8(rt.sliceToByteVec(_5.value)); + if (_2.ok) { + _0 = rt.Ok(_2.value); + } else { + residual2 = _2; + _0 = rt.Err(DecodeError.from$From_FromUtf8Error((residual2 as { ok: false; error: rt.FromUtf8Error }).error)); + } + } else { + _0 = _5; } - return rt.Ok(fromUtf8.value); + return _0; } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts index bb973eeae..c571d46af 100644 --- a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts +++ b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts @@ -4,25 +4,43 @@ import * as rt from "../rt.ts"; import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; export function fmt$Display(self: EncodeError, __formatter: rt.Formatter): rt.Result { + let _0!: rt.Result; if (self === "BoundsExceeded") { - return rt.fmtWriteStr(__formatter, "bounds exceeded"); + _0 = rt.fmtWriteStr(__formatter, "bounds exceeded"); } else if (self === "TooLarge") { - return rt.fmtWriteStr(__formatter, "too large"); + _0 = rt.fmtWriteStr(__formatter, "too large"); } else if (self === "Short") { - return rt.fmtWriteStr(__formatter, "short buffer"); + _0 = rt.fmtWriteStr(__formatter, "short buffer"); } else if (self === "InvalidState") { - return rt.fmtWriteStr(__formatter, "invalid state"); + _0 = rt.fmtWriteStr(__formatter, "invalid state"); } else if (self === "TooMany") { - return rt.fmtWriteStr(__formatter, "too many"); + _0 = rt.fmtWriteStr(__formatter, "too many"); } else if (self === "Version") { - return rt.fmtWriteStr(__formatter, "unsupported version"); + _0 = rt.fmtWriteStr(__formatter, "unsupported version"); } else { - return rt.fmtWriteStr(__formatter, "unsupported"); + _0 = rt.fmtWriteStr(__formatter, "unsupported"); } + return _0; } export function fmt$Debug(self: EncodeError, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, self === "BoundsExceeded" ? "BoundsExceeded" : self === "TooLarge" ? "TooLarge" : self === "Short" ? "Short" : self === "InvalidState" ? "InvalidState" : self === "TooMany" ? "TooMany" : self === "Version" ? "Version" : "Unsupported"); + let _3!: string; + if (self === "BoundsExceeded") { + _3 = "BoundsExceeded"; + } else if (self === "TooLarge") { + _3 = "TooLarge"; + } else if (self === "Short") { + _3 = "Short"; + } else if (self === "InvalidState") { + _3 = "InvalidState"; + } else if (self === "TooMany") { + _3 = "TooMany"; + } else if (self === "Version") { + _3 = "Version"; + } else { + _3 = "Unsupported"; + } + return rt.fmtWriteStr(f, _3); } /** An error that occurs during encoding. */ @@ -35,8 +53,8 @@ export type EncodeError = | "Version" | "Unsupported"; -export function from$From_BoundsExceeded(_: BoundsExceeded.BoundsExceeded): EncodeError { - return "BoundsExceeded"; +export function from$From_BoundsExceeded(_1: BoundsExceeded.BoundsExceeded): EncodeError { + return "BoundsExceeded" as EncodeError; } //# sourceMappingURL=encode.EncodeError.ts.map diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index ede1a9e32..c98598591 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -3,7 +3,9 @@ import * as rt from "../rt.ts"; import * as EncodeError from "../coding/encode.EncodeError.ts"; import type * as Prefix from "../coding/encode.Prefix.ts"; +import type * as PrefixKind from "../coding/encode.PrefixKind.ts"; import { write } from "../coding/varint.ts"; +import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import type * as Form from "../coding/varint.Form.ts"; import type * as Control from "../stats.Control.ts"; @@ -26,56 +28,79 @@ function new_(buf: rt.ByteVec, form: Form.Form): Encoder { /** Write raw bytes. */ export function slice(self: Encoder, v: Uint8Array): void { rt.byteVecExtendFromSlice(self.buf, v); + return; } /** Write a single byte. */ export function u8(self: Encoder, v: rt.u8): void { rt.byteVecPush(self.buf, v); + return; } /** Write a big-endian `u16`. */ export function u16(self: Encoder, v: rt.u16): void { - rt.byteVecExtendFromSlice(self.buf, rt.u16ToBeBytes(v)); + let _6!: Uint8Array; + let _7!: rt.ByteVec; + _7 = self.buf; + _6 = rt.u16ToBeBytes(v); + rt.byteVecExtendFromSlice(_7, _6); + return; } /** Write a bool as a 0 or 1 byte. */ export function bool(self: Encoder, v: boolean): void { rt.byteVecPush(self.buf, v ? 1 : 0); + return; } /** Write a varint, or fail with [`EncodeError::BoundsExceeded`] if the form cannot carry it. */ export function varint(self: Encoder, v: rt.u64): rt.Result { - const write_ = write(v, self.form, self.buf); - if (!write_.ok) { - return rt.Err(EncodeError.from$From_BoundsExceeded(write_.error)); + let _0!: rt.Result; + let _3!: rt.Result; + _3 = write(v, self.form, self.buf); + if (_3.ok) { + _0 = rt.Ok(undefined); + } else { + const residual = rt.Err({}); + _0 = rt.Err(EncodeError.from$From_BoundsExceeded((residual as { ok: false; error: BoundsExceeded.BoundsExceeded }).error)); } - return rt.Ok(write_.value); + return _0; } /** Write an optional varint: `None` as 0, and `Some(n)` as `n + 1`. */ export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { - let v2: rt.u64; - if (v !== undefined) { - const v3 = v; - const okOr = rt.optionOkOr(rt.u64CheckedAdd(v3, 1), "TooLarge" as EncodeError.EncodeError); - if (!okOr.ok) { - return rt.Err(okOr.error); + let _0!: rt.Result; + let v2!: rt.u64; + let _6!: rt.Result; + b0: { + if (v === undefined) { + v2 = 0; + } else { + _6 = rt.optionOkOr(rt.u64CheckedAdd(v, 1), "TooLarge" as EncodeError.EncodeError); + if (_6.ok) { + v2 = _6.value; + } else { + _0 = _6; + break b0; + } } - v2 = okOr.value; - } else { - v2 = 0; + _0 = varint(self, v2); } - return varint(self, v2); + return _0; } /** Write a varint length, then the raw bytes. */ export function bytes(self: Encoder, v: Uint8Array): rt.Result { - const varint_ = varint(self, v.length as rt.u64); - if (!varint_.ok) { - return rt.Err(varint_.error); + let _0!: rt.Result; + let _3!: rt.Result; + _3 = varint(self, v.length as rt.u64); + if (_3.ok) { + slice(self, v); + _0 = rt.Ok(undefined); + } else { + _0 = _3; } - slice(self, v); - return rt.Ok(undefined); + return _0; } /** Write a varint length, then the UTF-8 bytes. */ @@ -89,61 +114,126 @@ export function string(self: Encoder, v: string): rt.Result { - const body = prefix.body; - const end = self.buf.length; - if (prefix.kind === "U16") { - const mapErr = rt.resultMapErr(rt.u16TryFrom(rt.usizeSub(end, body)), (_: rt.TryFromIntError): EncodeError.EncodeError => { - return "TooLarge"; - }); - if (!mapErr.ok) { - return rt.Err(mapErr.error); - } - const size = mapErr.value; - rt.sliceCopyFromSlice(rt.sliceRange(rt.byteVecView(self.buf), rt.usizeSub(body, 2), body), rt.u16ToBeBytes(size)); - } else { - const write_ = write(rt.usizeSub(end, body) as rt.u64, self.form, self.buf); - if (!write_.ok) { - return rt.Err(EncodeError.from$From_BoundsExceeded(write_.error)); - } - const len = rt.usizeSub(self.buf.length, end); - if (len === 1) { - const value = rt.at(rt.byteVecView(self.buf), end); - const slice_ = rt.byteVecView(self.buf); - const index = rt.usizeSub(body, 1); - slice_[rt.idx(slice_, index)] = value; - rt.byteVecTruncate(self.buf, end); - return rt.Ok(undefined); + let _0!: rt.Result; + let body!: rt.usize; + let end!: rt.usize; + let _7!: rt.Result; + let size!: rt.u16; + let _16!: Uint8Array; + let _22!: Uint8Array; + let _23!: rt.Result; + let len!: rt.usize; + let _35!: rt.u8; + let _39!: rt.usize; + let size2!: Uint8Array; + let _44!: Uint8Array; + let _56!: Uint8Array; + let _58!: rt.usize; + let _74!: rt.ByteVec; + let _75!: rt.ByteVec; + let _77!: rt.ByteVec; + let _78!: rt.ByteVec; + let _79!: rt.ByteVec; + let _81!: rt.ByteVec; + let _84!: rt.ByteVec; + body = prefix.body; + _74 = self.buf; + end = _74.length; + b0: { + if (prefix.kind === "Varint") { + _23 = write(rt.usizeSub(end, body) as rt.u64, self.form, self.buf); + if (_23.ok) { + _77 = self.buf; + len = rt.usizeSub(_77.length, end); + if (!(len === 1)) { + size2 = rt.bytes(9); + _44 = rt.sliceRange(size2, 0, len); + _81 = self.buf; + const slice4 = rt.byteVecView(_81); + rt.sliceCopyFromSlice(_44, rt.sliceRange(slice4, end)); + rt.byteVecTruncate(self.buf, rt.usizeSub(rt.usizeAdd(end, len), 1)); + _58 = rt.usizeSub(rt.usizeAdd(body, len), 1); + _56 = rt.byteVecView(self.buf); + rt.sliceCopyWithin(_56, body, end, _58); + _84 = self.buf; + const part2 = rt.usizeSub(body, 1); + const part3 = rt.usizeAdd(rt.usizeSub(body, 1), len); + const slice5 = rt.byteVecView(_84); + rt.sliceCopyFromSlice(rt.sliceRange(slice5, part2, part3), rt.sliceRange(size2, 0, len)); + } else { + _78 = self.buf; + const slice2 = rt.byteVecView(_78); + const at = rt.idx(slice2, end); + _35 = slice2[at]; + _79 = self.buf; + _39 = rt.usizeSub(body, 1); + const slice3 = rt.byteVecView(_79); + const at2 = rt.idx(slice3, _39); + slice3[at2] = _35; + rt.byteVecTruncate(self.buf, end); + _0 = rt.Ok(undefined); + break b0; + } + } else { + const residual2 = rt.Err({}); + _0 = rt.Err(EncodeError.from$From_BoundsExceeded((residual2 as { ok: false; error: BoundsExceeded.BoundsExceeded }).error)); + break b0; + } + } else { + _7 = rt.resultMapErr(rt.u16TryFrom(rt.usizeSub(end, body)), (_2: rt.TryFromIntError): EncodeError.EncodeError => { + return "TooLarge" as EncodeError.EncodeError; + }); + if (_7.ok) { + size = _7.value; + _75 = self.buf; + const part = rt.usizeSub(body, 2); + const slice_ = rt.byteVecView(_75); + _16 = rt.sliceRange(slice_, part, body); + _22 = rt.u16ToBeBytes(size); + rt.sliceCopyFromSlice(_16, _22); + } else { + _0 = _7; + break b0; + } } - let size2: Uint8Array = rt.bytes(9); - rt.sliceCopyFromSlice(rt.sliceRange(size2, 0, len), rt.sliceRange(rt.byteVecView(self.buf), end)); - rt.byteVecTruncate(self.buf, rt.usizeSub(rt.usizeAdd(end, len), 1)); - rt.sliceCopyWithin(rt.byteVecView(self.buf), body, end, rt.usizeSub(rt.usizeAdd(body, len), 1)); - rt.sliceCopyFromSlice(rt.sliceRange(rt.byteVecView(self.buf), rt.usizeSub(body, 1), rt.usizeAdd(rt.usizeSub(body, 1), len)), rt.sliceRange(size2, 0, len)); + _0 = rt.Ok(undefined); } - return rt.Ok(undefined); + return _0; } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/varint.Form.ts b/ts/fixtures/codec/expected/coding/varint.Form.ts index 35c33abb4..1e6399701 100644 --- a/ts/fixtures/codec/expected/coding/varint.Form.ts +++ b/ts/fixtures/codec/expected/coding/varint.Form.ts @@ -6,11 +6,15 @@ import type * as Version from "../lite/version.Version.ts"; export type Form = { tag: "Quic" } | { tag: "LeadingOnes"; seven: boolean }; export function from$From_Version(version: Version.Version): Form { - if (version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06") { - return { tag: "Quic" }; - } else { - return { tag: "LeadingOnes", seven: true }; + let _0!: Form; + b0: { + if (!(version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06")) { + _0 = { tag: "LeadingOnes", seven: true } as Form; + break b0; + } + _0 = { tag: "Quic" } as Form; } + return _0; } //# sourceMappingURL=varint.Form.ts.map diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 2170e1627..fa7b0d9a9 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -7,7 +7,7 @@ import type * as Form from "../coding/varint.Form.ts"; /** The high and low 32 bits: the only place the codec splits a `u64`. */ export function toHalves(value: rt.u64): [rt.u32, rt.u32] { - return [rt.u64Low(rt.u64Shr(value, 32)), rt.u64Low(value)]; + return [rt.u64Low(rt.u64Shr(value, 32)), rt.u64Low(value)] as [rt.u32, rt.u32]; } /** The inverse of [`to_halves`]. */ @@ -17,36 +17,84 @@ export function fromHalves(hi: rt.u32, lo: rt.u32): rt.u64 { /** The bytes `value` takes on the wire in `form`, or [`BoundsExceeded`] if it does not fit. */ export function size(value: rt.u64, form: Form.Form): rt.Result { - const [hi, lo] = toHalves(value); - let value2: rt.usize; - if (form.tag === "Quic" && hi === 0 && lo < (1 << 6)) { - value2 = 1; - } else if (form.tag === "Quic" && hi === 0 && lo < (1 << 14)) { - value2 = 2; - } else if (form.tag === "Quic" && hi === 0 && lo < (1 << 30)) { - value2 = 4; - } else if (form.tag === "Quic" && hi < (1 << 30)) { - value2 = 8; - } else if (form.tag === "Quic") { - return rt.Err({}); - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 7)) { - value2 = 1; - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 14)) { - value2 = 2; - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 21)) { - value2 = 3; - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 28)) { - value2 = 4; - } else if (form.tag === "LeadingOnes" && hi < (1 << 3)) { - value2 = 5; - } else if (form.tag === "LeadingOnes" && hi < (1 << 10)) { - value2 = 6; - } else if (form.tag === "LeadingOnes" && hi < (1 << 24)) { - value2 = 8; - } else { - value2 = 9; + let _0!: rt.Result; + let hi!: rt.u32; + let lo!: rt.u32; + let _5!: [rt.u32, rt.u32]; + let _6!: rt.usize; + _5 = toHalves(value); + b0: { + b1: { + hi = _5[0]; + lo = _5[1]; + if (form.tag === "Quic") { + if (hi === 0) { + if (lo < 64) { + _6 = 1; + break b1; + } + } + if (hi === 0) { + if (lo < 16384) { + _6 = 2; + break b1; + } + } + if (hi === 0) { + if (lo < 1073741824) { + _6 = 4; + break b1; + } + } + if (!(hi < 1073741824)) { + _0 = rt.Err({}); + break b0; + } else { + _6 = 8; + } + } else { + if (hi === 0) { + if (lo < 128) { + _6 = 1; + break b1; + } + } + if (hi === 0) { + if (lo < 16384) { + _6 = 2; + break b1; + } + } + if (hi === 0) { + if (lo < 2097152) { + _6 = 3; + break b1; + } + } + if (hi === 0) { + if (lo < 268435456) { + _6 = 4; + break b1; + } + } + if (!(hi < 8)) { + if (!(hi < 1024)) { + if (!(hi < 16777216)) { + _6 = 9; + } else { + _6 = 8; + } + } else { + _6 = 6; + } + } else { + _6 = 5; + } + } + } + _0 = rt.Ok(_6); } - return rt.Ok(value2); + return _0; } /** @@ -55,227 +103,331 @@ export function size(value: rt.u64, form: Form.Form): rt.Result { + let _0!: rt.Result; if (form.tag === "Quic") { - return writeQuic(value, out); + _0 = writeQuic(value, out); } else { writeLeadingOnes(value, out); - return rt.Ok(undefined); + _0 = rt.Ok(undefined); } + return _0; } export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result { - const [hi, lo] = toHalves(value); - if (hi === 0 && lo < (1 << 6)) { - rt.byteVecPush(out, lo & 0xff); - } else if (hi === 0 && lo < (1 << 14)) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(0x4000 | (lo & 0xffff))); - } else if (hi === 0 && lo < (1 << 30)) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes((0x8000_0000 | lo) >>> 0)); - } else if (hi < (1 << 30)) { - const toBeBytes = rt.u32ToBeBytes((0xc000_0000 | hi) >>> 0); - const a = toBeBytes[0]; - const b = toBeBytes[1]; - const c = toBeBytes[2]; - const d = toBeBytes[3]; - const toBeBytes2 = rt.u32ToBeBytes(lo); - const e = toBeBytes2[0]; - const f = toBeBytes2[1]; - const g = toBeBytes2[2]; - const h = toBeBytes2[3]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a, b, c, d, e, f, g, h)); - } else { - return rt.Err({}); + let _0!: rt.Result; + let hi!: rt.u32; + let lo!: rt.u32; + let _5!: [rt.u32, rt.u32]; + let _21!: Uint8Array; + let _32!: Uint8Array; + let a!: rt.u8; + let b!: rt.u8; + let c!: rt.u8; + let d!: rt.u8; + let _42!: Uint8Array; + let _48!: Uint8Array; + let _52!: Uint8Array; + _5 = toHalves(value); + b0: { + b1: { + hi = _5[0]; + lo = _5[1]; + if (hi === 0) { + if (lo < 64) { + rt.byteVecPush(out, lo & 0xff); + break b1; + } + } + if (hi === 0) { + if (lo < 16384) { + _21 = rt.u16ToBeBytes(16384 | (lo & 0xffff)); + rt.byteVecExtendFromSlice(out, _21); + break b1; + } + } + if (hi === 0) { + if (lo < 1073741824) { + _32 = rt.u32ToBeBytes((2147483648 | lo) >>> 0); + rt.byteVecExtendFromSlice(out, _32); + break b1; + } + } + if (!(hi < 1073741824)) { + _0 = rt.Err({}); + break b0; + } else { + _42 = rt.u32ToBeBytes((3221225472 | hi) >>> 0); + a = _42[0]; + b = _42[1]; + c = _42[2]; + d = _42[3]; + _48 = rt.u32ToBeBytes(lo); + _52 = Uint8Array.of(a, b, c, d, _48[0], _48[1], _48[2], _48[3]); + rt.byteVecExtendFromSlice(out, _52); + } + } + _0 = rt.Ok(undefined); } - return rt.Ok(undefined); + return _0; } export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { - const [hi, lo] = toHalves(value); - const toBeBytes = rt.u32ToBeBytes(lo); - const a = toBeBytes[0]; - const b = toBeBytes[1]; - const c = toBeBytes[2]; - const d = toBeBytes[3]; - if (hi === 0 && lo < (1 << 7)) { - rt.byteVecPush(out, d); - } else if (hi === 0 && lo < (1 << 14)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0x80 | c, d)); - } else if (hi === 0 && lo < (1 << 21)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xc0 | b, c, d)); - } else if (hi === 0 && lo < (1 << 28)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xe0 | a, b, c, d)); - } else if (hi < (1 << 3)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xf0 | (hi & 0xff), a, b, c, d)); - } else if (hi < (1 << 10)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xf8 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d)); - } else if (hi < (1 << 24)) { - const toBeBytes2 = rt.u32ToBeBytes(hi); - const f = toBeBytes2[1]; - const g = toBeBytes2[2]; - const h = toBeBytes2[3]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xfe, f, g, h, a, b, c, d)); - } else { - const toBeBytes3 = rt.u32ToBeBytes(hi); - const e = toBeBytes3[0]; - const f2 = toBeBytes3[1]; - const g2 = toBeBytes3[2]; - const h2 = toBeBytes3[3]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xff, e, f2, g2, h2, a, b, c, d)); + let hi!: rt.u32; + let lo!: rt.u32; + let _5!: [rt.u32, rt.u32]; + let a!: rt.u8; + let b!: rt.u8; + let c!: rt.u8; + let d!: rt.u8; + let _10!: Uint8Array; + let _25!: Uint8Array; + let _35!: Uint8Array; + let _45!: Uint8Array; + let _54!: Uint8Array; + let _64!: Uint8Array; + let _78!: Uint8Array; + let _82!: Uint8Array; + let _87!: Uint8Array; + let _91!: Uint8Array; + _5 = toHalves(value); + hi = _5[0]; + lo = _5[1]; + _10 = rt.u32ToBeBytes(lo); + b0: { + a = _10[0]; + b = _10[1]; + c = _10[2]; + d = _10[3]; + if (hi === 0) { + if (lo < 128) { + rt.byteVecPush(out, d); + break b0; + } + } + if (hi === 0) { + if (lo < 16384) { + _25 = Uint8Array.of(128 | c, d); + rt.byteVecExtendFromSlice(out, _25); + break b0; + } + } + if (hi === 0) { + if (lo < 2097152) { + _35 = Uint8Array.of(192 | b, c, d); + rt.byteVecExtendFromSlice(out, _35); + break b0; + } + } + if (hi === 0) { + if (lo < 268435456) { + _45 = Uint8Array.of(224 | a, b, c, d); + rt.byteVecExtendFromSlice(out, _45); + break b0; + } + } + if (!(hi < 8)) { + if (!(hi < 1024)) { + if (!(hi < 16777216)) { + _87 = rt.u32ToBeBytes(hi); + _91 = Uint8Array.of(255, _87[0], _87[1], _87[2], _87[3], a, b, c, d); + rt.byteVecExtendFromSlice(out, _91); + } else { + _78 = rt.u32ToBeBytes(hi); + _82 = Uint8Array.of(254, _78[1], _78[2], _78[3], a, b, c, d); + rt.byteVecExtendFromSlice(out, _82); + } + } else { + _64 = Uint8Array.of(248 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d); + rt.byteVecExtendFromSlice(out, _64); + } + } else { + _54 = Uint8Array.of(240 | (hi & 0xff), a, b, c, d); + rt.byteVecExtendFromSlice(out, _54); + } } + return; } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ export function read(buf: Uint8Array, form: Form.Form): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { + let _0!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; if (form.tag === "Quic") { - return readQuic(buf); + _0 = readQuic(buf); } else { - const seven = form.seven; - return readLeadingOnes(buf, seven); + _0 = readLeadingOnes(buf, form.seven); } + return _0; } export function readQuic(buf: Uint8Array): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - const splitFirst = rt.sliceSplitFirst(buf); - if (splitFirst === undefined) { - return rt.Err({ tag: "Short" }); - } - const first = splitFirst[0]; - const rest = splitFirst[1]; - if (first < 0x40) { - return rt.Ok([first as rt.u64, rest]); - } else if (first < 0x80) { - const okOr = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr.ok) { - return rt.Err(okOr.error); + let _0!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; + let first!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let _14!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val!: [Uint8Array, Uint8Array]; + let _33!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val2!: [Uint8Array, Uint8Array]; + let _54!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val3!: [Uint8Array, Uint8Array]; + _5 = rt.sliceSplitFirst(buf); + if (_5 !== undefined) { + first = _5[0]; + if (!(first < 64)) { + if (!(first < 128)) { + if (!(first < 192)) { + _54 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + if (_54.ok) { + val3 = _54.value; + const slice = val3[0]; + _0 = rt.Ok([fromHalves((((val3[0][0] & 63) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0, rt.u32FromBeBytes(slice.subarray(4, 8))), val3[1]] as [rt.u64, Uint8Array]); + } else { + _0 = _54; + } + } else { + _33 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + if (_33.ok) { + val2 = _33.value; + _0 = rt.Ok([(((val2[0][0] & 63) << 24) | (val2[0][1] << 16) | (val2[0][2] << 8) | val2[0][3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, Uint8Array]); + } else { + _0 = _33; + } + } + } else { + _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + if (_14.ok) { + val = _14.value; + _0 = rt.Ok([(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]); + } else { + _0 = _14; + } + } + } else { + _0 = rt.Ok([first as rt.u64, _5[1]] as [rt.u64, Uint8Array]); } - const a = okOr.value[0][0]; - const b = okOr.value[0][1]; - const rest2 = okOr.value[1]; - return rt.Ok([((((a & 0x3f) << 8) | b)) as rt.u64, rest2]); - } else if (first < 0xc0) { - const okOr2 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr2.ok) { - return rt.Err(okOr2.error); - } - const a2 = okOr2.value[0][0]; - const b2 = okOr2.value[0][1]; - const c = okOr2.value[0][2]; - const d = okOr2.value[0][3]; - const rest3 = okOr2.value[1]; - return rt.Ok([(((a2 & 0x3f) << 24) | (b2 << 16) | (c << 8) | d) >>> 0 as rt.u64, rest3]); } else { - const okOr3 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr3.ok) { - return rt.Err(okOr3.error); - } - const a3 = okOr3.value[0][0]; - const b3 = okOr3.value[0][1]; - const c2 = okOr3.value[0][2]; - const d2 = okOr3.value[0][3]; - const lo = okOr3.value[0].subarray(4, 8); - const rest4 = okOr3.value[1]; - return rt.Ok([fromHalves((((a3 & 0x3f) << 24) | (b3 << 16) | (c2 << 8) | d2) >>> 0, rt.u32FromBeBytes(lo)), rest4]); + _0 = rt.Err({ tag: "Short" } as DecodeError.DecodeError); } + return _0; } export function readLeadingOnes(buf: Uint8Array, seven: boolean): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - const splitFirst = rt.sliceSplitFirst(buf); - if (splitFirst === undefined) { - return rt.Err({ tag: "Short" }); - } - const first = splitFirst[0]; - const rest = splitFirst[1]; - let value: [rt.u64, Uint8Array]; - const leadingOnes = rt.u8LeadingOnes(first); - if (leadingOnes === 0) { - value = [first as rt.u64, rest]; - } else if (leadingOnes === 1) { - const okOr = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr.ok) { - return rt.Err(okOr.error); - } - const a = okOr.value[0][0]; - const b = okOr.value[0][1]; - const rest2 = okOr.value[1]; - value = [((((a & 0x3f) << 8) | b)) as rt.u64, rest2]; - } else if (leadingOnes === 2) { - const okOr2 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr2.ok) { - return rt.Err(okOr2.error); - } - const a2 = okOr2.value[0][0]; - const b2 = okOr2.value[0][1]; - const c = okOr2.value[0][2]; - const rest3 = okOr2.value[1]; - value = [((((a2 & 0x1f) << 16) | (b2 << 8) | c)) as rt.u64, rest3]; - } else if (leadingOnes === 3) { - const okOr3 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr3.ok) { - return rt.Err(okOr3.error); - } - const a3 = okOr3.value[0][0]; - const b3 = okOr3.value[0][1]; - const c2 = okOr3.value[0][2]; - const d = okOr3.value[0][3]; - const rest4 = okOr3.value[1]; - value = [(((a3 & 0x0f) << 24) | (b3 << 16) | (c2 << 8) | d) >>> 0 as rt.u64, rest4]; - } else if (leadingOnes === 4) { - const okOr4 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr4.ok) { - return rt.Err(okOr4.error); - } - const a4 = okOr4.value[0][0]; - const lo = okOr4.value[0].subarray(1, 5); - const rest5 = okOr4.value[1]; - value = [fromHalves(((a4 & 0x07)) as rt.u32, rt.u32FromBeBytes(lo)), rest5]; - } else if (leadingOnes === 5) { - const okOr5 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr5.ok) { - return rt.Err(okOr5.error); - } - const a5 = okOr5.value[0][0]; - const b4 = okOr5.value[0][1]; - const lo2 = okOr5.value[0].subarray(2, 6); - const rest6 = okOr5.value[1]; - value = [fromHalves(((a5 & 0x03) << 8) | b4, rt.u32FromBeBytes(lo2)), rest6]; - } else if (leadingOnes === 6 && !seven) { - return rt.Err({ tag: "InvalidValue" }); - } else if (leadingOnes === 6) { - const okOr6 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr6.ok) { - return rt.Err(okOr6.error); - } - const a6 = okOr6.value[0][0]; - const b5 = okOr6.value[0][1]; - const c3 = okOr6.value[0][2]; - const lo3 = okOr6.value[0].subarray(3, 7); - const rest7 = okOr6.value[1]; - value = [fromHalves(((a6 & 0x01) << 16) | (b5 << 8) | c3, rt.u32FromBeBytes(lo3)), rest7]; - } else if (leadingOnes === 7) { - const okOr7 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr7.ok) { - return rt.Err(okOr7.error); - } - const b6 = okOr7.value[0][1]; - const c4 = okOr7.value[0][2]; - const d2 = okOr7.value[0][3]; - const lo4 = okOr7.value[0].subarray(4, 8); - const rest8 = okOr7.value[1]; - value = [fromHalves((b6 << 16) | (c4 << 8) | d2, rt.u32FromBeBytes(lo4)), rest8]; - } else { - const okOr8 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr8.ok) { - return rt.Err(okOr8.error); + let _0!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; + let first!: rt.u8; + let _6!: [rt.u8, Uint8Array] | undefined; + let _8!: [rt.u64, Uint8Array]; + let _9!: rt.u32; + let _14!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val!: [Uint8Array, Uint8Array]; + let _30!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val2!: [Uint8Array, Uint8Array]; + let _48!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val3!: [Uint8Array, Uint8Array]; + let _65!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val4!: [Uint8Array, Uint8Array]; + let _81!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val5!: [Uint8Array, Uint8Array]; + let _101!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val6!: [Uint8Array, Uint8Array]; + let _121!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val7!: [Uint8Array, Uint8Array]; + let _142!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val8!: [Uint8Array, Uint8Array]; + _6 = rt.sliceSplitFirst(buf); + b0: { + if (_6 !== undefined) { + first = _6[0]; + _9 = rt.u8LeadingOnes(first); + if (_9 === 0) { + _8 = [first as rt.u64, _6[1]] as [rt.u64, Uint8Array]; + } else if (_9 === 1) { + _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + if (_14.ok) { + val = _14.value; + _8 = [(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _14; + break b0; + } + } else if (_9 === 2) { + _30 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); + if (_30.ok) { + val2 = _30.value; + _8 = [(((val2[0][0] & 31) << 16) | (val2[0][1] << 8) | val2[0][2]) as rt.u64, val2[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _30; + break b0; + } + } else if (_9 === 3) { + _48 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + if (_48.ok) { + val3 = _48.value; + _8 = [(((val3[0][0] & 15) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _48; + break b0; + } + } else if (_9 === 4) { + _65 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); + if (_65.ok) { + val4 = _65.value; + const slice5 = val4[0]; + _8 = [fromHalves(((val4[0][0] & 7)) as rt.u32, rt.u32FromBeBytes(slice5.subarray(1, 5))), val4[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _65; + break b0; + } + } else if (_9 === 5) { + _81 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); + if (_81.ok) { + val5 = _81.value; + const slice4 = val5[0]; + _8 = [fromHalves(((val5[0][0] & 3) << 8) | val5[0][1], rt.u32FromBeBytes(slice4.subarray(2, 6))), val5[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _81; + break b0; + } + } else if (_9 === 6) { + if (!seven) { + _0 = rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + break b0; + } else { + _101 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); + if (_101.ok) { + val6 = _101.value; + const slice3 = val6[0]; + _8 = [fromHalves(((val6[0][0] & 1) << 16) | (val6[0][1] << 8) | val6[0][2], rt.u32FromBeBytes(slice3.subarray(3, 7))), val6[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _101; + break b0; + } + } + } else if (_9 === 7) { + _121 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + if (_121.ok) { + val7 = _121.value; + const slice2 = val7[0]; + _8 = [fromHalves((val7[0][1] << 16) | (val7[0][2] << 8) | val7[0][3], rt.u32FromBeBytes(slice2.subarray(4, 8))), val7[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _121; + break b0; + } + } else { + _142 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); + if (_142.ok) { + val8 = _142.value; + const slice = val8[0]; + _8 = [fromHalves(rt.u32FromBeBytes(slice.subarray(1, 5)), ((val8[0][5] << 24) | (val8[0][6] << 16) | (val8[0][7] << 8) | val8[0][8]) >>> 0), val8[1]] as [rt.u64, Uint8Array]; + } else { + _0 = _142; + break b0; + } + } + _0 = rt.Ok(_8); + } else { + _0 = rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - const e = okOr8.value[0][5]; - const f = okOr8.value[0][6]; - const g = okOr8.value[0][7]; - const h = okOr8.value[0][8]; - const hi = okOr8.value[0].subarray(1, 5); - const rest9 = okOr8.value[1]; - value = [fromHalves(rt.u32FromBeBytes(hi), ((e << 24) | (f << 16) | (g << 8) | h) >>> 0), rest9]; } - return rt.Ok(value); + return _0; } /** @@ -289,7 +441,11 @@ export function zigzag(signed: rt.i64): rt.u64 { /** The inverse of [`zigzag`]. */ export function unzigzag(value: rt.u64): rt.i64 { - return rt.i64Xor(rt.i64Cast(rt.u64Shr(value, 1)), rt.i64Neg(rt.i64Cast(rt.u64And(value, 1)))); + let _2!: rt.i64; + let _7!: rt.i64; + _2 = rt.i64Cast(rt.u64Shr(value, 1)); + _7 = rt.i64Cast(rt.u64And(value, 1)); + return rt.i64Xor(_2, rt.i64Neg(_7)); } //# sourceMappingURL=varint.ts.map diff --git a/ts/fixtures/codec/expected/coding/version.Version.ts b/ts/fixtures/codec/expected/coding/version.Version.ts index 06ed65a7c..4799eca0a 100644 --- a/ts/fixtures/codec/expected/coding/version.Version.ts +++ b/ts/fixtures/codec/expected/coding/version.Version.ts @@ -14,30 +14,42 @@ export interface Version { } /** Decode the version number. */ -export function decode$Decode_Form(r: Decoder.Decoder, _: Form.Form): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); +export function decode$Decode_Form(r: Decoder.Decoder, _2: Form.Form): rt.Result { + let _0!: rt.Result; + let _4!: rt.Result; + _4 = Decoder.varint(r); + if (_4.ok) { + _0 = rt.Ok({ _0: _4.value }); + } else { + _0 = _4; } - return rt.Ok({ _0: varint.value }); + return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$Encode_Form(self: Version, w: Encoder.Encoder, _: Form.Form): rt.Result { - const varint = Encoder.varint(w, self._0); - if (!varint.ok) { - return rt.Err(varint.error); +export function encode$Encode_Form(self: Version, w: Encoder.Encoder, _3: Form.Form): rt.Result { + let _0!: rt.Result; + let _4!: rt.Result; + _4 = Encoder.varint(w, self._0); + if (_4.ok) { + _0 = rt.Ok(undefined); + } else { + _0 = _4; } - return rt.Ok(undefined); + return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$Encode_Version(self: Version, w: Encoder.Encoder, _: version_Version.Version): rt.Result { - const varint = Encoder.varint(w, self._0); - if (!varint.ok) { - return rt.Err(varint.error); +export function encode$Encode_Version(self: Version, w: Encoder.Encoder, _3: version_Version.Version): rt.Result { + let _0!: rt.Result; + let _4!: rt.Result; + _4 = Encoder.varint(w, self._0); + if (_4.ok) { + _0 = rt.Ok(undefined); + } else { + _0 = _4; } - return rt.Ok(undefined); + return _0; } //# sourceMappingURL=version.Version.ts.map diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 2cda18088..fce06232e 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -11,13 +11,23 @@ import type * as version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ export function decodeSlice$Decode_Form(buf: Uint8Array, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { - let r: Decoder.Decoder = Decoder.new(buf, version); - const decode = decode$Decode_Form(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result<[Versions, rt.usize], DecodeError.DecodeError>; + let r!: Decoder.Decoder; + let value!: Versions; + let _6!: rt.Result; + let val!: Versions; + let _13!: Versions; + r = Decoder.new(buf, version); + _6 = decode$Decode_Form(r, version); + if (_6.ok) { + val = _6.value; + value = val; + _13 = value; + _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Versions, rt.usize]); + } else { + _0 = _6; } - const value = decode.value; - return rt.Ok([value, rt.usizeSub(buf.length, Decoder.remaining(r))]); + return _0; } /** A list of versions in preferred order. */ @@ -27,52 +37,101 @@ export interface Versions { /** Decode the version list. */ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const count = varint.value; - let vs: Version.Version[] = []; - const end = count; - for (const _ of new rt.Range(0, end, rt.u64Step)) { - const decode = Version.decode$Decode_Form(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result; + let _3!: rt.Result; + let count!: rt.u64; + let vs!: Version.Version[]; + let iter!: rt.Range; + let _12!: rt.u64 | rt.Done; + let _15!: rt.Result; + _3 = Decoder.varint(r); + b0: { + if (_3.ok) { + count = _3.value; + vs = []; + iter = new rt.Range(0, count, rt.u64Step); + while (true) { + _12 = iter.next(); + if (_12 === rt.DONE) { + _0 = rt.Ok({ _0: vs }); + break b0; + } else { + _15 = Version.decode$Decode_Form(r, version); + if (_15.ok) { + vs.push(_15.value); + } else { + _0 = _15; + break b0; + } + } + } + } else { + _0 = _3; } - const v = decode.value; - vs.push(rt.copy(v)); } - return rt.Ok({ _0: vs }); + return _0; } /** Encode the version list. */ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: Form.Form): rt.Result { - const varint = Encoder.varint(w, self._0.length as rt.u64); - if (!varint.ok) { - return rt.Err(varint.error); - } - for (const v of self._0) { - const encode = Version.encode$Encode_Form(v, w, version); - if (!encode.ok) { - return rt.Err(encode.error); + let _0!: rt.Result; + let _4!: rt.Result; + let iter!: rt.Iter; + let _14!: Version.Version | rt.Done; + let _18!: rt.Result; + _4 = Encoder.varint(w, self._0.length as rt.u64); + b0: { + if (_4.ok) { + iter = rt.iterSlice(self._0); + while (true) { + _14 = iter.next(); + if (_14 === rt.DONE) { + _0 = rt.Ok(undefined); + break b0; + } else { + _18 = Version.encode$Encode_Form(_14, w, version); + if (!_18.ok) { + _0 = _18; + break b0; + } + } + } + } else { + _0 = _4; } } - return rt.Ok(undefined); + return _0; } /** Encode the version list. */ export function encode$Encode_Version(self: Versions, w: Encoder.Encoder, version: version_Version.Version): rt.Result { - const varint = Encoder.varint(w, self._0.length as rt.u64); - if (!varint.ok) { - return rt.Err(varint.error); - } - for (const v of self._0) { - const encode = Version.encode$Encode_Version(v, w, version); - if (!encode.ok) { - return rt.Err(encode.error); + let _0!: rt.Result; + let _4!: rt.Result; + let iter!: rt.Iter; + let _14!: Version.Version | rt.Done; + let _18!: rt.Result; + _4 = Encoder.varint(w, self._0.length as rt.u64); + b0: { + if (_4.ok) { + iter = rt.iterSlice(self._0); + while (true) { + _14 = iter.next(); + if (_14 === rt.DONE) { + _0 = rt.Ok(undefined); + break b0; + } else { + _18 = Version.encode$Encode_Version(_14, w, version); + if (!_18.ok) { + _0 = _18; + break b0; + } + } + } + } else { + _0 = _4; } } - return rt.Ok(undefined); + return _0; } export function from$From_Versions(vs: Version.Version[]): Versions { diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index c8ba2c0f0..3c1c710c3 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -17,92 +17,124 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { - let out: rt.ByteVec = new rt.ByteVec(); - const splitFirst = rt.sliceSplitFirst(input); - if (splitFirst === undefined) { - return out; - } - const op = splitFirst[0]; - const data = splitFirst[1]; - const value = rt.u8Rem(op, 9); - if (value === 0) { - decodeScript(data, out); - } else if (value === 1) { - encodeScript(data, out); - } else if (value === 2) { - zigzag(data, out); - } else if (value === 3) { - sizes(data, out); - } else if (value === 4) { - roundtrip$Versions(data, out); - } else if (value === 5) { - roundtripLite$Group(data, out); - } else if (value === 6) { - roundtripLite$Probe(data, out); - } else if (value === 7) { - encodeMessages(data, out); + let _0!: rt.ByteVec; + let out!: rt.ByteVec; + let _5!: [rt.u8, Uint8Array] | undefined; + let _8!: rt.u8; + out = new rt.ByteVec(); + _5 = rt.sliceSplitFirst(input); + if (_5 !== undefined) { + _8 = rt.u8Rem(_5[0], 9); + if (_8 === 0) { + decodeScript(_5[1], out); + } else if (_8 === 1) { + encodeScript(_5[1], out); + } else if (_8 === 2) { + zigzag(_5[1], out); + } else if (_8 === 3) { + sizes(_5[1], out); + } else if (_8 === 4) { + roundtrip$Versions(_5[1], out); + } else if (_8 === 5) { + roundtripLite$Group(_5[1], out); + } else if (_8 === 6) { + roundtripLite$Probe(_5[1], out); + } else if (_8 === 7) { + encodeMessages(_5[1], out); + } else { + errors(_5[1], out); + } + _0 = out; } else { - errors(data, out); + _0 = out; } - return out; + return _0; } export function form(selector: rt.u8): Form.Form { - const value = rt.u8Rem(selector, 3); - if (value === 0) { - return { tag: "Quic" }; - } else if (value === 1) { - return { tag: "LeadingOnes", seven: false }; + let _0!: Form.Form; + let _2!: rt.u8; + _2 = rt.u8Rem(selector, 3); + if (_2 === 0) { + _0 = { tag: "Quic" } as Form.Form; + } else if (_2 === 1) { + _0 = { tag: "LeadingOnes", seven: false } as Form.Form; } else { - return { tag: "LeadingOnes", seven: true }; + _0 = { tag: "LeadingOnes", seven: true } as Form.Form; } + return _0; } export function liteVersion(selector: rt.u8): Version.Version { - const value = rt.u8Rem(selector, 7); - if (value === 0) { - return "Lite01"; - } else if (value === 1) { - return "Lite02"; - } else if (value === 2) { - return "Lite03"; - } else if (value === 3) { - return "Lite04"; - } else if (value === 4) { - return "Lite05"; - } else if (value === 5) { - return "Lite06"; + let _0!: Version.Version; + let _2!: rt.u8; + _2 = rt.u8Rem(selector, 7); + if (_2 === 0) { + _0 = "Lite01" as Version.Version; + } else if (_2 === 1) { + _0 = "Lite02" as Version.Version; + } else if (_2 === 2) { + _0 = "Lite03" as Version.Version; + } else if (_2 === 3) { + _0 = "Lite04" as Version.Version; + } else if (_2 === 4) { + _0 = "Lite05" as Version.Version; + } else if (_2 === 5) { + _0 = "Lite06" as Version.Version; } else { - return "Lite07"; + _0 = "Lite07" as Version.Version; } + return _0; } export function putU64(out: rt.ByteVec, value: rt.u64): void { - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(value)); + let _6!: Uint8Array; + _6 = rt.u64ToBeBytes(value); + rt.byteVecExtendFromSlice(out, _6); + return; } export function putUsize(out: rt.ByteVec, value: rt.usize): void { putU64(out, value as rt.u64); + return; } /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ export function takeU64(data: Uint8Array): [rt.u64, Uint8Array] { - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data.length, 8); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(8); + n = rt.min(data.length, 8); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - return [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)]; + return [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; } /** A decode error's code, then its text. */ export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): void { + let _5!: string; + let _6!: string; + let args!: [DecodeError.DecodeError]; decodeError(out, err); - putText(out, rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$Display(err, f)), rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Debug(err, f)])); + _5 = rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$Display(err, f)); + args = [err] as [DecodeError.DecodeError]; + const arg = args[0]; + _6 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Debug(arg, f)]); + putText(out, _5, _6); + return; } /** An encode error's code, then its text. */ export function encodeFailed(out: rt.ByteVec, err: EncodeError.EncodeError): void { + let _5!: string; + let _6!: string; + let args!: [EncodeError.EncodeError]; encodeError(out, err); - putText(out, rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$Display(err, f)), rt.fmtFormat([(f: rt.Formatter) => EncodeError.fmt$Debug(err, f)])); + _5 = rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$Display(err, f)); + args = [err] as [EncodeError.EncodeError]; + const arg = args[0]; + _6 = rt.fmtFormat([(f: rt.Formatter) => EncodeError.fmt$Debug(arg, f)]); + putText(out, _5, _6); + return; } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ @@ -111,10 +143,11 @@ export function putText(out: rt.ByteVec, display: string, debug: string): void { rt.byteVecPush(out, 0); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(debug)); rt.byteVecPush(out, 0); + return; } export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void { - rt.byteVecPush(out, 0xee); + rt.byteVecPush(out, 238); if (err.tag === "Short") { rt.byteVecPush(out, 0); } else if (err.tag === "Long") { @@ -122,9 +155,8 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } else if (err.tag === "InvalidString") { rt.byteVecPush(out, 2); } else if (err.tag === "InvalidMessage") { - const id = err._0; rt.byteVecPush(out, 3); - putU64(out, id); + putU64(out, err._0); } else if (err.tag === "InvalidSubscribeLocation") { rt.byteVecPush(out, 4); } else if (err.tag === "InvalidValue") { @@ -136,11 +168,9 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } else if (err.tag === "ExpectedEnd") { rt.byteVecPush(out, 8); } else if (err.tag === "MessageTooLarge") { - const size_ = err.size; - const max = err.max; rt.byteVecPush(out, 9); - putUsize(out, size_); - putUsize(out, max); + putUsize(out, err.size); + putUsize(out, err.max); } else if (err.tag === "ExpectedData") { rt.byteVecPush(out, 10); } else if (err.tag === "Duplicate") { @@ -160,11 +190,29 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } else { rt.byteVecPush(out, 18); } + return; } export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void { - rt.byteVecPush(out, 0xef); - rt.byteVecPush(out, err === "BoundsExceeded" ? 0 : err === "TooLarge" ? 1 : err === "Short" ? 2 : err === "InvalidState" ? 3 : err === "TooMany" ? 4 : err === "Version" ? 5 : 6); + let _5!: rt.u8; + rt.byteVecPush(out, 239); + if (err === "BoundsExceeded") { + _5 = 0; + } else if (err === "TooLarge") { + _5 = 1; + } else if (err === "Short") { + _5 = 2; + } else if (err === "InvalidState") { + _5 = 3; + } else if (err === "TooMany") { + _5 = 4; + } else if (err === "Version") { + _5 = 5; + } else { + _5 = 6; + } + rt.byteVecPush(out, _5); + return; } /** @@ -172,410 +220,621 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void * `data[1]` bytes after the form selector, and the wire is everything after it. */ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const splitFirst2 = rt.sliceSplitFirst(data2); - if (splitFirst2 === undefined) { - return; - } - const len = splitFirst2[0]; - const data3 = splitFirst2[1]; - const [script, wire] = rt.sliceSplitAt(data3, rt.min(data3.length, len as rt.usize)); - let r: Decoder.Decoder = Decoder.new(wire, form(selector)); - for (const item of script) { - const step = item; - const decodeStep_ = decodeStep(r, step, out); - if (decodeStep_.ok) { - rt.byteVecPush(out, 0); - } else { - const err = decodeStep_.error; - decodeFailed(out, err); - putUsize(out, Decoder.need(r)); - break; + let selector!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let len!: rt.u8; + let _9!: [rt.u8, Uint8Array] | undefined; + let _13!: [Uint8Array, Uint8Array]; + let _14!: rt.usize; + let _15!: rt.usize; + let r!: Decoder.Decoder; + let _18!: Form.Form; + let iter!: rt.Iter; + let _21!: rt.u8 | rt.Done; + let _26!: rt.Result; + let err!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + b0: { + if (_5 !== undefined) { + selector = _5[0]; + _9 = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + len = _9[0]; + _15 = _9[1].length; + _14 = rt.min(_15, len as rt.usize); + _13 = rt.sliceSplitAt(_9[1], _14); + _18 = form(selector); + r = Decoder.new(_13[1], _18); + iter = rt.iterSlice(_13[0]); + l1: while (true) { + _21 = iter.next(); + if (_21 !== rt.DONE) { + _26 = decodeStep(r, _21, out); + if (_26.ok) { + rt.byteVecPush(out, 0); + putUsize(out, Decoder.remaining(r)); + continue l1; + } else { + err = _26.error; + decodeFailed(out, err); + putUsize(out, Decoder.need(r)); + } + } + rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); + break b0; + } + } } - putUsize(out, Decoder.remaining(r)); } - rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); + return; } export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt.Result { - const value = rt.u8Rem(step, 10); - if (value === 0) { - const arg = out; - const u8 = Decoder.u8(r); - if (!u8.ok) { - return rt.Err(u8.error); - } - rt.byteVecPush(arg, u8.value); - } else if (value === 1) { - const arg2 = out; - const u16 = Decoder.u16(r); - if (!u16.ok) { - return rt.Err(u16.error); - } - rt.byteVecExtendFromSlice(arg2, rt.u16ToBeBytes(u16.value)); - } else if (value === 2) { - const arg3 = out; - const bool = Decoder.bool(r); - if (!bool.ok) { - return rt.Err(bool.error); - } - rt.byteVecPush(arg3, bool.value ? 1 : 0); - } else if (value === 3) { - const arg4 = out; - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - putU64(arg4, varint.value); - } else if (value === 4) { - const varintOpt = Decoder.varintOpt(r); - if (!varintOpt.ok) { - return rt.Err(varintOpt.error); - } - if (varintOpt.value !== undefined) { - const v = varintOpt.value; - rt.byteVecPush(out, 1); - putU64(out, v); - } else { - rt.byteVecPush(out, 0); - } - } else if (value === 5) { - const bytes = Decoder.bytes(r); - if (!bytes.ok) { - return rt.Err(bytes.error); - } - const bytes2 = bytes.value; - putUsize(out, bytes2.length); - rt.byteVecExtendFromSlice(out, bytes2); - } else if (value === 6) { - const string = Decoder.string(r); - if (!string.ok) { - return rt.Err(string.error); - } - const s = string.value; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - } else if (value === 7) { - const slice = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); - if (!slice.ok) { - return rt.Err(slice.error); - } - const slice2 = slice.value; - rt.byteVecExtendFromSlice(out, slice2); - } else if (value === 8) { - const sub = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); - if (!sub.ok) { - return rt.Err(sub.error); - } - let sub2: Decoder.Decoder = sub.value; - const arg5 = out; - const varint2 = Decoder.varint(sub2); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - putU64(arg5, varint2.value); - putUsize(out, Decoder.rest(sub2).length); - } else { - putUsize(out, Decoder.rest(r).length); - } - return rt.Ok(undefined); -} - -/** Write primitives as a script says, taking each value from the data that follows. */ -export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const splitFirst2 = rt.sliceSplitFirst(data2); - if (splitFirst2 === undefined) { - return; - } - const len = splitFirst2[0]; - const data3 = splitFirst2[1]; - let [script, values] = rt.sliceSplitAt(data3, rt.min(data3.length, len as rt.usize)); - let buf: rt.ByteVec = new rt.ByteVec(); - let w: Encoder.Encoder = Encoder.new(buf, form(selector)); - let prefixes: Prefix.Prefix[] = []; - for (const item of script) { - const step = item; - const [value, rest] = takeU64(values); - values = rest; - let result: rt.Result; - const value2 = rt.u8Rem(step, 10); - if (value2 === 0) { - Encoder.u8(w, rt.u64Low(value) & 0xff); - result = rt.Ok(undefined); - } else if (value2 === 1) { - Encoder.u16(w, rt.u64Low(value) & 0xffff); - result = rt.Ok(undefined); - } else if (value2 === 2) { - Encoder.bool(w, rt.u64And(value, 1) === 1); - result = rt.Ok(undefined); - } else if (value2 === 3) { - result = Encoder.varint(w, value); - } else if (value2 === 4) { - const arg = w; - const value3 = rt.u64Rem(value, 3); - result = Encoder.varintOpt(arg, value3 === 0 ? undefined : value3 === 1 ? value : rt.u64Of(18446744073709551615n)); - } else if (value2 === 5) { - result = Encoder.bytes(w, rt.sliceRange(rt.u64ToBeBytes(value), 0, rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize)); - } else if (value2 === 6) { - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); - if (fromUtf8.ok) { - const s = fromUtf8.value; - result = Encoder.string(w, s); + let _0!: rt.Result; + let _5!: rt.u8; + let _7!: rt.Result; + let _14!: Uint8Array; + let _15!: rt.Result; + let _21!: rt.Result; + let _26!: rt.Result; + let _31!: rt.Result; + let val5!: rt.u64 | undefined; + let v!: rt.u64; + let _40!: rt.Result; + let s!: string; + let _49!: rt.Result; + let _57!: rt.Result; + let sub!: Decoder.Decoder; + let _67!: rt.Result; + let _76!: rt.Result; + b0: { + _5 = rt.u8Rem(step, 10); + if (_5 === 0) { + _7 = Decoder.u8(r); + if (_7.ok) { + rt.byteVecPush(out, _7.value); } else { - result = Encoder.string(w, "not utf-8"); + _0 = _7; + break b0; } - } else if (value2 === 7) { - prefixes.push(rt.u64Rem(value, 2) === 0 ? Encoder.prefixVarint(w) : Encoder.prefixU16(w)); - result = rt.Ok(undefined); - } else if (value2 === 8) { - const pop = prefixes.pop(); - if (pop !== undefined) { - const prefix = pop; - putUsize(out, Encoder.since(w, prefix)); - result = Encoder.fill(w, prefix); + } else if (_5 === 1) { + _15 = Decoder.u16(r); + if (_15.ok) { + _14 = rt.u16ToBeBytes(_15.value); + rt.byteVecExtendFromSlice(out, _14); } else { - result = rt.Ok(undefined); + _0 = _15; + break b0; } - } else { - const pop2 = prefixes.pop(); - if (pop2 !== undefined) { - const prefix2 = pop2; - Encoder.discard(w, prefix2); + } else if (_5 === 2) { + _21 = Decoder.bool(r); + if (_21.ok) { + rt.byteVecPush(out, _21.value ? 1 : 0); + } else { + _0 = _21; + break b0; } - result = rt.Ok(undefined); - } - if (!result.ok) { - const err = result.error; - encodeFailed(out, err); + } else if (_5 === 3) { + _26 = Decoder.varint(r); + if (_26.ok) { + putU64(out, _26.value); + } else { + _0 = _26; + break b0; + } + } else if (_5 === 4) { + _31 = Decoder.varintOpt(r); + if (_31.ok) { + val5 = _31.value; + if (val5 === undefined) { + rt.byteVecPush(out, 0); + } else { + v = val5; + rt.byteVecPush(out, 1); + putU64(out, v); + } + } else { + _0 = _31; + break b0; + } + } else if (_5 === 5) { + _40 = Decoder.bytes(r); + if (_40.ok) { + putUsize(out, _40.value.length); + rt.byteVecExtendFromSlice(out, _40.value); + } else { + _0 = _40; + break b0; + } + } else if (_5 === 6) { + _49 = Decoder.string(r); + if (_49.ok) { + s = _49.value; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + } else { + _0 = _49; + break b0; + } + } else if (_5 === 7) { + _57 = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + if (_57.ok) { + rt.byteVecExtendFromSlice(out, _57.value); + } else { + _0 = _57; + break b0; + } + } else if (_5 === 8) { + _67 = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); + if (_67.ok) { + sub = _67.value; + _76 = Decoder.varint(sub); + if (_76.ok) { + putU64(out, _76.value); + putUsize(out, Decoder.rest(sub).length); + } else { + _0 = _76; + break b0; + } + } else { + _0 = _67; + break b0; + } + } else { + putUsize(out, Decoder.rest(r).length); } + _0 = rt.Ok(undefined); } - while (true) { - const pop3 = prefixes.pop(); - if (pop3 !== undefined) { - const prefix3 = pop3; - const fill = Encoder.fill(w, prefix3); - if (!fill.ok) { - const err2 = fill.error; - encodeFailed(out, err2); + return _0; +} + +/** Write primitives as a script says, taking each value from the data that follows. */ +export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { + let selector!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let len!: rt.u8; + let _9!: [rt.u8, Uint8Array] | undefined; + let values!: Uint8Array; + let _13!: [Uint8Array, Uint8Array]; + let _14!: rt.usize; + let _15!: rt.usize; + let buf!: rt.ByteVec; + let w!: Encoder.Encoder; + let _20!: Form.Form; + let prefixes!: Prefix.Prefix[]; + let iter!: rt.Iter; + let _24!: rt.u8 | rt.Done; + let step!: rt.u8; + let value!: rt.u64; + let _30!: [rt.u64, Uint8Array]; + let result!: rt.Result; + let _33!: rt.u8; + let _47!: rt.u64 | undefined; + let _48!: rt.u64; + let _51!: Uint8Array; + let _53!: Uint8Array; + let _60!: rt.Result; + let _64!: Uint8Array; + let s!: string; + let _68!: string; + let _74!: Prefix.Prefix; + let _79!: Prefix.Prefix | undefined; + let prefix!: Prefix.Prefix; + let _88!: Prefix.Prefix | undefined; + let err!: EncodeError.EncodeError; + let _98!: Prefix.Prefix | undefined; + let _102!: rt.Result; + let err2!: EncodeError.EncodeError; + _5 = rt.sliceSplitFirst(data); + b0: { + if (_5 !== undefined) { + selector = _5[0]; + _9 = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + len = _9[0]; + _15 = _9[1].length; + _14 = rt.min(_15, len as rt.usize); + _13 = rt.sliceSplitAt(_9[1], _14); + values = _13[1]; + buf = new rt.ByteVec(); + _20 = form(selector); + w = Encoder.new(buf, _20); + prefixes = []; + iter = rt.iterSlice(_13[0]); + while (true) { + _24 = iter.next(); + if (_24 === rt.DONE) { + while (true) { + _98 = prefixes.pop(); + if (_98 !== undefined) { + _102 = Encoder.fill(w, _98); + if (!_102.ok) { + err2 = _102.error; + encodeFailed(out, err2); + } + } else { + putUsize(out, buf.length); + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + break b0; + } + } + } else { + step = _24; + _30 = takeU64(values); + value = _30[0]; + values = _30[1]; + _33 = rt.u8Rem(step, 10); + if (_33 === 0) { + Encoder.u8(w, rt.u64Low(value) & 0xff); + result = rt.Ok(undefined); + } else if (_33 === 1) { + Encoder.u16(w, rt.u64Low(value) & 0xffff); + result = rt.Ok(undefined); + } else if (_33 === 2) { + Encoder.bool(w, rt.u64And(value, 1) === 1); + result = rt.Ok(undefined); + } else if (_33 === 3) { + result = Encoder.varint(w, value); + } else if (_33 === 4) { + _48 = rt.u64Rem(value, 3); + if (_48 === 0) { + _47 = undefined; + } else if (_48 === 1) { + _47 = value; + } else { + _47 = rt.u64Of(18446744073709551615n); + } + result = Encoder.varintOpt(w, _47); + } else if (_33 === 5) { + _53 = rt.u64ToBeBytes(value); + const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; + _51 = rt.sliceRange(_53, 0, part); + result = Encoder.bytes(w, _51); + } else if (_33 === 6) { + _64 = rt.u64ToBeBytes(value); + _60 = rt.stringFromUtf8(rt.sliceToByteVec(_64)); + if (_60.ok) { + s = _60.value; + _68 = s; + result = Encoder.string(w, _68); + } else { + result = Encoder.string(w, "not utf-8"); + } + } else if (_33 === 7) { + if (rt.u64Rem(value, 2) === 0) { + _74 = Encoder.prefixVarint(w); + } else { + _74 = Encoder.prefixU16(w); + } + prefixes.push(_74); + result = rt.Ok(undefined); + } else if (_33 === 8) { + _79 = prefixes.pop(); + if (_79 === undefined) { + result = rt.Ok(undefined); + } else { + prefix = _79; + putUsize(out, Encoder.since(w, prefix)); + result = Encoder.fill(w, prefix); + } + } else { + _88 = prefixes.pop(); + if (_88 !== undefined) { + Encoder.discard(w, _88); + } + result = rt.Ok(undefined); + } + if (!result.ok) { + err = result.error; + encodeFailed(out, err); + } + } + } } - } else { - break; } } - putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + return; } export function zigzag(data: Uint8Array, out: rt.ByteVec): void { - const [value, ] = takeU64(data); - const signed = rt.i64Cast(value); + let value!: rt.u64; + let signed!: rt.i64; + value = takeU64(data)[0]; + signed = rt.i64Cast(value); putU64(out, varint_zigzag(signed)); putU64(out, rt.u64Cast(unzigzag(value))); putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); + return; } export function sizes(data: Uint8Array, out: rt.ByteVec): void { - const [value, ] = takeU64(data); - for (let selector = 0; selector < 3; selector++) { - const size_ = size(value, form(selector)); - if (size_.ok) { - const size2 = size_.value; - putUsize(out, size2); + let value!: rt.u64; + let iter!: rt.Range; + let _9!: rt.u8; + let _13!: rt.Result; + let _9Some!: boolean; + value = takeU64(data)[0]; + iter = new rt.Range(0, 3); + while (true) { + _9Some = iter.start < iter.end; + if (_9Some) { + _9 = iter.start++; + } + if (!_9Some) { + return; } else { - rt.byteVecPush(out, 0xff); + _13 = size(value, form(_9)); + if (_13.ok) { + putUsize(out, _13.value); + } else { + rt.byteVecPush(out, 255); + } } } } /** Decode a `T` from the wire, then encode what came out. */ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const wire = splitFirst[1]; - const form_ = form(selector); - const decodeSlice = Versions.decodeSlice$Decode_Form(wire, form_); - if (decodeSlice.ok) { - const value = decodeSlice.value[0]; - const used = decodeSlice.value[1]; - putUsize(out, used); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Versions.encode$Encode_Form(value, Encoder.new(buf, form_), form_); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + let _5!: [rt.u8, Uint8Array] | undefined; + let form_!: Form.Form; + let _8!: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError>; + let value!: Versions.Versions; + let buf!: rt.ByteVec; + let _14!: rt.Result; + let _17!: Encoder.Encoder; + let err!: EncodeError.EncodeError; + let err2!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + form_ = form(_5[0]); + _8 = Versions.decodeSlice$Decode_Form(_5[1], form_); + if (_8.ok) { + value = _8.value[0]; + putUsize(out, _8.value[1]); + buf = new rt.ByteVec(); + _17 = Encoder.new(buf, form_); + _14 = Versions.encode$Encode_Form(value, _17, form_); + if (_14.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + err = _14.error; + encodeFailed(out, err); + } } else { - const err = encode.error; - encodeFailed(out, err); + err2 = _8.error; + decodeFailed(out, err2); } - } else { - const err2 = decodeSlice.error; - decodeFailed(out, err2); } + return; } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const wire = splitFirst[1]; - const version = liteVersion(selector); - const decodeSlice = Group.decodeSlice$Decode_Version(wire, version); - if (decodeSlice.ok) { - const value = decodeSlice.value[0]; - const used = decodeSlice.value[1]; - putUsize(out, used); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Group.encode$Encode_Version(value, Encoder.new(buf, Form.from$From_Version(version)), version); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + let _5!: [rt.u8, Uint8Array] | undefined; + let version!: Version.Version; + let _8!: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError>; + let value!: Group.Group; + let buf!: rt.ByteVec; + let _14!: rt.Result; + let _17!: Encoder.Encoder; + let _19!: Form.Form; + let err!: EncodeError.EncodeError; + let err2!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + version = liteVersion(_5[0]); + _8 = Group.decodeSlice$Decode_Version(_5[1], version); + if (_8.ok) { + value = _8.value[0]; + putUsize(out, _8.value[1]); + buf = new rt.ByteVec(); + _19 = Form.from$From_Version(version); + _17 = Encoder.new(buf, _19); + _14 = Group.encode$Encode_Version(value, _17, version); + if (_14.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + err = _14.error; + encodeFailed(out, err); + } } else { - const err = encode.error; - encodeFailed(out, err); + err2 = _8.error; + decodeFailed(out, err2); } - } else { - const err2 = decodeSlice.error; - decodeFailed(out, err2); } + return; } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const wire = splitFirst[1]; - const version = liteVersion(selector); - const decodeSlice = Probe.decodeSlice$Decode_Version(wire, version); - if (decodeSlice.ok) { - const value = decodeSlice.value[0]; - const used = decodeSlice.value[1]; - putUsize(out, used); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Probe.encode$Encode_Version(value, Encoder.new(buf, Form.from$From_Version(version)), version); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + let _5!: [rt.u8, Uint8Array] | undefined; + let version!: Version.Version; + let _8!: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError>; + let value!: Probe.Probe; + let buf!: rt.ByteVec; + let _14!: rt.Result; + let _17!: Encoder.Encoder; + let _19!: Form.Form; + let err!: EncodeError.EncodeError; + let err2!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + version = liteVersion(_5[0]); + _8 = Probe.decodeSlice$Decode_Version(_5[1], version); + if (_8.ok) { + value = _8.value[0]; + putUsize(out, _8.value[1]); + buf = new rt.ByteVec(); + _19 = Form.from$From_Version(version); + _17 = Encoder.new(buf, _19); + _14 = Probe.encode$Encode_Version(value, _17, version); + if (_14.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + err = _14.error; + encodeFailed(out, err); + } } else { - const err = encode.error; - encodeFailed(out, err); + err2 = _8.error; + decodeFailed(out, err2); } - } else { - const err2 = decodeSlice.error; - decodeFailed(out, err2); } + return; } /** Encode messages built from the data, at a lite version. */ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const version = liteVersion(selector); - const [subscribe, data3] = takeU64(data2); - const [sequence, data4] = takeU64(data3); - const [frameStart, data5] = takeU64(data4); - const [bitrate, data6] = takeU64(data5); - const [rtt, ] = takeU64(data6); - const group = { subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }; - encodeMessage$Group(group, version, out); - const probe = { bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }; - encodeMessage$Probe(probe, version, out); - const versions = Versions.from$From_Versions([{ _0: subscribe }, { _0: sequence }]); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Versions.encode$Encode_Version(versions, Encoder.new(buf, Form.from$From_Version(version)), version); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); - } else { - const err = encode.error; - encodeFailed(out, err); + let _5!: [rt.u8, Uint8Array] | undefined; + let version!: Version.Version; + let subscribe!: rt.u64; + let _10!: [rt.u64, Uint8Array]; + let sequence!: rt.u64; + let _13!: [rt.u64, Uint8Array]; + let frameStart!: rt.u64; + let _16!: [rt.u64, Uint8Array]; + let bitrate!: rt.u64; + let _19!: [rt.u64, Uint8Array]; + let rtt!: rt.u64; + let group!: Group.Group; + let probe!: Probe.Probe; + let versions!: Versions.Versions; + let buf!: rt.ByteVec; + let _40!: rt.Result; + let _43!: Encoder.Encoder; + let _45!: Form.Form; + let err!: EncodeError.EncodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + version = liteVersion(_5[0]); + _10 = takeU64(_5[1]); + subscribe = _10[0]; + _13 = takeU64(_10[1]); + sequence = _13[0]; + _16 = takeU64(_13[1]); + frameStart = _16[0]; + _19 = takeU64(_16[1]); + bitrate = _19[0]; + rtt = takeU64(_19[1])[0]; + group = { subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }; + encodeMessage$Group(group, version, out); + probe = { bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }; + encodeMessage$Probe(probe, version, out); + versions = Versions.from$From_Versions([{ _0: subscribe }, { _0: sequence }]); + buf = new rt.ByteVec(); + _45 = Form.from$From_Version(version); + _43 = Encoder.new(buf, _45); + _40 = Versions.encode$Encode_Version(versions, _43, version); + if (_40.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + err = _40.error; + encodeFailed(out, err); + } } + return; } export function encodeMessage$Group(msg: Group.Group, version: Version.Version, out: rt.ByteVec): void { - let buf: rt.ByteVec = new rt.ByteVec(); - let w: Encoder.Encoder = Encoder.new(buf, Form.from$From_Version(version)); - const encode = Group.encode$Encode_Version(msg, w, version); - if (encode.ok) { + let buf!: rt.ByteVec; + let w!: Encoder.Encoder; + let _7!: Form.Form; + let _8!: rt.Result; + let err!: EncodeError.EncodeError; + buf = new rt.ByteVec(); + _7 = Form.from$From_Version(version); + w = Encoder.new(buf, _7); + _8 = Group.encode$Encode_Version(msg, w, version); + if (_8.ok) { rt.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - const err = encode.error; + err = _8.error; encodeFailed(out, err); } + return; } export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, out: rt.ByteVec): void { - let buf: rt.ByteVec = new rt.ByteVec(); - let w: Encoder.Encoder = Encoder.new(buf, Form.from$From_Version(version)); - const encode = Probe.encode$Encode_Version(msg, w, version); - if (encode.ok) { + let buf!: rt.ByteVec; + let w!: Encoder.Encoder; + let _7!: Form.Form; + let _8!: rt.Result; + let err!: EncodeError.EncodeError; + buf = new rt.ByteVec(); + _7 = Form.from$From_Version(version); + w = Encoder.new(buf, _7); + _8 = Probe.encode$Encode_Version(msg, w, version); + if (_8.ok) { rt.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - const err = encode.error; + err = _8.error; encodeFailed(out, err); } + return; } /** Each error the codec can return, built from the data, as callers see it. */ export function errors(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const [value, ] = takeU64(data2); - let err: DecodeError.DecodeError; - const value2 = rt.u8Rem(selector, 8); - if (value2 === 0) { - err = { tag: "InvalidMessage", _0: value }; - } else if (value2 === 1) { - err = { tag: "MessageTooLarge", size: rt.u64Low(value), max: rt.u64Low(rt.u64Shr(value, 32)) }; - } else if (value2 === 2) { - err = { tag: "Session", _0: { tag: "App", _0: rt.u64Low(value) & 0xffff } as SessionError.SessionError }; - } else if (value2 === 3) { - err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError }; - } else if (value2 === 4) { - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(data2)); - if (fromUtf8.ok) { - err = { tag: "Missing" }; - } else { - const e = fromUtf8.error; - err = { tag: "InvalidString", _0: e }; + let selector!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let value!: rt.u64; + let err!: DecodeError.DecodeError; + let _10!: rt.u8; + let _20!: rt.Result; + let _26!: string; + let _28!: string; + let args!: [BoundsExceeded.BoundsExceeded]; + let _38!: string; + let args3!: [DecodeError.DecodeError]; + let _47!: string; + let args5!: [DecodeError.DecodeError]; + _5 = rt.sliceSplitFirst(data); + b0: { + if (_5 !== undefined) { + selector = _5[0]; + value = takeU64(_5[1])[0]; + _10 = rt.u8Rem(selector, 8); + if (_10 === 0) { + err = { tag: "InvalidMessage", _0: value } as DecodeError.DecodeError; + } else if (_10 === 1) { + err = { tag: "MessageTooLarge", size: rt.u64Low(value), max: rt.u64Low(rt.u64Shr(value, 32)) } as DecodeError.DecodeError; + } else if (_10 === 2) { + err = { tag: "Session", _0: { tag: "App", _0: rt.u64Low(value) & 0xffff } as SessionError.SessionError } as DecodeError.DecodeError; + } else if (_10 === 3) { + err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; + } else if (_10 === 4) { + _20 = rt.stringFromUtf8(rt.sliceToByteVec(_5[1])); + if (_20.ok) { + err = { tag: "Missing" } as DecodeError.DecodeError; + } else { + err = { tag: "InvalidString", _0: _20.error } as DecodeError.DecodeError; + } + } else if (_10 === 5) { + err = DecodeError.from$From_BoundsExceeded({}); + } else if (_10 === 6) { + const arg = {}; + _26 = rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$Display(arg, f)); + args = [{}] as [BoundsExceeded.BoundsExceeded]; + const arg2 = args[0]; + _28 = rt.fmtFormat([(f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f))]); + putText(out, _26, _28); + break b0; + } else { + err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; + } + args3 = [err] as [DecodeError.DecodeError]; + const arg3 = args3[0]; + _38 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Display(arg3, f), " ", rt.fmtSpec({ align: ">", width: 30 }, (f: rt.Formatter) => DecodeError.fmt$Display(arg3, f)), "|"]); + args5 = [err] as [DecodeError.DecodeError]; + const arg4 = args5[0]; + _47 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => DecodeError.fmt$Debug(arg4, f))]); + putText(out, _38, _47); + decodeFailed(out, err); } - } else if (value2 === 5) { - err = DecodeError.from$From_BoundsExceeded({}); - } else if (value2 === 6) { - const bounds = {}; - putText(out, rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$Display(bounds, f)), rt.fmtFormat([(f: rt.Formatter) => BoundsExceeded.fmt$Debug(bounds, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => BoundsExceeded.fmt$Debug(bounds, f))])); - return; - } else { - err = { tag: "MalformedAuthToken" }; } - putText(out, rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Display(err, f), " ", rt.fmtSpec({ align: ">", width: 30 }, (f: rt.Formatter) => DecodeError.fmt$Display(err, f)), "|"]), rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => DecodeError.fmt$Debug(err, f))])); - decodeFailed(out, err); + return; } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index 4d33f5ae5..5dfd068c6 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -3,23 +3,36 @@ import * as rt from "./rt.ts"; export function fmt$Display(self: SessionError, __formatter: rt.Formatter): rt.Result { + let _0!: rt.Result; + let _02!: rt.u16; + let __display0!: rt.u16; + let args!: [rt.u16]; if (self.tag === "ProtocolViolation") { - return rt.fmtWriteStr(__formatter, "protocol violation"); + _0 = rt.fmtWriteStr(__formatter, "protocol violation"); } else { - const _0 = self._0; - const value = [_0] as [rt.u16]; - const __display0 = value[0]; - return rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(__display0, f)]); + _02 = self._0; + __display0 = ([_02] as [rt.u16])[0]; + args = [__display0] as [rt.u16]; + const arg = args[0]; + _0 = rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(arg, f)]); } + return _0; } export function fmt$Debug(self: SessionError, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: rt.u16; + let _6!: string; + let _7!: rt.Fmt; if (self.tag === "ProtocolViolation") { - return rt.fmtWriteStr(f, "ProtocolViolation"); + _0 = rt.fmtWriteStr(f, "ProtocolViolation"); } else { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "App"), (f: rt.Formatter) => rt.u16Display(__self0, f))); + __self0 = self._0; + _6 = "App"; + _7 = (f: rt.Formatter) => rt.u16Display(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } + return _0; } /** moq-net's session error, trimmed to a few variants: the codec only carries it. */ diff --git a/ts/fixtures/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index 9c9c525f9..180000943 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -5,19 +5,30 @@ import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; import * as Encoder from "../coding/encode.Encoder.ts"; +import type * as Prefix from "../coding/encode.Prefix.ts"; import * as Form from "../coding/varint.Form.ts"; import { decodeWith$Group_decode_closure0 } from "../lite/message.ts"; import * as Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { - let r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); - const decode = decode$Decode_Version(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result<[Group, rt.usize], DecodeError.DecodeError>; + let r!: Decoder.Decoder; + let value!: Group; + let _6!: rt.Result; + let val!: Group; + let _13!: Group; + r = Decoder.new(buf, Form.from$From_Version(version)); + _6 = decode$Decode_Version(r, version); + if (_6.ok) { + val = _6.value; + value = val; + _13 = value; + _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Group, rt.usize]); + } else { + _0 = _6; } - const value = decode.value; - return rt.Ok([value, rt.usizeSub(buf.length, Decoder.remaining(r))]); + return _0; } export interface Group { @@ -28,67 +39,101 @@ export interface Group { /** Decode a message body (without size prefix). */ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const subscribe = varint.value; - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - const sequence = varint2.value; - let frameStart: rt.u64; - if (Version.hasFrameBounds(version)) { - const varint3 = Decoder.varint(r); - if (!varint3.ok) { - return rt.Err(varint3.error); + let _0!: rt.Result; + let _3!: rt.Result; + let subscribe!: rt.u64; + let _8!: rt.Result; + let sequence!: rt.u64; + let frameStart!: rt.u64; + let _15!: rt.Result; + _3 = Decoder.varint(r); + b0: { + if (_3.ok) { + subscribe = _3.value; + _8 = Decoder.varint(r); + if (_8.ok) { + sequence = _8.value; + if (!Version.hasFrameBounds(version)) { + frameStart = 0; + } else { + _15 = Decoder.varint(r); + if (_15.ok) { + frameStart = _15.value; + } else { + _0 = _15; + break b0; + } + } + _0 = rt.Ok({ subscribe, sequence, frameStart }); + } else { + _0 = _8; + } + } else { + _0 = _3; } - frameStart = varint3.value; - } else { - frameStart = 0; } - return rt.Ok({ subscribe, sequence, frameStart }); + return _0; } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Group, w: Encoder.Encoder, version: Version.Version): rt.Result { - const varint = Encoder.varint(w, self.subscribe); - if (!varint.ok) { - return rt.Err(varint.error); - } - const varint2 = Encoder.varint(w, self.sequence); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - if (Version.hasFrameBounds(version)) { - const varint3 = Encoder.varint(w, self.frameStart); - if (!varint3.ok) { - return rt.Err(varint3.error); + let _0!: rt.Result; + let _4!: rt.Result; + let _9!: rt.Result; + let _15!: rt.Result; + _4 = Encoder.varint(w, self.subscribe); + b0: { + if (_4.ok) { + _9 = Encoder.varint(w, self.sequence); + if (_9.ok) { + if (!Version.hasFrameBounds(version)) { + if (self.frameStart !== 0) { + _0 = rt.Err("Version" as EncodeError.EncodeError); + break b0; + } + } else { + _15 = Encoder.varint(w, self.frameStart); + if (!_15.ok) { + _0 = _15; + break b0; + } + } + _0 = rt.Ok(undefined); + } else { + _0 = _9; + } + } else { + _0 = _4; } - } else if (self.frameStart !== 0) { - return rt.Err("Version"); } - return rt.Ok(undefined); + return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Group, w: Encoder.Encoder, version: Version.Version): rt.Result { - const prefix = Encoder.prefixVarint(w); - const encodeMsg = encodeMsg$Message(self, w, version); - if (!encodeMsg.ok) { - return rt.Err(encodeMsg.error); - } - if (Encoder.since(w, prefix) > 65535) { - Encoder.discard(w, prefix); - return rt.Err("TooLarge"); - } - const fill = Encoder.fill(w, prefix); - if (!fill.ok) { - return rt.Err(fill.error); + let _0!: rt.Result; + let prefix!: Prefix.Prefix; + let _39!: rt.Result; + let _49!: rt.Result; + prefix = Encoder.prefixVarint(w); + _39 = encodeMsg$Message(self, w, version); + if (_39.ok) { + if (!(Encoder.since(w, prefix) > 65535)) { + _49 = Encoder.fill(w, prefix); + if (_49.ok) { + w.control = undefined; + _0 = rt.Ok(undefined); + } else { + _0 = _49; + } + } else { + Encoder.discard(w, prefix); + _0 = rt.Err("TooLarge" as EncodeError.EncodeError); + } + } else { + _0 = _39; } - w.control = undefined; - return rt.Ok(undefined); + return _0; } /** Decode the value from the front of the decoder. */ diff --git a/ts/fixtures/codec/expected/lite/message.ts b/ts/fixtures/codec/expected/lite/message.ts index b3f545b1a..68436d127 100644 --- a/ts/fixtures/codec/expected/lite/message.ts +++ b/ts/fixtures/codec/expected/lite/message.ts @@ -9,21 +9,27 @@ import type * as Control from "../stats.Control.ts"; /** Read a lite message's varint size prefix, refusing one past `max`. */ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const size = varint.value; - const tryFrom = rt.usizeTryFrom(size); - arms: { - if (tryFrom.ok) { - const size2 = tryFrom.value; - if (size2 <= max) { - return rt.Ok(size2); + let _0!: rt.Result; + let _3!: rt.Result; + let size!: rt.u64; + let _8!: rt.Result; + _3 = Decoder.varint(r); + b0: { + if (_3.ok) { + size = _3.value; + _8 = rt.usizeTryFrom(size); + if (_8.ok) { + if (_8.value <= max) { + _0 = rt.Ok(_8.value); + break b0; + } } + _0 = rt.Err({ tag: "MessageTooLarge", size: rt.resultUnwrapOr(rt.usizeTryFrom(size), 4294967295), max } as DecodeError.DecodeError); + } else { + _0 = _3; } - return rt.Err({ tag: "MessageTooLarge", size: rt.resultUnwrapOr(rt.usizeTryFrom(size), 4294967295), max }); } + return _0; } /** @@ -31,27 +37,38 @@ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.Result rt.Result): rt.Result { - const decodeSize_ = decodeSize(r, 65535); - if (!decodeSize_.ok) { - return rt.Err(decodeSize_.error); - } - const size = decodeSize_.value; - const sub = Decoder.sub(r, size); - if (!sub.ok) { - return rt.Err(sub.error); - } - let body: Decoder.Decoder = sub.value; - const result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Group.Group): rt.Result => { - if (Decoder.isEmpty(body)) { - return rt.Ok(msg); + let _0!: rt.Result; + let _3!: rt.Result; + let body!: Decoder.Decoder; + let _9!: rt.Result; + let result!: rt.Result; + _3 = decodeSize(r, 65535); + if (_3.ok) { + _9 = Decoder.sub(r, _3.value); + if (_9.ok) { + body = _9.value; + result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg2: Group.Group): rt.Result => { + let _02!: rt.Result; + if (!Decoder.isEmpty(body)) { + _02 = rt.Err({ tag: "Long" } as DecodeError.DecodeError); + } else { + _02 = rt.Ok(msg2); + } + return _02; + }); + if (result.ok) { + } + if (result.ok) { + r.control = undefined; + } + _0 = result; } else { - return rt.Err({ tag: "Long" }); + _0 = _9; } - }); - if (result.ok) { - r.control = undefined; + } else { + _0 = _3; } - return result; + return _0; } /** @@ -59,27 +76,38 @@ export function decodeWith$Group_decode_closure0(r: Decoder.Decoder, decode: (a0 * [`Message::decode_msg`], for a body whose bounds come from the session. */ export function decodeWith$Probe_decode_closure0(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rt.Result): rt.Result { - const decodeSize_ = decodeSize(r, 65535); - if (!decodeSize_.ok) { - return rt.Err(decodeSize_.error); - } - const size = decodeSize_.value; - const sub = Decoder.sub(r, size); - if (!sub.ok) { - return rt.Err(sub.error); - } - let body: Decoder.Decoder = sub.value; - const result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Probe.Probe): rt.Result => { - if (Decoder.isEmpty(body)) { - return rt.Ok(msg); + let _0!: rt.Result; + let _3!: rt.Result; + let body!: Decoder.Decoder; + let _9!: rt.Result; + let result!: rt.Result; + _3 = decodeSize(r, 65535); + if (_3.ok) { + _9 = Decoder.sub(r, _3.value); + if (_9.ok) { + body = _9.value; + result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg2: Probe.Probe): rt.Result => { + let _02!: rt.Result; + if (!Decoder.isEmpty(body)) { + _02 = rt.Err({ tag: "Long" } as DecodeError.DecodeError); + } else { + _02 = rt.Ok(msg2); + } + return _02; + }); + if (result.ok) { + } + if (result.ok) { + r.control = "Probe" as Control.Control; + } + _0 = result; } else { - return rt.Err({ tag: "Long" }); + _0 = _9; } - }); - if (result.ok) { - r.control = "Probe" as Control.Control; + } else { + _0 = _3; } - return result; + return _0; } //# sourceMappingURL=message.ts.map diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index 4ba96d851..a281ddffc 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -5,6 +5,7 @@ import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; import * as Encoder from "../coding/encode.Encoder.ts"; +import type * as Prefix from "../coding/encode.Prefix.ts"; import * as Form from "../coding/varint.Form.ts"; import { decodeWith$Probe_decode_closure0 } from "../lite/message.ts"; import * as Version from "../lite/version.Version.ts"; @@ -12,32 +13,50 @@ import type * as Control from "../stats.Control.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { - let r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); - const decode = decode$Decode_Version(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result<[Probe, rt.usize], DecodeError.DecodeError>; + let r!: Decoder.Decoder; + let value!: Probe; + let _6!: rt.Result; + let val!: Probe; + let _13!: Probe; + r = Decoder.new(buf, Form.from$From_Version(version)); + _6 = decode$Decode_Version(r, version); + if (_6.ok) { + val = _6.value; + value = val; + _13 = value; + _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Probe, rt.usize]); + } else { + _0 = _6; } - const value = decode.value; - return rt.Ok([value, rt.usizeSub(buf.length, Decoder.remaining(r))]); + return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { - const prefix = Encoder.prefixVarint(w); - const encodeMsg = encodeMsg$Message(self, w, version); - if (!encodeMsg.ok) { - return rt.Err(encodeMsg.error); - } - if (Encoder.since(w, prefix) > 65535) { - Encoder.discard(w, prefix); - return rt.Err("TooLarge"); - } - const fill = Encoder.fill(w, prefix); - if (!fill.ok) { - return rt.Err(fill.error); + let _0!: rt.Result; + let prefix!: Prefix.Prefix; + let _39!: rt.Result; + let _49!: rt.Result; + prefix = Encoder.prefixVarint(w); + _39 = encodeMsg$Message(self, w, version); + if (_39.ok) { + if (!(Encoder.since(w, prefix) > 65535)) { + _49 = Encoder.fill(w, prefix); + if (_49.ok) { + w.control = "Probe" as Control.Control; + _0 = rt.Ok(undefined); + } else { + _0 = _49; + } + } else { + Encoder.discard(w, prefix); + _0 = rt.Err("TooLarge" as EncodeError.EncodeError); + } + } else { + _0 = _39; } - w.control = "Probe" as Control.Control; - return rt.Ok(undefined); + return _0; } /** Decode the value from the front of the decoder. */ @@ -60,60 +79,81 @@ export interface Probe { /** Decode a message body (without size prefix). */ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): rt.Result { - if (version === "Lite01" || version === "Lite02") { - return rt.Err({ tag: "Version" }); - } - let bitrate: rt.u64 | undefined; - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - if (varint.value === 0) { - bitrate = undefined; - } else { - const v = varint.value; - bitrate = v; - } - let rtt: rt.u64 | undefined; - if (!Version.hasProbeRtt(version)) { - rtt = undefined; - } else { - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - if (varint2.value === 0) { - rtt = undefined; - } else { - const v2 = varint2.value; - rtt = v2; + let _0!: rt.Result; + let bitrate!: rt.u64 | undefined; + let _6!: rt.Result; + let val!: rt.u64; + let rtt!: rt.u64 | undefined; + let _13!: rt.Result; + let val2!: rt.u64; + b0: { + if (!(version === "Lite01" || version === "Lite02")) { + _6 = Decoder.varint(r); + if (_6.ok) { + val = _6.value; + if (val === 0) { + bitrate = undefined; + } else { + bitrate = val; + } + if (!Version.hasProbeRtt(version)) { + rtt = undefined; + } else { + _13 = Decoder.varint(r); + if (_13.ok) { + val2 = _13.value; + if (val2 === 0) { + rtt = undefined; + } else { + rtt = val2; + } + } else { + _0 = _13; + break b0; + } + } + _0 = rt.Ok({ bitrate, rtt }); + break b0; + } else { + _0 = _6; + break b0; + } } + _0 = rt.Err({ tag: "Version" } as DecodeError.DecodeError); } - return rt.Ok({ bitrate, rtt }); + return _0; } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { - if (version === "Lite01" || version === "Lite02") { - return rt.Err("Version"); - } - const wire = rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { - return rt.u64Max(v, 1); - }), 0); - const varint = Encoder.varint(w, wire); - if (!varint.ok) { - return rt.Err(varint.error); - } - if (Version.hasProbeRtt(version)) { - const wire2 = rt.optionUnwrapOr(rt.optionMap(self.rtt, (v2: rt.u64): rt.u64 => { - return rt.u64Max(v2, 1); - }), 0); - const varint2 = Encoder.varint(w, wire2); - if (!varint2.ok) { - return rt.Err(varint2.error); + let _0!: rt.Result; + let _9!: rt.Result; + let _17!: rt.Result; + b0: { + if (!(version === "Lite01" || version === "Lite02")) { + _9 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { + return rt.u64Max(v, 1); + }), 0)); + if (_9.ok) { + if (Version.hasProbeRtt(version)) { + _17 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.rtt, (v2: rt.u64): rt.u64 => { + return rt.u64Max(v2, 1); + }), 0)); + if (!_17.ok) { + _0 = _17; + break b0; + } + } + _0 = rt.Ok(undefined); + break b0; + } else { + _0 = _9; + break b0; + } } + _0 = rt.Err("Version" as EncodeError.EncodeError); } - return rt.Ok(undefined); + return _0; } //# sourceMappingURL=probe.Probe.ts.map diff --git a/ts/fixtures/codec/expected/lite/version.Version.ts b/ts/fixtures/codec/expected/lite/version.Version.ts index a3931888d..e259d7165 100644 --- a/ts/fixtures/codec/expected/lite/version.Version.ts +++ b/ts/fixtures/codec/expected/lite/version.Version.ts @@ -9,7 +9,15 @@ export type Version = "Lite01" | "Lite02" | "Lite03" | "Lite04" | "Lite05" | "Li * there and must not be sent. */ export function hasProbeRtt(self: Version): boolean { - return !(self === "Lite01" || self === "Lite02" || self === "Lite03"); + let _2!: boolean; + b0: { + if (!(self === "Lite01" || self === "Lite02" || self === "Lite03")) { + _2 = false; + break b0; + } + _2 = true; + } + return !_2; } /** @@ -21,7 +29,15 @@ export function hasProbeRtt(self: Version): boolean { * next group before it can resume. */ export function hasFrameBounds(self: Version): boolean { - return !(self === "Lite01" || self === "Lite02" || self === "Lite03" || self === "Lite04" || self === "Lite05"); + let _2!: boolean; + b0: { + if (!(self === "Lite01" || self === "Lite02" || self === "Lite03" || self === "Lite04" || self === "Lite05")) { + _2 = false; + break b0; + } + _2 = true; + } + return !_2; } //# sourceMappingURL=version.Version.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fails.ts b/ts/fixtures/lang/expected/fmt.Fails.ts index 2f4b136a2..bbbf078f4 100644 --- a/ts/fixtures/lang/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/expected/fmt.Fails.ts @@ -8,14 +8,22 @@ export interface Fails { } export function fmt$Display(self: Fails, f: rt.Formatter): rt.Result { - if (rt.u8Rem(self._0, 2) === 0) { - return rt.fmtWriteStr(f, "fine"); + let _0!: rt.Result; + let _8!: rt.Result; + let args!: [rt.u8]; + if (!(rt.u8Rem(self._0, 2) === 0)) { + args = [self._0] as [rt.u8]; + const arg = args[0]; + _8 = rt.fmtWriteFmt(f, ["half ", (f: rt.Formatter) => rt.u8Display(arg, f)]); + if (_8.ok) { + _0 = rt.Err(new rt.FmtError()); + } else { + _0 = rt.Err(new rt.FmtError()); + } + } else { + _0 = rt.fmtWriteStr(f, "fine"); } - const writeFmt = rt.fmtWriteFmt(f, ["half ", (f: rt.Formatter) => rt.u8Display(self._0, f)]); - if (!writeFmt.ok) { - return rt.Err(writeFmt.error); - } - return rt.Err(new rt.FmtError()); + return _0; } //# sourceMappingURL=fmt.Fails.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index ae83a266c..5e30e4d7f 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -4,19 +4,41 @@ import * as rt from "./rt.ts"; import * as Pair from "./fmt.Pair.ts"; export function fmt$Debug(self: Fault, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: rt.u16; + let _6!: string; + let _7!: rt.Fmt; + let __self1!: rt.usize; + let _11!: string; + let _12!: string; + let _13!: rt.Fmt; + let _14!: string; + let _15!: rt.Fmt; + let __self02!: Pair.Pair; + let _18!: string; + let _19!: rt.Fmt; if (self.tag === "Short") { - return rt.fmtWriteStr(f, "Short"); + _0 = rt.fmtWriteStr(f, "Short"); } else if (self.tag === "Code") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Code"), (f: rt.Formatter) => rt.u16Display(__self0, f))); + __self0 = self._0; + _6 = "Code"; + _7 = (f: rt.Formatter) => rt.u16Display(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } else if (self.tag === "TooLarge") { - const __self02 = self.size; - const __self1 = self.max; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "TooLarge"), "size", (f: rt.Formatter) => rt.usizeDisplay(__self02, f)), "max", (f: rt.Formatter) => rt.usizeDisplay(__self1, f))); + __self1 = self.max; + _11 = "TooLarge"; + _12 = "size"; + _13 = (f: rt.Formatter) => rt.usizeDisplay(self.size, f); + _14 = "max"; + _15 = (f: rt.Formatter) => rt.usizeDisplay(__self1, f); + _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _11), _12, _13), _14, _15)); } else { - const __self03 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "At"), (f: rt.Formatter) => Pair.fmt$Debug(__self03, f))); + __self02 = self._0; + _18 = "At"; + _19 = (f: rt.Formatter) => Pair.fmt$Debug(__self02, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _18), _19)); } + return _0; } /** @@ -30,36 +52,52 @@ export type Fault = | { tag: "At"; _0: Pair.Pair }; export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let code!: rt.u16; + let args!: [rt.u16]; + let size!: rt.usize; + let max!: rt.usize; + let pair!: Pair.Pair; + let args5!: [Pair.Pair]; if (self.tag === "Short") { - return rt.fmtPad(f, "short buffer"); + _0 = rt.fmtPad(f, "short buffer"); } else if (self.tag === "Code") { - const code = self._0; - return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, (f: rt.Formatter) => rt.u16LowerHex(code, f))]); + code = self._0; + args = [code] as [rt.u16]; + const arg2 = args[0]; + _0 = rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, (f: rt.Formatter) => rt.u16LowerHex(arg2, f))]); } else if (self.tag === "TooLarge") { - const size = self.size; - const max = self.max; - return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); + size = self.size; + max = self.max; + _0 = rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); } else { - const pair = self._0; - return rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(pair, f)]); + pair = self._0; + args5 = [pair] as [Pair.Pair]; + const arg = args5[0]; + _0 = rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(arg, f)]); } + return _0; } /** The fault `data` picks. */ function new_(data: Uint8Array): Fault { - const at = (i: rt.usize): rt.u8 => { + let _0!: Fault; + let at!: (a0: rt.usize) => rt.u8; + let _3!: rt.u8; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const value = rt.u8Rem(at(0), 4); - if (value === 0) { - return { tag: "Short" }; - } else if (value === 1) { - return { tag: "Code", _0: (at(1) << 8) | at(2) }; - } else if (value === 2) { - return { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize }; + _3 = rt.u8Rem(at(0), 4); + if (_3 === 0) { + _0 = { tag: "Short" } as Fault; + } else if (_3 === 1) { + _0 = { tag: "Code", _0: (at(1) << 8) | at(2) } as Fault; + } else if (_3 === 2) { + _0 = { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize } as Fault; } else { - return { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } }; + _0 = { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } } as Fault; } + return _0; } export { new_ as new }; diff --git a/ts/fixtures/lang/expected/fmt.Hex.ts b/ts/fixtures/lang/expected/fmt.Hex.ts index 611e12b20..8e0af7e57 100644 --- a/ts/fixtures/lang/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/expected/fmt.Hex.ts @@ -8,11 +8,19 @@ export interface Hex { } export function fmt$Display(self: Hex, f: rt.Formatter): rt.Result { - if (rt.fmtAlternate(f)) { - return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(self._0, f))]); + let _0!: rt.Result; + let args!: [rt.u32]; + let args3!: [rt.u32]; + if (!rt.fmtAlternate(f)) { + args3 = [self._0] as [rt.u32]; + const arg2 = args3[0]; + _0 = rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]); } else { - return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(self._0, f)]); + args = [self._0] as [rt.u32]; + const arg = args[0]; + _0 = rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(arg, f))]); } + return _0; } export function fmt$Debug(self: Hex, f: rt.Formatter): rt.Result { diff --git a/ts/fixtures/lang/expected/fmt.Kind.ts b/ts/fixtures/lang/expected/fmt.Kind.ts index 6b8106eb8..ee98e83de 100644 --- a/ts/fixtures/lang/expected/fmt.Kind.ts +++ b/ts/fixtures/lang/expected/fmt.Kind.ts @@ -3,20 +3,37 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: rt.u8; + let _8!: string; + let _9!: rt.Fmt; + let __self1!: rt.ByteVec; + let _13!: string; + let _14!: string; + let _15!: rt.Fmt; + let _16!: string; + let _17!: rt.Fmt; if (self.tag === "Empty") { - return rt.fmtWriteStr(f, "Empty"); + _0 = rt.fmtWriteStr(f, "Empty"); } else if (self.tag === "Braced") { - return rt.fmtWriteStr(f, "Braced"); + _0 = rt.fmtWriteStr(f, "Braced"); } else if (self.tag === "Bare") { - return rt.fmtWriteStr(f, "Bare"); + _0 = rt.fmtWriteStr(f, "Bare"); } else if (self.tag === "One") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "One"), (f: rt.Formatter) => rt.u8Display(__self0, f))); + __self0 = self._0; + _8 = "One"; + _9 = (f: rt.Formatter) => rt.u8Display(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _8), _9)); } else { - const __self02 = self.count; - const __self1 = self.items; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Many"), "count", (f: rt.Formatter) => rt.u32Display(__self02, f)), "items", (f: rt.Formatter) => rt.fmtList(rt.byteVecView(__self1), f, rt.u8Display))); + __self1 = self.items; + _13 = "Many"; + _14 = "count"; + _15 = (f: rt.Formatter) => rt.u32Display(self.count, f); + _16 = "items"; + _17 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(__self1), f, rt.u8Display); + _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _13), _14, _15), _16, _17)); } + return _0; } export type Kind = diff --git a/ts/fixtures/lang/expected/fmt.Manual.ts b/ts/fixtures/lang/expected/fmt.Manual.ts index 4f2f5f506..4691ba0a5 100644 --- a/ts/fixtures/lang/expected/fmt.Manual.ts +++ b/ts/fixtures/lang/expected/fmt.Manual.ts @@ -9,7 +9,9 @@ export interface Manual { } export function fmt$Debug(self: Manual, f: rt.Formatter): rt.Result { - return rt.debugStructFinishNonExhaustive(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Manual"), "id", (f: rt.Formatter) => rt.u8Display(self.id, f)), "list", (f: rt.Formatter) => rt.fmtList(self.list, f, rt.u16Display))); + let _6!: rt.DebugStruct; + _6 = rt.fmtDebugStruct(f, "Manual"); + return rt.debugStructFinishNonExhaustive(rt.debugStructField(rt.debugStructField(_6, "id", (f: rt.Formatter) => rt.u8Display(self.id, f)), "list", (f: rt.Formatter) => rt.fmtList(self.list, f, rt.u16Display))); } //# sourceMappingURL=fmt.Manual.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Nested.ts b/ts/fixtures/lang/expected/fmt.Nested.ts index 2ec601e43..99b8e48e6 100644 --- a/ts/fixtures/lang/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/expected/fmt.Nested.ts @@ -7,9 +7,43 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$Debug(self: Nested, f: rt.Formatter): rt.Result { - const names = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; - const values = [(f: rt.Formatter) => rt.fmtStr(self.name, f), (f: rt.Formatter) => Point.fmt$Debug(self.point, f), (f: rt.Formatter) => Shape.fmt$Debug(self.shape, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(self.pairs, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Display), (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Display, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Display), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.single[0], f)], f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Display), (f: rt.Formatter) => rt.fmtUnit(self.unit, f), (f: rt.Formatter) => Kind.fmt$Debug(self.boxed, f)]; - return rt.fmtDebugStructFields(f, "Nested", names, values); + let names!: string[]; + let values!: rt.Fmt[]; + let _6!: rt.Fmt[]; + let _7!: rt.Fmt; + let _9!: rt.Fmt; + let _11!: rt.Fmt; + let _13!: rt.Fmt; + let _15!: rt.Fmt; + let _17!: rt.Fmt; + let _19!: rt.Fmt; + let _21!: rt.Fmt; + let _23!: rt.Fmt; + let _25!: rt.Fmt; + let _27!: rt.Fmt; + let _29!: rt.Fmt; + let _31!: rt.Fmt; + let _35!: Kind.Kind; + let _36!: string; + _7 = (f: rt.Formatter) => rt.fmtStr(self.name, f); + _9 = (f: rt.Formatter) => Point.fmt$Debug(self.point, f); + _11 = (f: rt.Formatter) => Shape.fmt$Debug(self.shape, f); + _13 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Display); + _15 = (f: rt.Formatter) => rt.fmtList(self.pairs, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); + _17 = (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); + _19 = (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Display); + _21 = (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Display, rt.fmtStr); + _23 = (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Display); + _25 = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f); + _27 = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.single[0], f)], f); + _29 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Display); + _31 = (f: rt.Formatter) => rt.fmtUnit(self.unit, f); + _35 = self.boxed; + _6 = [_7, _9, _11, _13, _15, _17, _19, _21, _23, _25, _27, _29, _31, (f: rt.Formatter) => Kind.fmt$Debug(_35, f)]; + names = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; + values = _6; + _36 = "Nested"; + return rt.fmtDebugStructFields(f, _36, names, values); } export interface Nested { diff --git a/ts/fixtures/lang/expected/fmt.Padded.ts b/ts/fixtures/lang/expected/fmt.Padded.ts index 3a64bd440..67449dc29 100644 --- a/ts/fixtures/lang/expected/fmt.Padded.ts +++ b/ts/fixtures/lang/expected/fmt.Padded.ts @@ -8,16 +8,19 @@ export interface Padded { } export function fmt$Display(self: Padded, f: rt.Formatter): rt.Result { - const width = rt.fmtWidth(f); - arms: { - if (width !== undefined) { - const width2 = width; - if (width2 > 20) { - return rt.fmtWriteStr(f, "wide"); + let _0!: rt.Result; + let _3!: rt.usize | undefined; + _3 = rt.fmtWidth(f); + b0: { + if (_3 !== undefined) { + if (_3 > 20) { + _0 = rt.fmtWriteStr(f, "wide"); + break b0; } } - return rt.fmtPad(f, self._0); + _0 = rt.fmtPad(f, self._0); } + return _0; } //# sourceMappingURL=fmt.Padded.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Pair.ts b/ts/fixtures/lang/expected/fmt.Pair.ts index 19d19dbee..f3b06dde2 100644 --- a/ts/fixtures/lang/expected/fmt.Pair.ts +++ b/ts/fixtures/lang/expected/fmt.Pair.ts @@ -3,11 +3,25 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Pair, f: rt.Formatter): rt.Result { - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Pair"), (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.i64Display(self._1, f))); + let _3!: string; + let _4!: rt.Fmt; + let _6!: rt.Fmt; + let _8!: rt.i64; + _4 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _8 = self._1; + _3 = "Pair"; + _6 = (f: rt.Formatter) => rt.i64Display(_8, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); } export function eq$PartialEq(self: Pair, other: Pair): boolean { - return self._0 === other._0 && rt.i64Eq(self._1, other._1); + let _0!: boolean; + if (!(self._0 === other._0)) { + _0 = false; + } else { + _0 = rt.i64Eq(self._1, other._1); + } + return _0; } export interface Pair { diff --git a/ts/fixtures/lang/expected/fmt.Seq.ts b/ts/fixtures/lang/expected/fmt.Seq.ts index 44c8a4bf4..4794e2f1e 100644 --- a/ts/fixtures/lang/expected/fmt.Seq.ts +++ b/ts/fixtures/lang/expected/fmt.Seq.ts @@ -8,7 +8,11 @@ export interface Seq { } export function fmt$Debug(self: Seq, f: rt.Formatter): rt.Result { - return rt.debugListFinish(rt.debugListEntries(rt.fmtDebugList(f), self._0, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f))); + let _5!: rt.DebugList; + let _6!: rt.Iter; + _5 = rt.fmtDebugList(f); + _6 = rt.iterSlice(self._0); + return rt.debugListFinish(rt.debugListEntries(_5, _6, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f))); } //# sourceMappingURL=fmt.Seq.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Six.ts b/ts/fixtures/lang/expected/fmt.Six.ts index d6aa4afd7..6dfd2cf28 100644 --- a/ts/fixtures/lang/expected/fmt.Six.ts +++ b/ts/fixtures/lang/expected/fmt.Six.ts @@ -3,8 +3,25 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Six, f: rt.Formatter): rt.Result { - const values = [(f: rt.Formatter) => rt.u8Display(self._0, f), (f: rt.Formatter) => rt.u8Display(self._1, f), (f: rt.Formatter) => rt.u8Display(self._2, f), (f: rt.Formatter) => rt.u8Display(self._3, f), (f: rt.Formatter) => rt.u8Display(self._4, f), (f: rt.Formatter) => rt.u8Display(self._5, f)]; - return rt.fmtDebugTupleFields(f, "Six", values); + let values!: rt.Fmt[]; + let _5!: rt.Fmt[]; + let _6!: rt.Fmt; + let _8!: rt.Fmt; + let _10!: rt.Fmt; + let _12!: rt.Fmt; + let _14!: rt.Fmt; + let _18!: rt.u8; + let _19!: string; + _6 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _8 = (f: rt.Formatter) => rt.u8Display(self._1, f); + _10 = (f: rt.Formatter) => rt.u8Display(self._2, f); + _12 = (f: rt.Formatter) => rt.u8Display(self._3, f); + _14 = (f: rt.Formatter) => rt.u8Display(self._4, f); + _18 = self._5; + _5 = [_6, _8, _10, _12, _14, (f: rt.Formatter) => rt.u8Display(_18, f)]; + values = _5; + _19 = "Six"; + return rt.fmtDebugTupleFields(f, _19, values); } export interface Six { diff --git a/ts/fixtures/lang/expected/fmt.Tup.ts b/ts/fixtures/lang/expected/fmt.Tup.ts index 22fc090ff..a9427a65a 100644 --- a/ts/fixtures/lang/expected/fmt.Tup.ts +++ b/ts/fixtures/lang/expected/fmt.Tup.ts @@ -8,11 +8,17 @@ export interface Tup { } export function fmt$Debug(self: Tup, f: rt.Formatter): rt.Result { - if (self._1 !== undefined) { - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Tup"), (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Display))); + let _0!: rt.Result; + let _7!: rt.DebugTuple; + let _15!: rt.DebugTuple; + if (self._1 === undefined) { + _15 = rt.fmtDebugTuple(f, "Tup"); + _0 = rt.debugTupleFinishNonExhaustive(rt.debugTupleField(_15, (f: rt.Formatter) => rt.u8Display(self._0, f))); } else { - return rt.debugTupleFinishNonExhaustive(rt.debugTupleField(rt.fmtDebugTuple(f, "Tup"), (f: rt.Formatter) => rt.u8Display(self._0, f))); + _7 = rt.fmtDebugTuple(f, "Tup"); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(_7, (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Display))); } + return _0; } //# sourceMappingURL=fmt.Tup.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Wide.ts b/ts/fixtures/lang/expected/fmt.Wide.ts index 96a097633..92b59e5a8 100644 --- a/ts/fixtures/lang/expected/fmt.Wide.ts +++ b/ts/fixtures/lang/expected/fmt.Wide.ts @@ -3,9 +3,27 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Wide, f: rt.Formatter): rt.Result { - const names = ["a", "b", "c", "d", "e", "f"]; - const values = [(f: rt.Formatter) => rt.u8Display(self.a, f), (f: rt.Formatter) => rt.u16Display(self.b, f), (f: rt.Formatter) => rt.u32Display(self.c, f), (f: rt.Formatter) => rt.u64Display(self.d, f), (f: rt.Formatter) => rt.i8Display(self.e, f), (f: rt.Formatter) => rt.fmtBool(self.f, f)]; - return rt.fmtDebugStructFields(f, "Wide", names, values); + let names!: string[]; + let values!: rt.Fmt[]; + let _6!: rt.Fmt[]; + let _7!: rt.Fmt; + let _9!: rt.Fmt; + let _11!: rt.Fmt; + let _13!: rt.Fmt; + let _15!: rt.Fmt; + let _19!: boolean; + let _20!: string; + _7 = (f: rt.Formatter) => rt.u8Display(self.a, f); + _9 = (f: rt.Formatter) => rt.u16Display(self.b, f); + _11 = (f: rt.Formatter) => rt.u32Display(self.c, f); + _13 = (f: rt.Formatter) => rt.u64Display(self.d, f); + _15 = (f: rt.Formatter) => rt.i8Display(self.e, f); + _19 = self.f; + _6 = [_7, _9, _11, _13, _15, (f: rt.Formatter) => rt.fmtBool(_19, f)]; + names = ["a", "b", "c", "d", "e", "f"]; + values = _6; + _20 = "Wide"; + return rt.fmtDebugStructFields(f, _20, names, values); } /** Past five fields, derived `Debug` takes the fields as slices. */ diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 654e0f43d..28e55113d 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -20,347 +20,714 @@ import type * as Shape from "./shapes.Shape.ts"; export function put(out: rt.ByteVec, s: string): void { rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 0xff); + rt.byteVecPush(out, 255); + return; } /** Integers of every width, with each spec. */ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 12); - if (value === 0) { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const v = rt.u8FromBeBytes(buf); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(v, f), " ", (f: rt.Formatter) => rt.u8Display(v, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", (f: rt.Formatter) => rt.u8LowerHex(v, f), " ", (f: rt.Formatter) => rt.u8UpperHex(v, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8Display(v, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u8Display(v, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f))); - } else if (value === 1) { - const data3 = data; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data3.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data3, 0, n2)); - const v2 = rt.u16FromBeBytes(buf2); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u16Display(v2, f), " ", (f: rt.Formatter) => rt.u16Display(v2, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", (f: rt.Formatter) => rt.u16LowerHex(v2, f), " ", (f: rt.Formatter) => rt.u16UpperHex(v2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16Display(v2, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u16Display(v2, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f))); - } else if (value === 2) { - const data4 = data; - let buf3: Uint8Array = rt.bytes(4); - const n3 = rt.min(data4.length, buf3.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data4, 0, n3)); - const v3 = rt.u32FromBeBytes(buf3); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u32Display(v3, f), " ", (f: rt.Formatter) => rt.u32Display(v3, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", (f: rt.Formatter) => rt.u32LowerHex(v3, f), " ", (f: rt.Formatter) => rt.u32UpperHex(v3, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32Display(v3, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u32Display(v3, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f))); - } else if (value === 3) { - const data5 = data; - let buf4: Uint8Array = rt.bytes(8); - const n4 = rt.min(data5.length, buf4.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data5, 0, n4)); - const v4 = rt.u64FromBeBytes(buf4); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u64Display(v4, f), " ", (f: rt.Formatter) => rt.u64Display(v4, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", (f: rt.Formatter) => rt.u64LowerHex(v4, f), " ", (f: rt.Formatter) => rt.u64UpperHex(v4, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64Display(v4, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u64Display(v4, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f))); - } else if (value === 4) { - const data6 = data; - let buf5: Uint8Array = rt.bytes(16); - const n5 = rt.min(data6.length, buf5.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data6, 0, n5)); - const v5 = rt.u128FromBeBytes(buf5); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u128Display(v5, f), " ", (f: rt.Formatter) => rt.u128Display(v5, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", (f: rt.Formatter) => rt.u128LowerHex(v5, f), " ", (f: rt.Formatter) => rt.u128UpperHex(v5, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128Display(v5, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u128Display(v5, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f))); - } else if (value === 5) { - const data7 = data; - let buf6: Uint8Array = rt.bytes(4); - const n6 = rt.min(data7.length, buf6.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data7, 0, n6)); - const v6 = rt.usizeFromBeBytes(buf6); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", (f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", (f: rt.Formatter) => rt.usizeLowerHex(v6, f), " ", (f: rt.Formatter) => rt.usizeUpperHex(v6, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f))); - } else if (value === 6) { - const data8 = data; - let buf7: Uint8Array = rt.bytes(1); - const n7 = rt.min(data8.length, buf7.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data8, 0, n7)); - const v7 = rt.i8FromBeBytes(buf7); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i8Display(v7, f), " ", (f: rt.Formatter) => rt.i8Display(v7, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", (f: rt.Formatter) => rt.i8LowerHex(v7, f), " ", (f: rt.Formatter) => rt.i8UpperHex(v7, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8Display(v7, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i8Display(v7, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f))); - } else if (value === 7) { - const data9 = data; - let buf8: Uint8Array = rt.bytes(2); - const n8 = rt.min(data9.length, buf8.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data9, 0, n8)); - const v8 = rt.i16FromBeBytes(buf8); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i16Display(v8, f), " ", (f: rt.Formatter) => rt.i16Display(v8, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", (f: rt.Formatter) => rt.i16LowerHex(v8, f), " ", (f: rt.Formatter) => rt.i16UpperHex(v8, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16Display(v8, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i16Display(v8, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f))); - } else if (value === 8) { - const data10 = data; - let buf9: Uint8Array = rt.bytes(4); - const n9 = rt.min(data10.length, buf9.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data10, 0, n9)); - const v9 = rt.i32FromBeBytes(buf9); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i32Display(v9, f), " ", (f: rt.Formatter) => rt.i32Display(v9, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", (f: rt.Formatter) => rt.i32LowerHex(v9, f), " ", (f: rt.Formatter) => rt.i32UpperHex(v9, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32Display(v9, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i32Display(v9, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f))); - } else if (value === 9) { - const data11 = data; - let buf10: Uint8Array = rt.bytes(8); - const n10 = rt.min(data11.length, buf10.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data11, 0, n10)); - const v10 = rt.i64FromBeBytes(buf10); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i64Display(v10, f), " ", (f: rt.Formatter) => rt.i64Display(v10, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", (f: rt.Formatter) => rt.i64LowerHex(v10, f), " ", (f: rt.Formatter) => rt.i64UpperHex(v10, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64Display(v10, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i64Display(v10, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f))); - } else if (value === 10) { - const data12 = data; - let buf11: Uint8Array = rt.bytes(16); - const n11 = rt.min(data12.length, buf11.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data12, 0, n11)); - const v11 = rt.i128FromBeBytes(buf11); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i128Display(v11, f), " ", (f: rt.Formatter) => rt.i128Display(v11, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", (f: rt.Formatter) => rt.i128LowerHex(v11, f), " ", (f: rt.Formatter) => rt.i128UpperHex(v11, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128Display(v11, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i128Display(v11, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f))); + let _4!: rt.u8; + let v!: rt.u8; + let buf!: Uint8Array; + let n!: rt.usize; + let _23!: string; + let _38!: string; + let v2!: rt.u16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _57!: string; + let _72!: string; + let v3!: rt.u32; + let buf3!: Uint8Array; + let n3!: rt.usize; + let _91!: string; + let _106!: string; + let v4!: rt.u64; + let buf4!: Uint8Array; + let n4!: rt.usize; + let _125!: string; + let _140!: string; + let v5!: rt.u128; + let buf5!: Uint8Array; + let n5!: rt.usize; + let _159!: string; + let _174!: string; + let v6!: rt.usize; + let buf6!: Uint8Array; + let n6!: rt.usize; + let _193!: string; + let _208!: string; + let v7!: rt.i8; + let buf7!: Uint8Array; + let n7!: rt.usize; + let _227!: string; + let _242!: string; + let v8!: rt.i16; + let buf8!: Uint8Array; + let n8!: rt.usize; + let _261!: string; + let _276!: string; + let v9!: rt.i32; + let buf9!: Uint8Array; + let n9!: rt.usize; + let _295!: string; + let _310!: string; + let v10!: rt.i64; + let buf10!: Uint8Array; + let n10!: rt.usize; + let _329!: string; + let _344!: string; + let v11!: rt.i128; + let buf11!: Uint8Array; + let n11!: rt.usize; + let _363!: string; + let _378!: string; + let v12!: rt.isize; + let buf12!: Uint8Array; + let n12!: rt.usize; + let _397!: string; + let _412!: string; + _4 = rt.u8Rem(kind, 12); + if (_4 === 0) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + v = rt.u8FromBeBytes(buf); + _23 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(v, f), " ", (f: rt.Formatter) => rt.u8Display(v, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", (f: rt.Formatter) => rt.u8LowerHex(v, f), " ", (f: rt.Formatter) => rt.u8UpperHex(v, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8Display(v, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u8Display(v, f))]); + put(out, _23); + _38 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f)); + put(out, _38); + } else if (_4 === 1) { + buf2 = rt.bytes(2); + n2 = rt.min(data.length, buf2.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); + v2 = rt.u16FromBeBytes(buf2); + _57 = rt.fmtFormat([(f: rt.Formatter) => rt.u16Display(v2, f), " ", (f: rt.Formatter) => rt.u16Display(v2, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", (f: rt.Formatter) => rt.u16LowerHex(v2, f), " ", (f: rt.Formatter) => rt.u16UpperHex(v2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16Display(v2, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u16Display(v2, f))]); + put(out, _57); + _72 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f)); + put(out, _72); + } else if (_4 === 2) { + buf3 = rt.bytes(4); + n3 = rt.min(data.length, buf3.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); + v3 = rt.u32FromBeBytes(buf3); + _91 = rt.fmtFormat([(f: rt.Formatter) => rt.u32Display(v3, f), " ", (f: rt.Formatter) => rt.u32Display(v3, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", (f: rt.Formatter) => rt.u32LowerHex(v3, f), " ", (f: rt.Formatter) => rt.u32UpperHex(v3, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32Display(v3, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u32Display(v3, f))]); + put(out, _91); + _106 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f)); + put(out, _106); + } else if (_4 === 3) { + buf4 = rt.bytes(8); + n4 = rt.min(data.length, buf4.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); + v4 = rt.u64FromBeBytes(buf4); + _125 = rt.fmtFormat([(f: rt.Formatter) => rt.u64Display(v4, f), " ", (f: rt.Formatter) => rt.u64Display(v4, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", (f: rt.Formatter) => rt.u64LowerHex(v4, f), " ", (f: rt.Formatter) => rt.u64UpperHex(v4, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64Display(v4, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u64Display(v4, f))]); + put(out, _125); + _140 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f)); + put(out, _140); + } else if (_4 === 4) { + buf5 = rt.bytes(16); + n5 = rt.min(data.length, buf5.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); + v5 = rt.u128FromBeBytes(buf5); + _159 = rt.fmtFormat([(f: rt.Formatter) => rt.u128Display(v5, f), " ", (f: rt.Formatter) => rt.u128Display(v5, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", (f: rt.Formatter) => rt.u128LowerHex(v5, f), " ", (f: rt.Formatter) => rt.u128UpperHex(v5, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128Display(v5, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u128Display(v5, f))]); + put(out, _159); + _174 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f)); + put(out, _174); + } else if (_4 === 5) { + buf6 = rt.bytes(4); + n6 = rt.min(data.length, buf6.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); + v6 = rt.usizeFromBeBytes(buf6); + _193 = rt.fmtFormat([(f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", (f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", (f: rt.Formatter) => rt.usizeLowerHex(v6, f), " ", (f: rt.Formatter) => rt.usizeUpperHex(v6, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f))]); + put(out, _193); + _208 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f)); + put(out, _208); + } else if (_4 === 6) { + buf7 = Uint8Array.of(0); + n7 = rt.min(data.length, buf7.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); + v7 = rt.i8FromBeBytes(buf7); + _227 = rt.fmtFormat([(f: rt.Formatter) => rt.i8Display(v7, f), " ", (f: rt.Formatter) => rt.i8Display(v7, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", (f: rt.Formatter) => rt.i8LowerHex(v7, f), " ", (f: rt.Formatter) => rt.i8UpperHex(v7, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8Display(v7, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i8Display(v7, f))]); + put(out, _227); + _242 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f)); + put(out, _242); + } else if (_4 === 7) { + buf8 = rt.bytes(2); + n8 = rt.min(data.length, buf8.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); + v8 = rt.i16FromBeBytes(buf8); + _261 = rt.fmtFormat([(f: rt.Formatter) => rt.i16Display(v8, f), " ", (f: rt.Formatter) => rt.i16Display(v8, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", (f: rt.Formatter) => rt.i16LowerHex(v8, f), " ", (f: rt.Formatter) => rt.i16UpperHex(v8, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16Display(v8, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i16Display(v8, f))]); + put(out, _261); + _276 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f)); + put(out, _276); + } else if (_4 === 8) { + buf9 = rt.bytes(4); + n9 = rt.min(data.length, buf9.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); + v9 = rt.i32FromBeBytes(buf9); + _295 = rt.fmtFormat([(f: rt.Formatter) => rt.i32Display(v9, f), " ", (f: rt.Formatter) => rt.i32Display(v9, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", (f: rt.Formatter) => rt.i32LowerHex(v9, f), " ", (f: rt.Formatter) => rt.i32UpperHex(v9, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32Display(v9, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i32Display(v9, f))]); + put(out, _295); + _310 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f)); + put(out, _310); + } else if (_4 === 9) { + buf10 = rt.bytes(8); + n10 = rt.min(data.length, buf10.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); + v10 = rt.i64FromBeBytes(buf10); + _329 = rt.fmtFormat([(f: rt.Formatter) => rt.i64Display(v10, f), " ", (f: rt.Formatter) => rt.i64Display(v10, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", (f: rt.Formatter) => rt.i64LowerHex(v10, f), " ", (f: rt.Formatter) => rt.i64UpperHex(v10, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64Display(v10, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i64Display(v10, f))]); + put(out, _329); + _344 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f)); + put(out, _344); + } else if (_4 === 10) { + buf11 = rt.bytes(16); + n11 = rt.min(data.length, buf11.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); + v11 = rt.i128FromBeBytes(buf11); + _363 = rt.fmtFormat([(f: rt.Formatter) => rt.i128Display(v11, f), " ", (f: rt.Formatter) => rt.i128Display(v11, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", (f: rt.Formatter) => rt.i128LowerHex(v11, f), " ", (f: rt.Formatter) => rt.i128UpperHex(v11, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128Display(v11, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i128Display(v11, f))]); + put(out, _363); + _378 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f)); + put(out, _378); } else { - const data13 = data; - let buf12: Uint8Array = rt.bytes(4); - const n12 = rt.min(data13.length, buf12.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data13, 0, n12)); - const v12 = rt.isizeFromBeBytes(buf12); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", (f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", (f: rt.Formatter) => rt.isizeLowerHex(v12, f), " ", (f: rt.Formatter) => rt.isizeUpperHex(v12, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f))); + buf12 = rt.bytes(4); + n12 = rt.min(data.length, buf12.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); + v12 = rt.isizeFromBeBytes(buf12); + _397 = rt.fmtFormat([(f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", (f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", (f: rt.Formatter) => rt.isizeLowerHex(v12, f), " ", (f: rt.Formatter) => rt.isizeUpperHex(v12, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f))]); + put(out, _397); + _412 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f)); + put(out, _412); } + return; } /** Strings padded and escaped, and bytes that may not be UTF-8. */ export function strings(data: Uint8Array, out: rt.ByteVec): void { - for (const item of rt.sliceRange(data, 0, rt.min(data.length, 3))) { - const b = item; - const value = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"]; - const s = rt.at(value, rt.usizeRem(b as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length)); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtPad(f, s), "|", rt.fmtSpec({ width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: "^", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", (f: rt.Formatter) => rt.fmtStr(s, f), "|", rt.fmtSpec({ width: 12 }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|{", (f: rt.Formatter) => rt.fmtPad(f, s), "}"])); - } - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(data)); - if (fromUtf8.ok) { - const s2 = fromUtf8.value; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtStr(s2, f), " ", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.fmtPad(f, s2))])); - } else { - const e = fromUtf8.error; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), " ", (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)), " ", rt.fmtSpec({ align: ">", width: 80 }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f))])); - } - let flag: boolean; - const first = rt.sliceFirst(data); - arms: { - if (first !== undefined) { - const b2 = first; - if (rt.u8Rem(b2, 2) === 0) { - flag = true; - break arms; + let iter!: rt.Iter; + let _9!: rt.u8 | rt.Done; + let s!: string; + let _15!: rt.usize; + let _16!: rt.usize; + let _17!: rt.usize; + let _25!: string; + let _36!: rt.Result; + let s2!: string; + let _42!: string; + let e!: rt.FromUtf8Error; + let _55!: string; + let flag!: boolean; + let _66!: rt.u8 | undefined; + let _76!: string; + let _93!: string; + let _94!: boolean; + let _95!: rt.Result; + let v!: rt.u8; + let _104!: string; + let args9!: [rt.u8]; + let e2!: rt.TryFromIntError; + let _116!: string; + iter = rt.iterSlice(rt.sliceRange(data, 0, rt.min(data.length, 3))); + while (true) { + _9 = iter.next(); + if (_9 === rt.DONE) { + _36 = rt.stringFromUtf8(rt.sliceToByteVec(data)); + if (_36.ok) { + s2 = _36.value; + _42 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtStr(s2, f), " ", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.fmtPad(f, s2))]); + put(out, _42); + } else { + e = _36.error; + _55 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), " ", (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)), " ", rt.fmtSpec({ align: ">", width: 80 }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f))]); + put(out, _55); + } + _66 = rt.sliceFirst(data); + b2: { + if (_66 !== undefined) { + if (rt.u8Rem(_66, 2) === 0) { + flag = true; + break b2; + } + } + flag = false; + } + _76 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtBool(flag, f), " ", (f: rt.Formatter) => rt.fmtBool(flag, f), " ", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => rt.fmtBool(flag, f)), " ", (f: rt.Formatter) => rt.fmtUnit(undefined, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtUnit(undefined, f))]); + put(out, _76); + _94 = flag; + _93 = rt.fmtToString((f: rt.Formatter) => rt.fmtBool(_94, f)); + put(out, _93); + _95 = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); + if (_95.ok) { + v = _95.value; + args9 = [v] as [rt.u8]; + const arg = args9[0]; + _104 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); + put(out, _104); + } else { + e2 = _95.error; + _116 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f), " ", (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(e2, f), " ", rt.fmtSpec({ align: ">", width: 40 }, (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f)), "|"]); + put(out, _116); + } + return; + } else { + _16 = _9 as rt.usize; + _17 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length; + _15 = rt.usizeRem(_16, _17); + if (!(_15 < 14)) { + rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); } + s = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]; + _25 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtPad(f, s), "|", rt.fmtSpec({ width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: "^", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", (f: rt.Formatter) => rt.fmtStr(s, f), "|", rt.fmtSpec({ width: 12 }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|{", (f: rt.Formatter) => rt.fmtPad(f, s), "}"]); + put(out, _25); } - flag = false; - } - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtBool(flag, f), " ", (f: rt.Formatter) => rt.fmtBool(flag, f), " ", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => rt.fmtBool(flag, f)), " ", (f: rt.Formatter) => rt.fmtUnit(undefined, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtUnit(undefined, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtBool(flag, f))); - const tryFrom = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); - if (tryFrom.ok) { - const v = tryFrom.value; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(v, f)])); - } else { - const e2 = tryFrom.error; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f), " ", (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(e2, f), " ", rt.fmtSpec({ align: ">", width: 40 }, (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f)), "|"])); } } export function nested(data: Uint8Array): Nested.Nested { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let _3!: string; + let _4!: string[]; + let _5!: rt.usize; + let _6!: rt.usize; + let _10!: rt.usize; + let _15!: Point.Point; + let _22!: Shape.Shape; + let _23!: rt.u8; + let _35!: rt.ByteVec; + let _40!: Pair.Pair[]; + let _43!: Pair.Pair[]; + let _49!: Pair.Pair | undefined; + let _60!: rt.u8 | undefined; + let _61!: rt.Result; + let _73!: rt.i16[]; + let _80!: [rt.u8, boolean, string]; + let _84!: [rt.u8]; + let _88!: rt.ByteVec; + let _90!: Kind.Kind; + let _91!: rt.u8; + let _102!: Uint8Array; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const value = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"]; - const arg = rt.at(value, rt.usizeRem(at(0) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length)); - const arg2 = { x: rt.i32Sub(at(1) as rt.i32, 128), y: -7 }; - const value2 = rt.u8Rem(at(2), 3); - const arg3 = arg; - const arg4 = arg2; - const arg5 = value2 === 0 ? { tag: "Dot" } as Shape.Shape : value2 === 1 ? { tag: "Line", _0: { x: 1, y: 2 }, _1: { x: -3, y: 4 } } as Shape.Shape : { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; - const arg6 = rt.sliceToByteVec(rt.sliceRange(data, 0, rt.min(data.length, 4))); - const arg7 = rt.sliceToVec([{ _0: at(4), _1: -1 }, { _0: 2, _1: rt.i64Of(-9223372036854775808n) }]); - const arg8 = rt.u8Rem(at(5), 2) === 0 ? { _0: at(5), _1: 5 } : undefined; - const arg9 = rt.u8Rem(at(6), 2) === 0 ? rt.Ok(at(6)) : rt.Err("no"); - const arg10 = [rt.i16Sub(at(7) as rt.i16, 100), 32767]; - const arg11 = [at(8), true, "t"] as [rt.u8, boolean, string]; - const arg12 = [at(9)] as [rt.u8]; - const arg13 = new rt.ByteVec(); - const value3 = rt.u8Rem(at(10), 3); - return { name: arg3, point: arg4, shape: arg5, tags: arg6, pairs: arg7, maybe: arg8, none: undefined, result: arg9, list: arg10, tuple: arg11, single: arg12, empty: arg13, unit: undefined, boxed: value3 === 0 ? { tag: "Empty" } as Kind.Kind : value3 === 1 ? { tag: "One", _0: at(11) } as Kind.Kind : { tag: "Many", count: 2, items: rt.sliceToByteVec(Uint8Array.of(at(11), at(12))) } as Kind.Kind }; + _6 = at(0) as rt.usize; + _10 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length; + _5 = rt.usizeRem(_6, _10); + if (!(_5 < 14)) { + rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); + } + _4 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"]; + _3 = _4[_5]; + _15 = { x: rt.i32Sub(at(1) as rt.i32, 128), y: -7 }; + _23 = rt.u8Rem(at(2), 3); + if (_23 === 0) { + _22 = { tag: "Dot" } as Shape.Shape; + } else if (_23 === 1) { + _22 = { tag: "Line", _0: { x: 1, y: 2 }, _1: { x: -3, y: 4 } } as Shape.Shape; + } else { + _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; + } + _35 = rt.sliceToByteVec(rt.sliceRange(data, 0, rt.min(data.length, 4))); + _43 = [{ _0: at(4), _1: -1 }, { _0: 2, _1: rt.i64Of(-9223372036854775808n) }]; + _40 = rt.sliceToVec(_43); + if (!(rt.u8Rem(at(5), 2) === 0)) { + _49 = undefined; + } else { + _49 = { _0: at(5), _1: 5 }; + } + _60 = undefined; + if (!(rt.u8Rem(at(6), 2) === 0)) { + _61 = rt.Err("no"); + } else { + _61 = rt.Ok(at(6)); + } + _73 = [rt.i16Sub(at(7) as rt.i16, 100), 32767]; + _80 = [at(8), true, "t"] as [rt.u8, boolean, string]; + _84 = [at(9)] as [rt.u8]; + _88 = new rt.ByteVec(); + _91 = rt.u8Rem(at(10), 3); + if (_91 === 0) { + _90 = { tag: "Empty" } as Kind.Kind; + } else if (_91 === 1) { + _90 = { tag: "One", _0: at(11) } as Kind.Kind; + } else { + _102 = Uint8Array.of(at(11), at(12)); + _90 = { tag: "Many", count: 2, items: rt.sliceToByteVec(_102) } as Kind.Kind; + } + return { name: _3, point: _15, shape: _22, tags: _35, pairs: _40, maybe: _49, none: _60, result: _61, list: _73, tuple: _80, single: _84, empty: _88, unit: undefined, boxed: _90 }; } /** Derived `Debug` of every shape, compact and pretty, with options passed to fields. */ export function derived(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let value!: Nested.Nested; + let _8!: string; + let args!: [Nested.Nested]; + let _20!: string; + let args3!: [Nested.Nested]; + let wide!: Wide.Wide; + let _30!: rt.u8; + let _33!: boolean; + let six!: Six.Six; + let _47!: string; + let _56!: rt.Fmt; + let _57!: rt.Fmt; + let _58!: rt.Fmt; + let _65!: string; + let point!: Point.Point; + let _84!: string; + let _89!: Pair.Pair; + let kinds!: Kind.Kind[]; + let _100!: Kind.Kind; + let _101!: Kind.Kind; + let _105!: Kind.Kind; + let _106!: Kind.Kind; + let _112!: string; + let _117!: Kind.Kind; + let _118!: Kind.Kind; + let _119!: rt.usize; + let _130!: string; + let args13!: [Kind.Kind[]]; + let bytes!: Uint8Array; + let words!: rt.u16[]; + let _148!: string; + let _153!: rt.u8 | undefined; + let _155!: rt.u8 | undefined; + let _168!: string; + let _177!: rt.Fmt; + let _178!: rt.Fmt; + let _179!: rt.Fmt; + let _186!: Uint8Array; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const value = nested(data); - put(out, rt.fmtFormat([(f: rt.Formatter) => Nested.fmt$Debug(value, f)])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Nested.fmt$Debug(value, f))])); - const wide = { a: at(0), b: 300, c: 70_000, d: rt.u64Of(18446744073709551615n), e: -1, f: at(1) > 10 }; - const six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; - const arg3 = out; - const arg = {}; - const arg2 = {}; - put(arg3, rt.fmtFormat([(f: rt.Formatter) => Wide.fmt$Debug(wide, f), " ", (f: rt.Formatter) => Six.fmt$Debug(six, f), " ", (f: rt.Formatter) => Unit.fmt$Debug(arg, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Unit.fmt$Debug(arg2, f))])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wide.fmt$Debug(wide, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Six.fmt$Debug(six, f))])); - const point = { x: at(2) as rt.i32, y: -1 }; - const arg5 = out; - const arg4 = { _0: at(3), _1: -9 }; - put(arg5, rt.fmtFormat([rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: "<", width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ alternate: true, width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: ">", width: 3 }, (f: rt.Formatter) => Pair.fmt$Debug(arg4, f))])); - const kinds = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rt.ByteVec() } as Kind.Kind]; - const arg7 = out; - const arg6 = kinds[1]; - put(arg7, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), " ", (f: rt.Formatter) => Kind.fmt$Debug(arg6, f)])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)))])); - const bytes = data; - const words = [at(5) as rt.u16, 0xffff]; - const arg10 = out; - const arg8 = rt.sliceFirst(data); - const arg9 = rt.sliceGet(data, 100); - put(arg10, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(bytes, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), " ", (f: rt.Formatter) => rt.fmtOption(arg8, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(arg9, f, rt.u8Display)])); - const arg15 = out; - const arg11 = {}; - const arg12 = {}; - const arg13 = {}; - const arg14 = {}; - put(arg15, rt.fmtFormat([(f: rt.Formatter) => Braced.fmt$Debug(arg11, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Braced.fmt$Debug(arg12, f)), " ", (f: rt.Formatter) => Bare.fmt$Debug(arg13, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Bare.fmt$Debug(arg14, f))])); - rt.byteVecExtendFromSlice(out, Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0)); + value = nested(data); + args = [value] as [Nested.Nested]; + const arg = args[0]; + _8 = rt.fmtFormat([(f: rt.Formatter) => Nested.fmt$Debug(arg, f)]); + put(out, _8); + args3 = [value] as [Nested.Nested]; + const arg2 = args3[0]; + _20 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Nested.fmt$Debug(arg2, f))]); + put(out, _20); + _30 = at(0); + _33 = at(1) > 10; + wide = { a: _30, b: 300, c: 70000, d: rt.u64Of(18446744073709551615n), e: -1, f: _33 }; + six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; + _56 = (f: rt.Formatter) => Wide.fmt$Debug(wide, f); + _57 = (f: rt.Formatter) => Six.fmt$Debug(six, f); + const arg3 = {}; + _58 = (f: rt.Formatter) => Unit.fmt$Debug(arg3, f); + const arg4 = {}; + _47 = rt.fmtFormat([_56, " ", _57, " ", _58, " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Unit.fmt$Debug(arg4, f))]); + put(out, _47); + _65 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wide.fmt$Debug(wide, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Six.fmt$Debug(six, f))]); + put(out, _65); + point = { x: at(2) as rt.i32, y: -1 }; + _89 = { _0: at(3), _1: -9 }; + _84 = rt.fmtFormat([rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: "<", width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ alternate: true, width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: ">", width: 3 }, (f: rt.Formatter) => Pair.fmt$Debug(_89, f))]); + put(out, _84); + _100 = { tag: "Empty" } as Kind.Kind; + _101 = { tag: "One", _0: at(4) } as Kind.Kind; + _105 = { tag: "Braced" } as Kind.Kind; + _106 = { tag: "Bare" } as Kind.Kind; + kinds = [_100, _101, _105, _106, { tag: "Many", count: 0, items: new rt.ByteVec() } as Kind.Kind]; + _119 = 1; + if (!(_119 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _119); + } + _118 = kinds[_119]; + _117 = _118; + _112 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), " ", (f: rt.Formatter) => Kind.fmt$Debug(_117, f)]); + put(out, _112); + args13 = [kinds] as [Kind.Kind[]]; + const arg5 = args13[0]; + _130 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtList(arg5, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)))]); + put(out, _130); + bytes = data; + words = [at(5) as rt.u16, 65535]; + _153 = rt.sliceFirst(data); + _155 = rt.sliceGet(data, 100); + _148 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(bytes, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), " ", (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(_155, f, rt.u8Display)]); + put(out, _148); + const arg6 = {}; + _177 = (f: rt.Formatter) => Braced.fmt$Debug(arg6, f); + const arg7 = {}; + _178 = (f: rt.Formatter) => Braced.fmt$Debug(arg7, f); + const arg8 = {}; + _179 = (f: rt.Formatter) => Bare.fmt$Debug(arg8, f); + const arg9 = {}; + _168 = rt.fmtFormat([_177, " ", rt.fmtSpec({ alternate: true }, _178), " ", _179, " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Bare.fmt$Debug(arg9, f))]); + put(out, _168); + _186 = Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0); + rt.byteVecExtendFromSlice(out, _186); + return; } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ export function written(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let hex!: Hex.Hex; + let _14!: string; + let _27!: string; + let padded!: Padded.Padded; + let _33!: string; + let args3!: [Padded.Padded]; + let manual!: Manual.Manual; + let _43!: rt.u8; + let _49!: rt.u16[]; + let empty!: Manual.Manual; + let _59!: string; + let seq!: Seq.Seq; + let _74!: Pair.Pair[]; + let none!: Seq.Seq; + let _85!: string; + let tup!: Tup.Tup; + let _97!: rt.u8; + let _100!: rt.u8 | undefined; + let _113!: string; + let args9!: [Tup.Tup]; + let fine!: Fails.Fails; + let _131!: string; + let args11!: [Fails.Fails]; + let _143!: string; + let _148!: rt.u8; + let _152!: rt.u8; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const hex = { _0: rt.u32Mul(at(0) as rt.u32, 0x1001) }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Hex.fmt$Display(hex, f), "|", rt.fmtSpec({ align: ">", width: 12 }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", (f: rt.Formatter) => Hex.fmt$Debug(hex, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => Hex.fmt$Display(hex, f))); - const padded = { _0: "pad" }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Padded.fmt$Display(padded, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Padded.fmt$Display(padded, f)), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, (f: rt.Formatter) => Padded.fmt$Display(padded, f)), "|", rt.fmtSpec({ width: 30 }, (f: rt.Formatter) => Padded.fmt$Display(padded, f)), "|"])); - const manual = { id: at(1), list: rt.sliceToVec([1, at(2) as rt.u16]) }; - const empty = { id: 0, list: [] }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Manual.fmt$Debug(manual, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Manual.fmt$Debug(manual, f)), " ", (f: rt.Formatter) => Manual.fmt$Debug(empty, f)])); - const seq = { _0: rt.sliceToVec([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }]) }; - const none = { _0: [] }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Seq.fmt$Debug(seq, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(seq, f)), " ", (f: rt.Formatter) => Seq.fmt$Debug(none, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(none, f))])); - const tup = { _0: at(4), _1: rt.u8Rem(at(5), 2) === 0 ? at(5) : undefined }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Tup.fmt$Debug(tup, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Tup.fmt$Debug(tup, f))])); - const fine = { _0: at(6) & (~1 & 0xff) }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(fine, f), " ", rt.fmtSpec({ align: ">", width: 9 }, (f: rt.Formatter) => Fails.fmt$Display(fine, f))])); - const arg3 = out; - const arg = at(7); - const arg2 = at(8); - put(arg3, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg2, f), " ", (f: rt.Formatter) => rt.u8Display(arg, f), " ", (f: rt.Formatter) => rt.u8Display(arg, f), " named ", rt.fmtSpec({ align: ">", width: 5 }, (f: rt.Formatter) => rt.fmtPad(f, "named"))])); + hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; + _14 = rt.fmtFormat([(f: rt.Formatter) => Hex.fmt$Display(hex, f), "|", rt.fmtSpec({ align: ">", width: 12 }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", (f: rt.Formatter) => Hex.fmt$Debug(hex, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f))]); + put(out, _14); + _27 = rt.fmtToString((f: rt.Formatter) => Hex.fmt$Display(hex, f)); + put(out, _27); + padded = { _0: "pad" }; + args3 = [padded] as [Padded.Padded]; + const arg = args3[0]; + _33 = rt.fmtFormat([(f: rt.Formatter) => Padded.fmt$Display(arg, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|", rt.fmtSpec({ width: 30 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|"]); + put(out, _33); + _43 = at(1); + _49 = [1, at(2) as rt.u16]; + manual = { id: _43, list: rt.sliceToVec(_49) }; + empty = { id: 0, list: [] }; + _59 = rt.fmtFormat([(f: rt.Formatter) => Manual.fmt$Debug(manual, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Manual.fmt$Debug(manual, f)), " ", (f: rt.Formatter) => Manual.fmt$Debug(empty, f)]); + put(out, _59); + _74 = [{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }]; + seq = { _0: rt.sliceToVec(_74) }; + none = { _0: [] }; + _85 = rt.fmtFormat([(f: rt.Formatter) => Seq.fmt$Debug(seq, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(seq, f)), " ", (f: rt.Formatter) => Seq.fmt$Debug(none, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(none, f))]); + put(out, _85); + _97 = at(4); + if (!(rt.u8Rem(at(5), 2) === 0)) { + _100 = undefined; + } else { + _100 = at(5); + } + tup = { _0: _97, _1: _100 }; + args9 = [tup] as [Tup.Tup]; + const arg2 = args9[0]; + _113 = rt.fmtFormat([(f: rt.Formatter) => Tup.fmt$Debug(arg2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Tup.fmt$Debug(arg2, f))]); + put(out, _113); + fine = { _0: at(6) & (~1 & 0xff) }; + args11 = [fine] as [Fails.Fails]; + const arg3 = args11[0]; + _131 = rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg3, f), " ", rt.fmtSpec({ align: ">", width: 9 }, (f: rt.Formatter) => Fails.fmt$Display(arg3, f))]); + put(out, _131); + _148 = at(7); + _152 = at(8); + _143 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(_152, f), " ", (f: rt.Formatter) => rt.u8Display(_148, f), " ", (f: rt.Formatter) => rt.u8Display(_148, f), " named ", rt.fmtSpec({ align: ">", width: 5 }, (f: rt.Formatter) => rt.fmtPad(f, "named"))]); + put(out, _143); + return; } /** Panics, each with the message native Rust formats. */ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { - const n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); - const value = rt.u8Rem(kind, 19); - if (value === 0) { + let n!: rt.u8; + let _7!: rt.u8; + let _23!: Hex.Hex; + let _37!: Pair.Pair; + let _58!: Pair.Pair; + let _60!: Pair.Pair; + let kind3!: string; + let _66!: rt.Arguments | undefined; + let args7!: [rt.u8]; + let r!: rt.Result; + let _94!: Uint8Array; + let _98!: string; + let _100!: rt.u8; + let r2!: rt.Result; + let _108!: string; + let _110!: rt.u8; + let _119!: string; + let _121!: rt.u8; + let missing!: rt.u8 | undefined; + let _127!: string; + let _129!: rt.u8; + let _132!: string; + let args9!: [rt.u8]; + let _143!: string; + let args11!: [Fails.Fails]; + let _148!: Fails.Fails; + let _155!: string; + let _157!: Fails.Fails; + let _162!: Hex.Hex; + let _165!: Fails.Fails; + let start!: rt.usize; + let end!: rt.usize; + let _173!: [rt.usize, rt.usize]; + let _183!: string; + let _188!: Uint8Array; + let _192!: Uint8Array; + let buf!: Uint8Array; + let _202!: Uint8Array; + let _211!: string; + let args17!: [Uint8Array]; + let r4!: rt.Result; + let _221!: rt.Result; + let s!: string; + let _225!: rt.u8; + let e!: rt.FromUtf8Error; + let _232!: string; + let _234!: rt.u8; + let buf2!: Uint8Array; + let dest!: rt.usize; + let _244!: Uint8Array; + let _258!: string; + let args19!: [Uint8Array]; + let r5!: rt.Result; + let _274!: string; + let args21!: [rt.u8]; + let _279!: rt.u8; + n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); + _7 = rt.u8Rem(kind, 19); + if (_7 === 0) { rt.panicFmt(["bad ", (f: rt.Formatter) => rt.u8Display(n, f), ": ", (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]); - } else if (value === 1) { - const arg = { _0: n as rt.u32 }; - rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(n, f)), " ", (f: rt.Formatter) => Hex.fmt$Display(arg, f)]); - } else if (value === 2) { + } else if (_7 === 1) { + _23 = { _0: n as rt.u32 }; + rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(n, f)), " ", (f: rt.Formatter) => Hex.fmt$Display(_23, f)]); + } else if (_7 === 2) { if (!(n > 200)) { - const arg2 = { _0: n, _1: 0 }; - rt.panicFmt(["small ", (f: rt.Formatter) => rt.u8Display(n, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(arg2, f)]); + _37 = { _0: n, _1: 0 }; + rt.panicFmt(["small ", (f: rt.Formatter) => rt.u8Display(n, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(_37, f)]); } - } else if (value === 3) { + } else if (_7 === 3) { if (!(n > 200)) { rt.panic("assertion failed: n > 200"); } - } else if (value === 4) { - const value2 = [n, 7] as [rt.u8, rt.u8]; - const leftVal = value2[0]; - const rightVal = value2[1]; - if (leftVal !== rightVal) { - const kind2 = "=="; - rt.assertFailed(kind2, (f: rt.Formatter) => rt.u8Display(leftVal, f), (f: rt.Formatter) => rt.u8Display(rightVal, f)); + } else if (_7 === 4) { + if (!(n === 7)) { + rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(7, f), undefined); } - } else if (value === 5) { - const value3 = [{ _0: n, _1: 1 }, { _0: n, _1: 1 }] as [Pair.Pair, Pair.Pair]; - const leftVal2 = value3[0]; - const rightVal2 = value3[1]; - if (Pair.eq$PartialEq(leftVal2, rightVal2)) { - const kind3 = "!="; - rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(leftVal2, f), (f: rt.Formatter) => Pair.fmt$Debug(rightVal2, f), ["same ", (f: rt.Formatter) => rt.u8Display(n, f)]); + } else if (_7 === 5) { + _58 = { _0: n, _1: 1 }; + _60 = { _0: n, _1: 1 }; + if (Pair.eq$PartialEq(_58, _60)) { + kind3 = "!="; + args7 = [n] as [rt.u8]; + const arg6 = args7[0]; + _66 = ["same ", (f: rt.Formatter) => rt.u8Display(arg6, f)]; + rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(_58, f), (f: rt.Formatter) => Pair.fmt$Debug(_60, f), _66); } - } else if (value === 6) { - const value4 = [n, 9] as [rt.u8, rt.u8]; - const leftVal3 = value4[0]; - const rightVal3 = value4[1]; - if (leftVal3 !== rightVal3) { - const kind4 = "=="; - rt.assertFailed(kind4, (f: rt.Formatter) => rt.u8Display(leftVal3, f), (f: rt.Formatter) => rt.u8Display(rightVal3, f), ["with context"]); + } else if (_7 === 6) { + if (!(n === 9)) { + rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(9, f), ["with context"]); } - } else if (value === 7) { - const r = rt.u8Rem(n, 2) === 0 ? rt.Err({ tag: "One", _0: n } as Kind.Kind) : rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(Uint8Array.of(n)) } as Kind.Kind); - const arg4 = out; - const arg3 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)); - put(arg4, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg3, f))); - } else if (value === 8) { - const r2 = n > 128 ? rt.Ok(n) : rt.Err({ _0: n, _1: -2 }); - const arg6 = out; - const arg5 = rt.resultExpect(rt.copy(r2), "expected a byte", (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); - put(arg6, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg5, f))); - } else if (value === 9) { - const r3 = rt.Ok({ x: n as rt.i32, y: 0 }); - const arg8 = out; - const arg7 = rt.resultUnwrapErr(rt.copy(r3), (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f)); - put(arg8, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg7, f))); - } else if (value === 10) { - const missing = rt.sliceGet(rest, 200); - const arg10 = out; - const arg9 = rt.optionExpect(missing, rt.fmtFormat(["missing ", (f: rt.Formatter) => rt.u8Display(n, f)])); - put(arg10, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg9, f))); - } else if (value === 11) { - const arg12 = out; - const arg11 = { _0: n }; - put(arg12, rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg11, f)])); - } else if (value === 12) { - const arg14 = out; - const arg13 = { _0: n }; - put(arg14, rt.fmtToString((f: rt.Formatter) => Fails.fmt$Display(arg13, f))); - } else if (value === 13) { - const arg15 = { _0: n as rt.u32 }; - const arg16 = { _0: n }; - rt.panicFmt([(f: rt.Formatter) => Hex.fmt$Display(arg15, f), " then ", (f: rt.Formatter) => Fails.fmt$Display(arg16, f)]); - } else if (value === 14) { - const [start, end] = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize] as [rt.usize, rt.usize]; - const arg19 = out; - const arg17 = rt.sliceRange(rest, start); - const arg18 = rt.sliceRange(rest, start, end); - put(arg19, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg17, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(arg18, f, rt.u8Display)])); - } else if (value === 15) { - let buf: Uint8Array = rt.bytes(3); - rt.sliceCopyFromSlice(buf, rt.sliceRange(rest, 0, rt.min(rest.length, 4))); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(buf, f, rt.u8Display)])); - } else if (value === 16) { - let r4: rt.Result; - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(rest)); - if (fromUtf8.ok) { - const s = fromUtf8.value; - r4 = rt.Ok(rt.stringLen(s) & 0xff); + } else if (_7 === 7) { + if (rt.u8Rem(n, 2) === 0) { + r = rt.Err({ tag: "One", _0: n } as Kind.Kind); } else { - const e = fromUtf8.error; + _94 = Uint8Array.of(n); + r = rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(_94) } as Kind.Kind); + } + _100 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)); + _98 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_100, f)); + put(out, _98); + } else if (_7 === 8) { + if (!(n > 128)) { + r2 = rt.Err({ _0: n, _1: -2 }); + } else { + r2 = rt.Ok(n); + } + _110 = rt.resultExpect(r2, "expected a byte", (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); + _108 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_110, f)); + put(out, _108); + } else if (_7 === 9) { + _121 = rt.resultUnwrapErr(rt.Ok({ x: n as rt.i32, y: 0 }), (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f)); + _119 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_121, f)); + put(out, _119); + } else if (_7 === 10) { + missing = rt.sliceGet(rest, 200); + args9 = [n] as [rt.u8]; + const arg5 = args9[0]; + _132 = rt.fmtFormat(["missing ", (f: rt.Formatter) => rt.u8Display(arg5, f)]); + _129 = rt.optionExpect(missing, _132); + _127 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_129, f)); + put(out, _127); + } else if (_7 === 11) { + _148 = { _0: n }; + args11 = [_148] as [Fails.Fails]; + const arg4 = args11[0]; + _143 = rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg4, f)]); + put(out, _143); + } else if (_7 === 12) { + _157 = { _0: n }; + _155 = rt.fmtToString((f: rt.Formatter) => Fails.fmt$Display(_157, f)); + put(out, _155); + } else if (_7 === 13) { + _162 = { _0: n as rt.u32 }; + _165 = { _0: n }; + rt.panicFmt([(f: rt.Formatter) => Hex.fmt$Display(_162, f), " then ", (f: rt.Formatter) => Fails.fmt$Display(_165, f)]); + } else if (_7 === 14) { + _173 = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize] as [rt.usize, rt.usize]; + start = _173[0]; + end = _173[1]; + _188 = rt.sliceRange(rest, start); + _192 = rt.sliceRange(rest, start, end); + _183 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(_188, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(_192, f, rt.u8Display)]); + put(out, _183); + } else if (_7 === 15) { + buf = rt.bytes(3); + _202 = buf; + const part3 = rt.min(rest.length, 4); + rt.sliceCopyFromSlice(_202, rt.sliceRange(rest, 0, part3)); + args17 = [buf] as [Uint8Array]; + const arg3 = args17[0]; + _211 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]); + put(out, _211); + } else if (_7 === 16) { + _221 = rt.stringFromUtf8(rt.sliceToByteVec(rest)); + if (_221.ok) { + s = _221.value; + _225 = rt.stringLen(s) & 0xff; + r4 = rt.Ok(_225); + } else { + e = _221.error; r4 = rt.Err(e); } - const arg21 = out; - const arg20 = rt.resultUnwrap(r4, rt.fmtFromUtf8ErrorDebug); - put(arg21, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg20, f))); - } else if (value === 17) { - let buf2: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const dest = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); - rt.sliceCopyWithin(buf2, rt.u8Rem(n, 6) as rt.usize, rt.u8Rem(rt.u8Div(n, 6), 6) as rt.usize, dest); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(buf2, f, rt.u8Display)])); + _234 = rt.resultUnwrap(r4, rt.fmtFromUtf8ErrorDebug); + _232 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_234, f)); + put(out, _232); + } else if (_7 === 17) { + buf2 = Uint8Array.of(1, 2, 3, 4); + const part = rt.u8Rem(n, 6) as rt.usize; + const part2 = rt.u8Rem(rt.u8Div(n, 6), 6) as rt.usize; + dest = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); + _244 = buf2; + rt.sliceCopyWithin(_244, part, part2, dest); + args19 = [buf2] as [Uint8Array]; + const arg2 = args19[0]; + _258 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Display)]); + put(out, _258); } else { - const r5 = rt.u8Rem(n, 2) === 0 ? rt.Err(n) : rt.Ok(n); - const arg23 = out; - const arg22 = rt.resultUnwrapErr(r5, rt.u8Display); - put(arg23, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg22, f)])); + if (!(rt.u8Rem(n, 2) === 0)) { + r5 = rt.Ok(n); + } else { + r5 = rt.Err(n); + } + _279 = rt.resultUnwrapErr(r5, rt.u8Display); + args21 = [_279] as [rt.u8]; + const arg = args21[0]; + _274 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); + put(out, _274); } + return; } //# sourceMappingURL=fmt.ts.map diff --git a/ts/fixtures/lang/expected/generics.Either.ts b/ts/fixtures/lang/expected/generics.Either.ts index 9f8804208..f1e5f1a9a 100644 --- a/ts/fixtures/lang/expected/generics.Either.ts +++ b/ts/fixtures/lang/expected/generics.Either.ts @@ -4,81 +4,126 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug_Point_u8(self: Either, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: Point.Point; + let _5!: string; + let _6!: rt.Fmt; + let __self02!: rt.u8; + let _9!: string; + let _10!: string; + let _11!: rt.Fmt; if (self.tag === "Left") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Left"), (f: rt.Formatter) => Point.fmt$Debug(__self0, f))); + __self0 = self._0; + _5 = "Left"; + _6 = (f: rt.Formatter) => Point.fmt$Debug(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - const __self02 = self.value; - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, "Right"), "value", (f: rt.Formatter) => rt.u8Display(__self02, f))); + __self02 = self.value; + _9 = "Right"; + _10 = "value"; + _11 = (f: rt.Formatter) => rt.u8Display(__self02, f); + _0 = rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { - return rt.fmtWriteStr(f, "Neither"); + _0 = rt.fmtWriteStr(f, "Neither"); } + return _0; } export function fmt$Debug_u8_Point(self: Either, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: rt.u8; + let _5!: string; + let _6!: rt.Fmt; + let __self02!: Point.Point; + let _9!: string; + let _10!: string; + let _11!: rt.Fmt; if (self.tag === "Left") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Left"), (f: rt.Formatter) => rt.u8Display(__self0, f))); + __self0 = self._0; + _5 = "Left"; + _6 = (f: rt.Formatter) => rt.u8Display(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - const __self02 = self.value; - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, "Right"), "value", (f: rt.Formatter) => Point.fmt$Debug(__self02, f))); + __self02 = self.value; + _9 = "Right"; + _10 = "value"; + _11 = (f: rt.Formatter) => Point.fmt$Debug(__self02, f); + _0 = rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { - return rt.fmtWriteStr(f, "Neither"); + _0 = rt.fmtWriteStr(f, "Neither"); } + return _0; } export function fmt$Debug_u8_u16(self: Either, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self0!: rt.u8; + let _5!: string; + let _6!: rt.Fmt; + let __self02!: rt.u16; + let _9!: string; + let _10!: string; + let _11!: rt.Fmt; if (self.tag === "Left") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Left"), (f: rt.Formatter) => rt.u8Display(__self0, f))); + __self0 = self._0; + _5 = "Left"; + _6 = (f: rt.Formatter) => rt.u8Display(__self0, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - const __self02 = self.value; - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, "Right"), "value", (f: rt.Formatter) => rt.u16Display(__self02, f))); + __self02 = self.value; + _9 = "Right"; + _10 = "value"; + _11 = (f: rt.Formatter) => rt.u16Display(__self02, f); + _0 = rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { - return rt.fmtWriteStr(f, "Neither"); + _0 = rt.fmtWriteStr(f, "Neither"); } + return _0; } /** A generic enum, with a companion function per instance. */ export type Either = { tag: "Left"; _0: L } | { tag: "Right"; value: R } | { tag: "Neither" }; export function left$Point_u8(self: Either): Point.Point | undefined { + let _0!: Point.Point | undefined; if (self.tag === "Left") { - const l = rt.copy(self._0); - return rt.copy(l); + _0 = rt.copy(self._0); } else { - return undefined; + _0 = undefined; } + return _0; } export function left$u8_Point(self: Either): rt.u8 | undefined { + let _0!: rt.u8 | undefined; if (self.tag === "Left") { - const l = self._0; - return l; + _0 = self._0; } else { - return undefined; + _0 = undefined; } + return _0; } export function left$u8_u16(self: Either): rt.u8 | undefined { + let _0!: rt.u8 | undefined; if (self.tag === "Left") { - const l = self._0; - return l; + _0 = self._0; } else { - return undefined; + _0 = undefined; } + return _0; } export function flip$u8_Point(self: Either): Either { + let _0!: Either; if (self.tag === "Left") { - const l = self._0; - return { tag: "Right", value: l }; + _0 = { tag: "Right", value: self._0 } as Either; } else if (self.tag === "Right") { - const value = rt.copy(self.value); - return { tag: "Left", _0: rt.copy(value) }; + _0 = { tag: "Left", _0: self.value } as Either; } else { - return { tag: "Neither" }; + _0 = { tag: "Neither" } as Either; } + return _0; } //# sourceMappingURL=generics.Either.ts.map diff --git a/ts/fixtures/lang/expected/generics.Tagged.ts b/ts/fixtures/lang/expected/generics.Tagged.ts index 10a8f9f21..f709cbd22 100644 --- a/ts/fixtures/lang/expected/generics.Tagged.ts +++ b/ts/fixtures/lang/expected/generics.Tagged.ts @@ -5,7 +5,23 @@ import * as Either from "./generics.Either.ts"; import * as Wrap from "./generics.Wrap.ts"; export function fmt$Debug_Either_u8_u16_i16(self: Tagged, rt.i16>, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Tagged"), "key", (f: rt.Formatter) => Either.fmt$Debug_u8_u16(self.key, f)), "inner", (f: rt.Formatter) => Wrap.fmt$Debug_i16(self.inner, f)), "all", (f: rt.Formatter) => rt.fmtList(self.all, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f)))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: string; + let _11!: rt.Fmt; + let _13!: Wrap.Wrap[]; + _5 = (f: rt.Formatter) => Either.fmt$Debug_u8_u16(self.key, f); + _8 = (f: rt.Formatter) => Wrap.fmt$Debug_i16(self.inner, f); + _13 = self.all; + _3 = "Tagged"; + _4 = "key"; + _7 = "inner"; + _10 = "all"; + _11 = (f: rt.Formatter) => rt.fmtList(_13, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f)); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } /** Two parameters, one nested in another generic type. */ diff --git a/ts/fixtures/lang/expected/generics.Wrap.ts b/ts/fixtures/lang/expected/generics.Wrap.ts index 97bc4b801..2e5230c67 100644 --- a/ts/fixtures/lang/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/expected/generics.Wrap.ts @@ -7,43 +7,157 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$Debug_Option_u8(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Display)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Display); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Pair(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => Pair.fmt$Debug(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => Pair.fmt$Debug(self.value, f); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Point(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => Point.fmt$Debug(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => Point.fmt$Debug(self.value, f); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Result_u8_Shape(self: Wrap>, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.fmtResult(self.value, f, rt.u8Display, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$Debug(value, f))), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => rt.fmtResult(self.value, f, rt.u8Display, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$Debug(value, f)); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Shape(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => Shape.fmt$Debug(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => Shape.fmt$Debug(self.value, f); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Vec_u16(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.fmtList(self.value, f, rt.u16Display)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => rt.fmtList(self.value, f, rt.u16Display); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Wrap_Pair(self: Wrap>, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => fmt$Debug_Pair(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => fmt$Debug_Pair(self.value, f); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_i16(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.i16Display(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => rt.i16Display(self.value, f); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_u8(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.u8Display(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.u8; + _5 = (f: rt.Formatter) => rt.u8Display(self.value, f); + _10 = self.count; + _3 = "Wrap"; + _4 = "value"; + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$PartialEq_Pair(self: Wrap, other: Wrap): boolean { - return self.count === other.count && Pair.eq$PartialEq(self.value, other.value); + let _0!: boolean; + if (!(self.count === other.count)) { + _0 = false; + } else { + _0 = Pair.eq$PartialEq(self.value, other.value); + } + return _0; } /** A generic struct, with methods on every instance, on some, and on one. */ @@ -62,11 +176,11 @@ export function new$Option_u8(value: rt.u8 | undefined): Wrap } export function new$Pair(value: Pair.Pair): Wrap { - return new Wrap({ value: rt.copy(value), count: 0 }); + return new Wrap({ value, count: 0 }); } export function new$Point(value: Point.Point): Wrap { - return new Wrap({ value: rt.copy(value), count: 0 }); + return new Wrap({ value, count: 0 }); } export function new$Shape(value: Shape.Shape): Wrap { @@ -74,7 +188,7 @@ export function new$Shape(value: Shape.Shape): Wrap { } export function new$Wrap_Pair(value: Wrap): Wrap> { - return new Wrap({ value: rt.copy(value), count: 0 }); + return new Wrap({ value, count: 0 }); } export function new$i16(value: rt.i16): Wrap { @@ -102,22 +216,28 @@ export function get$u8(self: Wrap): rt.u8 { } export function bump$Point(self: Wrap): rt.u8 { - self.count = rt.u8WrappingAdd(self.count, 1); + let _2!: rt.u8; + _2 = rt.u8WrappingAdd(self.count, 1); + self.count = _2; return self.count; } export function bump$Vec_u16(self: Wrap): rt.u8 { - self.count = rt.u8WrappingAdd(self.count, 1); + let _2!: rt.u8; + _2 = rt.u8WrappingAdd(self.count, 1); + self.count = _2; return self.count; } export function bump$u8(self: Wrap): rt.u8 { - self.count = rt.u8WrappingAdd(self.count, 1); + let _2!: rt.u8; + _2 = rt.u8WrappingAdd(self.count, 1); + self.count = _2; return self.count; } export function intoInner$Point(self: Wrap): Point.Point { - return rt.copy(self.value); + return self.value; } /** A method with its own type parameter. */ @@ -147,14 +267,20 @@ export function area$Area_Shape(self: Wrap): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area_Meters(self: Wrap, out: rt.ByteVec): void { + let _7!: Uint8Array; rt.byteVecPush(out, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area_Meters(self))); + _7 = rt.u64ToBeBytes(area$Area_Meters(self)); + rt.byteVecExtendFromSlice(out, _7); + return; } /** A default method, monomorphized for each type. */ export function describe$Area_Shape(self: Wrap, out: rt.ByteVec): void { + let _7!: Uint8Array; rt.byteVecPush(out, 4); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area_Shape(self))); + _7 = rt.u64ToBeBytes(area$Area_Shape(self)); + rt.byteVecExtendFromSlice(out, _7); + return; } //# sourceMappingURL=generics.Wrap.ts.map diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 3dbb9be39..532fb5e2b 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -6,60 +6,115 @@ import type * as Pair from "./fmt.Pair.ts"; import * as Either from "./generics.Either.ts"; import * as Tagged from "./generics.Tagged.ts"; import * as Wrap from "./generics.Wrap.ts"; +import type * as Meters from "./shapes.Meters.ts"; import * as Point from "./shapes.Point.ts"; import type * as Shape from "./shapes.Shape.ts"; /** Each method once per instance: `Wrap` of a struct, an enum, a number, and itself. */ export function methods(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let point!: Wrap.Wrap; + let byte!: Wrap.Wrap; + let nested!: Wrap.Wrap>; + let meters!: Wrap.Wrap; + let shape!: Wrap.Wrap; + let _46!: string; + let _64!: string; + let args3!: [Wrap.Wrap>]; + let _76!: Uint8Array; + let _91!: Uint8Array; + let _97!: Uint8Array; + let mapped!: Wrap.Wrap; + let _111!: string; + let _116!: boolean; + let _119!: Wrap.Wrap; + let iter!: rt.Iter>; + let _140!: Either.Either | rt.Done; + let either!: Either.Either; + let flipped!: Either.Either; + let _148!: string; + let _153!: rt.u8 | undefined; + let _156!: Point.Point | undefined; + let list!: Wrap.Wrap; + let _171!: rt.u16; + let none!: Wrap.Wrap; + let some!: Wrap.Wrap; + let err!: Wrap.Wrap>; + let _188!: string; + let _193!: rt.u8; + let tagged!: Tagged.Tagged, rt.i16>; + let _212!: Wrap.Wrap; + let _222!: Wrap.Wrap[]; + let _232!: string; + let _237!: Wrap.Wrap | undefined; + let _248!: Uint8Array; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - let point: Wrap.Wrap = Wrap.new$Point({ x: at(0) as rt.i32, y: -2 }); + point = rt.copy(Wrap.new$Point({ x: at(0) as rt.i32, y: -2 })); Wrap.bump$Point(point); - let byte: Wrap.Wrap = Wrap.new$u8(at(1)); + byte = rt.copy(Wrap.new$u8(at(1))); Wrap.bump$u8(byte); Wrap.bump$u8(byte); - const nested = Wrap.new$Wrap_Pair(Wrap.new$Pair({ _0: at(2), _1: -3 })); - const meters = new Wrap.Wrap({ value: { _0: at(3) as rt.u64 }, count: at(4) }); - const shape = Wrap.new$Shape({ tag: "Rect", corner: Wrap.intoInner$Point(rt.copy(point)), width: at(5) as rt.u16, height: 3 }); - put(out, rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f))])); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(Wrap.double$u8(byte))); + nested = Wrap.new$Wrap_Pair(Wrap.new$Pair({ _0: at(2), _1: -3 })); + meters = new Wrap.Wrap({ value: { _0: at(3) as rt.u64 }, count: at(4) }); + shape = Wrap.new$Shape({ tag: "Rect", corner: Wrap.intoInner$Point(point), width: at(5) as rt.u16, height: 3 } as Shape.Shape); + _46 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)]); + put(out, _46); + args3 = [nested] as [Wrap.Wrap>]; + const arg = args3[0]; + _64 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(arg, f))]); + put(out, _64); + _76 = rt.u16ToBeBytes(Wrap.double$u8(byte)); + rt.byteVecExtendFromSlice(out, _76); rt.byteVecPush(out, Wrap.get$u8(byte)); rt.byteVecPush(out, Wrap.get$Pair(Wrap.get$Wrap_Pair(nested))._0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Meters(meters))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Shape(shape))); + _91 = rt.u64ToBeBytes(Wrap.scaled$Meters(meters)); + rt.byteVecExtendFromSlice(out, _91); + _97 = rt.u64ToBeBytes(Wrap.scaled$Shape(shape)); + rt.byteVecExtendFromSlice(out, _97); Wrap.describe$Area_Meters(meters, out); Wrap.describe$Area_Shape(shape, out); - const mapped = Wrap.map$u8_Pair_methods_closure1(rt.copy(byte), (b: rt.u8): Pair.Pair => { + mapped = Wrap.map$u8_Pair_methods_closure1(byte, (b: rt.u8): Pair.Pair => { return { _0: b, _1: at(6) as rt.i64 }; }); - const arg2 = out; - const arg = Wrap.eq$PartialEq_Pair(mapped, Wrap.new$Pair({ _0: at(1), _1: 0 })); - put(arg2, rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Pair(mapped, f), " ", (f: rt.Formatter) => rt.fmtBool(arg, f)])); - const eithers = [{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either]; - for (const either of rt.copy(eithers)) { - const flipped = Either.flip$u8_Point(either); - const arg5 = out; - const arg3 = Either.left$u8_Point(either); - const arg4 = Either.left$Point_u8(flipped); - put(arg5, rt.fmtFormat([(f: rt.Formatter) => Either.fmt$Debug_u8_Point(either, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Either.fmt$Debug_Point_u8(flipped, f)), " ", (f: rt.Formatter) => rt.fmtOption(arg3, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(arg4, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))])); + _119 = Wrap.new$Pair({ _0: at(1), _1: 0 }); + _116 = Wrap.eq$PartialEq_Pair(mapped, _119); + _111 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Pair(mapped, f), " ", (f: rt.Formatter) => rt.fmtBool(_116, f)]); + put(out, _111); + iter = rt.iterSlice([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either]); + while (true) { + _140 = iter.next(); + if (_140 === rt.DONE) { + list = new Wrap.Wrap({ value: [], count: 1 }); + _171 = at(10) as rt.u16; + list.value.push(_171); + Wrap.bump$Vec_u16(list); + none = new Wrap.Wrap({ value: undefined, count: 0 }); + some = Wrap.new$Option_u8(rt.sliceGet(data, 11)); + err = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); + _193 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); + _188 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), " ", (f: rt.Formatter) => rt.u8Display(_193, f)]); + put(out, _188); + _212 = Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)); + _222 = [Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]; + tagged = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: _212, all: rt.sliceToVec(_222) }); + _237 = Tagged.first$Either_u8_u16_i16(tagged); + _232 = rt.fmtFormat([(f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f), " ", (f: rt.Formatter) => rt.fmtOption(_237, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]); + put(out, _232); + _248 = rt.i16ToBeBytes(tagged.inner.value); + rt.byteVecExtendFromSlice(out, _248); + rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); + return; + } else { + either = _140; + flipped = Either.flip$u8_Point(either); + _153 = Either.left$u8_Point(either); + _156 = Either.left$Point_u8(flipped); + _148 = rt.fmtFormat([(f: rt.Formatter) => Either.fmt$Debug_u8_Point(either, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Either.fmt$Debug_Point_u8(flipped, f)), " ", (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(_156, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))]); + put(out, _148); + } } - let list: Wrap.Wrap = new Wrap.Wrap({ value: [], count: 1 }); - list.value.push(at(10) as rt.u16); - Wrap.bump$Vec_u16(list); - const none = new Wrap.Wrap({ value: undefined, count: 0 }); - const some = Wrap.new$Option_u8(rt.sliceGet(data, 11)); - const err = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); - const arg7 = out; - const arg6 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); - put(arg7, rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), " ", (f: rt.Formatter) => rt.u8Display(arg6, f)])); - const tagged = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), all: rt.sliceToVec([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]) }); - const arg9 = out; - const arg8 = Tagged.first$Either_u8_u16_i16(tagged); - put(arg9, rt.fmtFormat([(f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f), " ", (f: rt.Formatter) => rt.fmtOption(arg8, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))])); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); - rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); } //# sourceMappingURL=generics.ts.map diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index bde574814..4a263de42 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -9,105 +9,112 @@ import { copies, order, discriminants, loops, patterns, closures, library } from /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { - let out: rt.ByteVec = new rt.ByteVec(); + let _0!: rt.ByteVec; + let out!: rt.ByteVec; + let op!: rt.u8; + let kind!: rt.u8; + let _10!: [rt.u8, rt.u8]; + let _14!: rt.u8; + let _28!: rt.u8; + let _36!: [rt.u8, Uint8Array] | undefined; + out = new rt.ByteVec(); if (!(input.length >= 2)) { - return out; - } - const op = input[0]; - const kind = input[1]; - const data = input.subarray(2, input.length - 0); - const [op2, kind2] = [op, kind] as [rt.u8, rt.u8]; - const value = rt.u8Rem(op2, 34); - if (value === 0) { - u8Op(kind2, data, out); - } else if (value === 1) { - u16Op(kind2, data, out); - } else if (value === 2) { - u32Op(kind2, data, out); - } else if (value === 3) { - u64Op(kind2, data, out); - } else if (value === 4) { - u128Op(kind2, data, out); - } else if (value === 5) { - usizeOp(kind2, data, out); - } else if (value === 6) { - i8Op(kind2, data, out); - } else if (value === 7) { - i16Op(kind2, data, out); - } else if (value === 8) { - i32Op(kind2, data, out); - } else if (value === 9) { - i64Op(kind2, data, out); - } else if (value === 10) { - i128Op(kind2, data, out); - } else if (value === 11) { - isizeOp(kind2, data, out); - } else if (value === 12) { - const value2 = rt.u8Rem(kind2, 6); - if (value2 === 0) { - i8Neg(data, out); - } else if (value2 === 1) { - i16Neg(data, out); - } else if (value2 === 2) { - i32Neg(data, out); - } else if (value2 === 3) { - i64Neg(data, out); - } else if (value2 === 4) { - i128Neg(data, out); - } else { - isizeNeg(data, out); - } - } else if (value === 13) { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst !== undefined) { - const to = splitFirst[0]; - const data2 = splitFirst[1]; - cast(kind2, to, data2, out); + _0 = out; + } else { + _10 = [input[0], input[1]] as [rt.u8, rt.u8]; + op = _10[0]; + kind = _10[1]; + _14 = rt.u8Rem(op, 34); + if (_14 === 0) { + u8Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 1) { + u16Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 2) { + u32Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 3) { + u64Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 4) { + u128Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 5) { + usizeOp(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 6) { + i8Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 7) { + i16Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 8) { + i32Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 9) { + i64Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 10) { + i128Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 11) { + isizeOp(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 12) { + _28 = rt.u8Rem(kind, 6); + if (_28 === 0) { + i8Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 1) { + i16Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 2) { + i32Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 3) { + i64Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 4) { + i128Neg(input.subarray(2, input.length - 0), out); + } else { + isizeNeg(input.subarray(2, input.length - 0), out); + } + } else if (_14 === 13) { + _36 = rt.sliceSplitFirst(input.subarray(2, input.length - 0)); + if (_36 === undefined) { + cast(kind, rt.u8Div(kind, 12), input.subarray(2, input.length - 0), out); + } else { + cast(kind, _36[0], _36[1], out); + } + } else if (_14 === 14) { + convert(input.subarray(2, input.length - 0), out); + } else if (_14 === 15) { + copies(input.subarray(2, input.length - 0), out); + } else if (_14 === 16) { + loops(input.subarray(2, input.length - 0), out); + } else if (_14 === 17) { + patterns(input.subarray(2, input.length - 0), out); + } else if (_14 === 18) { + closures(input.subarray(2, input.length - 0), out); + } else if (_14 === 19) { + discriminants(input.subarray(2, input.length - 0), out); + } else if (_14 === 20) { + library(input.subarray(2, input.length - 0), out); + } else if (_14 === 21) { + ints(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 22) { + strings(input.subarray(2, input.length - 0), out); + } else if (_14 === 23) { + derived(input.subarray(2, input.length - 0), out); + } else if (_14 === 24) { + written(input.subarray(2, input.length - 0), out); + } else if (_14 === 25) { + panics(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 26) { + methods(input.subarray(2, input.length - 0), out); + } else if (_14 === 27) { + adaptors(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 28) { + consumers(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 29) { + ranges(input.subarray(2, input.length - 0), out); + } else if (_14 === 30) { + options(input.subarray(2, input.length - 0), out); + } else if (_14 === 31) { + own(input.subarray(2, input.length - 0), out); + } else if (_14 === 32) { + values(input.subarray(2, input.length - 0), out); } else { - cast(kind2, rt.u8Div(kind2, 12), data, out); + order(input.subarray(2, input.length - 0), out); } - } else if (value === 14) { - convert(data, out); - } else if (value === 15) { - copies(data, out); - } else if (value === 16) { - loops(data, out); - } else if (value === 17) { - patterns(data, out); - } else if (value === 18) { - closures(data, out); - } else if (value === 19) { - discriminants(data, out); - } else if (value === 20) { - library(data, out); - } else if (value === 21) { - ints(kind2, data, out); - } else if (value === 22) { - strings(data, out); - } else if (value === 23) { - derived(data, out); - } else if (value === 24) { - written(data, out); - } else if (value === 25) { - panics(kind2, data, out); - } else if (value === 26) { - methods(data, out); - } else if (value === 27) { - adaptors(kind2, data, out); - } else if (value === 28) { - consumers(kind2, data, out); - } else if (value === 29) { - ranges(data, out); - } else if (value === 30) { - options(data, out); - } else if (value === 31) { - own(data, out); - } else if (value === 32) { - values(data, out); - } else { - order(data, out); + _0 = out; } - return out; + return _0; } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 66cb0cb96..d9a4917f5 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -4,358 +4,551 @@ import * as rt from "./rt.ts"; /** Apply operation `op` to operands taken from `data`. */ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u8, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(1); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u8FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u8, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 8)); - const put = (out2: rt.ByteVec, v: rt.u8): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + let a!: rt.u8; + let _6!: [rt.u8, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u8; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u8; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u8) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void; + let _52!: rt.u8; + let _117!: Uint8Array; + let _121!: Uint8Array; + let x!: rt.u8; + _50 = (out2: rt.ByteVec, v: rt.u8): void => { + let _7!: Uint8Array; + _7 = rt.u128ToBeBytes(v as rt.u128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { + let v3!: rt.u8; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.u128ToBeBytes(v3 as rt.u128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u8Add(a, b)); - } else if (value === 1) { - put(out, rt.u8Sub(a, b)); - } else if (value === 2) { - put(out, rt.u8Mul(a, b)); - } else if (value === 3) { - put(out, rt.u8Div(a, b)); - } else if (value === 4) { - put(out, rt.u8Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.u8Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u8Shr(a, shift)); - } else if (value === 10) { - put(out, ~a & 0xff); - } else if (value === 11) { - putOpt(out, rt.u8CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u8CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u8CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u8SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u8SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u8WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u8WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u8, Uint8Array]; + a = _6[0]; + buf2 = Uint8Array.of(0); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u8FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u8, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 8); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.u8Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u8Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u8Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u8Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u8Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.u8Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u8Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a & 0xff); + } else if (_52 === 11) { + const part9 = rt.u8CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u8CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u8CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u8SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u8SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u8WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u8WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _117 = rt.u32ToBeBytes(rt.u8LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _117); + } else if (_52 === 19) { + _121 = rt.u32ToBeBytes(rt.u8LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _121); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u8WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.u8 = a; + x = a; x = rt.u8Add(x, b); x = rt.u8Sub(x, 1); x = rt.u8Mul(x, 2); - x = rt.u8Shr(x, 1); - x = rt.u8Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; + x = x >> 1; + x = (x << 1) & 0xff; + x = x | (1 << 3); x = x ^ b; - const value3 = ~(1 << 2) & 0xff; - x = x & value3; - put(out, x); + x = x & (~(1 << 2) & 0xff); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(2); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u16FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u16, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u16FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u16, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 16)); - const put = (out2: rt.ByteVec, v: rt.u16): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + let a!: rt.u16; + let _6!: [rt.u16, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u16; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u16) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u16 | undefined) => void; + let _52!: rt.u8; + let _117!: Uint8Array; + let _121!: Uint8Array; + let x!: rt.u16; + _50 = (out2: rt.ByteVec, v: rt.u16): void => { + let _7!: Uint8Array; + _7 = rt.u128ToBeBytes(v as rt.u128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { + let v3!: rt.u16; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.u128ToBeBytes(v3 as rt.u128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u16Add(a, b)); - } else if (value === 1) { - put(out, rt.u16Sub(a, b)); - } else if (value === 2) { - put(out, rt.u16Mul(a, b)); - } else if (value === 3) { - put(out, rt.u16Div(a, b)); - } else if (value === 4) { - put(out, rt.u16Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.u16Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u16Shr(a, shift)); - } else if (value === 10) { - put(out, ~a & 0xffff); - } else if (value === 11) { - putOpt(out, rt.u16CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u16CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u16CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u16SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u16SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u16WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u16WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = rt.bytes(2); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u16, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(2); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u16FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u16, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 16); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.u16Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u16Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u16Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u16Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u16Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.u16Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u16Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a & 0xffff); + } else if (_52 === 11) { + const part9 = rt.u16CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u16CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u16CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u16SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u16SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u16WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u16WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _117 = rt.u32ToBeBytes(rt.u16LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _117); + } else if (_52 === 19) { + _121 = rt.u32ToBeBytes(rt.u16LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _121); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u16WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.u16 = a; + x = a; x = rt.u16Add(x, b); x = rt.u16Sub(x, 1); x = rt.u16Mul(x, 2); - x = rt.u16Shr(x, 1); - x = rt.u16Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; + x = x >> 1; + x = (x << 1) & 0xffff; + x = x | (1 << 3); x = x ^ b; - const value3 = ~(1 << 2) & 0xffff; - x = x & value3; - put(out, x); + x = x & (~(1 << 2) & 0xffff); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u32FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u32, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u32FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u32, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.u32): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + let a!: rt.u32; + let _6!: [rt.u32, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u32; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u32; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u32) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u32 | undefined) => void; + let _52!: rt.u8; + let _117!: Uint8Array; + let _121!: Uint8Array; + let x!: rt.u32; + _50 = (out2: rt.ByteVec, v: rt.u32): void => { + let _7!: Uint8Array; + _7 = rt.u128ToBeBytes(v as rt.u128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { + let v3!: rt.u32; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.u128ToBeBytes(v3 as rt.u128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u32Add(a, b)); - } else if (value === 1) { - put(out, rt.u32Sub(a, b)); - } else if (value === 2) { - put(out, rt.u32Mul(a, b)); - } else if (value === 3) { - put(out, rt.u32Div(a, b)); - } else if (value === 4) { - put(out, rt.u32Rem(a, b)); - } else if (value === 5) { - put(out, (a & b) >>> 0); - } else if (value === 6) { - put(out, (a | b) >>> 0); - } else if (value === 7) { - put(out, (a ^ b) >>> 0); - } else if (value === 8) { - put(out, rt.u32Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u32Shr(a, shift)); - } else if (value === 10) { - put(out, ~a >>> 0); - } else if (value === 11) { - putOpt(out, rt.u32CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u32CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u32CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u32SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u32SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u32WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u32WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u32, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u32FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u32, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 32); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.u32Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u32Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u32Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u32Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u32Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, (a & b) >>> 0); + } else if (_52 === 6) { + _50(out, (a | b) >>> 0); + } else if (_52 === 7) { + _50(out, (a ^ b) >>> 0); + } else if (_52 === 8) { + const part11 = rt.u32Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u32Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a >>> 0); + } else if (_52 === 11) { + const part9 = rt.u32CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u32CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u32CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u32SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u32SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u32WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u32WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _117 = rt.u32ToBeBytes(rt.u32LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _117); + } else if (_52 === 19) { + _121 = rt.u32ToBeBytes(rt.u32LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _121); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u32WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.u32 = a; + x = a; x = rt.u32Add(x, b); x = rt.u32Sub(x, 1); x = rt.u32Mul(x, 2); - x = rt.u32Shr(x, 1); - x = rt.u32Shl(x, 1); - const value2 = 1 << 3; - x = (x | value2) >>> 0; + x = x >>> 1; + x = (x << 1) >>> 0; + x = (x | (1 << 3)) >>> 0; x = (x ^ b) >>> 0; - const value3 = ~(1 << 2) >>> 0; - x = (x & value3) >>> 0; - put(out, x); + x = (x & (~(1 << 2) >>> 0)) >>> 0; + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u64, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(8); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u64FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u64, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 64)); - const put = (out2: rt.ByteVec, v: rt.u64): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(rt.u128Cast(v))); + let a!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u64; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u64; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u64) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u64 | undefined) => void; + let _52!: rt.u8; + let _117!: Uint8Array; + let _121!: Uint8Array; + let x!: rt.u64; + _50 = (out2: rt.ByteVec, v: rt.u64): void => { + let _7!: Uint8Array; + _7 = rt.u128ToBeBytes(rt.u128Cast(v)); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(rt.u128Cast(v3))); - } else { + _51 = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { + let v3!: rt.u64; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.u128ToBeBytes(rt.u128Cast(v3)); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u64Add(a, b)); - } else if (value === 1) { - put(out, rt.u64Sub(a, b)); - } else if (value === 2) { - put(out, rt.u64Mul(a, b)); - } else if (value === 3) { - put(out, rt.u64Div(a, b)); - } else if (value === 4) { - put(out, rt.u64Rem(a, b)); - } else if (value === 5) { - put(out, rt.u64And(a, b)); - } else if (value === 6) { - put(out, rt.u64Or(a, b)); - } else if (value === 7) { - put(out, rt.u64Xor(a, b)); - } else if (value === 8) { - put(out, rt.u64Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u64Shr(a, shift)); - } else if (value === 10) { - put(out, rt.u64Not(a)); - } else if (value === 11) { - putOpt(out, rt.u64CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u64CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u64CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u64SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u64SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u64WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u64WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.u64Max(a, b)); - } else if (value === 21) { - put(out, rt.u64Min(a, b)); - } else if (value === 22) { + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(8); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u64FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u64, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 64); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.u64Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u64Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u64Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u64Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u64Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.u64And(a, b)); + } else if (_52 === 6) { + _50(out, rt.u64Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.u64Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.u64Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u64Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.u64Not(a)); + } else if (_52 === 11) { + const part9 = rt.u64CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u64CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u64CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u64SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u64SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u64WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u64WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _117 = rt.u32ToBeBytes(rt.u64LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _117); + } else if (_52 === 19) { + _121 = rt.u32ToBeBytes(rt.u64LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _121); + } else if (_52 === 20) { + const part2 = rt.u64Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.u64Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.u64Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.u64 = a; + x = a; x = rt.u64Add(x, b); x = rt.u64Sub(x, 1); x = rt.u64Mul(x, 2); @@ -363,550 +556,855 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.u64Shl(x, 1); x = rt.u64Or(x, 8); x = rt.u64Xor(x, b); - const value2 = rt.u64Not(4); - x = rt.u64And(x, value2); - put(out, x); + x = rt.u64And(x, rt.u64Not(4)); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(16); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u128FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u128, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(16); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u128FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u128, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 128)); - const put = (out2: rt.ByteVec, v: rt.u128): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v)); + let a!: rt.u128; + let _6!: [rt.u128, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u128; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u128; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u128) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u128 | undefined) => void; + let _52!: rt.u8; + let _117!: Uint8Array; + let _121!: Uint8Array; + let x!: rt.u128; + _50 = (out2: rt.ByteVec, v: rt.u128): void => { + let _7!: Uint8Array; + _7 = rt.u128ToBeBytes(v); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { + let v3!: rt.u128; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.u128ToBeBytes(v3); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u128Add(a, b)); - } else if (value === 1) { - put(out, rt.u128Sub(a, b)); - } else if (value === 2) { - put(out, rt.u128Mul(a, b)); - } else if (value === 3) { - put(out, rt.u128Div(a, b)); - } else if (value === 4) { - put(out, rt.u128Rem(a, b)); - } else if (value === 5) { - put(out, rt.u128And(a, b)); - } else if (value === 6) { - put(out, rt.u128Or(a, b)); - } else if (value === 7) { - put(out, rt.u128Xor(a, b)); - } else if (value === 8) { - put(out, rt.u128Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u128Shr(a, shift)); - } else if (value === 10) { - put(out, rt.u128Not(a)); - } else if (value === 11) { - putOpt(out, rt.u128CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u128CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u128CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u128SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u128SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u128WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u128WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.u128Max(a, b)); - } else if (value === 21) { - put(out, rt.u128Min(a, b)); - } else if (value === 22) { + buf = rt.bytes(16); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u128, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(16); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u128FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u128, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 128); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.u128Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u128Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u128Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u128Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u128Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.u128And(a, b)); + } else if (_52 === 6) { + _50(out, rt.u128Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.u128Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.u128Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u128Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.u128Not(a)); + } else if (_52 === 11) { + const part9 = rt.u128CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u128CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u128CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u128SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u128SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u128WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u128WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _117 = rt.u32ToBeBytes(rt.u128LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _117); + } else if (_52 === 19) { + _121 = rt.u32ToBeBytes(rt.u128LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _121); + } else if (_52 === 20) { + const part2 = rt.u128Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.u128Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.u128Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.u128 = a; + x = a; x = rt.u128Add(x, b); x = rt.u128Sub(x, 1); x = rt.u128Mul(x, 2); x = rt.u128Shr(x, 1); x = rt.u128Shl(x, 1); - const value2 = rt.u128Shl(1, 3); - x = rt.u128Or(x, value2); + x = rt.u128Or(x, rt.u128Shl(1, 3)); x = rt.u128Xor(x, b); - const value3 = rt.u128Not(rt.u128Shl(1, 2)); - x = rt.u128And(x, value3); - put(out, x); + x = rt.u128And(x, rt.u128Not(rt.u128Shl(1, 2))); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.usizeFromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.usize, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.usizeFromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.usize, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.usize): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + let a!: rt.usize; + let _6!: [rt.usize, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.usize; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.usize; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.usize) => void; + let _51!: (a0: rt.ByteVec, a1: rt.usize | undefined) => void; + let _52!: rt.u8; + let _117!: Uint8Array; + let _121!: Uint8Array; + let x!: rt.usize; + _50 = (out2: rt.ByteVec, v: rt.usize): void => { + let _7!: Uint8Array; + _7 = rt.u128ToBeBytes(v as rt.u128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { + let v3!: rt.usize; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.u128ToBeBytes(v3 as rt.u128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.usizeAdd(a, b)); - } else if (value === 1) { - put(out, rt.usizeSub(a, b)); - } else if (value === 2) { - put(out, rt.usizeMul(a, b)); - } else if (value === 3) { - put(out, rt.usizeDiv(a, b)); - } else if (value === 4) { - put(out, rt.usizeRem(a, b)); - } else if (value === 5) { - put(out, (a & b) >>> 0); - } else if (value === 6) { - put(out, (a | b) >>> 0); - } else if (value === 7) { - put(out, (a ^ b) >>> 0); - } else if (value === 8) { - put(out, rt.usizeShl(a, shift)); - } else if (value === 9) { - put(out, rt.usizeShr(a, shift)); - } else if (value === 10) { - put(out, ~a >>> 0); - } else if (value === 11) { - putOpt(out, rt.usizeCheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.usizeCheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.usizeCheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.usizeSaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.usizeSaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.usizeWrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.usizeWrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.usizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.usize, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.usizeFromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.usize, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 32); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.usizeAdd(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.usizeSub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.usizeMul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.usizeDiv(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.usizeRem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, (a & b) >>> 0); + } else if (_52 === 6) { + _50(out, (a | b) >>> 0); + } else if (_52 === 7) { + _50(out, (a ^ b) >>> 0); + } else if (_52 === 8) { + const part11 = rt.usizeShl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.usizeShr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a >>> 0); + } else if (_52 === 11) { + const part9 = rt.usizeCheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.usizeCheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.usizeCheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.usizeSaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.usizeSaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.usizeWrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.usizeWrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _117 = rt.u32ToBeBytes(rt.usizeLeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _117); + } else if (_52 === 19) { + _121 = rt.u32ToBeBytes(rt.usizeLeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _121); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.usizeWrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.usize = a; + x = a; x = rt.usizeAdd(x, b); x = rt.usizeSub(x, 1); x = rt.usizeMul(x, 2); - x = rt.usizeShr(x, 1); - x = rt.usizeShl(x, 1); - const value2 = 1 << 3; - x = (x | value2) >>> 0; + x = x >>> 1; + x = (x << 1) >>> 0; + x = (x | (1 << 3)) >>> 0; x = (x ^ b) >>> 0; - const value3 = ~(1 << 2) >>> 0; - x = (x & value3) >>> 0; - put(out, x); + x = (x & (~(1 << 2) >>> 0)) >>> 0; + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i8, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(1); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i8FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i8, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 8)); - const put = (out2: rt.ByteVec, v: rt.i8): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + let a!: rt.i8; + let _6!: [rt.i8, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i8; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i8; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i8) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i8 | undefined) => void; + let _52!: rt.u8; + let _123!: Uint8Array; + let _127!: Uint8Array; + let x!: rt.i8; + _50 = (out2: rt.ByteVec, v: rt.i8): void => { + let _7!: Uint8Array; + _7 = rt.i128ToBeBytes(v as rt.i128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { + let v3!: rt.i8; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.i128ToBeBytes(v3 as rt.i128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i8Add(a, b)); - } else if (value === 1) { - put(out, rt.i8Sub(a, b)); - } else if (value === 2) { - put(out, rt.i8Mul(a, b)); - } else if (value === 3) { - put(out, rt.i8Div(a, b)); - } else if (value === 4) { - put(out, rt.i8Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.i8Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i8Shr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.i8CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i8CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i8CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i8SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i8SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i8WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i8WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array]; + a = _6[0]; + buf2 = Uint8Array.of(0); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i8FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i8, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 8); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.i8Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i8Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i8Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + b === -1; + a === -128; + const part13 = rt.i8Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + b === -1; + a === -128; + const part12 = rt.i8Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.i8Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i8Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.i8CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i8CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i8CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i8SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i8SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i8WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i8WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _123 = rt.u32ToBeBytes(rt.i8LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _123); + } else if (_52 === 19) { + _127 = rt.u32ToBeBytes(rt.i8LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _127); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i8WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.i8 = a; + x = a; x = rt.i8Add(x, b); x = rt.i8Sub(x, 1); x = rt.i8Mul(x, 2); - x = rt.i8Shr(x, 1); - x = rt.i8Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; + x = x >> 1; + x = (x << 1 << 24) >> 24; + x = x | (1 << 3); x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x = x & ~(1 << 2); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(2); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i16FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i16, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i16FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i16, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 16)); - const put = (out2: rt.ByteVec, v: rt.i16): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + let a!: rt.i16; + let _6!: [rt.i16, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i16; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i16) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i16 | undefined) => void; + let _52!: rt.u8; + let _123!: Uint8Array; + let _127!: Uint8Array; + let x!: rt.i16; + _50 = (out2: rt.ByteVec, v: rt.i16): void => { + let _7!: Uint8Array; + _7 = rt.i128ToBeBytes(v as rt.i128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { + let v3!: rt.i16; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.i128ToBeBytes(v3 as rt.i128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i16Add(a, b)); - } else if (value === 1) { - put(out, rt.i16Sub(a, b)); - } else if (value === 2) { - put(out, rt.i16Mul(a, b)); - } else if (value === 3) { - put(out, rt.i16Div(a, b)); - } else if (value === 4) { - put(out, rt.i16Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.i16Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i16Shr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.i16CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i16CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i16CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i16SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i16SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i16WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i16WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = rt.bytes(2); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(2); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i16FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i16, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 16); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.i16Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i16Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i16Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + b === -1; + a === -32768; + const part13 = rt.i16Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + b === -1; + a === -32768; + const part12 = rt.i16Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.i16Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i16Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.i16CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i16CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i16CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i16SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i16SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i16WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i16WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _123 = rt.u32ToBeBytes(rt.i16LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _123); + } else if (_52 === 19) { + _127 = rt.u32ToBeBytes(rt.i16LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _127); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i16WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.i16 = a; + x = a; x = rt.i16Add(x, b); x = rt.i16Sub(x, 1); x = rt.i16Mul(x, 2); - x = rt.i16Shr(x, 1); - x = rt.i16Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; + x = x >> 1; + x = (x << 1 << 16) >> 16; + x = x | (1 << 3); x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x = x & ~(1 << 2); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i32FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i32, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i32FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i32, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.i32): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + let a!: rt.i32; + let _6!: [rt.i32, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i32; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i32; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i32) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i32 | undefined) => void; + let _52!: rt.u8; + let _123!: Uint8Array; + let _127!: Uint8Array; + let x!: rt.i32; + _50 = (out2: rt.ByteVec, v: rt.i32): void => { + let _7!: Uint8Array; + _7 = rt.i128ToBeBytes(v as rt.i128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { + let v3!: rt.i32; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.i128ToBeBytes(v3 as rt.i128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i32Add(a, b)); - } else if (value === 1) { - put(out, rt.i32Sub(a, b)); - } else if (value === 2) { - put(out, rt.i32Mul(a, b)); - } else if (value === 3) { - put(out, rt.i32Div(a, b)); - } else if (value === 4) { - put(out, rt.i32Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.i32Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i32Shr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.i32CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i32CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i32CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i32SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i32SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i32WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i32WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i32FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 32); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.i32Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i32Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i32Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + b === -1; + a === -2147483648; + const part13 = rt.i32Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + b === -1; + a === -2147483648; + const part12 = rt.i32Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.i32Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i32Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.i32CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i32CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i32CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i32SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i32SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i32WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i32WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _123 = rt.u32ToBeBytes(rt.i32LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _123); + } else if (_52 === 19) { + _127 = rt.u32ToBeBytes(rt.i32LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _127); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i32WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.i32 = a; + x = a; x = rt.i32Add(x, b); x = rt.i32Sub(x, 1); x = rt.i32Mul(x, 2); - x = rt.i32Shr(x, 1); - x = rt.i32Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; + x = x >> 1; + x = (x << 1) | 0; + x = x | (1 << 3); x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x = x & ~(1 << 2); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i64, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(8); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i64FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i64, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 64)); - const put = (out2: rt.ByteVec, v: rt.i64): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(rt.i128Cast(v))); + let a!: rt.i64; + let _6!: [rt.i64, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i64; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i64; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i64) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i64 | undefined) => void; + let _52!: rt.u8; + let _123!: Uint8Array; + let _127!: Uint8Array; + let x!: rt.i64; + _50 = (out2: rt.ByteVec, v: rt.i64): void => { + let _7!: Uint8Array; + _7 = rt.i128ToBeBytes(rt.i128Cast(v)); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(rt.i128Cast(v3))); - } else { + _51 = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { + let v3!: rt.i64; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.i128ToBeBytes(rt.i128Cast(v3)); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i64Add(a, b)); - } else if (value === 1) { - put(out, rt.i64Sub(a, b)); - } else if (value === 2) { - put(out, rt.i64Mul(a, b)); - } else if (value === 3) { - put(out, rt.i64Div(a, b)); - } else if (value === 4) { - put(out, rt.i64Rem(a, b)); - } else if (value === 5) { - put(out, rt.i64And(a, b)); - } else if (value === 6) { - put(out, rt.i64Or(a, b)); - } else if (value === 7) { - put(out, rt.i64Xor(a, b)); - } else if (value === 8) { - put(out, rt.i64Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i64Shr(a, shift)); - } else if (value === 10) { - put(out, rt.i64Not(a)); - } else if (value === 11) { - putOpt(out, rt.i64CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i64CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i64CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i64SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i64SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i64WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i64WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.i64Max(a, b)); - } else if (value === 21) { - put(out, rt.i64Min(a, b)); - } else if (value === 22) { + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(8); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i64FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i64, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 64); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.i64Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i64Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i64Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + b === -1; + rt.i64Eq(a, rt.i64Of(-9223372036854775808n)); + const part13 = rt.i64Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + b === -1; + rt.i64Eq(a, rt.i64Of(-9223372036854775808n)); + const part12 = rt.i64Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.i64And(a, b)); + } else if (_52 === 6) { + _50(out, rt.i64Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.i64Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.i64Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i64Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.i64Not(a)); + } else if (_52 === 11) { + const part9 = rt.i64CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i64CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i64CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i64SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i64SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i64WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i64WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _123 = rt.u32ToBeBytes(rt.i64LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _123); + } else if (_52 === 19) { + _127 = rt.u32ToBeBytes(rt.i64LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _127); + } else if (_52 === 20) { + const part2 = rt.i64Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.i64Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.i64Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.i64 = a; + x = a; x = rt.i64Add(x, b); x = rt.i64Sub(x, 1); x = rt.i64Mul(x, 2); @@ -914,1000 +1412,1931 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.i64Shl(x, 1); x = rt.i64Or(x, 8); x = rt.i64Xor(x, b); - const value2 = rt.i64Not(4); - x = rt.i64And(x, value2); - put(out, x); + x = rt.i64And(x, rt.i64Not(4)); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(16); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i128FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i128, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(16); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i128FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i128, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 128)); - const put = (out2: rt.ByteVec, v: rt.i128): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v)); + let a!: rt.i128; + let _6!: [rt.i128, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i128; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i128; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i128) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i128 | undefined) => void; + let _52!: rt.u8; + let _123!: Uint8Array; + let _127!: Uint8Array; + let x!: rt.i128; + _50 = (out2: rt.ByteVec, v: rt.i128): void => { + let _7!: Uint8Array; + _7 = rt.i128ToBeBytes(v); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { + let v3!: rt.i128; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.i128ToBeBytes(v3); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i128Add(a, b)); - } else if (value === 1) { - put(out, rt.i128Sub(a, b)); - } else if (value === 2) { - put(out, rt.i128Mul(a, b)); - } else if (value === 3) { - put(out, rt.i128Div(a, b)); - } else if (value === 4) { - put(out, rt.i128Rem(a, b)); - } else if (value === 5) { - put(out, rt.i128And(a, b)); - } else if (value === 6) { - put(out, rt.i128Or(a, b)); - } else if (value === 7) { - put(out, rt.i128Xor(a, b)); - } else if (value === 8) { - put(out, rt.i128Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i128Shr(a, shift)); - } else if (value === 10) { - put(out, rt.i128Not(a)); - } else if (value === 11) { - putOpt(out, rt.i128CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i128CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i128CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i128SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i128SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i128WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i128WrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.i128Max(a, b)); - } else if (value === 21) { - put(out, rt.i128Min(a, b)); - } else if (value === 22) { + buf = rt.bytes(16); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(16); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i128FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i128, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 128); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.i128Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i128Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i128Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + b === -1; + rt.i128Eq(a, rt.i128Of(-170141183460469231731687303715884105728n)); + const part13 = rt.i128Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + b === -1; + rt.i128Eq(a, rt.i128Of(-170141183460469231731687303715884105728n)); + const part12 = rt.i128Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.i128And(a, b)); + } else if (_52 === 6) { + _50(out, rt.i128Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.i128Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.i128Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i128Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.i128Not(a)); + } else if (_52 === 11) { + const part9 = rt.i128CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i128CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i128CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i128SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i128SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i128WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i128WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _123 = rt.u32ToBeBytes(rt.i128LeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _123); + } else if (_52 === 19) { + _127 = rt.u32ToBeBytes(rt.i128LeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _127); + } else if (_52 === 20) { + const part2 = rt.i128Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.i128Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.i128Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128WrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.i128 = a; + x = a; x = rt.i128Add(x, b); x = rt.i128Sub(x, 1); x = rt.i128Mul(x, 2); x = rt.i128Shr(x, 1); x = rt.i128Shl(x, 1); - const value2 = rt.i128Shl(1, 3); - x = rt.i128Or(x, value2); + x = rt.i128Or(x, rt.i128Shl(1, 3)); x = rt.i128Xor(x, b); - const value3 = rt.i128Not(rt.i128Shl(1, 2)); - x = rt.i128And(x, value3); - put(out, x); + x = rt.i128And(x, rt.i128Not(rt.i128Shl(1, 2))); + _50(out, x); } + return; } /** Apply operation `op` to operands taken from `data`. */ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.isizeFromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.isize, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.isizeFromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.isize, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.isize): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + let a!: rt.isize; + let _6!: [rt.isize, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.isize; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.isize; + let shift!: rt.u32; + let _43!: rt.u32; + let _47!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.isize) => void; + let _51!: (a0: rt.ByteVec, a1: rt.isize | undefined) => void; + let _52!: rt.u8; + let _123!: Uint8Array; + let _127!: Uint8Array; + let x!: rt.isize; + _50 = (out2: rt.ByteVec, v: rt.isize): void => { + let _7!: Uint8Array; + _7 = rt.i128ToBeBytes(v as rt.i128); + rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); + return; }; - const putOpt = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { + _51 = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { + let v3!: rt.isize; + let _106!: Uint8Array; + if (v2 === undefined) { rt.byteVecPush(out3, 0); + } else { + v3 = v2; + rt.byteVecPush(out3, 1); + _106 = rt.i128ToBeBytes(v3 as rt.i128); + rt.byteVecExtendFromSlice(out3, _106); } + return; }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.isizeAdd(a, b)); - } else if (value === 1) { - put(out, rt.isizeSub(a, b)); - } else if (value === 2) { - put(out, rt.isizeMul(a, b)); - } else if (value === 3) { - put(out, rt.isizeDiv(a, b)); - } else if (value === 4) { - put(out, rt.isizeRem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.isizeShl(a, shift)); - } else if (value === 9) { - put(out, rt.isizeShr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.isizeCheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.isizeCheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.isizeCheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.isizeSaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.isizeSaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.isizeWrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.isizeWrappingSub(a, b)); - } else if (value === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingOnes(a))); - } else if (value === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.isizeFromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.isize, Uint8Array]; + b = _38; + _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; + _47 = rt.u32Mul(2, 32); + shift = rt.u32Rem(_43, _47); + _52 = rt.u8Rem(op, 24); + if (_52 === 0) { + const part16 = rt.isizeAdd(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.isizeSub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.isizeMul(a, b); + _50(out, part14); + } else if (_52 === 3) { + b === -1; + a === -2147483648; + const part13 = rt.isizeDiv(a, b); + _50(out, part13); + } else if (_52 === 4) { + b === -1; + a === -2147483648; + const part12 = rt.isizeRem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.isizeShl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.isizeShr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.isizeCheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.isizeCheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.isizeCheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.isizeSaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.isizeSaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.isizeWrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.isizeWrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { + _123 = rt.u32ToBeBytes(rt.isizeLeadingOnes(a)); + rt.byteVecExtendFromSlice(out, _123); + } else if (_52 === 19) { + _127 = rt.u32ToBeBytes(rt.isizeLeadingZeros(a)); + rt.byteVecExtendFromSlice(out, _127); + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.isizeWrappingSub(a, b) === 0 ? 1 : 0); } else { - let x: rt.isize = a; + x = a; x = rt.isizeAdd(x, b); x = rt.isizeSub(x, 1); x = rt.isizeMul(x, 2); - x = rt.isizeShr(x, 1); - x = rt.isizeShl(x, 1); - const value2 = 1 << 3; - x = x | value2; + x = x >> 1; + x = (x << 1) | 0; + x = x | (1 << 3); x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x = x & ~(1 << 2); + _50(out, x); } + return; } /** Negate, which overflows at the minimum. */ export function i8Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i8, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128)); + let a!: rt.i8; + let buf!: Uint8Array; + let n!: rt.usize; + let _24!: Uint8Array; + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + a = ([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]; + _24 = rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128); + rt.byteVecExtendFromSlice(out, _24); + return; } /** Negate, which overflows at the minimum. */ export function i16Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(2); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i16FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i16, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128)); + let a!: rt.i16; + let buf!: Uint8Array; + let n!: rt.usize; + let _24!: Uint8Array; + buf = rt.bytes(2); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + a = ([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]; + _24 = rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128); + rt.byteVecExtendFromSlice(out, _24); + return; } /** Negate, which overflows at the minimum. */ export function i32Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i32FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i32, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128)); + let a!: rt.i32; + let buf!: Uint8Array; + let n!: rt.usize; + let _24!: Uint8Array; + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + a = ([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]; + _24 = rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128); + rt.byteVecExtendFromSlice(out, _24); + return; } /** Negate, which overflows at the minimum. */ export function i64Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i64, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a)))); + let a!: rt.i64; + let buf!: Uint8Array; + let n!: rt.usize; + let _24!: Uint8Array; + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + a = ([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0]; + _24 = rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a))); + rt.byteVecExtendFromSlice(out, _24); + return; } /** Negate, which overflows at the minimum. */ export function i128Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(16); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i128FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i128, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(a))); + let a!: rt.i128; + let buf!: Uint8Array; + let n!: rt.usize; + let _24!: Uint8Array; + buf = rt.bytes(16); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + a = ([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]; + _24 = rt.i128ToBeBytes(rt.i128Neg(a)); + rt.byteVecExtendFromSlice(out, _24); + return; } /** Negate, which overflows at the minimum. */ export function isizeNeg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.isizeFromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.isize, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128)); + let a!: rt.isize; + let buf!: Uint8Array; + let n!: rt.usize; + let _24!: Uint8Array; + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + a = ([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]; + _24 = rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128); + rt.byteVecExtendFromSlice(out, _24); + return; } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(from, 12); - if (value === 0) { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const v = ([rt.u8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u8, Uint8Array])[0]; - const out2 = out; - const value2 = rt.u8Rem(to, 12); - if (value2 === 0) { - const v2 = v; - rt.byteVecExtendFromSlice(out2, rt.u8ToBeBytes(v2)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)))); - } else if (value2 === 1) { - const v3 = v as rt.u16; - rt.byteVecExtendFromSlice(out2, rt.u16ToBeBytes(v3)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)))); - } else if (value2 === 2) { - const v4 = v as rt.u32; - rt.byteVecExtendFromSlice(out2, rt.u32ToBeBytes(v4)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)))); - } else if (value2 === 3) { - const v5 = v as rt.u64; - rt.byteVecExtendFromSlice(out2, rt.u64ToBeBytes(v5)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)))); - } else if (value2 === 4) { - const v6 = v as rt.u128; - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v6)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)))); - } else if (value2 === 5) { - const v7 = v as rt.usize; - rt.byteVecExtendFromSlice(out2, rt.usizeToBeBytes(v7)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)))); - } else if (value2 === 6) { - const v8 = (v << 24) >> 24; - rt.byteVecExtendFromSlice(out2, rt.i8ToBeBytes(v8)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)))); - } else if (value2 === 7) { - const v9 = v as rt.i16; - rt.byteVecExtendFromSlice(out2, rt.i16ToBeBytes(v9)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)))); - } else if (value2 === 8) { - const v10 = v as rt.i32; - rt.byteVecExtendFromSlice(out2, rt.i32ToBeBytes(v10)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)))); - } else if (value2 === 9) { - const v11 = v as rt.i64; - rt.byteVecExtendFromSlice(out2, rt.i64ToBeBytes(v11)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)))); - } else if (value2 === 10) { - const v12 = v as rt.i128; - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v12)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)))); + let _5!: rt.u8; + let v!: rt.u8; + let buf!: Uint8Array; + let n!: rt.usize; + let _25!: rt.u8; + let v2!: rt.u8; + let _31!: Uint8Array; + let _35!: string; + let v3!: rt.u16; + let _41!: Uint8Array; + let _45!: string; + let v4!: rt.u32; + let _51!: Uint8Array; + let _55!: string; + let v5!: rt.u64; + let _61!: Uint8Array; + let _65!: string; + let v6!: rt.u128; + let _71!: Uint8Array; + let _75!: string; + let v7!: rt.usize; + let _81!: Uint8Array; + let _85!: string; + let v8!: rt.i8; + let _91!: Uint8Array; + let _95!: string; + let v9!: rt.i16; + let _101!: Uint8Array; + let _105!: string; + let v10!: rt.i32; + let _111!: Uint8Array; + let _115!: string; + let v11!: rt.i64; + let _121!: Uint8Array; + let _125!: string; + let v12!: rt.i128; + let _131!: Uint8Array; + let _135!: string; + let v13!: rt.isize; + let _141!: Uint8Array; + let _145!: string; + let v14!: rt.u16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _165!: rt.u8; + let v15!: rt.u8; + let _171!: Uint8Array; + let _175!: string; + let v16!: rt.u16; + let _181!: Uint8Array; + let _185!: string; + let v17!: rt.u32; + let _191!: Uint8Array; + let _195!: string; + let v18!: rt.u64; + let _201!: Uint8Array; + let _205!: string; + let v19!: rt.u128; + let _211!: Uint8Array; + let _215!: string; + let v20!: rt.usize; + let _221!: Uint8Array; + let _225!: string; + let v21!: rt.i8; + let _231!: Uint8Array; + let _235!: string; + let v22!: rt.i16; + let _241!: Uint8Array; + let _245!: string; + let v23!: rt.i32; + let _251!: Uint8Array; + let _255!: string; + let v24!: rt.i64; + let _261!: Uint8Array; + let _265!: string; + let v25!: rt.i128; + let _271!: Uint8Array; + let _275!: string; + let v26!: rt.isize; + let _281!: Uint8Array; + let _285!: string; + let v27!: rt.u32; + let buf3!: Uint8Array; + let n3!: rt.usize; + let _305!: rt.u8; + let v28!: rt.u8; + let _311!: Uint8Array; + let _315!: string; + let v29!: rt.u16; + let _321!: Uint8Array; + let _325!: string; + let v30!: rt.u32; + let _331!: Uint8Array; + let _335!: string; + let v31!: rt.u64; + let _341!: Uint8Array; + let _345!: string; + let v32!: rt.u128; + let _351!: Uint8Array; + let _355!: string; + let v33!: rt.usize; + let _361!: Uint8Array; + let _365!: string; + let v34!: rt.i8; + let _371!: Uint8Array; + let _375!: string; + let v35!: rt.i16; + let _381!: Uint8Array; + let _385!: string; + let v36!: rt.i32; + let _391!: Uint8Array; + let _395!: string; + let v37!: rt.i64; + let _401!: Uint8Array; + let _405!: string; + let v38!: rt.i128; + let _411!: Uint8Array; + let _415!: string; + let v39!: rt.isize; + let _421!: Uint8Array; + let _425!: string; + let v40!: rt.u64; + let buf4!: Uint8Array; + let n4!: rt.usize; + let _445!: rt.u8; + let v41!: rt.u8; + let _451!: Uint8Array; + let _455!: string; + let v42!: rt.u16; + let _461!: Uint8Array; + let _465!: string; + let v43!: rt.u32; + let _471!: Uint8Array; + let _475!: string; + let v44!: rt.u64; + let _481!: Uint8Array; + let _485!: string; + let v45!: rt.u128; + let _491!: Uint8Array; + let _495!: string; + let v46!: rt.usize; + let _501!: Uint8Array; + let _505!: string; + let v47!: rt.i8; + let _511!: Uint8Array; + let _515!: string; + let v48!: rt.i16; + let _521!: Uint8Array; + let _525!: string; + let v49!: rt.i32; + let _531!: Uint8Array; + let _535!: string; + let v50!: rt.i64; + let _541!: Uint8Array; + let _545!: string; + let v51!: rt.i128; + let _551!: Uint8Array; + let _555!: string; + let v52!: rt.isize; + let _561!: Uint8Array; + let _565!: string; + let v53!: rt.u128; + let buf5!: Uint8Array; + let n5!: rt.usize; + let _585!: rt.u8; + let v54!: rt.u8; + let _591!: Uint8Array; + let _595!: string; + let v55!: rt.u16; + let _601!: Uint8Array; + let _605!: string; + let v56!: rt.u32; + let _611!: Uint8Array; + let _615!: string; + let v57!: rt.u64; + let _621!: Uint8Array; + let _625!: string; + let v58!: rt.u128; + let _631!: Uint8Array; + let _635!: string; + let v59!: rt.usize; + let _641!: Uint8Array; + let _645!: string; + let v60!: rt.i8; + let _651!: Uint8Array; + let _655!: string; + let v61!: rt.i16; + let _661!: Uint8Array; + let _665!: string; + let v62!: rt.i32; + let _671!: Uint8Array; + let _675!: string; + let v63!: rt.i64; + let _681!: Uint8Array; + let _685!: string; + let v64!: rt.i128; + let _691!: Uint8Array; + let _695!: string; + let v65!: rt.isize; + let _701!: Uint8Array; + let _705!: string; + let v66!: rt.usize; + let buf6!: Uint8Array; + let n6!: rt.usize; + let _725!: rt.u8; + let v67!: rt.u8; + let _731!: Uint8Array; + let _735!: string; + let v68!: rt.u16; + let _741!: Uint8Array; + let _745!: string; + let v69!: rt.u32; + let _751!: Uint8Array; + let _755!: string; + let v70!: rt.u64; + let _761!: Uint8Array; + let _765!: string; + let v71!: rt.u128; + let _771!: Uint8Array; + let _775!: string; + let v72!: rt.usize; + let _781!: Uint8Array; + let _785!: string; + let v73!: rt.i8; + let _791!: Uint8Array; + let _795!: string; + let v74!: rt.i16; + let _801!: Uint8Array; + let _805!: string; + let v75!: rt.i32; + let _811!: Uint8Array; + let _815!: string; + let v76!: rt.i64; + let _821!: Uint8Array; + let _825!: string; + let v77!: rt.i128; + let _831!: Uint8Array; + let _835!: string; + let v78!: rt.isize; + let _841!: Uint8Array; + let _845!: string; + let v79!: rt.i8; + let buf7!: Uint8Array; + let n7!: rt.usize; + let _865!: rt.u8; + let v80!: rt.u8; + let _871!: Uint8Array; + let _875!: string; + let v81!: rt.u16; + let _881!: Uint8Array; + let _885!: string; + let v82!: rt.u32; + let _891!: Uint8Array; + let _895!: string; + let v83!: rt.u64; + let _901!: Uint8Array; + let _905!: string; + let v84!: rt.u128; + let _911!: Uint8Array; + let _915!: string; + let v85!: rt.usize; + let _921!: Uint8Array; + let _925!: string; + let v86!: rt.i8; + let _931!: Uint8Array; + let _935!: string; + let v87!: rt.i16; + let _941!: Uint8Array; + let _945!: string; + let v88!: rt.i32; + let _951!: Uint8Array; + let _955!: string; + let v89!: rt.i64; + let _961!: Uint8Array; + let _965!: string; + let v90!: rt.i128; + let _971!: Uint8Array; + let _975!: string; + let v91!: rt.isize; + let _981!: Uint8Array; + let _985!: string; + let v92!: rt.i16; + let buf8!: Uint8Array; + let n8!: rt.usize; + let _1005!: rt.u8; + let v93!: rt.u8; + let _1011!: Uint8Array; + let _1015!: string; + let v94!: rt.u16; + let _1021!: Uint8Array; + let _1025!: string; + let v95!: rt.u32; + let _1031!: Uint8Array; + let _1035!: string; + let v96!: rt.u64; + let _1041!: Uint8Array; + let _1045!: string; + let v97!: rt.u128; + let _1051!: Uint8Array; + let _1055!: string; + let v98!: rt.usize; + let _1061!: Uint8Array; + let _1065!: string; + let v99!: rt.i8; + let _1071!: Uint8Array; + let _1075!: string; + let v100!: rt.i16; + let _1081!: Uint8Array; + let _1085!: string; + let v101!: rt.i32; + let _1091!: Uint8Array; + let _1095!: string; + let v102!: rt.i64; + let _1101!: Uint8Array; + let _1105!: string; + let v103!: rt.i128; + let _1111!: Uint8Array; + let _1115!: string; + let v104!: rt.isize; + let _1121!: Uint8Array; + let _1125!: string; + let v105!: rt.i32; + let buf9!: Uint8Array; + let n9!: rt.usize; + let _1145!: rt.u8; + let v106!: rt.u8; + let _1151!: Uint8Array; + let _1155!: string; + let v107!: rt.u16; + let _1161!: Uint8Array; + let _1165!: string; + let v108!: rt.u32; + let _1171!: Uint8Array; + let _1175!: string; + let v109!: rt.u64; + let _1181!: Uint8Array; + let _1185!: string; + let v110!: rt.u128; + let _1191!: Uint8Array; + let _1195!: string; + let v111!: rt.usize; + let _1201!: Uint8Array; + let _1205!: string; + let v112!: rt.i8; + let _1211!: Uint8Array; + let _1215!: string; + let v113!: rt.i16; + let _1221!: Uint8Array; + let _1225!: string; + let v114!: rt.i32; + let _1231!: Uint8Array; + let _1235!: string; + let v115!: rt.i64; + let _1241!: Uint8Array; + let _1245!: string; + let v116!: rt.i128; + let _1251!: Uint8Array; + let _1255!: string; + let v117!: rt.isize; + let _1261!: Uint8Array; + let _1265!: string; + let v118!: rt.i64; + let buf10!: Uint8Array; + let n10!: rt.usize; + let _1285!: rt.u8; + let v119!: rt.u8; + let _1291!: Uint8Array; + let _1295!: string; + let v120!: rt.u16; + let _1301!: Uint8Array; + let _1305!: string; + let v121!: rt.u32; + let _1311!: Uint8Array; + let _1315!: string; + let v122!: rt.u64; + let _1321!: Uint8Array; + let _1325!: string; + let v123!: rt.u128; + let _1331!: Uint8Array; + let _1335!: string; + let v124!: rt.usize; + let _1341!: Uint8Array; + let _1345!: string; + let v125!: rt.i8; + let _1351!: Uint8Array; + let _1355!: string; + let v126!: rt.i16; + let _1361!: Uint8Array; + let _1365!: string; + let v127!: rt.i32; + let _1371!: Uint8Array; + let _1375!: string; + let v128!: rt.i64; + let _1381!: Uint8Array; + let _1385!: string; + let v129!: rt.i128; + let _1391!: Uint8Array; + let _1395!: string; + let v130!: rt.isize; + let _1401!: Uint8Array; + let _1405!: string; + let v131!: rt.i128; + let buf11!: Uint8Array; + let n11!: rt.usize; + let _1425!: rt.u8; + let v132!: rt.u8; + let _1431!: Uint8Array; + let _1435!: string; + let v133!: rt.u16; + let _1441!: Uint8Array; + let _1445!: string; + let v134!: rt.u32; + let _1451!: Uint8Array; + let _1455!: string; + let v135!: rt.u64; + let _1461!: Uint8Array; + let _1465!: string; + let v136!: rt.u128; + let _1471!: Uint8Array; + let _1475!: string; + let v137!: rt.usize; + let _1481!: Uint8Array; + let _1485!: string; + let v138!: rt.i8; + let _1491!: Uint8Array; + let _1495!: string; + let v139!: rt.i16; + let _1501!: Uint8Array; + let _1505!: string; + let v140!: rt.i32; + let _1511!: Uint8Array; + let _1515!: string; + let v141!: rt.i64; + let _1521!: Uint8Array; + let _1525!: string; + let v142!: rt.i128; + let _1531!: Uint8Array; + let _1535!: string; + let v143!: rt.isize; + let _1541!: Uint8Array; + let _1545!: string; + let v144!: rt.isize; + let buf12!: Uint8Array; + let n12!: rt.usize; + let _1565!: rt.u8; + let v145!: rt.u8; + let _1571!: Uint8Array; + let _1575!: string; + let v146!: rt.u16; + let _1581!: Uint8Array; + let _1585!: string; + let v147!: rt.u32; + let _1591!: Uint8Array; + let _1595!: string; + let v148!: rt.u64; + let _1601!: Uint8Array; + let _1605!: string; + let v149!: rt.u128; + let _1611!: Uint8Array; + let _1615!: string; + let v150!: rt.usize; + let _1621!: Uint8Array; + let _1625!: string; + let v151!: rt.i8; + let _1631!: Uint8Array; + let _1635!: string; + let v152!: rt.i16; + let _1641!: Uint8Array; + let _1645!: string; + let v153!: rt.i32; + let _1651!: Uint8Array; + let _1655!: string; + let v154!: rt.i64; + let _1661!: Uint8Array; + let _1665!: string; + let v155!: rt.i128; + let _1671!: Uint8Array; + let _1675!: string; + let v156!: rt.isize; + let _1681!: Uint8Array; + let _1685!: string; + _5 = rt.u8Rem(from, 12); + if (_5 === 0) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + v = ([rt.u8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u8, Uint8Array])[0]; + _25 = rt.u8Rem(to, 12); + if (_25 === 0) { + v2 = v; + _31 = rt.u8ToBeBytes(v2); + rt.byteVecExtendFromSlice(out, _31); + _35 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_35)); + } else if (_25 === 1) { + v3 = v as rt.u16; + _41 = rt.u16ToBeBytes(v3); + rt.byteVecExtendFromSlice(out, _41); + _45 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_45)); + } else if (_25 === 2) { + v4 = v as rt.u32; + _51 = rt.u32ToBeBytes(v4); + rt.byteVecExtendFromSlice(out, _51); + _55 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_55)); + } else if (_25 === 3) { + v5 = v as rt.u64; + _61 = rt.u64ToBeBytes(v5); + rt.byteVecExtendFromSlice(out, _61); + _65 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_65)); + } else if (_25 === 4) { + v6 = v as rt.u128; + _71 = rt.u128ToBeBytes(v6); + rt.byteVecExtendFromSlice(out, _71); + _75 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_75)); + } else if (_25 === 5) { + v7 = v as rt.usize; + _81 = rt.usizeToBeBytes(v7); + rt.byteVecExtendFromSlice(out, _81); + _85 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_85)); + } else if (_25 === 6) { + v8 = (v << 24) >> 24; + _91 = rt.i8ToBeBytes(v8); + rt.byteVecExtendFromSlice(out, _91); + _95 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_95)); + } else if (_25 === 7) { + v9 = v as rt.i16; + _101 = rt.i16ToBeBytes(v9); + rt.byteVecExtendFromSlice(out, _101); + _105 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_105)); + } else if (_25 === 8) { + v10 = v as rt.i32; + _111 = rt.i32ToBeBytes(v10); + rt.byteVecExtendFromSlice(out, _111); + _115 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_115)); + } else if (_25 === 9) { + v11 = v as rt.i64; + _121 = rt.i64ToBeBytes(v11); + rt.byteVecExtendFromSlice(out, _121); + _125 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_125)); + } else if (_25 === 10) { + v12 = v as rt.i128; + _131 = rt.i128ToBeBytes(v12); + rt.byteVecExtendFromSlice(out, _131); + _135 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_135)); } else { - const v13 = v as rt.isize; - rt.byteVecExtendFromSlice(out2, rt.isizeToBeBytes(v13)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)))); + v13 = v as rt.isize; + _141 = rt.isizeToBeBytes(v13); + rt.byteVecExtendFromSlice(out, _141); + _145 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_145)); } - } else if (value === 1) { - const data3 = data; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data3.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data3, 0, n2)); - const v14 = ([rt.u16FromBeBytes(buf2), rt.sliceRange(data3, n2)] as [rt.u16, Uint8Array])[0]; - const out3 = out; - const value3 = rt.u8Rem(to, 12); - if (value3 === 0) { - const v15 = v14 & 0xff; - rt.byteVecExtendFromSlice(out3, rt.u8ToBeBytes(v15)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)))); - } else if (value3 === 1) { - const v16 = v14; - rt.byteVecExtendFromSlice(out3, rt.u16ToBeBytes(v16)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)))); - } else if (value3 === 2) { - const v17 = v14 as rt.u32; - rt.byteVecExtendFromSlice(out3, rt.u32ToBeBytes(v17)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)))); - } else if (value3 === 3) { - const v18 = v14 as rt.u64; - rt.byteVecExtendFromSlice(out3, rt.u64ToBeBytes(v18)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)))); - } else if (value3 === 4) { - const v19 = v14 as rt.u128; - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v19)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)))); - } else if (value3 === 5) { - const v20 = v14 as rt.usize; - rt.byteVecExtendFromSlice(out3, rt.usizeToBeBytes(v20)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)))); - } else if (value3 === 6) { - const v21 = (v14 << 24) >> 24; - rt.byteVecExtendFromSlice(out3, rt.i8ToBeBytes(v21)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)))); - } else if (value3 === 7) { - const v22 = (v14 << 16) >> 16; - rt.byteVecExtendFromSlice(out3, rt.i16ToBeBytes(v22)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)))); - } else if (value3 === 8) { - const v23 = v14 as rt.i32; - rt.byteVecExtendFromSlice(out3, rt.i32ToBeBytes(v23)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)))); - } else if (value3 === 9) { - const v24 = v14 as rt.i64; - rt.byteVecExtendFromSlice(out3, rt.i64ToBeBytes(v24)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)))); - } else if (value3 === 10) { - const v25 = v14 as rt.i128; - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v25)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)))); + } else if (_5 === 1) { + buf2 = rt.bytes(2); + n2 = rt.min(data.length, buf2.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); + v14 = ([rt.u16FromBeBytes(buf2), rt.sliceRange(data, n2)] as [rt.u16, Uint8Array])[0]; + _165 = rt.u8Rem(to, 12); + if (_165 === 0) { + v15 = v14 & 0xff; + _171 = rt.u8ToBeBytes(v15); + rt.byteVecExtendFromSlice(out, _171); + _175 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_175)); + } else if (_165 === 1) { + v16 = v14; + _181 = rt.u16ToBeBytes(v16); + rt.byteVecExtendFromSlice(out, _181); + _185 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_185)); + } else if (_165 === 2) { + v17 = v14 as rt.u32; + _191 = rt.u32ToBeBytes(v17); + rt.byteVecExtendFromSlice(out, _191); + _195 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_195)); + } else if (_165 === 3) { + v18 = v14 as rt.u64; + _201 = rt.u64ToBeBytes(v18); + rt.byteVecExtendFromSlice(out, _201); + _205 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_205)); + } else if (_165 === 4) { + v19 = v14 as rt.u128; + _211 = rt.u128ToBeBytes(v19); + rt.byteVecExtendFromSlice(out, _211); + _215 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_215)); + } else if (_165 === 5) { + v20 = v14 as rt.usize; + _221 = rt.usizeToBeBytes(v20); + rt.byteVecExtendFromSlice(out, _221); + _225 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_225)); + } else if (_165 === 6) { + v21 = (v14 << 24) >> 24; + _231 = rt.i8ToBeBytes(v21); + rt.byteVecExtendFromSlice(out, _231); + _235 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_235)); + } else if (_165 === 7) { + v22 = (v14 << 16) >> 16; + _241 = rt.i16ToBeBytes(v22); + rt.byteVecExtendFromSlice(out, _241); + _245 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_245)); + } else if (_165 === 8) { + v23 = v14 as rt.i32; + _251 = rt.i32ToBeBytes(v23); + rt.byteVecExtendFromSlice(out, _251); + _255 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_255)); + } else if (_165 === 9) { + v24 = v14 as rt.i64; + _261 = rt.i64ToBeBytes(v24); + rt.byteVecExtendFromSlice(out, _261); + _265 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_265)); + } else if (_165 === 10) { + v25 = v14 as rt.i128; + _271 = rt.i128ToBeBytes(v25); + rt.byteVecExtendFromSlice(out, _271); + _275 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_275)); } else { - const v26 = v14 as rt.isize; - rt.byteVecExtendFromSlice(out3, rt.isizeToBeBytes(v26)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)))); + v26 = v14 as rt.isize; + _281 = rt.isizeToBeBytes(v26); + rt.byteVecExtendFromSlice(out, _281); + _285 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_285)); } - } else if (value === 2) { - const data4 = data; - let buf3: Uint8Array = rt.bytes(4); - const n3 = rt.min(data4.length, buf3.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data4, 0, n3)); - const v27 = ([rt.u32FromBeBytes(buf3), rt.sliceRange(data4, n3)] as [rt.u32, Uint8Array])[0]; - const out4 = out; - const value4 = rt.u8Rem(to, 12); - if (value4 === 0) { - const v28 = v27 & 0xff; - rt.byteVecExtendFromSlice(out4, rt.u8ToBeBytes(v28)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)))); - } else if (value4 === 1) { - const v29 = v27 & 0xffff; - rt.byteVecExtendFromSlice(out4, rt.u16ToBeBytes(v29)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)))); - } else if (value4 === 2) { - const v30 = v27; - rt.byteVecExtendFromSlice(out4, rt.u32ToBeBytes(v30)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)))); - } else if (value4 === 3) { - const v31 = v27 as rt.u64; - rt.byteVecExtendFromSlice(out4, rt.u64ToBeBytes(v31)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)))); - } else if (value4 === 4) { - const v32 = v27 as rt.u128; - rt.byteVecExtendFromSlice(out4, rt.u128ToBeBytes(v32)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)))); - } else if (value4 === 5) { - const v33 = v27 as rt.usize; - rt.byteVecExtendFromSlice(out4, rt.usizeToBeBytes(v33)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)))); - } else if (value4 === 6) { - const v34 = (v27 << 24) >> 24; - rt.byteVecExtendFromSlice(out4, rt.i8ToBeBytes(v34)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)))); - } else if (value4 === 7) { - const v35 = (v27 << 16) >> 16; - rt.byteVecExtendFromSlice(out4, rt.i16ToBeBytes(v35)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)))); - } else if (value4 === 8) { - const v36 = v27 | 0; - rt.byteVecExtendFromSlice(out4, rt.i32ToBeBytes(v36)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)))); - } else if (value4 === 9) { - const v37 = v27 as rt.i64; - rt.byteVecExtendFromSlice(out4, rt.i64ToBeBytes(v37)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)))); - } else if (value4 === 10) { - const v38 = v27 as rt.i128; - rt.byteVecExtendFromSlice(out4, rt.i128ToBeBytes(v38)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)))); + } else if (_5 === 2) { + buf3 = rt.bytes(4); + n3 = rt.min(data.length, buf3.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); + v27 = ([rt.u32FromBeBytes(buf3), rt.sliceRange(data, n3)] as [rt.u32, Uint8Array])[0]; + _305 = rt.u8Rem(to, 12); + if (_305 === 0) { + v28 = v27 & 0xff; + _311 = rt.u8ToBeBytes(v28); + rt.byteVecExtendFromSlice(out, _311); + _315 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_315)); + } else if (_305 === 1) { + v29 = v27 & 0xffff; + _321 = rt.u16ToBeBytes(v29); + rt.byteVecExtendFromSlice(out, _321); + _325 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_325)); + } else if (_305 === 2) { + v30 = v27; + _331 = rt.u32ToBeBytes(v30); + rt.byteVecExtendFromSlice(out, _331); + _335 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_335)); + } else if (_305 === 3) { + v31 = v27 as rt.u64; + _341 = rt.u64ToBeBytes(v31); + rt.byteVecExtendFromSlice(out, _341); + _345 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_345)); + } else if (_305 === 4) { + v32 = v27 as rt.u128; + _351 = rt.u128ToBeBytes(v32); + rt.byteVecExtendFromSlice(out, _351); + _355 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_355)); + } else if (_305 === 5) { + v33 = v27 as rt.usize; + _361 = rt.usizeToBeBytes(v33); + rt.byteVecExtendFromSlice(out, _361); + _365 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_365)); + } else if (_305 === 6) { + v34 = (v27 << 24) >> 24; + _371 = rt.i8ToBeBytes(v34); + rt.byteVecExtendFromSlice(out, _371); + _375 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_375)); + } else if (_305 === 7) { + v35 = (v27 << 16) >> 16; + _381 = rt.i16ToBeBytes(v35); + rt.byteVecExtendFromSlice(out, _381); + _385 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_385)); + } else if (_305 === 8) { + v36 = v27 | 0; + _391 = rt.i32ToBeBytes(v36); + rt.byteVecExtendFromSlice(out, _391); + _395 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_395)); + } else if (_305 === 9) { + v37 = v27 as rt.i64; + _401 = rt.i64ToBeBytes(v37); + rt.byteVecExtendFromSlice(out, _401); + _405 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_405)); + } else if (_305 === 10) { + v38 = v27 as rt.i128; + _411 = rt.i128ToBeBytes(v38); + rt.byteVecExtendFromSlice(out, _411); + _415 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_415)); } else { - const v39 = v27 | 0; - rt.byteVecExtendFromSlice(out4, rt.isizeToBeBytes(v39)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)))); + v39 = v27 | 0; + _421 = rt.isizeToBeBytes(v39); + rt.byteVecExtendFromSlice(out, _421); + _425 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_425)); } - } else if (value === 3) { - const data5 = data; - let buf4: Uint8Array = rt.bytes(8); - const n4 = rt.min(data5.length, buf4.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data5, 0, n4)); - const v40 = ([rt.u64FromBeBytes(buf4), rt.sliceRange(data5, n4)] as [rt.u64, Uint8Array])[0]; - const out5 = out; - const value5 = rt.u8Rem(to, 12); - if (value5 === 0) { - const v41 = rt.u64Low(v40) & 0xff; - rt.byteVecExtendFromSlice(out5, rt.u8ToBeBytes(v41)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)))); - } else if (value5 === 1) { - const v42 = rt.u64Low(v40) & 0xffff; - rt.byteVecExtendFromSlice(out5, rt.u16ToBeBytes(v42)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)))); - } else if (value5 === 2) { - const v43 = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out5, rt.u32ToBeBytes(v43)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)))); - } else if (value5 === 3) { - const v44 = v40; - rt.byteVecExtendFromSlice(out5, rt.u64ToBeBytes(v44)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)))); - } else if (value5 === 4) { - const v45 = rt.u128Cast(v40); - rt.byteVecExtendFromSlice(out5, rt.u128ToBeBytes(v45)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)))); - } else if (value5 === 5) { - const v46 = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out5, rt.usizeToBeBytes(v46)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)))); - } else if (value5 === 6) { - const v47 = (rt.u64Low(v40) << 24) >> 24; - rt.byteVecExtendFromSlice(out5, rt.i8ToBeBytes(v47)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)))); - } else if (value5 === 7) { - const v48 = (rt.u64Low(v40) << 16) >> 16; - rt.byteVecExtendFromSlice(out5, rt.i16ToBeBytes(v48)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)))); - } else if (value5 === 8) { - const v49 = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out5, rt.i32ToBeBytes(v49)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)))); - } else if (value5 === 9) { - const v50 = rt.i64Cast(v40); - rt.byteVecExtendFromSlice(out5, rt.i64ToBeBytes(v50)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)))); - } else if (value5 === 10) { - const v51 = rt.i128Cast(v40); - rt.byteVecExtendFromSlice(out5, rt.i128ToBeBytes(v51)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)))); + } else if (_5 === 3) { + buf4 = rt.bytes(8); + n4 = rt.min(data.length, buf4.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); + v40 = ([rt.u64FromBeBytes(buf4), rt.sliceRange(data, n4)] as [rt.u64, Uint8Array])[0]; + _445 = rt.u8Rem(to, 12); + if (_445 === 0) { + v41 = rt.u64Low(v40) & 0xff; + _451 = rt.u8ToBeBytes(v41); + rt.byteVecExtendFromSlice(out, _451); + _455 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_455)); + } else if (_445 === 1) { + v42 = rt.u64Low(v40) & 0xffff; + _461 = rt.u16ToBeBytes(v42); + rt.byteVecExtendFromSlice(out, _461); + _465 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_465)); + } else if (_445 === 2) { + v43 = rt.u64Low(v40); + _471 = rt.u32ToBeBytes(v43); + rt.byteVecExtendFromSlice(out, _471); + _475 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_475)); + } else if (_445 === 3) { + v44 = v40; + _481 = rt.u64ToBeBytes(v44); + rt.byteVecExtendFromSlice(out, _481); + _485 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_485)); + } else if (_445 === 4) { + v45 = rt.u128Cast(v40); + _491 = rt.u128ToBeBytes(v45); + rt.byteVecExtendFromSlice(out, _491); + _495 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_495)); + } else if (_445 === 5) { + v46 = rt.u64Low(v40); + _501 = rt.usizeToBeBytes(v46); + rt.byteVecExtendFromSlice(out, _501); + _505 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_505)); + } else if (_445 === 6) { + v47 = (rt.u64Low(v40) << 24) >> 24; + _511 = rt.i8ToBeBytes(v47); + rt.byteVecExtendFromSlice(out, _511); + _515 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_515)); + } else if (_445 === 7) { + v48 = (rt.u64Low(v40) << 16) >> 16; + _521 = rt.i16ToBeBytes(v48); + rt.byteVecExtendFromSlice(out, _521); + _525 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_525)); + } else if (_445 === 8) { + v49 = rt.u64Low(v40) | 0; + _531 = rt.i32ToBeBytes(v49); + rt.byteVecExtendFromSlice(out, _531); + _535 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_535)); + } else if (_445 === 9) { + v50 = rt.i64Cast(v40); + _541 = rt.i64ToBeBytes(v50); + rt.byteVecExtendFromSlice(out, _541); + _545 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_545)); + } else if (_445 === 10) { + v51 = rt.i128Cast(v40); + _551 = rt.i128ToBeBytes(v51); + rt.byteVecExtendFromSlice(out, _551); + _555 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_555)); } else { - const v52 = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out5, rt.isizeToBeBytes(v52)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)))); + v52 = rt.u64Low(v40) | 0; + _561 = rt.isizeToBeBytes(v52); + rt.byteVecExtendFromSlice(out, _561); + _565 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_565)); } - } else if (value === 4) { - const data6 = data; - let buf5: Uint8Array = rt.bytes(16); - const n5 = rt.min(data6.length, buf5.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data6, 0, n5)); - const v53 = ([rt.u128FromBeBytes(buf5), rt.sliceRange(data6, n5)] as [rt.u128, Uint8Array])[0]; - const out6 = out; - const value6 = rt.u8Rem(to, 12); - if (value6 === 0) { - const v54 = rt.u128Low(v53) & 0xff; - rt.byteVecExtendFromSlice(out6, rt.u8ToBeBytes(v54)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)))); - } else if (value6 === 1) { - const v55 = rt.u128Low(v53) & 0xffff; - rt.byteVecExtendFromSlice(out6, rt.u16ToBeBytes(v55)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)))); - } else if (value6 === 2) { - const v56 = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out6, rt.u32ToBeBytes(v56)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)))); - } else if (value6 === 3) { - const v57 = rt.u64Cast(v53); - rt.byteVecExtendFromSlice(out6, rt.u64ToBeBytes(v57)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)))); - } else if (value6 === 4) { - const v58 = v53; - rt.byteVecExtendFromSlice(out6, rt.u128ToBeBytes(v58)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)))); - } else if (value6 === 5) { - const v59 = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out6, rt.usizeToBeBytes(v59)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)))); - } else if (value6 === 6) { - const v60 = (rt.u128Low(v53) << 24) >> 24; - rt.byteVecExtendFromSlice(out6, rt.i8ToBeBytes(v60)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)))); - } else if (value6 === 7) { - const v61 = (rt.u128Low(v53) << 16) >> 16; - rt.byteVecExtendFromSlice(out6, rt.i16ToBeBytes(v61)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)))); - } else if (value6 === 8) { - const v62 = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out6, rt.i32ToBeBytes(v62)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)))); - } else if (value6 === 9) { - const v63 = rt.i64Cast(v53); - rt.byteVecExtendFromSlice(out6, rt.i64ToBeBytes(v63)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)))); - } else if (value6 === 10) { - const v64 = rt.i128Cast(v53); - rt.byteVecExtendFromSlice(out6, rt.i128ToBeBytes(v64)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)))); + } else if (_5 === 4) { + buf5 = rt.bytes(16); + n5 = rt.min(data.length, buf5.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); + v53 = ([rt.u128FromBeBytes(buf5), rt.sliceRange(data, n5)] as [rt.u128, Uint8Array])[0]; + _585 = rt.u8Rem(to, 12); + if (_585 === 0) { + v54 = rt.u128Low(v53) & 0xff; + _591 = rt.u8ToBeBytes(v54); + rt.byteVecExtendFromSlice(out, _591); + _595 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_595)); + } else if (_585 === 1) { + v55 = rt.u128Low(v53) & 0xffff; + _601 = rt.u16ToBeBytes(v55); + rt.byteVecExtendFromSlice(out, _601); + _605 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_605)); + } else if (_585 === 2) { + v56 = rt.u128Low(v53); + _611 = rt.u32ToBeBytes(v56); + rt.byteVecExtendFromSlice(out, _611); + _615 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_615)); + } else if (_585 === 3) { + v57 = rt.u64Cast(v53); + _621 = rt.u64ToBeBytes(v57); + rt.byteVecExtendFromSlice(out, _621); + _625 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_625)); + } else if (_585 === 4) { + v58 = v53; + _631 = rt.u128ToBeBytes(v58); + rt.byteVecExtendFromSlice(out, _631); + _635 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_635)); + } else if (_585 === 5) { + v59 = rt.u128Low(v53); + _641 = rt.usizeToBeBytes(v59); + rt.byteVecExtendFromSlice(out, _641); + _645 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_645)); + } else if (_585 === 6) { + v60 = (rt.u128Low(v53) << 24) >> 24; + _651 = rt.i8ToBeBytes(v60); + rt.byteVecExtendFromSlice(out, _651); + _655 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_655)); + } else if (_585 === 7) { + v61 = (rt.u128Low(v53) << 16) >> 16; + _661 = rt.i16ToBeBytes(v61); + rt.byteVecExtendFromSlice(out, _661); + _665 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_665)); + } else if (_585 === 8) { + v62 = rt.u128Low(v53) | 0; + _671 = rt.i32ToBeBytes(v62); + rt.byteVecExtendFromSlice(out, _671); + _675 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_675)); + } else if (_585 === 9) { + v63 = rt.i64Cast(v53); + _681 = rt.i64ToBeBytes(v63); + rt.byteVecExtendFromSlice(out, _681); + _685 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_685)); + } else if (_585 === 10) { + v64 = rt.i128Cast(v53); + _691 = rt.i128ToBeBytes(v64); + rt.byteVecExtendFromSlice(out, _691); + _695 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_695)); } else { - const v65 = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out6, rt.isizeToBeBytes(v65)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)))); + v65 = rt.u128Low(v53) | 0; + _701 = rt.isizeToBeBytes(v65); + rt.byteVecExtendFromSlice(out, _701); + _705 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_705)); } - } else if (value === 5) { - const data7 = data; - let buf6: Uint8Array = rt.bytes(4); - const n6 = rt.min(data7.length, buf6.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data7, 0, n6)); - const v66 = ([rt.usizeFromBeBytes(buf6), rt.sliceRange(data7, n6)] as [rt.usize, Uint8Array])[0]; - const out7 = out; - const value7 = rt.u8Rem(to, 12); - if (value7 === 0) { - const v67 = v66 & 0xff; - rt.byteVecExtendFromSlice(out7, rt.u8ToBeBytes(v67)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)))); - } else if (value7 === 1) { - const v68 = v66 & 0xffff; - rt.byteVecExtendFromSlice(out7, rt.u16ToBeBytes(v68)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)))); - } else if (value7 === 2) { - const v69 = v66 as rt.u32; - rt.byteVecExtendFromSlice(out7, rt.u32ToBeBytes(v69)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)))); - } else if (value7 === 3) { - const v70 = v66 as rt.u64; - rt.byteVecExtendFromSlice(out7, rt.u64ToBeBytes(v70)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)))); - } else if (value7 === 4) { - const v71 = v66 as rt.u128; - rt.byteVecExtendFromSlice(out7, rt.u128ToBeBytes(v71)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)))); - } else if (value7 === 5) { - const v72 = v66; - rt.byteVecExtendFromSlice(out7, rt.usizeToBeBytes(v72)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)))); - } else if (value7 === 6) { - const v73 = (v66 << 24) >> 24; - rt.byteVecExtendFromSlice(out7, rt.i8ToBeBytes(v73)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)))); - } else if (value7 === 7) { - const v74 = (v66 << 16) >> 16; - rt.byteVecExtendFromSlice(out7, rt.i16ToBeBytes(v74)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)))); - } else if (value7 === 8) { - const v75 = v66 | 0; - rt.byteVecExtendFromSlice(out7, rt.i32ToBeBytes(v75)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)))); - } else if (value7 === 9) { - const v76 = v66 as rt.i64; - rt.byteVecExtendFromSlice(out7, rt.i64ToBeBytes(v76)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)))); - } else if (value7 === 10) { - const v77 = v66 as rt.i128; - rt.byteVecExtendFromSlice(out7, rt.i128ToBeBytes(v77)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)))); + } else if (_5 === 5) { + buf6 = rt.bytes(4); + n6 = rt.min(data.length, buf6.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); + v66 = ([rt.usizeFromBeBytes(buf6), rt.sliceRange(data, n6)] as [rt.usize, Uint8Array])[0]; + _725 = rt.u8Rem(to, 12); + if (_725 === 0) { + v67 = v66 & 0xff; + _731 = rt.u8ToBeBytes(v67); + rt.byteVecExtendFromSlice(out, _731); + _735 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_735)); + } else if (_725 === 1) { + v68 = v66 & 0xffff; + _741 = rt.u16ToBeBytes(v68); + rt.byteVecExtendFromSlice(out, _741); + _745 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_745)); + } else if (_725 === 2) { + v69 = v66 as rt.u32; + _751 = rt.u32ToBeBytes(v69); + rt.byteVecExtendFromSlice(out, _751); + _755 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_755)); + } else if (_725 === 3) { + v70 = v66 as rt.u64; + _761 = rt.u64ToBeBytes(v70); + rt.byteVecExtendFromSlice(out, _761); + _765 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_765)); + } else if (_725 === 4) { + v71 = v66 as rt.u128; + _771 = rt.u128ToBeBytes(v71); + rt.byteVecExtendFromSlice(out, _771); + _775 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_775)); + } else if (_725 === 5) { + v72 = v66; + _781 = rt.usizeToBeBytes(v72); + rt.byteVecExtendFromSlice(out, _781); + _785 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_785)); + } else if (_725 === 6) { + v73 = (v66 << 24) >> 24; + _791 = rt.i8ToBeBytes(v73); + rt.byteVecExtendFromSlice(out, _791); + _795 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_795)); + } else if (_725 === 7) { + v74 = (v66 << 16) >> 16; + _801 = rt.i16ToBeBytes(v74); + rt.byteVecExtendFromSlice(out, _801); + _805 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_805)); + } else if (_725 === 8) { + v75 = v66 | 0; + _811 = rt.i32ToBeBytes(v75); + rt.byteVecExtendFromSlice(out, _811); + _815 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_815)); + } else if (_725 === 9) { + v76 = v66 as rt.i64; + _821 = rt.i64ToBeBytes(v76); + rt.byteVecExtendFromSlice(out, _821); + _825 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_825)); + } else if (_725 === 10) { + v77 = v66 as rt.i128; + _831 = rt.i128ToBeBytes(v77); + rt.byteVecExtendFromSlice(out, _831); + _835 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_835)); } else { - const v78 = v66 | 0; - rt.byteVecExtendFromSlice(out7, rt.isizeToBeBytes(v78)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)))); + v78 = v66 | 0; + _841 = rt.isizeToBeBytes(v78); + rt.byteVecExtendFromSlice(out, _841); + _845 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_845)); } - } else if (value === 6) { - const data8 = data; - let buf7: Uint8Array = rt.bytes(1); - const n7 = rt.min(data8.length, buf7.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data8, 0, n7)); - const v79 = ([rt.i8FromBeBytes(buf7), rt.sliceRange(data8, n7)] as [rt.i8, Uint8Array])[0]; - const out8 = out; - const value8 = rt.u8Rem(to, 12); - if (value8 === 0) { - const v80 = v79 & 0xff; - rt.byteVecExtendFromSlice(out8, rt.u8ToBeBytes(v80)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)))); - } else if (value8 === 1) { - const v81 = v79 & 0xffff; - rt.byteVecExtendFromSlice(out8, rt.u16ToBeBytes(v81)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)))); - } else if (value8 === 2) { - const v82 = v79 >>> 0; - rt.byteVecExtendFromSlice(out8, rt.u32ToBeBytes(v82)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)))); - } else if (value8 === 3) { - const v83 = rt.u64Cast(v79); - rt.byteVecExtendFromSlice(out8, rt.u64ToBeBytes(v83)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)))); - } else if (value8 === 4) { - const v84 = rt.u128Cast(v79); - rt.byteVecExtendFromSlice(out8, rt.u128ToBeBytes(v84)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)))); - } else if (value8 === 5) { - const v85 = v79 >>> 0; - rt.byteVecExtendFromSlice(out8, rt.usizeToBeBytes(v85)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)))); - } else if (value8 === 6) { - const v86 = v79; - rt.byteVecExtendFromSlice(out8, rt.i8ToBeBytes(v86)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)))); - } else if (value8 === 7) { - const v87 = v79 as rt.i16; - rt.byteVecExtendFromSlice(out8, rt.i16ToBeBytes(v87)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)))); - } else if (value8 === 8) { - const v88 = v79 as rt.i32; - rt.byteVecExtendFromSlice(out8, rt.i32ToBeBytes(v88)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)))); - } else if (value8 === 9) { - const v89 = v79 as rt.i64; - rt.byteVecExtendFromSlice(out8, rt.i64ToBeBytes(v89)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)))); - } else if (value8 === 10) { - const v90 = v79 as rt.i128; - rt.byteVecExtendFromSlice(out8, rt.i128ToBeBytes(v90)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)))); + } else if (_5 === 6) { + buf7 = Uint8Array.of(0); + n7 = rt.min(data.length, buf7.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); + v79 = ([rt.i8FromBeBytes(buf7), rt.sliceRange(data, n7)] as [rt.i8, Uint8Array])[0]; + _865 = rt.u8Rem(to, 12); + if (_865 === 0) { + v80 = v79 & 0xff; + _871 = rt.u8ToBeBytes(v80); + rt.byteVecExtendFromSlice(out, _871); + _875 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_875)); + } else if (_865 === 1) { + v81 = v79 & 0xffff; + _881 = rt.u16ToBeBytes(v81); + rt.byteVecExtendFromSlice(out, _881); + _885 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_885)); + } else if (_865 === 2) { + v82 = v79 >>> 0; + _891 = rt.u32ToBeBytes(v82); + rt.byteVecExtendFromSlice(out, _891); + _895 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_895)); + } else if (_865 === 3) { + v83 = rt.u64Cast(v79); + _901 = rt.u64ToBeBytes(v83); + rt.byteVecExtendFromSlice(out, _901); + _905 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_905)); + } else if (_865 === 4) { + v84 = rt.u128Cast(v79); + _911 = rt.u128ToBeBytes(v84); + rt.byteVecExtendFromSlice(out, _911); + _915 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_915)); + } else if (_865 === 5) { + v85 = v79 >>> 0; + _921 = rt.usizeToBeBytes(v85); + rt.byteVecExtendFromSlice(out, _921); + _925 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_925)); + } else if (_865 === 6) { + v86 = v79; + _931 = rt.i8ToBeBytes(v86); + rt.byteVecExtendFromSlice(out, _931); + _935 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_935)); + } else if (_865 === 7) { + v87 = v79 as rt.i16; + _941 = rt.i16ToBeBytes(v87); + rt.byteVecExtendFromSlice(out, _941); + _945 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_945)); + } else if (_865 === 8) { + v88 = v79 as rt.i32; + _951 = rt.i32ToBeBytes(v88); + rt.byteVecExtendFromSlice(out, _951); + _955 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_955)); + } else if (_865 === 9) { + v89 = v79 as rt.i64; + _961 = rt.i64ToBeBytes(v89); + rt.byteVecExtendFromSlice(out, _961); + _965 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_965)); + } else if (_865 === 10) { + v90 = v79 as rt.i128; + _971 = rt.i128ToBeBytes(v90); + rt.byteVecExtendFromSlice(out, _971); + _975 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_975)); } else { - const v91 = v79 as rt.isize; - rt.byteVecExtendFromSlice(out8, rt.isizeToBeBytes(v91)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)))); + v91 = v79 as rt.isize; + _981 = rt.isizeToBeBytes(v91); + rt.byteVecExtendFromSlice(out, _981); + _985 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_985)); } - } else if (value === 7) { - const data9 = data; - let buf8: Uint8Array = rt.bytes(2); - const n8 = rt.min(data9.length, buf8.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data9, 0, n8)); - const v92 = ([rt.i16FromBeBytes(buf8), rt.sliceRange(data9, n8)] as [rt.i16, Uint8Array])[0]; - const out9 = out; - const value9 = rt.u8Rem(to, 12); - if (value9 === 0) { - const v93 = v92 & 0xff; - rt.byteVecExtendFromSlice(out9, rt.u8ToBeBytes(v93)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)))); - } else if (value9 === 1) { - const v94 = v92 & 0xffff; - rt.byteVecExtendFromSlice(out9, rt.u16ToBeBytes(v94)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)))); - } else if (value9 === 2) { - const v95 = v92 >>> 0; - rt.byteVecExtendFromSlice(out9, rt.u32ToBeBytes(v95)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)))); - } else if (value9 === 3) { - const v96 = rt.u64Cast(v92); - rt.byteVecExtendFromSlice(out9, rt.u64ToBeBytes(v96)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)))); - } else if (value9 === 4) { - const v97 = rt.u128Cast(v92); - rt.byteVecExtendFromSlice(out9, rt.u128ToBeBytes(v97)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)))); - } else if (value9 === 5) { - const v98 = v92 >>> 0; - rt.byteVecExtendFromSlice(out9, rt.usizeToBeBytes(v98)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)))); - } else if (value9 === 6) { - const v99 = (v92 << 24) >> 24; - rt.byteVecExtendFromSlice(out9, rt.i8ToBeBytes(v99)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)))); - } else if (value9 === 7) { - const v100 = v92; - rt.byteVecExtendFromSlice(out9, rt.i16ToBeBytes(v100)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)))); - } else if (value9 === 8) { - const v101 = v92 as rt.i32; - rt.byteVecExtendFromSlice(out9, rt.i32ToBeBytes(v101)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)))); - } else if (value9 === 9) { - const v102 = v92 as rt.i64; - rt.byteVecExtendFromSlice(out9, rt.i64ToBeBytes(v102)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)))); - } else if (value9 === 10) { - const v103 = v92 as rt.i128; - rt.byteVecExtendFromSlice(out9, rt.i128ToBeBytes(v103)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)))); + } else if (_5 === 7) { + buf8 = rt.bytes(2); + n8 = rt.min(data.length, buf8.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); + v92 = ([rt.i16FromBeBytes(buf8), rt.sliceRange(data, n8)] as [rt.i16, Uint8Array])[0]; + _1005 = rt.u8Rem(to, 12); + if (_1005 === 0) { + v93 = v92 & 0xff; + _1011 = rt.u8ToBeBytes(v93); + rt.byteVecExtendFromSlice(out, _1011); + _1015 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1015)); + } else if (_1005 === 1) { + v94 = v92 & 0xffff; + _1021 = rt.u16ToBeBytes(v94); + rt.byteVecExtendFromSlice(out, _1021); + _1025 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1025)); + } else if (_1005 === 2) { + v95 = v92 >>> 0; + _1031 = rt.u32ToBeBytes(v95); + rt.byteVecExtendFromSlice(out, _1031); + _1035 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1035)); + } else if (_1005 === 3) { + v96 = rt.u64Cast(v92); + _1041 = rt.u64ToBeBytes(v96); + rt.byteVecExtendFromSlice(out, _1041); + _1045 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1045)); + } else if (_1005 === 4) { + v97 = rt.u128Cast(v92); + _1051 = rt.u128ToBeBytes(v97); + rt.byteVecExtendFromSlice(out, _1051); + _1055 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1055)); + } else if (_1005 === 5) { + v98 = v92 >>> 0; + _1061 = rt.usizeToBeBytes(v98); + rt.byteVecExtendFromSlice(out, _1061); + _1065 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1065)); + } else if (_1005 === 6) { + v99 = (v92 << 24) >> 24; + _1071 = rt.i8ToBeBytes(v99); + rt.byteVecExtendFromSlice(out, _1071); + _1075 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1075)); + } else if (_1005 === 7) { + v100 = v92; + _1081 = rt.i16ToBeBytes(v100); + rt.byteVecExtendFromSlice(out, _1081); + _1085 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1085)); + } else if (_1005 === 8) { + v101 = v92 as rt.i32; + _1091 = rt.i32ToBeBytes(v101); + rt.byteVecExtendFromSlice(out, _1091); + _1095 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1095)); + } else if (_1005 === 9) { + v102 = v92 as rt.i64; + _1101 = rt.i64ToBeBytes(v102); + rt.byteVecExtendFromSlice(out, _1101); + _1105 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1105)); + } else if (_1005 === 10) { + v103 = v92 as rt.i128; + _1111 = rt.i128ToBeBytes(v103); + rt.byteVecExtendFromSlice(out, _1111); + _1115 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1115)); } else { - const v104 = v92 as rt.isize; - rt.byteVecExtendFromSlice(out9, rt.isizeToBeBytes(v104)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)))); + v104 = v92 as rt.isize; + _1121 = rt.isizeToBeBytes(v104); + rt.byteVecExtendFromSlice(out, _1121); + _1125 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1125)); } - } else if (value === 8) { - const data10 = data; - let buf9: Uint8Array = rt.bytes(4); - const n9 = rt.min(data10.length, buf9.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data10, 0, n9)); - const v105 = ([rt.i32FromBeBytes(buf9), rt.sliceRange(data10, n9)] as [rt.i32, Uint8Array])[0]; - const out10 = out; - const value10 = rt.u8Rem(to, 12); - if (value10 === 0) { - const v106 = v105 & 0xff; - rt.byteVecExtendFromSlice(out10, rt.u8ToBeBytes(v106)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)))); - } else if (value10 === 1) { - const v107 = v105 & 0xffff; - rt.byteVecExtendFromSlice(out10, rt.u16ToBeBytes(v107)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)))); - } else if (value10 === 2) { - const v108 = v105 >>> 0; - rt.byteVecExtendFromSlice(out10, rt.u32ToBeBytes(v108)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)))); - } else if (value10 === 3) { - const v109 = rt.u64Cast(v105); - rt.byteVecExtendFromSlice(out10, rt.u64ToBeBytes(v109)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)))); - } else if (value10 === 4) { - const v110 = rt.u128Cast(v105); - rt.byteVecExtendFromSlice(out10, rt.u128ToBeBytes(v110)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)))); - } else if (value10 === 5) { - const v111 = v105 >>> 0; - rt.byteVecExtendFromSlice(out10, rt.usizeToBeBytes(v111)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)))); - } else if (value10 === 6) { - const v112 = (v105 << 24) >> 24; - rt.byteVecExtendFromSlice(out10, rt.i8ToBeBytes(v112)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)))); - } else if (value10 === 7) { - const v113 = (v105 << 16) >> 16; - rt.byteVecExtendFromSlice(out10, rt.i16ToBeBytes(v113)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)))); - } else if (value10 === 8) { - const v114 = v105; - rt.byteVecExtendFromSlice(out10, rt.i32ToBeBytes(v114)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)))); - } else if (value10 === 9) { - const v115 = v105 as rt.i64; - rt.byteVecExtendFromSlice(out10, rt.i64ToBeBytes(v115)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)))); - } else if (value10 === 10) { - const v116 = v105 as rt.i128; - rt.byteVecExtendFromSlice(out10, rt.i128ToBeBytes(v116)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)))); + } else if (_5 === 8) { + buf9 = rt.bytes(4); + n9 = rt.min(data.length, buf9.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); + v105 = ([rt.i32FromBeBytes(buf9), rt.sliceRange(data, n9)] as [rt.i32, Uint8Array])[0]; + _1145 = rt.u8Rem(to, 12); + if (_1145 === 0) { + v106 = v105 & 0xff; + _1151 = rt.u8ToBeBytes(v106); + rt.byteVecExtendFromSlice(out, _1151); + _1155 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1155)); + } else if (_1145 === 1) { + v107 = v105 & 0xffff; + _1161 = rt.u16ToBeBytes(v107); + rt.byteVecExtendFromSlice(out, _1161); + _1165 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1165)); + } else if (_1145 === 2) { + v108 = v105 >>> 0; + _1171 = rt.u32ToBeBytes(v108); + rt.byteVecExtendFromSlice(out, _1171); + _1175 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1175)); + } else if (_1145 === 3) { + v109 = rt.u64Cast(v105); + _1181 = rt.u64ToBeBytes(v109); + rt.byteVecExtendFromSlice(out, _1181); + _1185 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1185)); + } else if (_1145 === 4) { + v110 = rt.u128Cast(v105); + _1191 = rt.u128ToBeBytes(v110); + rt.byteVecExtendFromSlice(out, _1191); + _1195 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1195)); + } else if (_1145 === 5) { + v111 = v105 >>> 0; + _1201 = rt.usizeToBeBytes(v111); + rt.byteVecExtendFromSlice(out, _1201); + _1205 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1205)); + } else if (_1145 === 6) { + v112 = (v105 << 24) >> 24; + _1211 = rt.i8ToBeBytes(v112); + rt.byteVecExtendFromSlice(out, _1211); + _1215 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1215)); + } else if (_1145 === 7) { + v113 = (v105 << 16) >> 16; + _1221 = rt.i16ToBeBytes(v113); + rt.byteVecExtendFromSlice(out, _1221); + _1225 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1225)); + } else if (_1145 === 8) { + v114 = v105; + _1231 = rt.i32ToBeBytes(v114); + rt.byteVecExtendFromSlice(out, _1231); + _1235 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1235)); + } else if (_1145 === 9) { + v115 = v105 as rt.i64; + _1241 = rt.i64ToBeBytes(v115); + rt.byteVecExtendFromSlice(out, _1241); + _1245 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1245)); + } else if (_1145 === 10) { + v116 = v105 as rt.i128; + _1251 = rt.i128ToBeBytes(v116); + rt.byteVecExtendFromSlice(out, _1251); + _1255 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1255)); } else { - const v117 = v105 as rt.isize; - rt.byteVecExtendFromSlice(out10, rt.isizeToBeBytes(v117)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)))); + v117 = v105 as rt.isize; + _1261 = rt.isizeToBeBytes(v117); + rt.byteVecExtendFromSlice(out, _1261); + _1265 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1265)); } - } else if (value === 9) { - const data11 = data; - let buf10: Uint8Array = rt.bytes(8); - const n10 = rt.min(data11.length, buf10.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data11, 0, n10)); - const v118 = ([rt.i64FromBeBytes(buf10), rt.sliceRange(data11, n10)] as [rt.i64, Uint8Array])[0]; - const out11 = out; - const value11 = rt.u8Rem(to, 12); - if (value11 === 0) { - const v119 = rt.i64Low(v118) & 0xff; - rt.byteVecExtendFromSlice(out11, rt.u8ToBeBytes(v119)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)))); - } else if (value11 === 1) { - const v120 = rt.i64Low(v118) & 0xffff; - rt.byteVecExtendFromSlice(out11, rt.u16ToBeBytes(v120)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)))); - } else if (value11 === 2) { - const v121 = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out11, rt.u32ToBeBytes(v121)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)))); - } else if (value11 === 3) { - const v122 = rt.u64Cast(v118); - rt.byteVecExtendFromSlice(out11, rt.u64ToBeBytes(v122)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)))); - } else if (value11 === 4) { - const v123 = rt.u128Cast(v118); - rt.byteVecExtendFromSlice(out11, rt.u128ToBeBytes(v123)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)))); - } else if (value11 === 5) { - const v124 = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out11, rt.usizeToBeBytes(v124)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)))); - } else if (value11 === 6) { - const v125 = (rt.i64Low(v118) << 24) >> 24; - rt.byteVecExtendFromSlice(out11, rt.i8ToBeBytes(v125)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)))); - } else if (value11 === 7) { - const v126 = (rt.i64Low(v118) << 16) >> 16; - rt.byteVecExtendFromSlice(out11, rt.i16ToBeBytes(v126)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)))); - } else if (value11 === 8) { - const v127 = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out11, rt.i32ToBeBytes(v127)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)))); - } else if (value11 === 9) { - const v128 = v118; - rt.byteVecExtendFromSlice(out11, rt.i64ToBeBytes(v128)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)))); - } else if (value11 === 10) { - const v129 = rt.i128Cast(v118); - rt.byteVecExtendFromSlice(out11, rt.i128ToBeBytes(v129)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)))); + } else if (_5 === 9) { + buf10 = rt.bytes(8); + n10 = rt.min(data.length, buf10.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); + v118 = ([rt.i64FromBeBytes(buf10), rt.sliceRange(data, n10)] as [rt.i64, Uint8Array])[0]; + _1285 = rt.u8Rem(to, 12); + if (_1285 === 0) { + v119 = rt.i64Low(v118) & 0xff; + _1291 = rt.u8ToBeBytes(v119); + rt.byteVecExtendFromSlice(out, _1291); + _1295 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1295)); + } else if (_1285 === 1) { + v120 = rt.i64Low(v118) & 0xffff; + _1301 = rt.u16ToBeBytes(v120); + rt.byteVecExtendFromSlice(out, _1301); + _1305 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1305)); + } else if (_1285 === 2) { + v121 = rt.i64Low(v118); + _1311 = rt.u32ToBeBytes(v121); + rt.byteVecExtendFromSlice(out, _1311); + _1315 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1315)); + } else if (_1285 === 3) { + v122 = rt.u64Cast(v118); + _1321 = rt.u64ToBeBytes(v122); + rt.byteVecExtendFromSlice(out, _1321); + _1325 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1325)); + } else if (_1285 === 4) { + v123 = rt.u128Cast(v118); + _1331 = rt.u128ToBeBytes(v123); + rt.byteVecExtendFromSlice(out, _1331); + _1335 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1335)); + } else if (_1285 === 5) { + v124 = rt.i64Low(v118); + _1341 = rt.usizeToBeBytes(v124); + rt.byteVecExtendFromSlice(out, _1341); + _1345 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1345)); + } else if (_1285 === 6) { + v125 = (rt.i64Low(v118) << 24) >> 24; + _1351 = rt.i8ToBeBytes(v125); + rt.byteVecExtendFromSlice(out, _1351); + _1355 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1355)); + } else if (_1285 === 7) { + v126 = (rt.i64Low(v118) << 16) >> 16; + _1361 = rt.i16ToBeBytes(v126); + rt.byteVecExtendFromSlice(out, _1361); + _1365 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1365)); + } else if (_1285 === 8) { + v127 = rt.i64Low(v118) | 0; + _1371 = rt.i32ToBeBytes(v127); + rt.byteVecExtendFromSlice(out, _1371); + _1375 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1375)); + } else if (_1285 === 9) { + v128 = v118; + _1381 = rt.i64ToBeBytes(v128); + rt.byteVecExtendFromSlice(out, _1381); + _1385 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1385)); + } else if (_1285 === 10) { + v129 = rt.i128Cast(v118); + _1391 = rt.i128ToBeBytes(v129); + rt.byteVecExtendFromSlice(out, _1391); + _1395 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1395)); } else { - const v130 = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out11, rt.isizeToBeBytes(v130)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)))); + v130 = rt.i64Low(v118) | 0; + _1401 = rt.isizeToBeBytes(v130); + rt.byteVecExtendFromSlice(out, _1401); + _1405 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1405)); } - } else if (value === 10) { - const data12 = data; - let buf11: Uint8Array = rt.bytes(16); - const n11 = rt.min(data12.length, buf11.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data12, 0, n11)); - const v131 = ([rt.i128FromBeBytes(buf11), rt.sliceRange(data12, n11)] as [rt.i128, Uint8Array])[0]; - const out12 = out; - const value12 = rt.u8Rem(to, 12); - if (value12 === 0) { - const v132 = rt.i128Low(v131) & 0xff; - rt.byteVecExtendFromSlice(out12, rt.u8ToBeBytes(v132)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)))); - } else if (value12 === 1) { - const v133 = rt.i128Low(v131) & 0xffff; - rt.byteVecExtendFromSlice(out12, rt.u16ToBeBytes(v133)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)))); - } else if (value12 === 2) { - const v134 = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out12, rt.u32ToBeBytes(v134)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)))); - } else if (value12 === 3) { - const v135 = rt.u64Cast(v131); - rt.byteVecExtendFromSlice(out12, rt.u64ToBeBytes(v135)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)))); - } else if (value12 === 4) { - const v136 = rt.u128Cast(v131); - rt.byteVecExtendFromSlice(out12, rt.u128ToBeBytes(v136)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)))); - } else if (value12 === 5) { - const v137 = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out12, rt.usizeToBeBytes(v137)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)))); - } else if (value12 === 6) { - const v138 = (rt.i128Low(v131) << 24) >> 24; - rt.byteVecExtendFromSlice(out12, rt.i8ToBeBytes(v138)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)))); - } else if (value12 === 7) { - const v139 = (rt.i128Low(v131) << 16) >> 16; - rt.byteVecExtendFromSlice(out12, rt.i16ToBeBytes(v139)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)))); - } else if (value12 === 8) { - const v140 = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out12, rt.i32ToBeBytes(v140)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)))); - } else if (value12 === 9) { - const v141 = rt.i64Cast(v131); - rt.byteVecExtendFromSlice(out12, rt.i64ToBeBytes(v141)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)))); - } else if (value12 === 10) { - const v142 = v131; - rt.byteVecExtendFromSlice(out12, rt.i128ToBeBytes(v142)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)))); + } else if (_5 === 10) { + buf11 = rt.bytes(16); + n11 = rt.min(data.length, buf11.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); + v131 = ([rt.i128FromBeBytes(buf11), rt.sliceRange(data, n11)] as [rt.i128, Uint8Array])[0]; + _1425 = rt.u8Rem(to, 12); + if (_1425 === 0) { + v132 = rt.i128Low(v131) & 0xff; + _1431 = rt.u8ToBeBytes(v132); + rt.byteVecExtendFromSlice(out, _1431); + _1435 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1435)); + } else if (_1425 === 1) { + v133 = rt.i128Low(v131) & 0xffff; + _1441 = rt.u16ToBeBytes(v133); + rt.byteVecExtendFromSlice(out, _1441); + _1445 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1445)); + } else if (_1425 === 2) { + v134 = rt.i128Low(v131); + _1451 = rt.u32ToBeBytes(v134); + rt.byteVecExtendFromSlice(out, _1451); + _1455 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1455)); + } else if (_1425 === 3) { + v135 = rt.u64Cast(v131); + _1461 = rt.u64ToBeBytes(v135); + rt.byteVecExtendFromSlice(out, _1461); + _1465 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1465)); + } else if (_1425 === 4) { + v136 = rt.u128Cast(v131); + _1471 = rt.u128ToBeBytes(v136); + rt.byteVecExtendFromSlice(out, _1471); + _1475 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1475)); + } else if (_1425 === 5) { + v137 = rt.i128Low(v131); + _1481 = rt.usizeToBeBytes(v137); + rt.byteVecExtendFromSlice(out, _1481); + _1485 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1485)); + } else if (_1425 === 6) { + v138 = (rt.i128Low(v131) << 24) >> 24; + _1491 = rt.i8ToBeBytes(v138); + rt.byteVecExtendFromSlice(out, _1491); + _1495 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1495)); + } else if (_1425 === 7) { + v139 = (rt.i128Low(v131) << 16) >> 16; + _1501 = rt.i16ToBeBytes(v139); + rt.byteVecExtendFromSlice(out, _1501); + _1505 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1505)); + } else if (_1425 === 8) { + v140 = rt.i128Low(v131) | 0; + _1511 = rt.i32ToBeBytes(v140); + rt.byteVecExtendFromSlice(out, _1511); + _1515 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1515)); + } else if (_1425 === 9) { + v141 = rt.i64Cast(v131); + _1521 = rt.i64ToBeBytes(v141); + rt.byteVecExtendFromSlice(out, _1521); + _1525 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1525)); + } else if (_1425 === 10) { + v142 = v131; + _1531 = rt.i128ToBeBytes(v142); + rt.byteVecExtendFromSlice(out, _1531); + _1535 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1535)); } else { - const v143 = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out12, rt.isizeToBeBytes(v143)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)))); + v143 = rt.i128Low(v131) | 0; + _1541 = rt.isizeToBeBytes(v143); + rt.byteVecExtendFromSlice(out, _1541); + _1545 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1545)); } } else { - const data13 = data; - let buf12: Uint8Array = rt.bytes(4); - const n12 = rt.min(data13.length, buf12.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data13, 0, n12)); - const v144 = ([rt.isizeFromBeBytes(buf12), rt.sliceRange(data13, n12)] as [rt.isize, Uint8Array])[0]; - const out13 = out; - const value13 = rt.u8Rem(to, 12); - if (value13 === 0) { - const v145 = v144 & 0xff; - rt.byteVecExtendFromSlice(out13, rt.u8ToBeBytes(v145)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)))); - } else if (value13 === 1) { - const v146 = v144 & 0xffff; - rt.byteVecExtendFromSlice(out13, rt.u16ToBeBytes(v146)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)))); - } else if (value13 === 2) { - const v147 = v144 >>> 0; - rt.byteVecExtendFromSlice(out13, rt.u32ToBeBytes(v147)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)))); - } else if (value13 === 3) { - const v148 = rt.u64Cast(v144); - rt.byteVecExtendFromSlice(out13, rt.u64ToBeBytes(v148)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)))); - } else if (value13 === 4) { - const v149 = rt.u128Cast(v144); - rt.byteVecExtendFromSlice(out13, rt.u128ToBeBytes(v149)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)))); - } else if (value13 === 5) { - const v150 = v144 >>> 0; - rt.byteVecExtendFromSlice(out13, rt.usizeToBeBytes(v150)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)))); - } else if (value13 === 6) { - const v151 = (v144 << 24) >> 24; - rt.byteVecExtendFromSlice(out13, rt.i8ToBeBytes(v151)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)))); - } else if (value13 === 7) { - const v152 = (v144 << 16) >> 16; - rt.byteVecExtendFromSlice(out13, rt.i16ToBeBytes(v152)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)))); - } else if (value13 === 8) { - const v153 = v144 as rt.i32; - rt.byteVecExtendFromSlice(out13, rt.i32ToBeBytes(v153)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)))); - } else if (value13 === 9) { - const v154 = v144 as rt.i64; - rt.byteVecExtendFromSlice(out13, rt.i64ToBeBytes(v154)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)))); - } else if (value13 === 10) { - const v155 = v144 as rt.i128; - rt.byteVecExtendFromSlice(out13, rt.i128ToBeBytes(v155)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)))); + buf12 = rt.bytes(4); + n12 = rt.min(data.length, buf12.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); + v144 = ([rt.isizeFromBeBytes(buf12), rt.sliceRange(data, n12)] as [rt.isize, Uint8Array])[0]; + _1565 = rt.u8Rem(to, 12); + if (_1565 === 0) { + v145 = v144 & 0xff; + _1571 = rt.u8ToBeBytes(v145); + rt.byteVecExtendFromSlice(out, _1571); + _1575 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1575)); + } else if (_1565 === 1) { + v146 = v144 & 0xffff; + _1581 = rt.u16ToBeBytes(v146); + rt.byteVecExtendFromSlice(out, _1581); + _1585 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1585)); + } else if (_1565 === 2) { + v147 = v144 >>> 0; + _1591 = rt.u32ToBeBytes(v147); + rt.byteVecExtendFromSlice(out, _1591); + _1595 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1595)); + } else if (_1565 === 3) { + v148 = rt.u64Cast(v144); + _1601 = rt.u64ToBeBytes(v148); + rt.byteVecExtendFromSlice(out, _1601); + _1605 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1605)); + } else if (_1565 === 4) { + v149 = rt.u128Cast(v144); + _1611 = rt.u128ToBeBytes(v149); + rt.byteVecExtendFromSlice(out, _1611); + _1615 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1615)); + } else if (_1565 === 5) { + v150 = v144 >>> 0; + _1621 = rt.usizeToBeBytes(v150); + rt.byteVecExtendFromSlice(out, _1621); + _1625 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1625)); + } else if (_1565 === 6) { + v151 = (v144 << 24) >> 24; + _1631 = rt.i8ToBeBytes(v151); + rt.byteVecExtendFromSlice(out, _1631); + _1635 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1635)); + } else if (_1565 === 7) { + v152 = (v144 << 16) >> 16; + _1641 = rt.i16ToBeBytes(v152); + rt.byteVecExtendFromSlice(out, _1641); + _1645 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1645)); + } else if (_1565 === 8) { + v153 = v144 as rt.i32; + _1651 = rt.i32ToBeBytes(v153); + rt.byteVecExtendFromSlice(out, _1651); + _1655 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1655)); + } else if (_1565 === 9) { + v154 = v144 as rt.i64; + _1661 = rt.i64ToBeBytes(v154); + rt.byteVecExtendFromSlice(out, _1661); + _1665 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1665)); + } else if (_1565 === 10) { + v155 = v144 as rt.i128; + _1671 = rt.i128ToBeBytes(v155); + rt.byteVecExtendFromSlice(out, _1671); + _1675 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1675)); } else { - const v156 = v144; - rt.byteVecExtendFromSlice(out13, rt.isizeToBeBytes(v156)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)))); + v156 = v144; + _1681 = rt.isizeToBeBytes(v156); + rt.byteVecExtendFromSlice(out, _1681); + _1685 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1685)); } } + return; } /** Conversions that check, and ones that cannot fail. */ export function convert(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [wide, data3] = [rt.u64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u64, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [signed, ] = [rt.i32FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i32, Uint8Array]; - rt.byteVecPush(out, rt.u8TryFrom(wide).ok ? 1 : 0); - const tryFrom = rt.u32TryFrom(wide); - if (tryFrom.ok) { - const v = tryFrom.value; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v)); + let wide!: rt.u64; + let _5!: [rt.u64, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let signed!: rt.i32; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _31!: Uint8Array; + let _36!: rt.i32; + let _44!: rt.Result; + let _46!: rt.Result; + let _51!: Uint8Array; + let _53!: rt.Result; + let _58!: Uint8Array; + let _60!: rt.Result; + let _65!: Uint8Array; + let widened!: rt.u64; + let into!: rt.i64; + let _72!: Uint8Array; + let _76!: Uint8Array; + let a!: rt.u8; + let b!: rt.u8; + let c!: rt.u8; + let d!: rt.u8; + let _86!: Uint8Array; + let _91!: Uint8Array; + let _97!: Uint8Array; + let _103!: Uint8Array; + let _109!: Uint8Array; + let _115!: Uint8Array; + let _122!: Uint8Array; + let _128!: Uint8Array; + let _134!: Uint8Array; + let _138!: Uint8Array; + let _142!: Uint8Array; + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _5 = [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; + wide = _5[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _31 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_31, rt.sliceRange(slice, 0, n2)); + _36 = rt.i32FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + signed = ([_36, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array])[0]; + _44 = rt.u8TryFrom(wide); + rt.byteVecPush(out, _44.ok ? 1 : 0); + _46 = rt.u32TryFrom(wide); + if (_46.ok) { + _51 = rt.u32ToBeBytes(_46.value); + rt.byteVecExtendFromSlice(out, _51); } else { - rt.byteVecPush(out, 0xff); + rt.byteVecPush(out, 255); } - const tryFrom2 = rt.usizeTryFrom(signed); - if (tryFrom2.ok) { - const v2 = tryFrom2.value; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v2)); + _53 = rt.usizeTryFrom(signed); + if (_53.ok) { + _58 = rt.usizeToBeBytes(_53.value); + rt.byteVecExtendFromSlice(out, _58); } else { - rt.byteVecPush(out, 0xfe); + rt.byteVecPush(out, 254); } - const tryFrom3 = rt.i8TryFrom(signed); - if (tryFrom3.ok) { - const v3 = tryFrom3.value; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v3)); + _60 = rt.i8TryFrom(signed); + if (_60.ok) { + _65 = rt.i8ToBeBytes(_60.value); + rt.byteVecExtendFromSlice(out, _65); } else { - rt.byteVecPush(out, 0xfd); + rt.byteVecPush(out, 253); } - const widened = (rt.u64Low(wide) & 0xffff) as rt.u64; - const into = signed as rt.i64; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(widened)); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(into)); + widened = (rt.u64Low(wide) & 0xffff) as rt.u64; + into = signed as rt.i64; + _72 = rt.u64ToBeBytes(widened); + rt.byteVecExtendFromSlice(out, _72); + _76 = rt.i64ToBeBytes(into); + rt.byteVecExtendFromSlice(out, _76); rt.byteVecPush(out, rt.u8Add(true ? 1 : 0, false ? 1 : 0)); - const toBeBytes = rt.u32ToBeBytes(signed >>> 0); - const a = toBeBytes[0]; - const b = toBeBytes[1]; - const c = toBeBytes[2]; - const d = toBeBytes[3]; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes((a << 24) >> 24)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes((a << 8) | b)); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((b & 0x3f) << 16) | (c << 8) | d)); - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes((a << 24) | (c << 8) | d)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(0)); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d)))); - const bytes = Uint8Array.of(d, c, b, a); - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(rt.i32FromBeBytes(bytes))); + _86 = rt.u32ToBeBytes(signed >>> 0); + a = _86[0]; + b = _86[1]; + c = _86[2]; + d = _86[3]; + _91 = rt.i8ToBeBytes((a << 24) >> 24); + rt.byteVecExtendFromSlice(out, _91); + _97 = rt.u16ToBeBytes((a << 8) | b); + rt.byteVecExtendFromSlice(out, _97); + _103 = rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16); + rt.byteVecExtendFromSlice(out, _103); + _109 = rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0); + rt.byteVecExtendFromSlice(out, _109); + _115 = rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d); + rt.byteVecExtendFromSlice(out, _115); + _122 = rt.i32ToBeBytes((a << 24) | (c << 8) | d); + rt.byteVecExtendFromSlice(out, _122); + _128 = rt.u32ToBeBytes(0); + rt.byteVecExtendFromSlice(out, _128); + _134 = rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d))); + rt.byteVecExtendFromSlice(out, _134); + _138 = Uint8Array.of(d, c, b, a); + _142 = rt.i32ToBeBytes(rt.i32FromBeBytes(_138)); + rt.byteVecExtendFromSlice(out, _142); + return; } //# sourceMappingURL=ints.ts.map diff --git a/ts/fixtures/lang/expected/iters.Countdown.ts b/ts/fixtures/lang/expected/iters.Countdown.ts index 97dee3dfd..0ebf15570 100644 --- a/ts/fixtures/lang/expected/iters.Countdown.ts +++ b/ts/fixtures/lang/expected/iters.Countdown.ts @@ -9,13 +9,18 @@ export interface Countdown { } export function next$Iterator(self: Countdown): rt.u8 | rt.Done { + let _0!: rt.u8 | rt.Done; + let left!: rt.u8; + let _3!: rt.u8; if (self.left === 0) { - return rt.DONE; + _0 = rt.DONE; } else { - const left = self.left; - self.left = rt.u8SaturatingSub(left, self.step); - return left; + left = self.left; + _3 = rt.u8SaturatingSub(left, self.step); + self.left = _3; + _0 = left; } + return _0; } //# sourceMappingURL=iters.Countdown.ts.map diff --git a/ts/fixtures/lang/expected/iters.Doubled.ts b/ts/fixtures/lang/expected/iters.Doubled.ts index 67fb2e11b..10eb2be27 100644 --- a/ts/fixtures/lang/expected/iters.Doubled.ts +++ b/ts/fixtures/lang/expected/iters.Doubled.ts @@ -8,10 +8,13 @@ export interface Doubled { } export function fmt$Debug(self: Doubled, f: rt.Formatter): rt.Result { - return rt.debugListFinish(rt.debugListEntries(rt.fmtDebugList(f), rt.iterMap(rt.iterSlice(self._0), (arg: rt.u8): rt.u16 => { - const b = arg; - return rt.u16Mul(b as rt.u16, 2); - }), rt.u16Display)); + let _5!: rt.DebugList; + let _6!: rt.Iter; + _5 = rt.fmtDebugList(f); + _6 = rt.iterMap(rt.iterSlice(self._0), (_2: rt.u8): rt.u16 => { + return rt.u16Mul(_2 as rt.u16, 2); + }); + return rt.debugListFinish(rt.debugListEntries(_5, _6, rt.u16Display)); } //# sourceMappingURL=iters.Doubled.ts.map diff --git a/ts/fixtures/lang/expected/iters.Evens.ts b/ts/fixtures/lang/expected/iters.Evens.ts index b9f888ef1..74c37c71a 100644 --- a/ts/fixtures/lang/expected/iters.Evens.ts +++ b/ts/fixtures/lang/expected/iters.Evens.ts @@ -8,15 +8,22 @@ export interface Evens { } export function next$Iterator(self: Evens): rt.u8 | rt.Done { - while (true) { - const next = self.inner.next(); - if (next === rt.DONE) { - return rt.DONE; - } - const b = next; - if (rt.u8Rem(b, 2) === 0) { - return b; + let _0!: rt.u8 | rt.Done; + let _2!: rt.u8 | rt.Done; + let b!: rt.u8; + l0: while (true) { + _2 = self.inner.next(); + if (_2 !== rt.DONE) { + b = _2; + if (!(rt.u8Rem(b, 2) === 0)) { + continue l0; + } else { + _0 = b; + } + } else { + _0 = rt.DONE; } + return _0; } } diff --git a/ts/fixtures/lang/expected/iters.Gaps.ts b/ts/fixtures/lang/expected/iters.Gaps.ts index f914498cb..15ec88b29 100644 --- a/ts/fixtures/lang/expected/iters.Gaps.ts +++ b/ts/fixtures/lang/expected/iters.Gaps.ts @@ -9,16 +9,24 @@ export interface Gaps { } export function next$Iterator(self: Gaps): rt.u8 | undefined | rt.Done { - const get = rt.sliceGet(self.data, self.at); - if (get === undefined) { - return rt.DONE; + let _0!: rt.u8 | undefined | rt.Done; + let b!: rt.u8; + let _3!: rt.u8 | undefined; + let _8!: rt.usize; + _3 = rt.sliceGet(self.data, self.at); + if (_3 !== undefined) { + b = _3; + _8 = rt.usizeAdd(self.at, 1); + self.at = _8; + if (!(b === 0)) { + _0 = b; + } else { + _0 = undefined; + } + } else { + _0 = rt.DONE; } - const b = get; - self.at = rt.usizeAdd(self.at, 1); - if (b === 0) { - return undefined; - } - return b; + return _0; } //# sourceMappingURL=iters.Gaps.ts.map diff --git a/ts/fixtures/lang/expected/iters.Halving.ts b/ts/fixtures/lang/expected/iters.Halving.ts index 56d40c387..13c996224 100644 --- a/ts/fixtures/lang/expected/iters.Halving.ts +++ b/ts/fixtures/lang/expected/iters.Halving.ts @@ -12,19 +12,23 @@ export class Halving { } export function next$Iterator_u8(self: Halving): rt.u8 | rt.Done { - const value = self.value; + let value!: rt.u8; + value = self.value; self.value = rt.u8Div(self.value, 2); return rt.iterFromOption(rt.thenSome(value !== 0, value)); } export function next$Iterator_u64(self: Halving): rt.u64 | rt.Done { + let _0!: rt.u64 | rt.Done; + let value!: rt.u64; if (self.value === 0) { - return rt.DONE; + _0 = rt.DONE; } else { - const value = self.value; + value = self.value; self.value = rt.u64Shr(value, 1); - return value; + _0 = value; } + return _0; } //# sourceMappingURL=iters.Halving.ts.map diff --git a/ts/fixtures/lang/expected/iters.Held.ts b/ts/fixtures/lang/expected/iters.Held.ts index 643f634f2..9847eedb8 100644 --- a/ts/fixtures/lang/expected/iters.Held.ts +++ b/ts/fixtures/lang/expected/iters.Held.ts @@ -8,8 +8,8 @@ export interface Held { } export function skipOne(self: Held): rt.u8 { - rt.iterToOption(self.it.next()); - return rt.optionUnwrapOr(rt.iterToOption(self.it.next()), 0xbb); + self.it.next(); + return rt.optionUnwrapOr(rt.iterToOption(self.it.next()), 187); } //# sourceMappingURL=iters.Held.ts.map diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 4a8175c49..89894c462 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -13,338 +13,421 @@ import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 8); - if (value === 0) { - const doubled = rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (arg: rt.u8): rt.u8 => { - const b = arg; - return rt.u8Div(b, 2); - }), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 3) !== 0; - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(doubled)); - const small = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (arg2: rt.u8): rt.u16 | undefined => { - const b3 = arg2; - return rt.thenSome(b3 < 100, rt.u16Mul(b3 as rt.u16, 200)); - })); - for (const v of small) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v)); - } - } else if (value === 1) { - const iter = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const i = item[0]; - const b4 = item[1]; - rt.byteVecPush(out, i & 0xff); - rt.byteVecPush(out, b4); - } - const iter2 = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); - while (true) { - const item2 = iter2.next(); - if (item2 === rt.DONE) { - break; + let _4!: rt.u8; + let doubled!: rt.ByteVec; + let iter!: rt.Iter; + let _18!: rt.u16 | rt.Done; + let _25!: Uint8Array; + let iter2!: rt.Iter<[rt.usize, rt.u8]>; + let _32!: [rt.usize, rt.u8] | rt.Done; + let i!: rt.usize; + let b!: rt.u8; + let iter3!: rt.Iter<[rt.usize, rt.u8]>; + let _46!: [rt.usize, rt.u8] | rt.Done; + let _56!: [Uint8Array, Uint8Array]; + let zipped!: rt.ByteVec; + let chained!: rt.ByteVec; + let taken!: rt.ByteVec; + let skipped!: rt.ByteVec; + let mapped!: rt.ByteVec; + let words!: rt.ByteVec[]; + let flat!: rt.ByteVec; + let it!: rt.Peekable; + let _118!: rt.u8 | rt.Done; + let b2!: rt.u8; + let run!: rt.u8; + let _125!: rt.u8 | undefined; + let _133!: rt.u8 | undefined; + let it2!: rt.Iter; + let firsts!: rt.ByteVec; + let _152!: rt.u8 | undefined; + let rest!: rt.ByteVec; + let pairs!: Uint8Array[]; + let copies!: Uint8Array[]; + let _176!: rt.usize; + let iter4!: rt.Iter; + let _187!: Uint8Array | rt.Done; + let v2!: rt.u16[]; + let _196!: rt.Iter; + b0: { + _4 = rt.u8Rem(kind, 8); + if (_4 === 0) { + doubled = rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_216: rt.u8): rt.u8 => { + return rt.u8Div(_216, 2); + }), (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) !== 0; + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(doubled)); + iter = rt.iterSlice(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { + let b12!: rt.u8; + b12 = _217; + return rt.thenSome(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); + }))); + while (true) { + _18 = iter.next(); + if (_18 === rt.DONE) { + break b0; + } else { + _25 = rt.u16ToBeBytes(_18); + rt.byteVecExtendFromSlice(out, _25); + } } - const i2 = item2[0]; - const b5 = item2[1]; - rt.byteVecPush(out, (i2 & 0xff) ^ b5); - } - } else if (value === 2) { - const [front, back] = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); - const zipped = rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(front), rt.iterRev(rt.iterSlice(back))), (arg3: [rt.u8, rt.u8]): rt.u8 => { - const a = arg3[0]; - const b6 = arg3[1]; - return a ^ b6; - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(zipped)); - const chained = rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(front), rt.iterSlice(back)))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(chained)); - } else if (value === 3) { - const taken = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (arg4: rt.u8): boolean => { - const b7 = arg4; - return b7 !== 0; - })); - const skipped = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (arg5: rt.u8): boolean => { - const b8 = arg5; - return b8 < 0x80; - })); - const mapped = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (arg6: rt.u8): rt.u8 | undefined => { - const b9 = arg6; - return rt.u8CheckedAdd(b9, 0x40); - })); - rt.byteVecPush(out, taken.length & 0xff); - rt.byteVecPush(out, skipped.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); - } else if (value === 4) { - const words = chunksByZero$ChunksByZero_u8s(data); - const flat = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { - return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); - const nested = rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { - return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (arg7: rt.u8): rt.u8 => { - const b10 = arg7; - return rt.u8WrappingAdd(b10, 3); - }); - })); - rt.iterExtendBytes(out, rt.iterRev(nested)); - } else if (value === 5) { - let it: rt.Peekable = rt.iterPeekable(rt.iterSlice(data)); - while (true) { - const next = rt.iterToOption(it.next()); - if (next !== undefined) { - const b11 = next; - let run: rt.u8 = 1; - while (rt.peekableNextIf(it, (arg8: rt.u8): boolean => { - const next2 = arg8; - return next2 === b11; - }) !== undefined) { - run = rt.u8Add(run, 1); + } else if (_4 === 1) { + iter2 = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); + while (true) { + _32 = iter2.next(); + if (_32 === rt.DONE) { + iter3 = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); + while (true) { + _46 = iter3.next(); + if (_46 === rt.DONE) { + break b0; + } else { + rt.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); + } + } + } else { + i = _32[0]; + b = _32[1]; + rt.byteVecPush(out, i & 0xff); + rt.byteVecPush(out, b); } - rt.byteVecPush(out, b11); - rt.byteVecPush(out, run); - const peek = rt.peekablePeek(it); - if (peek !== undefined) { - const next3 = peek; - rt.byteVecPush(out, next3); + } + } else if (_4 === 2) { + _56 = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); + zipped = rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(_56[0]), rt.iterRev(rt.iterSlice(_56[1]))), (_215: [rt.u8, rt.u8]): rt.u8 => { + return _215[0] ^ _215[1]; + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(zipped)); + chained = rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(_56[0]), rt.iterSlice(_56[1])))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(chained)); + } else if (_4 === 3) { + taken = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (_212: rt.u8): boolean => { + return _212 !== 0; + })); + skipped = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (_213: rt.u8): boolean => { + return _213 < 128; + })); + mapped = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (_214: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedAdd(_214, 64); + })); + rt.byteVecPush(out, taken.length & 0xff); + rt.byteVecPush(out, skipped.length & 0xff); + rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); + } else if (_4 === 4) { + words = chunksByZero$ChunksByZero_u8s(data); + flat = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { + return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); + rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { + return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (_211: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(_211, 3); + }); + })))); + } else if (_4 === 5) { + it = rt.iterPeekable(rt.iterSlice(data)); + l4: while (true) { + _118 = it.next(); + if (_118 !== rt.DONE) { + b2 = _118; + run = 1; + while (true) { + _125 = rt.peekableNextIf(it, (_210: rt.u8): boolean => { + return _210 === b2; + }); + if (!((_125 !== undefined))) { + rt.byteVecPush(out, b2); + rt.byteVecPush(out, run); + _133 = rt.peekablePeek(it); + if (_133 !== undefined) { + rt.byteVecPush(out, _133); + continue l4; + } else { + continue l4; + } + } else { + run = rt.u8Add(run, 1); + } + } + } else { + break b0; } + } + } else if (_4 === 6) { + it2 = rt.iterSlice(data); + firsts = rt.iterToByteVec(rt.iterTake(it2, 2)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); + rt.byteVecPush(out, it2.len() & 0xff); + _152 = rt.iterToOption(it2.nextBack()); + if (_152 === undefined) { + rt.byteVecPush(out, 238); } else { - break; + rt.byteVecPush(out, _152); } - } - } else if (value === 6) { - let it2: rt.Iter = rt.iterSlice(data); - const firsts = rt.iterToByteVec(rt.iterTake(it2, 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); - rt.byteVecPush(out, it2.len() & 0xff); - const nextBack = rt.iterToOption(it2.nextBack()); - if (nextBack !== undefined) { - const last = nextBack; - rt.byteVecPush(out, last); + rest = rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rest)); } else { - rt.byteVecPush(out, 0xee); - } - const rest = rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rest)); - } else { - const pairs = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg9: rt.u8): Uint8Array => { - const b12 = arg9; - return Uint8Array.of(b12, ~b12 & 0xff); - })); - let copies: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); - if (!((copies.length === 0))) { - const value2 = copies[rt.idx(copies, 0)]; - value2[0] = 0x55; - } - const iter3 = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); - while (true) { - const pair = iter3.next(); - if (pair === rt.DONE) { - break; + pairs = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Uint8Array => { + let b3!: rt.u8; + b3 = _2; + return Uint8Array.of(b3, ~b3 & 0xff); + })); + copies = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); + if (!((copies.length === 0))) { + const at = rt.idx(copies, 0); + _176 = 0; + if (!(_176 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _176); + } + copies[at][_176] = 85; + } + iter4 = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); + while (true) { + _187 = iter4.next(); + if (_187 === rt.DONE) { + v2 = []; + _196 = rt.iterMap(rt.iterSlice(data), (_22: rt.u8): rt.u16 => { + return rt.u16Add(_22 as rt.u16, 1); + }); + rt.iterExtend(v2, _196); + rt.byteVecPush(out, v2.length & 0xff); + rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (_24: rt.u8): boolean => { + return _24 > 128; + })); + break b0; + } else { + rt.byteVecExtendFromSlice(out, _187); + } } - rt.byteVecExtendFromSlice(out, pair); } - let v2: rt.u16[] = []; - rt.iterExtend(v2, rt.iterMap(rt.iterSlice(data), (arg10: rt.u8): rt.u16 => { - const b13 = arg10; - return rt.u16Add(b13 as rt.u16, 1); - })); - rt.byteVecPush(out, v2.length & 0xff); - rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (arg11: rt.u8): boolean => { - const b14 = arg11; - return b14 > 0x80; - })); } + return; } /** The runs between zero bytes. */ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { - let words: rt.ByteVec[] = []; - let word: rt.ByteVec = new rt.ByteVec(); - for (const item of self) { - const b = item; - if (b === 0) { - const arg = words; - const taken = word; - word = new rt.ByteVec(); - arg.push(taken); + let _0!: rt.ByteVec[]; + let words!: rt.ByteVec[]; + let word!: rt.ByteVec; + let iter!: rt.Iter; + let _6!: rt.u8 | rt.Done; + let b!: rt.u8; + let _13!: rt.ByteVec; + words = []; + word = new rt.ByteVec(); + iter = rt.iterSlice(self); + while (true) { + _6 = iter.next(); + if (_6 === rt.DONE) { + words.push(word); + _0 = words; + return _0; } else { - rt.byteVecPush(word, b); + b = _6; + if (!(b === 0)) { + rt.byteVecPush(word, b); + } else { + const taken = word; + word = new rt.ByteVec(); + _13 = taken; + words.push(_13); + } } } - words.push(word); - return words; } /** Consumers, and how far each reads: `log` records every item a closure sees. */ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - let log: rt.ByteVec = new rt.ByteVec(); - const value = rt.u8Rem(kind, 6); - if (value === 0) { - const any = rt.iterAny(rt.iterInspect(rt.iterSlice(data), (arg: rt.u8): void => { - const b = arg; - rt.byteVecPush(log, b); - }), (arg2: rt.u8): boolean => { - const b2 = arg2; - return b2 > 0xf0; - }); - rt.byteVecPush(out, any ? 1 : 0); - const all = rt.iterAll(rt.iterSlice(data), (arg3: rt.u8): boolean => { - const b3 = arg3; - return b3 !== 0; - }); - rt.byteVecPush(out, all ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (arg4: rt.u8): boolean => { - const b4 = arg4; - return rt.u8Rem(b4, 2) === 0; - })) & 0xff); - } else if (value === 1) { - const found = rt.iterFind(rt.iterInspect(rt.iterSlice(data), (arg5: rt.u8): void => { - const b5 = arg5; - rt.byteVecPush(log, b5); - }), (arg6: rt.u8): boolean => { - const b6 = arg6; - return rt.u8Rem(b6, 7) === 3; - }); - rt.byteVecPush(out, rt.optionUnwrapOr(found, 0xff)); - const mapped = rt.iterFindMap(rt.iterSlice(data), (arg7: rt.u8): rt.u8 | undefined => { - const b7 = arg7; - if (b7 > 0x50) { - return rt.u8CheckedMul(b7, 3); - } else { - return undefined; - } - }); - rt.byteVecPush(out, rt.optionUnwrapOr(mapped, 0)); - const position = rt.iterPosition(rt.iterSlice(data), (arg8: rt.u8): boolean => { - const b8 = arg8; - return b8 === 0x40; - }); - rt.byteVecPush(out, rt.optionMapOr(position, 0xff, (p: rt.usize): rt.u8 => { - return p & 0xff; - })); - const short = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); - const logged = (b9: rt.u8): rt.u8 => { - return b9; - }; - const pairs = rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (arg9: rt.u8): rt.u8 => { - const b10 = arg9; - rt.byteVecPush(log, b10); - return b10; - }), rt.iterSlice(short), true)); - rt.byteVecPush(out, pairs & 0xff); - const walked = rt.iterMap(rt.iterSlice(data), (arg10: rt.u8): rt.u8 => { - const b11 = arg10; - rt.byteVecPush(log, ~b11 & 0xff); - return b11; - }); - const iter = rt.iterZip(walked, rt.iterSlice(short), true); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const a = item[0]; - const b12 = item[1]; - rt.byteVecPush(out, a ^ b12); - } - const iter2 = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (arg11: rt.u8): void => { - const b13 = arg11; - rt.byteVecPush(log, b13); - }), logged), rt.iterSlice(short)); - while (true) { - const item2 = iter2.next(); - if (item2 === rt.DONE) { - break; + let log!: rt.ByteVec; + let _5!: rt.u8; + let _9!: rt.Iter; + let _17!: rt.Iter; + let _31!: rt.Iter; + let _40!: rt.Iter; + let _45!: rt.Iter; + let short!: Uint8Array; + let iter!: rt.Iter<[rt.u8, rt.u8]>; + let _69!: [rt.u8, rt.u8] | rt.Done; + let iter2!: rt.Iter<[rt.u8, rt.u8]>; + let _85!: [rt.u8, rt.u8] | rt.Done; + let back!: rt.Iter<[rt.u8, rt.u8]>; + let _97!: [rt.u8, rt.u8] | undefined; + let a3!: rt.u8; + let b2!: rt.u8; + let _140!: rt.Iter; + let it!: rt.Iter; + let _147!: rt.Iter; + let _162!: rt.Iter; + let _178!: Uint8Array; + let _184!: Uint8Array; + let _198!: Uint8Array; + let parsed!: rt.Result; + let v!: rt.ByteVec; + log = new rt.ByteVec(); + b0: { + _5 = rt.u8Rem(kind, 6); + if (_5 === 0) { + _9 = rt.iterInspect(rt.iterSlice(data), (_228: rt.u8): void => { + rt.byteVecPush(log, _228); + return; + }); + rt.byteVecPush(out, rt.iterAny(_9, (_229: rt.u8): boolean => { + return _229 > 240; + }) ? 1 : 0); + _17 = rt.iterSlice(data); + rt.byteVecPush(out, rt.iterAll(_17, (_230: rt.u8): boolean => { + return _230 !== 0; + }) ? 1 : 0); + rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (_231: rt.u8): boolean => { + return rt.u8Rem(_231, 2) === 0; + })) & 0xff); + } else if (_5 === 1) { + _31 = rt.iterInspect(rt.iterSlice(data), (_220: rt.u8): void => { + rt.byteVecPush(log, _220); + return; + }); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFind(_31, (_221: rt.u8): boolean => { + return rt.u8Rem(_221, 7) === 3; + }), 255)); + _40 = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFindMap(_40, (_222: rt.u8): rt.u8 | undefined => { + let _010!: rt.u8 | undefined; + let b14!: rt.u8; + b14 = _222; + if (!(b14 > 80)) { + _010 = undefined; + } else { + _010 = rt.u8CheckedMul(b14, 3); + } + return _010; + }), 0)); + _45 = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionMapOr(rt.iterPosition(_45, (_223: rt.u8): boolean => { + return _223 === 64; + }), 255, (p: rt.usize): rt.u8 => { + return p & 0xff; + })); + short = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); + rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (_224: rt.u8): rt.u8 => { + let b16!: rt.u8; + b16 = _224; + rt.byteVecPush(log, b16); + return b16; + }), rt.iterSlice(short), true)) & 0xff); + iter = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_225: rt.u8): rt.u8 => { + let b17!: rt.u8; + b17 = _225; + rt.byteVecPush(log, ~b17 & 0xff); + return b17; + }), rt.iterSlice(short), true); + while (true) { + _69 = iter.next(); + if (_69 === rt.DONE) { + iter2 = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_226: rt.u8): void => { + rt.byteVecPush(log, _226); + return; + }), (b19: rt.u8): rt.u8 => { + return b19; + }), rt.iterSlice(short)); + while (true) { + _85 = iter2.next(); + if (_85 === rt.DONE) { + back = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_227: rt.u8): rt.u8 => { + return rotateFree$RotateFree_u8(_227); + }), rt.iterSlice(short), true); + _97 = rt.iterToOption(back.nextBack()); + if (_97 !== undefined) { + a3 = _97[0]; + b2 = _97[1]; + rt.byteVecPush(out, a3); + rt.byteVecPush(out, b2); + } + rt.byteVecPush(out, back.len() & 0xff); + break b0; + } else { + rt.byteVecPush(out, _85[0] ^ _85[1]); + } + } + } else { + rt.byteVecPush(out, _69[0] ^ _69[1]); + } } - const a2 = item2[0]; - const b14 = item2[1]; - rt.byteVecPush(out, a2 ^ b14); - } - let back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (arg12: rt.u8): rt.u8 => { - const b15 = arg12; - return rotateFree$RotateFree_u8(b15); - }), rt.iterSlice(short), true); - const nextBack = rt.iterToOption(back.nextBack()); - if (nextBack !== undefined) { - const a3 = nextBack[0]; - const b16 = nextBack[1]; - rt.byteVecPush(out, a3); - rt.byteVecPush(out, b16); - } - rt.byteVecPush(out, back.len() & 0xff); - } else if (value === 2) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 0xff)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (arg13: rt.u8): rt.u8 => { - const b17 = arg13; - return rt.u8Rem(b17, 16); - }), 0xee)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (arg14: rt.u8): rt.u8 => { - const b18 = arg14; - return rt.u8Div(b18, 16); - }), 0xee)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 0xdd)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(rt.iterSlice(data), 3), 0xcc)); - let it: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(rt.iterTake(it, rt.usizeRem(data.length, 3)).nthBackItem(1)), 0xbb)); - rt.byteVecPush(out, it.len() & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(rt.iterTake(it, rt.usizeRem(data.length, 5)), 2), 0xbb)); - rt.byteVecPush(out, it.len() & 0xff); - } else if (value === 3) { - const wide = rt.iterSum(rt.iterMap(rt.iterSlice(data), (arg15: rt.u8): rt.u64 => { - const b19 = arg15; - return rt.u64Mul(b19 as rt.u64, 0x0101_0101_0101); - }), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(wide)); - const folded = rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, arg16: rt.u8): rt.u32 => { - const b20 = arg16; - return rt.u32WrappingAdd((acc << 3) >>> 0, (b20 as rt.u32 ^ acc) >>> 0); - }); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(folded)); - rt.iterForEach(rt.iterSlice(data), (arg17: rt.u8): void => { - const b21 = arg17; - rt.byteVecPush(log, rotateFree$RotateFree_u8(b21)); - }); - } else if (value === 4) { - const total = rt.iterSum(rt.iterSlice(data), rt.u8Add, 0); - rt.byteVecPush(out, total); - const product = rt.iterProduct(rt.iterMap(rt.iterSlice(data), (arg18: rt.u8): rt.u16 => { - const b22 = arg18; - return rt.u16Add(rt.u16Rem(b22 as rt.u16, 4), 1); - }), rt.u16Mul, 1); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(product)); - } else { - const parsed = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (arg19: rt.u8): rt.Result => { - const b23 = arg19; - if (b23 < 0xf0) { - return rt.Ok(b23); + } else if (_5 === 2) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 255)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (_218: rt.u8): rt.u8 => { + return rt.u8Rem(_218, 16); + }), 238)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (_219: rt.u8): rt.u8 => { + return rt.u8Div(_219, 16); + }), 238)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 221)); + _140 = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_140, 3), 204)); + it = rt.iterSlice(data); + _147 = rt.iterTake(it, rt.usizeRem(data.length, 3)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(_147.nthBackItem(1)), 187)); + rt.byteVecPush(out, it.len() & 0xff); + _162 = rt.iterTake(it, rt.usizeRem(data.length, 5)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_162, 2), 187)); + rt.byteVecPush(out, it.len() & 0xff); + } else if (_5 === 3) { + _178 = rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { + return rt.u64Mul(_214 as rt.u64, 1103823438081); + }), rt.u64Add, 0)); + rt.byteVecExtendFromSlice(out, _178); + _184 = rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { + let b8!: rt.u8; + let _510!: rt.u32; + b8 = _34; + _510 = (acc << 3) >>> 0; + return rt.u32WrappingAdd(_510, (b8 as rt.u32 ^ acc) >>> 0); + })); + rt.byteVecExtendFromSlice(out, _184); + rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { + rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); + return; + }); + } else if (_5 === 4) { + rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); + _198 = rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { + return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); + }), rt.u16Mul, 1)); + rt.byteVecExtendFromSlice(out, _198); + } else { + parsed = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { + let _0!: rt.Result; + let b3!: rt.u8; + b3 = _2; + if (!(b3 < 240)) { + _0 = rt.Err(b3); + } else { + _0 = rt.Ok(b3); + } + return _0; + }), (values__: rt.Iter) => rt.iterToByteVec(values__)); + if (parsed.ok) { + v = parsed.value; + rt.byteVecExtendFromSlice(out, rt.byteVecView(v)); } else { - return rt.Err(b23); + rt.byteVecPush(out, parsed.error); } - }), (values__: rt.Iter) => rt.iterToByteVec(values__)); - if (parsed.ok) { - const v = parsed.value; - rt.byteVecExtendFromSlice(out, rt.byteVecView(v)); - } else { - const e = parsed.error; - rt.byteVecPush(out, e); + rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_24: rt.u8): void => { + rt.byteVecPush(log, _24); + return; + }), (_29: rt.u8): rt.u16 | undefined => { + let b5!: rt.u8; + b5 = _29; + return rt.thenSome(b5 !== 32, b5 as rt.u16); + }), (values__: rt.Iter) => rt.iterToArray(values__)), 255, (v2: rt.u16[]): rt.u8 => { + return v2.length & 0xff; + })); } - const some = rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (arg20: rt.u8): void => { - const b24 = arg20; - rt.byteVecPush(log, b24); - }), (arg21: rt.u8): rt.u16 | undefined => { - const b25 = arg21; - return rt.thenSome(b25 !== 0x20, b25 as rt.u16); - }), (values__: rt.Iter) => rt.iterToArray(values__)); - rt.byteVecPush(out, rt.optionMapOr(some, 0xff, (v2: rt.u16[]): rt.u8 => { - return v2.length & 0xff; - })); } rt.byteVecExtendFromSlice(out, rt.byteVecView(log)); + return; } export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { @@ -353,99 +436,159 @@ export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { /** Ranges as values and as iterators. */ export function ranges(data: Uint8Array, out: rt.ByteVec): void { - const a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); - const range = new rt.Range(a, b); - rt.byteVecPush(out, range.start); - rt.byteVecPush(out, range.end); + let a!: rt.u8; + let b!: rt.u8; + let range!: rt.Range; + let copy!: rt.Range; + let iter!: rt.Iter; + let _37!: rt.u8 | rt.Done; + let iter2!: rt.Iter; + let _47!: rt.u8 | rt.Done; + let _56!: rt.Range; + let top!: rt.ByteVec; + let inclusive!: rt.RangeInclusive; + let near!: rt.RangeInclusive; + let low!: rt.RangeInclusive; + let _107!: rt.usize; + let _119!: rt.u8; + let reversed!: rt.RangeInclusive; + let _126!: rt.Iter; + let counted!: rt.Iter<[rt.usize, rt.u8]>; + let i3!: rt.usize; + let n!: rt.u8; + let _143!: [rt.usize, rt.u8]; + let _146!: rt.usize; + let stepped!: rt.RangeInclusive; + let wide!: rt.Range; + let _196!: Uint8Array; + let edge!: rt.u64; + let past!: rt.Range; + let _213!: Uint8Array; + let _217!: rt.usize; + let _223!: Uint8Array; + let _230!: Uint8Array; + let _234!: rt.RangeInclusive; + let _237!: rt.usize; + let _244!: rt.u64; + let _251!: Uint8Array; + let _261!: Uint8Array; + let _265!: rt.i64; + let _267!: rt.i64; + let _274!: rt.i64; + let _282!: Uint8Array; + let iter3!: rt.Iter; + let _289!: rt.u32 | rt.Done; + a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); + range = new rt.Range(a, b); + rt.byteVecPush(out, a); + rt.byteVecPush(out, b); rt.byteVecPush(out, rt.rangeIsEmpty(range) ? 1 : 0); - rt.byteVecPush(out, rt.rangeContains(range, 0x40) ? 1 : 0); - let copy: rt.Range = rt.rangeClone(range); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(copy.next()), 0xff)); + rt.byteVecPush(out, rt.rangeContains(range, 64) ? 1 : 0); + copy = rt.rangeClone(range); + rt.byteVecPush(out, rt.optionUnwrapOr(copy.start < copy.end ? copy.start++ : undefined, 255)); rt.byteVecPush(out, range.len() & 0xff); - const iter = rt.iterStepBy(rt.iterRev(range), 3); - while (true) { - const i = iter.next(); - if (i === rt.DONE) { - break; - } - rt.byteVecPush(out, i); - } - const iter2 = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); + iter = rt.iterStepBy(rt.iterRev(range), 3); while (true) { - const i2 = iter2.next(); - if (i2 === rt.DONE) { - break; + _37 = iter.next(); + if (_37 === rt.DONE) { + iter2 = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); + while (true) { + _47 = iter2.next(); + if (_47 === rt.DONE) { + _56 = new rt.Range(a, b); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_56, 5), 238)); + top = rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(top)); + inclusive = new rt.RangeInclusive(a, b, rt.u8Step); + rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); + rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); + near = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 238)); + rt.byteVecPush(out, rt.rangeInclusiveStart(near)); + rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); + low = new rt.RangeInclusive(0, b, rt.u8Step); + _107 = rt.usizeRem(a as rt.usize, 16); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(_107)), 238)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); + _119 = rt.u8Div(b, 2); + rt.byteVecPush(out, rt.rangeInclusiveContains(low, _119) ? 1 : 0); + reversed = new rt.RangeInclusive(a, b, rt.u8Step); + _126 = rt.iterRev(reversed); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_126, a as rt.usize), 238)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); + rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); + counted = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); + _146 = rt.usizeDiv(b as rt.usize, 4); + _143 = rt.optionUnwrapOr(rt.iterNth(counted, _146), [221, 221] as [rt.usize, rt.u8]); + i3 = _143[0]; + n = _143[1]; + rt.byteVecPush(out, i3 & 0xff); + rt.byteVecPush(out, n); + rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 204, (_2: [rt.usize, rt.u8]): rt.u8 => { + return _2[0] & 0xff; + })); + stepped = new rt.RangeInclusive(a, b, rt.u8Step); + rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(stepped, 3)) & 0xff); + rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step)), (i5: rt.i8): rt.u8 => { + return i5 & 0xff; + })); + wide = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(wide, (n2: rt.u64): rt.u64 => { + return rt.u64Rem(n2, 5); + }), (_23: rt.u64): boolean => { + return _23 === 0; + })) & 0xff); + rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); + _196 = rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0)); + rt.byteVecExtendFromSlice(out, _196); + edge = rt.u64Add(rt.u64Sub(rt.u64Of(9007199254740992n), 2), rt.u64Rem(a as rt.u64, 4)); + past = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); + _217 = rt.usizeRem(b as rt.usize, 3); + _213 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _217), 0)); + rt.byteVecExtendFromSlice(out, _213); + _223 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0)); + rt.byteVecExtendFromSlice(out, _223); + _234 = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); + _237 = rt.usizeRem(b as rt.usize, 5); + _230 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_234, _237), 0)); + rt.byteVecExtendFromSlice(out, _230); + _244 = rt.u64Rem(a as rt.u64, 3); + _251 = rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _244), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { + return rt.u64Rem(n4, 7); + }), rt.u64Add, 0)); + rt.byteVecExtendFromSlice(out, _251); + _261 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { + return _24; + }), 0)); + rt.byteVecExtendFromSlice(out, _261); + _267 = rt.i64Of(9007199254740992n); + _265 = rt.i64Sub(rt.i64Neg(_267), 1); + _274 = rt.i64Of(9007199254740992n); + _282 = rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(_265, rt.i64Add(rt.i64Neg(_274), 1), rt.i64Step)), 0)); + rt.byteVecExtendFromSlice(out, _282); + iter3 = rt.iterSlice(rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)))); + while (true) { + _289 = iter3.next(); + if (_289 === rt.DONE) { + updates(a, b, data, out); + return; + } else { + rt.byteVecPush(out, _289 & 0xff); + } + } + } else { + rt.byteVecPush(out, _47); + } + } + } else { + rt.byteVecPush(out, _37); } - rt.byteVecPush(out, i2); } - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(new rt.Range(a, b), 5), 0xee)); - const top = rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(top)); - const inclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); - let near: rt.RangeInclusive = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 0xee)); - rt.byteVecPush(out, rt.rangeInclusiveStart(near)); - rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); - let low: rt.RangeInclusive = new rt.RangeInclusive(0, b, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(rt.usizeRem(a as rt.usize, 16))), 0xee)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); - rt.byteVecPush(out, rt.rangeInclusiveContains(low, rt.u8Div(b, 2)) ? 1 : 0); - let reversed: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(rt.iterRev(reversed), a as rt.usize), 0xee)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); - rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); - let counted: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); - const [i3, n] = rt.optionUnwrapOr(rt.iterNth(counted, rt.usizeDiv(b as rt.usize, 4)), [0xdd, 0xdd] as [rt.usize, rt.u8]); - rt.byteVecPush(out, i3 & 0xff); - rt.byteVecPush(out, n); - rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 0xcc, (arg: [rt.usize, rt.u8]): rt.u8 => { - const i4 = arg[0]; - return i4 & 0xff; - })); - let stepped: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(stepped, 3)) & 0xff); - rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); - const signed = new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(signed), (i5: rt.i8): rt.u8 => { - return i5 & 0xff; - })); - let wide: rt.Range = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(wide, (n2: rt.u64): rt.u64 => { - return rt.u64Rem(n2, 5); - }), (arg2: rt.u64): boolean => { - const n3 = arg2; - return n3 === 0; - })) & 0xff); - rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); - const total = rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total)); - const edge = rt.u64Add(9007199254740990, rt.u64Rem(a as rt.u64, 4)); - let past: rt.Range = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, rt.usizeRem(b as rt.usize, 3)), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step), rt.usizeRem(b as rt.usize, 5)), 0))); - const top2 = rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), rt.u64Rem(a as rt.u64, 3)), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { - return rt.u64Rem(n4, 7); - }), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(top2)); - const most = rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (arg3: rt.u64): rt.u64 => { - const n5 = arg3; - return n5; - }), 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(most)); - const least = rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(least)); - const steps = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); - for (const s of steps) { - rt.byteVecPush(out, s & 0xff); - } - updates(a, b, data, out); } /** @@ -453,173 +596,244 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { * the rest are read from it. */ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - let base: rt.Range = new rt.Range(a, b); - rt.byteVecPush(out, 0xd0); - const field = rt.u8Div(b, 2); - rt.byteVecPush(out, 0xd1); - const range = rt.rangeClone(base); - const field2 = field; - const made = new rt.Range(range.start, field2); - const clone = rt.rangeClone(base); - const whole = new rt.Range(clone.start, clone.end); - rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, made.end, whole.start, whole.end)); - const start = rt.u8Div(a, 2); - const end = base.end; - for (let i = start; i < end; i++) { - base.end = rt.u8WrappingAdd(base.end, 1); - rt.byteVecPush(out, i); + let base!: rt.Range; + let made!: rt.Range; + let _7!: rt.u8; + let whole!: rt.Range; + let _14!: rt.Range; + let _19!: Uint8Array; + let iter!: rt.Range; + let _29!: rt.u8; + let i!: rt.u8; + let _33!: rt.u8; + let len!: rt.usize; + let to!: rt.usize; + let from!: rt.usize; + let _41!: [rt.usize, rt.usize]; + let all!: rt.Range; + let copied!: rt.ByteVec; + let _76!: Uint8Array; + let _29Some!: boolean; + base = new rt.Range(a, b); + rt.byteVecPush(out, 208); + _7 = rt.u8Div(b, 2); + rt.byteVecPush(out, 209); + made = new rt.Range(rt.rangeClone(base).start, _7); + _14 = rt.rangeClone(base); + whole = new rt.Range(_14.start, _14.end); + _19 = Uint8Array.of(made.start, _7, whole.start, whole.end); + rt.byteVecExtendFromSlice(out, _19); + iter = new rt.Range(rt.u8Div(a, 2), base.end); + while (true) { + _29Some = iter.start < iter.end; + if (_29Some) { + _29 = iter.start++; + } + if (!_29Some) { + rt.byteVecPush(out, base.end); + len = data.length; + _41 = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)] as [rt.usize, rt.usize]; + to = _41[0]; + from = _41[1]; + all = new rt.Range(0, len); + rt.byteVecPush(out, 210); + rt.byteVecPush(out, 211); + rt.byteVecPush(out, 212); + rt.byteVecExtendFromSlice(out, rt.sliceRange(data, from, rt.rangeClone(all).end)); + rt.byteVecPush(out, 213); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, 214); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + fullRange(out); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + copied = rt.sliceToByteVec(data); + _76 = rt.byteVecView(copied); + rt.sliceCopyWithin(_76, 0, to, 0); + rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); + return; + } else { + i = _29; + _33 = rt.u8WrappingAdd(base.end, 1); + base.end = _33; + rt.byteVecPush(out, i); + } } - rt.byteVecPush(out, base.end); - const len = data.length; - const [to, from] = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)] as [rt.usize, rt.usize]; - const all = new rt.Range(0, len); - rt.byteVecPush(out, 0xd2); - const arg = data; - rt.byteVecPush(out, 0xd3); - const field3 = from; - rt.byteVecPush(out, 0xd4); - const range2 = rt.rangeClone(all); - const sliced = rt.sliceRange(arg, field3, range2.end); - rt.byteVecExtendFromSlice(out, sliced); - const arg2 = data; - rt.byteVecPush(out, 0xd5); - const full = rt.sliceRange(arg2, 0); - rt.byteVecPush(out, full.length & 0xff); - const arg3 = data; - rt.byteVecPush(out, 0xd6); - const full2 = rt.sliceRange(arg3, 0); - rt.byteVecPush(out, full2.length & 0xff); - const arg4 = data; - fullRange(out); - const full3 = rt.sliceRange(arg4, 0); - rt.byteVecPush(out, full3.length & 0xff); - const full4 = rt.sliceRange(data, 0); - rt.byteVecPush(out, full4.length & 0xff); - let copied: rt.ByteVec = rt.sliceToByteVec(data); - const arg5 = rt.byteVecView(copied); - const field4 = to; - rt.sliceCopyWithin(arg5, all.start, field4, 0); - rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); } /** `..`, logging that it was made. */ export function fullRange(out: rt.ByteVec): undefined { - rt.byteVecPush(out, 0xd7); - return undefined; + rt.byteVecPush(out, 215); + return; } /** Iterators of `Option`, which keep each `None` apart from their end. */ export function options(data: Uint8Array, out: rt.ByteVec): void { - const maybe = (b: rt.u8): rt.u8 | undefined => { - if (rt.u8Rem(b, 3) === 0) { - return undefined; + let all!: Array; + let iter!: rt.Iter; + let _15!: rt.u8 | undefined | rt.Done; + let item!: rt.u8 | undefined; + let flat!: rt.ByteVec; + let first!: rt.u8 | undefined; + let iter2!: rt.Iter; + let _49!: rt.u8 | rt.Done; + let _57!: rt.Iter; + let n!: rt.u8; + let counted!: rt.ByteVec; + let iter3!: Gaps.Gaps; + let _70!: rt.u8 | undefined | rt.Done; + all = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (b2: rt.u8): rt.u8 | undefined => { + let _0!: rt.u8 | undefined; + if (!(rt.u8Rem(b2, 3) === 0)) { + _0 = b2; } else { - return b; + _0 = undefined; } - }; - const all = rt.iterToArray(rt.iterMap(rt.iterSlice(data), maybe)); + return _0; + })); rt.byteVecPush(out, all.length & 0xff); - const iter = rt.iterMap(rt.iterSlice(data), maybe); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - if (item !== undefined) { - const b2 = item; - rt.byteVecPush(out, b2); + iter = rt.iterMap(rt.iterSlice(data), (b3: rt.u8): rt.u8 | undefined => { + let _02!: rt.u8 | undefined; + if (!(rt.u8Rem(b3, 3) === 0)) { + _02 = b3; } else { - rt.byteVecPush(out, 0); + _02 = undefined; } - } - const flat = rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), maybe), (value: rt.u8 | undefined) => rt.iterOption(value))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); - const somes = rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { - return o !== undefined; - })); - rt.byteVecPush(out, somes & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), maybe)), 0xcd)); - const first = rt.sliceFirst(data); - const iter2 = rt.iterChain(rt.iterOption(first), rt.iterOnce(0x99)); - while (true) { - const b3 = iter2.next(); - if (b3 === rt.DONE) { - break; - } - rt.byteVecPush(out, b3); - } - rt.iterExtendBytes(out, rt.iterChain(rt.iterOption(first), rt.iterEmpty())); - let n: rt.u8 = 0; - const counted = rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { - n = rt.u8Add(n, 1); - return rt.thenSome(n < 4, n); - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(counted)); - const gaps = { data, at: 0 }; + return _02; + }); while (true) { - const gap = Gaps.next$Iterator(gaps); - if (gap === rt.DONE) { - break; + _15 = iter.next(); + if (_15 === rt.DONE) { + flat = rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), (b4: rt.u8): rt.u8 | undefined => { + let _03!: rt.u8 | undefined; + if (!(rt.u8Rem(b4, 3) === 0)) { + _03 = b4; + } else { + _03 = undefined; + } + return _03; + }), (value: rt.u8 | undefined) => rt.iterOption(value))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { + return o !== undefined; + })) & 0xff); + rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), (b5: rt.u8): rt.u8 | undefined => { + let _05!: rt.u8 | undefined; + if (!(rt.u8Rem(b5, 3) === 0)) { + _05 = b5; + } else { + _05 = undefined; + } + return _05; + })), 205)); + first = rt.sliceFirst(data); + iter2 = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); + while (true) { + _49 = iter2.next(); + if (_49 === rt.DONE) { + _57 = rt.iterOption(first); + rt.iterEmpty(); + rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty())); + n = 0; + counted = rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { + n = rt.u8Add(n, 1); + return rt.thenSome(n < 4, n); + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(counted)); + iter3 = { data, at: 0 }; + while (true) { + _70 = Gaps.next$Iterator(iter3); + if (_70 === rt.DONE) { + return; + } else { + rt.byteVecPush(out, rt.optionMapOr(_70, 170, (b6: rt.u8): rt.u8 => { + return b6; + })); + } + } + } else { + rt.byteVecPush(out, _49); + } + } + } else { + item = _15; + if (item === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, item); + } } - rt.byteVecPush(out, rt.optionMapOr(gap, 0xaa, (b4: rt.u8): rt.u8 => { - return b4; - })); } } /** The second item of an iterator of options, through `?`, which tests for its end. */ export function second$Map_Iter_u8_options_closure0(items: rt.Iter): rt.u8 | undefined { - const next = items.next(); - if (next === rt.DONE) { - return undefined; - } - const next2 = items.next(); - if (next2 === rt.DONE) { - return undefined; + let _0!: rt.u8 | undefined; + let _2!: rt.u8 | undefined | rt.Done; + let _7!: rt.u8 | undefined | rt.Done; + _2 = items.next(); + if (_2 !== rt.DONE) { + _7 = items.next(); + if (_7 !== rt.DONE) { + _0 = rt.optionUnwrapOr(_7, 171); + } else { + _0 = undefined; + } + } else { + _0 = undefined; } - const item = next2; - return rt.optionUnwrapOr(item, 0xab); + return _0; } /** The crate's own iterators, through `for`, adaptors, and `next`. */ export function own(data: Uint8Array, out: rt.ByteVec): void { - const left = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const step = rt.max(rt.optionUnwrapOr(rt.sliceGet(data, 1), 1), 1); - const iter = { left, step }; + let left!: rt.u8; + let step!: rt.u8; + let iter!: Countdown.Countdown; + let _13!: rt.u8 | rt.Done; + let _24!: Uint8Array; + let down!: Countdown.Countdown; + let _26!: rt.u8 | rt.Done; + let evens!: rt.ByteVec; + let byRef!: Evens.Evens; + let firsts!: rt.ByteVec; + let halves!: rt.ByteVec; + let _73!: Uint8Array; + left = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + step = rt.max(rt.optionUnwrapOr(rt.sliceGet(data, 1), 1), 1); + iter = { left, step }; while (true) { - const n = Countdown.next$Iterator(iter); - if (n === rt.DONE) { - break; - } - rt.byteVecPush(out, n); - } - const total = rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n2: rt.u8): rt.u64 => { - return rt.u64Div(rt.u64Mul(n2 as rt.u64, 1000), 7); - }), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total)); - let down: Countdown.Countdown = { left, step }; - while (true) { - const next = rt.iterToOption(Countdown.next$Iterator(down)); - if (next !== undefined) { - const n3 = next; - if (rt.u8Rem(n3, 5) === 0) { - break; + _13 = Countdown.next$Iterator(iter); + if (_13 === rt.DONE) { + _24 = rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { + return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); + }), rt.u64Add, 0)); + rt.byteVecExtendFromSlice(out, _24); + down = { left, step }; + l1: while (true) { + _26 = Countdown.next$Iterator(down); + if (_26 !== rt.DONE) { + if (!(rt.u8Rem(_26, 5) === 0)) { + continue l1; + } + } + rt.byteVecPush(out, down.left); + evens = rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(evens)); + byRef = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; + firsts = rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); + rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); + halves = rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(halves)); + _73 = rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0)); + rt.byteVecExtendFromSlice(out, _73); + return; } } else { - break; + rt.byteVecPush(out, _13); } } - rt.byteVecPush(out, down.left); - const evens = rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(evens)); - let byRef: Evens.Evens = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; - const firsts = rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); - rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); - const halves = rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(halves)); - const total2 = rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 0x1_0000_0001) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total2)); } /** @@ -639,67 +853,84 @@ export function odds(data: Uint8Array): rt.Iter { /** Iterators as values: returned, stored, and printed. */ export function values(data: Uint8Array, out: rt.ByteVec): void { - const iter = tail(Uint8Array.of(1, 2, 3), data); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const b = item; - rt.byteVecPush(out, b); - } - let held: Held.Held = { it: rt.iterSlice(data) }; - rt.byteVecPush(out, Held.skipOne(held)); - const iter2 = odds(data); - while (true) { - const b2 = iter2.next(); - if (b2 === rt.DONE) { - break; - } - rt.byteVecPush(out, b2); - } - const arg = { _0: data }; - const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; - const printed = rt.fmtFormat([(f: rt.Formatter) => Doubled.fmt$Debug(arg, f), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f))]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(printed)); - const tags = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg3: rt.u8): Tag.Tag => { - const b3 = arg3; - return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; - })); - let cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); - const iter3 = rt.iterSlice(cloned); + let iter!: rt.Iter; + let _8!: rt.u8 | rt.Done; + let held!: Held.Held; + let iter2!: rt.Iter; + let _21!: rt.u8 | rt.Done; + let printed!: string; + let _31!: Doubled.Doubled; + let _33!: Doubled.Doubled; + let tags!: Tag.Tag[]; + let cloned!: Tag.Tag[]; + let iter3!: rt.Iter; + let _59!: Tag.Tag | rt.Done; + let iter4!: rt.Iter; + let _74!: Tag.Tag | rt.Done; + let bumps!: Bumped.Bumped[]; + let wrapped!: Wrapper.Wrapper[]; + iter = tail(Uint8Array.of(1, 2, 3), data); while (true) { - const tag = iter3.next(); - if (tag === rt.DONE) { - break; - } - rt.byteVecPush(tag.bytes, 0x77); - } - const iter4 = rt.iterChain(rt.iterSlice(tags), rt.iterSlice(cloned)); - while (true) { - const tag2 = iter4.next(); - if (tag2 === rt.DONE) { - break; + _8 = iter.next(); + if (_8 === rt.DONE) { + held = { it: rt.iterSlice(data) }; + rt.byteVecPush(out, Held.skipOne(held)); + iter2 = odds(data); + while (true) { + _21 = iter2.next(); + if (_21 === rt.DONE) { + _31 = { _0: data }; + _33 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; + printed = rt.fmtFormat([(f: rt.Formatter) => Doubled.fmt$Debug(_31, f), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Doubled.fmt$Debug(_33, f))]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(printed)); + tags = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tag.Tag => { + let b3!: rt.u8; + let _7!: Uint8Array; + b3 = _2; + _7 = Uint8Array.of(b3, ~b3 & 0xff); + return { bytes: rt.sliceToByteVec(_7) }; + })); + cloned = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); + iter3 = rt.iterSlice(cloned); + while (true) { + _59 = iter3.next(); + if (_59 === rt.DONE) { + iter4 = rt.iterChain(rt.iterSlice(tags), rt.iterSlice(cloned)); + while (true) { + _74 = iter4.next(); + if (_74 === rt.DONE) { + bumps = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_22: rt.u8): Bumped.Bumped => { + return { _0: _22 }; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { + return b5._0; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), rt.copy), (b6: Bumped.Bumped): rt.u8 => { + return b6._0; + })); + wrapped = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_23: rt.u8): Wrapper.Wrapper => { + return new Wrapper.Wrapper({ _0: _23 }); + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(wrapped), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { + return w._0._0; + })); + return; + } else { + rt.byteVecExtendFromSlice(out, rt.byteVecView(_74.bytes)); + } + } + } else { + rt.byteVecPush(_59.bytes, 119); + } + } + } else { + rt.byteVecPush(out, _21); + } + } + } else { + rt.byteVecPush(out, _8); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(tag2.bytes)); } - const bumps = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg4: rt.u8): Bumped.Bumped => { - const b4 = arg4; - return { _0: b4 }; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { - return b5._0; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), rt.copy), (b6: Bumped.Bumped): rt.u8 => { - return b6._0; - })); - const wrapped = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg5: rt.u8): Wrapper.Wrapper => { - const b7 = arg5; - return new Wrapper.Wrapper({ _0: b7 }); - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(wrapped), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { - return w._0._0; - })); } //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Meters.ts b/ts/fixtures/lang/expected/shapes.Meters.ts index 538a61deb..8de1e986d 100644 --- a/ts/fixtures/lang/expected/shapes.Meters.ts +++ b/ts/fixtures/lang/expected/shapes.Meters.ts @@ -13,8 +13,11 @@ export function area$Area(self: Meters): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area(self: Meters, out: rt.ByteVec): void { - rt.byteVecPush(out, 0xaa); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(self._0)); + let _7!: Uint8Array; + rt.byteVecPush(out, 170); + _7 = rt.u64ToBeBytes(self._0); + rt.byteVecExtendFromSlice(out, _7); + return; } //# sourceMappingURL=shapes.Meters.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Moved.ts b/ts/fixtures/lang/expected/shapes.Moved.ts index 8ea849406..9c8b36d11 100644 --- a/ts/fixtures/lang/expected/shapes.Moved.ts +++ b/ts/fixtures/lang/expected/shapes.Moved.ts @@ -3,7 +3,15 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Moved, f: rt.Formatter): rt.Result { - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Moved"), (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.u16Display(self._1, f))); + let _3!: string; + let _4!: rt.Fmt; + let _6!: rt.Fmt; + let _8!: rt.u16; + _4 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _8 = self._1; + _3 = "Moved"; + _6 = (f: rt.Formatter) => rt.u16Display(_8, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); } /** A tuple struct that is not `Copy`, so struct update syntax reads its base in place. */ diff --git a/ts/fixtures/lang/expected/shapes.Point.ts b/ts/fixtures/lang/expected/shapes.Point.ts index 578bdb159..5827aff93 100644 --- a/ts/fixtures/lang/expected/shapes.Point.ts +++ b/ts/fixtures/lang/expected/shapes.Point.ts @@ -3,11 +3,29 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Point, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Point"), "x", (f: rt.Formatter) => rt.i32Display(self.x, f)), "y", (f: rt.Formatter) => rt.i32Display(self.y, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: rt.i32; + _5 = (f: rt.Formatter) => rt.i32Display(self.x, f); + _10 = self.y; + _3 = "Point"; + _4 = "x"; + _7 = "y"; + _8 = (f: rt.Formatter) => rt.i32Display(_10, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$PartialEq(self: Point, other: Point): boolean { - return self.x === other.x && self.y === other.y; + let _0!: boolean; + if (!(self.x === other.x)) { + _0 = false; + } else { + _0 = self.y === other.y; + } + return _0; } /** A `Copy` struct, which Rust copies where JS would share. */ @@ -22,12 +40,18 @@ function new_(x: rt.i32, y: rt.i32): Point { /** Changes `self`, which a caller's copy must not see. */ export function shift(self: Point, by: rt.i32): Point { - self.x = rt.i32Add(self.x, by); + let _3!: rt.i32; + self = rt.copy(self); + _3 = rt.i32Add(self.x, by); + self.x = _3; return rt.copy(self); } export function bump(self: Point): void { - self.y = rt.i32Add(self.y, 1); + let _2!: rt.i32; + _2 = rt.i32Add(self.y, 1); + self.y = _2; + return; } export { new_ as new }; diff --git a/ts/fixtures/lang/expected/shapes.Shape.ts b/ts/fixtures/lang/expected/shapes.Shape.ts index e9a1ea58d..00a2f9d25 100644 --- a/ts/fixtures/lang/expected/shapes.Shape.ts +++ b/ts/fixtures/lang/expected/shapes.Shape.ts @@ -4,18 +4,39 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug(self: Shape, f: rt.Formatter): rt.Result { + let _0!: rt.Result; + let __self1!: Point.Point; + let _7!: string; + let _8!: rt.Fmt; + let _9!: rt.Fmt; + let __self2!: rt.u16; + let _14!: string; + let _15!: string; + let _16!: rt.Fmt; + let _17!: string; + let _18!: rt.Fmt; + let _19!: string; + let _20!: rt.Fmt; if (self.tag === "Dot") { - return rt.fmtWriteStr(f, "Dot"); + _0 = rt.fmtWriteStr(f, "Dot"); } else if (self.tag === "Line") { - const __self0 = self._0; - const __self1 = self._1; - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Line"), (f: rt.Formatter) => Point.fmt$Debug(__self0, f)), (f: rt.Formatter) => Point.fmt$Debug(__self1, f))); + __self1 = self._1; + _7 = "Line"; + _8 = (f: rt.Formatter) => Point.fmt$Debug(self._0, f); + _9 = (f: rt.Formatter) => Point.fmt$Debug(__self1, f); + _0 = rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8), _9)); } else { - const __self02 = self.corner; - const __self12 = self.width; - const __self2 = self.height; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Rect"), "corner", (f: rt.Formatter) => Point.fmt$Debug(__self02, f)), "width", (f: rt.Formatter) => rt.u16Display(__self12, f)), "height", (f: rt.Formatter) => rt.u16Display(__self2, f))); + __self2 = self.height; + _14 = "Rect"; + _15 = "corner"; + _16 = (f: rt.Formatter) => Point.fmt$Debug(self.corner, f); + _17 = "width"; + _18 = (f: rt.Formatter) => rt.u16Display(self.width, f); + _19 = "height"; + _20 = (f: rt.Formatter) => rt.u16Display(__self2, f); + _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); } + return _0; } /** An enum with data, and one without. */ @@ -26,20 +47,27 @@ export type Shape = /** A default method, monomorphized for each type. */ export function describe$Area(self: Shape, out: rt.ByteVec): void { + let _7!: Uint8Array; rt.byteVecPush(out, 4); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area(self))); + _7 = rt.u64ToBeBytes(area$Area(self)); + rt.byteVecExtendFromSlice(out, _7); + return; } export function area$Area(self: Shape): rt.u64 { + let _0!: rt.u64; + let width!: rt.u16; + let height!: rt.u16; if (self.tag === "Dot") { - return 0; + _0 = 0; } else if (self.tag === "Line") { - return 0; + _0 = 0; } else { - const width = self.width; - const height = self.height; - return rt.u64Mul(width as rt.u64, height as rt.u64); + width = self.width; + height = self.height; + _0 = rt.u64Mul(width as rt.u64, height as rt.u64); } + return _0; } //# sourceMappingURL=shapes.Shape.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Void.ts b/ts/fixtures/lang/expected/shapes.Void.ts index ed108a3d6..136df03fe 100644 --- a/ts/fixtures/lang/expected/shapes.Void.ts +++ b/ts/fixtures/lang/expected/shapes.Void.ts @@ -2,8 +2,8 @@ import * as rt from "./rt.ts"; -export function fmt$Debug(self: Void, _f: rt.Formatter): rt.Result { - rt.unreachable(self); +export function fmt$Debug(_self: Void, _f: rt.Formatter): rt.Result { + rt.unreachable(undefined); } /** An enum without variants: no value of it exists. */ diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 23703598c..6aa9edc77 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -12,147 +12,312 @@ import * as Void from "./shapes.Void.ts"; import type * as Wide from "./shapes.Wide.ts"; export function total$Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { - let sum: rt.u64 = 0; - for (const item of items) { - Meters.describe$Area(item, out); - sum = rt.u64SaturatingAdd(sum, Meters.area$Area(item)); + let sum!: rt.u64; + let iter!: rt.Iter; + let _6!: Meters.Meters | rt.Done; + sum = 0; + iter = rt.iterSlice(items); + while (true) { + _6 = iter.next(); + if (_6 === rt.DONE) { + return sum; + } else { + Meters.describe$Area(_6, out); + sum = rt.u64SaturatingAdd(sum, Meters.area$Area(_6)); + } } - return sum; } export function total$Shape(items: Shape.Shape[], out: rt.ByteVec): rt.u64 { - let sum: rt.u64 = 0; - for (const item of items) { - Shape.describe$Area(item, out); - sum = rt.u64SaturatingAdd(sum, Shape.area$Area(item)); + let sum!: rt.u64; + let iter!: rt.Iter; + let _6!: Shape.Shape | rt.Done; + sum = 0; + iter = rt.iterSlice(items); + while (true) { + _6 = iter.next(); + if (_6 === rt.DONE) { + return sum; + } else { + Shape.describe$Area(_6, out); + sum = rt.u64SaturatingAdd(sum, Shape.area$Area(_6)); + } } - return sum; } export function from$From_Dir_u8(dir_: Dir.Dir): rt.u8 { - return { North: 1, East: 2, South: 4, West: 8 }[dir_]; + return { North: 1, East: 2, South: 4, West: 8 }[dir_] & 0xff; } export function dir(byte: rt.u8): Dir.Dir | undefined { - const value = rt.u8Rem(byte, 5); - if (value === 0) { - return "North"; - } else if (value === 1) { - return "East"; - } else if (value === 2) { - return "South"; - } else if (value === 3) { - return "West"; + let _0!: Dir.Dir | undefined; + let _2!: rt.u8; + _2 = rt.u8Rem(byte, 5); + if (_2 === 0) { + _0 = "North" as Dir.Dir; + } else if (_2 === 1) { + _0 = "East" as Dir.Dir; + } else if (_2 === 2) { + _0 = "South" as Dir.Dir; + } else if (_2 === 3) { + _0 = "West" as Dir.Dir; } else { - return undefined; + _0 = undefined; } + return _0; } export function shape(data: Uint8Array): Shape.Shape { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return { tag: "Dot" }; - } - const kind = splitFirst[0]; - const rest = splitFirst[1]; - const at = (i: rt.usize): rt.i32 => { - return rt.i32Sub(rt.optionUnwrapOr(rt.sliceGet(rest, i), 0) as rt.i32, 128); - }; - const value = rt.u8Rem(kind, 3); - if (value === 0) { - return { tag: "Dot" }; - } else if (value === 1) { - return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) }; + let _0!: Shape.Shape; + let kind!: rt.u8; + let _4!: [rt.u8, Uint8Array] | undefined; + let at!: (a0: rt.usize) => rt.i32; + let _7!: rt.u8; + _4 = rt.sliceSplitFirst(data); + if (_4 !== undefined) { + kind = _4[0]; + at = (i: rt.usize): rt.i32 => { + return rt.i32Sub(rt.optionUnwrapOr(rt.sliceGet(_4[1], i), 0) as rt.i32, 128); + }; + _7 = rt.u8Rem(kind, 3); + if (_7 === 0) { + _0 = { tag: "Dot" } as Shape.Shape; + } else if (_7 === 1) { + _0 = { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; + } else { + _0 = { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; + } } else { - return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(rest, 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(rest, 3), 0) as rt.u16 }; + _0 = { tag: "Dot" } as Shape.Shape; } + return _0; } /** `Copy` aggregates: a copy changes apart from its original. */ export function copies(data: Uint8Array, out: rt.ByteVec): void { - const p = Point.new(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.i32, 7); - let q: Point.Point = rt.copy(p); - q.x = rt.i32Add(q.x, 100); + let p!: Point.Point; + let q!: Point.Point; + let _9!: rt.i32; + let r!: Point.Point; + let pair!: [Point.Point, rt.u8]; + let saved!: [Point.Point, rt.u8]; + let _15!: rt.u8; + let grid!: Point.Point[]; + let _17!: rt.usize; + let row!: Point.Point[]; + let _20!: Point.Point; + let _21!: rt.usize; + let _25!: rt.i32; + let _26!: rt.i32; + let _27!: rt.i32; + let _28!: rt.i32; + let _29!: rt.i32; + let _30!: rt.i32; + let _31!: rt.i32; + let _32!: rt.i32; + let _33!: rt.usize; + let _35!: rt.i32; + let _36!: rt.usize; + let _39!: rt.usize; + let iter!: rt.Iter; + let _42!: rt.i32 | rt.Done; + let _49!: Uint8Array; + let a!: Point.Point; + let b!: Point.Point; + let old!: Point.Point; + let _66!: Point.Point; + let _70!: Uint8Array; + let _71!: rt.u8; + let _73!: rt.u8; + let n!: rt.u32; + let both!: [rt.u32, rt.u32]; + let _85!: Uint8Array; + let word!: Uint8Array; + let converted!: rt.u32; + let _98!: rt.usize; + let _103!: Uint8Array; + let _107!: rt.usize; + let cell!: Uint8Array; + let source!: Uint8Array; + let returned!: Uint8Array; + let _122!: rt.usize; + let _127!: Uint8Array; + let _128!: rt.u8; + let _129!: rt.usize; + let _132!: rt.usize; + let marked!: boolean; + let opt!: Meters.Meters | undefined; + let taken!: Meters.Meters | undefined; + let _155!: Uint8Array; + let res!: rt.Result; + let first!: Point.Point; + let fail!: rt.Result; + let err!: Point.Point; + let _165!: Uint8Array; + p = Point.new(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.i32, 7); + q = rt.copy(p); + _9 = rt.i32Add(q.x, 100); + q.x = _9; Point.bump(q); - const r = Point.shift(rt.copy(p), 5); - let pair: [Point.Point, rt.u8] = [rt.copy(p), 3]; - const saved = rt.copy(pair); + r = Point.shift(p, 5); + pair = [rt.copy(p), 3] as [Point.Point, rt.u8]; + saved = rt.copy(pair); pair[0].y = -1; - pair[1] = rt.u8Add(pair[1], 1); - const point = rt.copy(p); - let grid: Point.Point[] = Array.from({ length: 3 }, (): Point.Point => { - return rt.copy(point); + _15 = rt.u8Add(pair[1], 1); + pair[1] = _15; + const item = rt.copy(p); + grid = Array.from({ length: 3 }, (): Point.Point => { + return rt.copy(item); }); - grid[1].x = 9; - const row = rt.copy(grid); - const value = rt.copy(q); - grid[2] = value; - for (const v of [p.x, p.y, q.x, q.y, r.x, saved[0].y, pair[0].y, row[1].x, row[2].x, grid[2].x]) { - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v)); + _17 = 1; + if (!(_17 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _17); + } + grid[_17].x = 9; + row = rt.copy(grid); + _20 = rt.copy(q); + _21 = 2; + if (!(_21 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _21); + } + grid[_21] = rt.copy(_20); + _25 = p.x; + _26 = p.y; + _27 = q.x; + _28 = q.y; + _29 = r.x; + _30 = saved[0].y; + _31 = pair[0].y; + _33 = 1; + if (!(_33 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _33); + } + _32 = row[_33].x; + _36 = 2; + if (!(_36 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _36); + } + _35 = row[_36].x; + _39 = 2; + if (!(_39 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _39); + } + iter = rt.iterSlice([_25, _26, _27, _28, _29, _30, _31, _32, _35, grid[_39].x]); + while (true) { + _42 = iter.next(); + if (_42 === rt.DONE) { + rt.byteVecPush(out, saved[1]); + rt.byteVecPush(out, pair[1]); + rt.byteVecPush(out, Point.eq$PartialEq(p, saved[0]) ? 1 : 0); + a = rt.copy(Point.new(1, 2)); + b = rt.copy(Point.new(3, 4)); + const swapped = a; + a = b; + b = swapped; + undefined; + _66 = Point.new(5, 6); + const old2 = a; + a = rt.copy(_66); + old = old2; + _71 = a.x & 0xff; + _73 = b.x & 0xff; + _70 = Uint8Array.of(_71, _73, old.x & 0xff); + rt.byteVecExtendFromSlice(out, _70); + n = data.length as rt.u32; + both = [n, n] as [rt.u32, rt.u32]; + n = 9; + _85 = rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n)); + rt.byteVecExtendFromSlice(out, _85); + word = Uint8Array.of(0, 0, 0, data.length & 0xff); + converted = rt.u32FromBeBytes(word); + _98 = 0; + if (!(_98 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _98); + } + word[_98] = 9; + _107 = 0; + if (!(_107 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _107); + } + _103 = rt.u32ToBeBytes(rt.u32Add(converted, word[_107] as rt.u32)); + rt.byteVecExtendFromSlice(out, _103); + cell = Uint8Array.of(data.length & 0xff); + rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); + source = Uint8Array.of(data.length & 0xff); + returned = same(rt.copy(source)); + _122 = 0; + if (!(_122 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _122); + } + source[_122] = 9; + _129 = 0; + if (!(_129 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _129); + } + _128 = returned[_129]; + _132 = 0; + if (!(_132 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _132); + } + _127 = Uint8Array.of(_128, source[_132]); + rt.byteVecExtendFromSlice(out, _127); + rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); + marked = mark(out, 1) === 0; + mark(out, 2); + rt.byteVecPush(out, marked ? 1 : 0); + opt = rt.copy({ _0: 9 }); + const taken2 = opt; + opt = undefined; + taken = taken2; + rt.byteVecPush(out, opt === undefined ? 1 : 0); + _155 = rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { + return m._0; + })); + rt.byteVecExtendFromSlice(out, _155); + res = rt.Ok(p); + first = rt.copy(rt.resultUnwrap(res, rt.u8Display)); + first.x = 2; + fail = rt.Err(rt.copy(q)); + err = rt.copy(rt.resultUnwrapErr(fail, rt.u8Display)); + err.y = 3; + _165 = Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff); + rt.byteVecExtendFromSlice(out, _165); + return; + } else { + _49 = rt.i32ToBeBytes(_42); + rt.byteVecExtendFromSlice(out, _49); + } } - rt.byteVecPush(out, saved[1]); - rt.byteVecPush(out, pair[1]); - rt.byteVecPush(out, Point.eq$PartialEq(p, saved[0]) ? 1 : 0); - let a: Point.Point = Point.new(1, 2); - let b: Point.Point = Point.new(3, 4); - const swapped = a; - a = b; - b = swapped; - const old = a; - a = Point.new(5, 6); - const old2 = old; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a.x & 0xff, b.x & 0xff, old2.x & 0xff)); - let n: rt.u32 = data.length as rt.u32; - const both = [n, n] as [rt.u32, rt.u32]; - n = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); - let word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); - const converted = rt.u32FromBeBytes(word); - word[0] = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); - let cell: Uint8Array = Uint8Array.of(data.length & 0xff); - rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); - let source: Uint8Array = Uint8Array.of(data.length & 0xff); - const returned = same(rt.copy(source)); - source[0] = 9; - rt.byteVecExtendFromSlice(out, Uint8Array.of(returned[0], source[0])); - rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0])); - const marked = mark(out, 1) === 0; - mark(out, 2); - rt.byteVecPush(out, marked ? 1 : 0); - let opt: Meters.Meters | undefined = { _0: 9 }; - const taken = opt; - opt = undefined; - const taken2 = taken; - rt.byteVecPush(out, opt === undefined ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(rt.copy(taken2), 0, (m: Meters.Meters): rt.u64 => { - return m._0; - }))); - const res = rt.Ok(rt.copy(p)); - let first: Point.Point = rt.resultUnwrap(rt.copy(res), rt.u8Display); - first.x = 2; - const fail = rt.Err(rt.copy(q)); - let err: Point.Point = rt.resultUnwrapErr(rt.copy(fail), rt.u8Display); - err.y = 3; - rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(rt.copy(res), rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(rt.copy(fail), rt.u8Display).y & 0xff)); } /** `a`'s byte, after writing `b`'s. */ export function writeThenRead(a: Uint8Array, b: Uint8Array): rt.u8 { - b[0] = 9; - return a[0]; + let _3!: rt.usize; + let _5!: rt.usize; + _3 = 0; + if (!(_3 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _3); + } + b[_3] = 9; + _5 = 0; + if (!(_5 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _5); + } + return a[_5]; } /** A copy of `a` read after `a` changes in place, which it doesn't see. */ export function copyThenWrite(a: [rt.u8, rt.u8]): rt.u8 { - const b = rt.copy(a); + let b!: [rt.u8, rt.u8]; + a = rt.copy(a); + b = rt.copy(a); a[0] = 9; return rt.u8WrappingAdd(b[0], a[0]); } /** `a` itself. */ export function same(a: Uint8Array): Uint8Array { - return rt.copy(a); + return a; } /** Logs `b`, returning how much is logged. */ @@ -166,46 +331,101 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { * written: each field logs as it runs. */ export function order(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + let at!: (a0: rt.usize) => rt.u8; + let rect!: Shape.Shape; + let _5!: rt.u16; + let _10!: rt.u16; + let _16!: rt.i32; + let _18!: rt.i32; + let line!: Shape.Shape; + let _21!: Point.Point; + let _24!: Point.Point; + let pair!: Pair.Pair; + let _28!: rt.i64; + let _30!: rt.u8; + let n!: Uint8Array; + let read!: Point.Point; + let _37!: rt.i32; + let _39!: rt.usize; + let _41!: rt.i32; + let base!: Moved.Moved; + let updated!: Moved.Moved; + let _49!: rt.u16; + let taken!: Shape.Shape; + let _57!: rt.u16; + let _59!: Point.Point; + let _63!: rt.usize; + let _64!: rt.usize; + let sum!: rt.usize; + let _70!: rt.usize; + let _71!: rt.usize; + let iter!: rt.Range; + let _75!: rt.usize; + let len!: rt.usize; + let slice!: Uint8Array; + let _83!: Uint8Array; + let _85!: rt.usize; + let _87!: rt.usize; + let text!: string; + let _75Some!: boolean; + at = (i2: rt.usize): rt.u8 => { + return rt.optionUnwrapOr(rt.sliceGet(data, i2), 0); }; - const arg = mark(out, at(0)) & 0xffff; - const arg2 = mark(out, at(1)) & 0xffff; - const field = mark(out, 2) | 0; - const field2 = arg; - const field3 = arg2; - const rect = { tag: "Rect", corner: { x: mark(out, 3) | 0, y: field }, width: field3, height: field2 } as Shape.Shape; - const field4 = Point.new(mark(out, 4) | 0, 0); - const line = { tag: "Line", _0: Point.new(mark(out, 5) | 0, 0), _1: field4 } as Shape.Shape; - const field5 = mark(out, 6) as rt.i64; - const pair = { _0: mark(out, 7) & 0xff, _1: field5 }; - let n: Uint8Array = Uint8Array.of(at(2)); - const field6 = n[0] as rt.i32; - const read = { x: increment(n) as rt.i32, y: field6 }; - let base: Moved.Moved = { _0: at(4), _1: 0 }; - const field7 = reset(base); - const updated = { _0: base._0, _1: field7 }; - let taken: Shape.Shape; + _5 = mark(out, at(0)) & 0xffff; + _10 = mark(out, at(1)) & 0xffff; + _16 = mark(out, 2) | 0; + _18 = mark(out, 3) | 0; + rect = { tag: "Rect", corner: { x: _18, y: _16 }, width: _10, height: _5 } as Shape.Shape; + _21 = Point.new(mark(out, 4) | 0, 0); + _24 = Point.new(mark(out, 5) | 0, 0); + line = { tag: "Line", _0: _24, _1: _21 } as Shape.Shape; + _28 = mark(out, 6) as rt.i64; + _30 = mark(out, 7) & 0xff; + pair = { _0: _30, _1: _28 }; + n = Uint8Array.of(at(2)); + _39 = 0; + if (!(_39 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _39); + } + _37 = n[_39] as rt.i32; + _41 = increment(n) as rt.i32; + read = { x: _41, y: _37 }; + base = { _0: at(4), _1: 0 }; + _49 = reset(base); + updated = { _0: base._0, _1: _49 }; if (rt.u8Rem(at(3), 2) === 0) { - const field8 = mark(out, 8) & 0xffff; - taken = { tag: "Rect", corner: Point.new(0, mark(out, 9) | 0), width: field8, height: 1 }; + _57 = mark(out, 8) & 0xffff; + _59 = Point.new(0, mark(out, 9) | 0); + taken = { tag: "Rect", corner: _59, width: _57, height: 1 } as Shape.Shape; } else { - taken = { tag: "Dot" }; + taken = { tag: "Dot" } as Shape.Shape; } - const field9 = mark(out, 10); - const range = new rt.Range(rt.usizeDiv(mark(out, 11), 2), field9); - let sum: rt.usize = 0; - const end = mark(out, 12); - for (let i2 = rt.usizeSub(mark(out, 13), 4); i2 < end; i2++) { - sum = rt.usizeAdd(sum, i2); + _63 = mark(out, 10); + _64 = rt.usizeDiv(mark(out, 11), 2); + new rt.Range(_64, _63); + sum = 0; + _70 = mark(out, 12); + _71 = rt.usizeSub(mark(out, 13), 4); + iter = new rt.Range(_71, _70); + while (true) { + _75Some = iter.start < iter.end; + if (_75Some) { + _75 = iter.start++; + } + if (!_75Some) { + len = data.length; + _83 = logged(data, out); + _85 = rt.min(mark(out, 14), len); + _87 = rt.usizeDiv(rt.min(mark(out, 15), len), 2); + slice = rt.sliceRange(_83, _87, _85); + text = rt.fmtFormat([(f: rt.Formatter) => Shape.fmt$Debug(rect, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(line, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(pair, f), " ", (f: rt.Formatter) => Point.fmt$Debug(read, f), " ", (f: rt.Formatter) => Moved.fmt$Debug(updated, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(taken, f), " ", (f: rt.Formatter) => rt.usizeDisplay(_64, f), " ", (f: rt.Formatter) => rt.usizeDisplay(_63, f), " ", (f: rt.Formatter) => rt.usizeDisplay(sum, f), " ", (f: rt.Formatter) => rt.fmtList(slice, f, rt.u8Display)]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + indexed(data, out); + return; + } else { + sum = rt.usizeAdd(sum, _75); + } } - const len = data.length; - const arg3 = logged(data, out); - const field10 = rt.min(mark(out, 14), len); - const slice = rt.sliceRange(arg3, rt.usizeDiv(rt.min(mark(out, 15), len), 2), field10); - const text = rt.fmtFormat([(f: rt.Formatter) => Shape.fmt$Debug(rect, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(line, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(pair, f), " ", (f: rt.Formatter) => Point.fmt$Debug(read, f), " ", (f: rt.Formatter) => Moved.fmt$Debug(updated, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(taken, f), " ", (f: rt.Formatter) => rt.usizeDisplay(range.start, f), " ", (f: rt.Formatter) => rt.usizeDisplay(range.end, f), " ", (f: rt.Formatter) => rt.usizeDisplay(sum, f), " ", (f: rt.Formatter) => rt.fmtList(slice, f, rt.u8Display)]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); - indexed(data, out); } /** @@ -214,50 +434,90 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { * earlier operand read. */ export function indexed(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let first!: rt.u8; + let _7!: rt.ByteVec; + let bytes!: Uint8Array; + let _23!: Uint8Array; + let _30!: Uint8Array; + let _36!: Uint8Array; + let second!: rt.u8; + let _41!: Uint8Array; + let _44!: rt.usize; + let _46!: rt.usize; + let f!: (a0: rt.u8) => rt.u8; + let called!: rt.u8; + let _50!: (a0: rt.u8) => rt.u8; + let n!: rt.u8; + let slots!: Uint8Array; + let _58!: rt.u8; + let _59!: rt.usize; + let _63!: rt.u8; + let _67!: Uint8Array; + let _68!: rt.u8; + let _71!: rt.usize; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const arg = rt.byteVecView(listed(out, at(0))); - rt.byteVecPush(out, 0xe1); - const first = rt.at(arg, 1); - let bytes: Uint8Array = Uint8Array.of(at(1), at(2), at(3), 4); - const arg2 = loggedMut(bytes, out); - rt.byteVecPush(out, 0xe3); - const arg3 = arg2; - rt.byteVecPush(out, 0xe4); - rt.sliceCopyWithin(arg3, 1, 3, 0); - const slice = loggedMut(bytes, out); - const arg4 = slice; - const arg5 = slice.length; - rt.byteVecPush(out, 0xe5); - rt.sliceCopyWithin(arg4, 2, arg5, 1); - const slice2 = loggedMut(bytes, out); - rt.sliceCopyWithin(slice2, 3, slice2.length, 0); - const value = logged(bytes, out); - rt.byteVecPush(out, 0xe6); - const second = rt.at(value, 1); - let f: (a0: rt.u8) => rt.u8 = halve; - const arg6 = f; + _7 = listed(out, at(0)); + rt.byteVecPush(out, 225); + const slice = rt.byteVecView(_7); + const at2 = rt.idx(slice, 1); + first = slice[at2]; + bytes = Uint8Array.of(at(1), at(2), at(3), 4); + _23 = loggedMut(bytes, out); + rt.byteVecPush(out, 227); + rt.byteVecPush(out, 228); + rt.sliceCopyWithin(_23, 1, 3, 0); + _30 = loggedMut(bytes, out); + rt.byteVecPush(out, 229); + rt.sliceCopyWithin(_30, 2, _30.length, 1); + _36 = loggedMut(bytes, out); + rt.sliceCopyWithin(_36, 3, _36.length, 0); + _41 = logged(bytes, out); + rt.byteVecPush(out, 230); + _44 = 1; + _46 = _41.length; + if (!(_44 < _46)) { + rt.panic("index out of bounds: the len is " + _46 + " but the index is " + _44); + } + second = _41[_44]; + f = halve; + _50 = f; f = twice; - const called = arg6(at(4)); - let n: rt.u8 = at(5); - let slots: Uint8Array = rt.bytes(2); - const value2 = n; + called = _50(at(4)); + n = at(5); + slots = rt.bytes(2); + _58 = n; n = rt.u8WrappingAdd(n, 1); - slots[rt.idx(slots, 0)] = rt.u8Add(slots[rt.idx(slots, 0)], value2); - rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, f(1), slots[0], n)); + _59 = 0; + if (!(_59 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _59); + } + _63 = rt.u8Add(slots[_59], _58); + slots[_59] = _63; + _68 = f(1); + _71 = 0; + if (!(_71 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _71); + } + _67 = Uint8Array.of(first, second, called, _68, slots[_71], n); + rt.byteVecExtendFromSlice(out, _67); rt.byteVecExtendFromSlice(out, bytes); + return; } /** A vector of `b`, logging that it was made. */ export function listed(out: rt.ByteVec, b: rt.u8): rt.ByteVec { - rt.byteVecPush(out, 0xe0); - return rt.sliceToByteVec(Uint8Array.of(b, b ^ 1)); + let _6!: Uint8Array; + rt.byteVecPush(out, 224); + _6 = Uint8Array.of(b, b ^ 1); + return rt.sliceToByteVec(_6); } /** `s`, logging that it was read. */ export function loggedMut(s: Uint8Array, out: rt.ByteVec): Uint8Array { - rt.byteVecPush(out, 0xe2); + rt.byteVecPush(out, 226); return s; } @@ -271,15 +531,31 @@ export function twice(b: rt.u8): rt.u8 { /** `data`, logging that it was read. */ export function logged(data: Uint8Array, out: rt.ByteVec): Uint8Array { - rt.byteVecPush(out, 0xee); + rt.byteVecPush(out, 238); return data; } /** `n`'s byte, incremented. */ export function increment(n: Uint8Array): rt.u8 { - const value = rt.u8WrappingAdd(n[0], 1); - n[0] = value; - return n[0]; + let _2!: rt.u8; + let _4!: rt.usize; + let _6!: rt.usize; + let _8!: rt.usize; + _4 = 0; + if (!(_4 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _4); + } + _2 = rt.u8WrappingAdd(n[_4], 1); + _6 = 0; + if (!(_6 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _6); + } + n[_6] = _2; + _8 = 0; + if (!(_8 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _8); + } + return n[_8]; } /** Changes `m`'s first field. */ @@ -290,21 +566,58 @@ export function reset(m: Moved.Moved): rt.u16 { /** Fieldless enums cast to every width, past their discriminant's range and sign. */ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { - for (const item of data) { - const b = item; - const value = rt.u8Rem(b, 3); - const wide = value === 0 ? "Low" as Wide.Wide : value === 1 ? "High" as Wide.Wide : "Top" as Wide.Wide; - const value2 = rt.u8Rem(b, 3); - const signed = value2 === 0 ? "Neg" as Signed.Signed : value2 === 1 ? "Min" as Signed.Signed : "Pos" as Signed.Signed; - rt.byteVecPush(out, { Low: 1, High: 44, Top: 255 }[wide]); - rt.byteVecPush(out, { Low: 1, High: 44, Top: -1 }[wide] & 0xff); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes({ Low: 1, High: 300, Top: -1 }[wide])); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide])); - rt.byteVecPush(out, { Neg: 255, Min: 128, Pos: 100 }[signed]); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes({ Neg: 65535, Min: 65408, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes({ Neg: 4294967295, Min: 4294967168, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes({ Neg: rt.u128Of(340282366920938463463374607431768211455n), Min: rt.u128Of(340282366920938463463374607431768211328n), Pos: 100 }[signed])); + let iter!: rt.Iter; + let _5!: rt.u8 | rt.Done; + let b!: rt.u8; + let wide!: Wide.Wide; + let _10!: rt.u8; + let signed!: Signed.Signed; + let _13!: rt.u8; + let _27!: Uint8Array; + let _34!: Uint8Array; + let _45!: Uint8Array; + let _52!: Uint8Array; + let _59!: Uint8Array; + let _66!: Uint8Array; + iter = rt.iterSlice(data); + while (true) { + _5 = iter.next(); + if (_5 === rt.DONE) { + return; + } else { + b = _5; + _10 = rt.u8Rem(b, 3); + if (_10 === 0) { + wide = "Low" as Wide.Wide; + } else if (_10 === 1) { + wide = "High" as Wide.Wide; + } else { + wide = "Top" as Wide.Wide; + } + _13 = rt.u8Rem(b, 3); + if (_13 === 0) { + signed = "Neg" as Signed.Signed; + } else if (_13 === 1) { + signed = "Min" as Signed.Signed; + } else { + signed = "Pos" as Signed.Signed; + } + rt.byteVecPush(out, { Low: 1, High: 300, Top: 65535 }[wide] & 0xff); + rt.byteVecPush(out, (({ Low: 1, High: 300, Top: 65535 }[wide] << 24) >> 24) & 0xff); + _27 = rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16); + rt.byteVecExtendFromSlice(out, _27); + _34 = rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64); + rt.byteVecExtendFromSlice(out, _34); + rt.byteVecPush(out, { Neg: -1, Min: -128, Pos: 100 }[signed] & 0xff); + _45 = rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff); + rt.byteVecExtendFromSlice(out, _45); + _52 = rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0); + rt.byteVecExtendFromSlice(out, _52); + _59 = rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64); + rt.byteVecExtendFromSlice(out, _59); + _66 = rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed])); + rt.byteVecExtendFromSlice(out, _66); + } } } @@ -313,107 +626,217 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { * and values of type `!`. */ export function loops(data: Uint8Array, out: rt.ByteVec): void { - let stack: rt.ByteVec = rt.sliceToByteVec(data); - let popped: rt.u32 = 0; - while (true) { - const pop = rt.byteVecPop(stack); - if (pop !== undefined) { - const top = pop; - if (top === 0) { - continue; + let stack!: rt.ByteVec; + let popped!: rt.u32; + let _5!: rt.u8 | undefined; + let top!: rt.u8; + let _17!: Uint8Array; + let found!: [rt.usize, rt.usize] | undefined; + let iter!: rt.Range; + let _24!: rt.usize; + let i!: rt.usize; + let iter2!: rt.Range; + let _34!: rt.usize; + let j!: rt.usize; + let _39!: rt.u8; + let _40!: rt.usize; + let _43!: rt.usize; + let _49!: rt.usize; + let i2!: rt.usize; + let j2!: rt.usize; + let _57!: Uint8Array; + let n!: rt.u64; + let steps!: rt.u8; + let _65!: rt.u64; + let count!: rt.u8; + let iter3!: rt.RangeInclusive; + let _84!: rt.u8 | rt.Done; + let i3!: rt.i8; + let lo!: rt.i32; + let _96!: rt.i32; + let r!: rt.Range; + let first!: rt.i32 | undefined; + let second!: rt.i32 | undefined; + let _114!: Uint8Array; + let _120!: Uint8Array; + let iter4!: rt.Range; + let _124!: rt.i32; + let iter5!: rt.Range; + let _136!: rt.i8; + let _147!: Uint8Array; + let _154!: Uint8Array; + let _158!: (a0: rt.u8) => rt.u8; + let _124Some!: boolean; + let _136Some!: boolean; + let _24Some!: boolean; + let _34Some!: boolean; + _158 = (x3: rt.u8): rt.u8 => { + while (true) { + if (!(x3 < 10)) { + x3 = rt.u8Div(x3, 3); + } else { + return x3; } - const value = top as rt.u32; - popped = rt.u32Add(popped, value); - if (popped > 1000) { - break; + } + }; + stack = rt.sliceToByteVec(data); + popped = 0; + l0: while (true) { + _5 = rt.byteVecPop(stack); + if (_5 !== undefined) { + top = _5; + if (!(top === 0)) { + popped = rt.u32Add(popped, top as rt.u32); + if (!(popped > 1000)) { + continue l0; + } + } else { + continue l0; } - } else { - break; } - } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); - let found: [rt.usize, rt.usize] | undefined = undefined; - const end = data.length; - loop2: for (let i = 0; i < end; i++) { - const start = rt.usizeAdd(i, 1); - const end2 = data.length; - for (let j = start; j < end2; j++) { - if (rt.at(data, i) === rt.at(data, j)) { - found = [i, j] as [rt.usize, rt.usize]; - break loop2; + _17 = rt.u32ToBeBytes(popped); + rt.byteVecExtendFromSlice(out, _17); + found = undefined; + iter = new rt.Range(0, data.length); + l2: while (true) { + _24Some = iter.start < iter.end; + if (_24Some) { + _24 = iter.start++; } - if (rt.at(data, j) === 0) { - continue loop2; + b3: { + if (_24Some) { + i = _24; + iter2 = new rt.Range(rt.usizeAdd(i, 1), data.length); + while (true) { + _34Some = iter2.start < iter2.end; + if (_34Some) { + _34 = iter2.start++; + } + if (!_34Some) { + continue l2; + } else { + j = _34; + _40 = data.length; + if (!(i < _40)) { + rt.panic("index out of bounds: the len is " + _40 + " but the index is " + i); + } + _39 = data[i]; + _43 = data.length; + if (!(j < _43)) { + rt.panic("index out of bounds: the len is " + _43 + " but the index is " + j); + } + if (!(_39 === data[j])) { + _49 = data.length; + if (!(j < _49)) { + rt.panic("index out of bounds: the len is " + _49 + " but the index is " + j); + } + if (data[j] === 0) { + continue l2; + } + } else { + found = [i, j] as [rt.usize, rt.usize]; + break b3; + } + } + } + } } - } - } - if (found !== undefined) { - const i2 = found[0]; - const j2 = found[1]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); - } else { - rt.byteVecPush(out, 0xff); - } - let n: rt.u64 = data.length as rt.u64; - let steps: rt.u8; - while (true) { - if (rt.u64Le(n, 1)) { - steps = 0; - break; - } - n = rt.u64Rem(n, 2) === 0 ? rt.u64Div(n, 2) : rt.u64Add(rt.u64Mul(3, n), 1); - if (rt.u64Gt(n, 100)) { - steps = 1; - break; - } - } - rt.byteVecPush(out, steps); - let count: rt.u8 = 0; - for (let _ = 0; _ <= 3; _++) { - count = rt.u8Add(count, 1); - } - let i3: rt.i8 = 10; - while (i3 > -3) { - i3 = rt.i8Sub(i3, 4); - count = rt.u8Add(count, 1); - } - rt.byteVecPush(out, count); - const lo = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); - let r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); - const first = rt.iterToOption(r.next()); - r.end = r.start; - const second = rt.iterToOption(r.next()); - if (first !== undefined) { - const x = first; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(x)); - } - if (second !== undefined) { - const x2 = second; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(x2)); - } - for (let k = lo; k < 2; k++) { - rt.byteVecPush(out, k & 0xff); - } - for (let k2 = rt.i8Sub(124, (lo << 24) >> 24); k2 < 127; k2++) { - rt.byteVecPush(out, k2 & 0xff); - } - rt.byteVecPush(out, firstRepeat(data)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); - rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); - const settle = (x3: rt.u8): rt.u8 => { - while (true) { - if (x3 < 10) { - return x3; + if (found === undefined) { + rt.byteVecPush(out, 255); + } else { + i2 = found[0]; + j2 = found[1]; + _57 = Uint8Array.of(i2 & 0xff, j2 & 0xff); + rt.byteVecExtendFromSlice(out, _57); + } + n = data.length as rt.u64; + l6: while (true) { + if (!rt.u64Le(n, 1)) { + if (!(rt.u64Rem(n, 2) === 0)) { + _65 = rt.u64Add(rt.u64Mul(3, n), 1); + } else { + _65 = rt.u64Div(n, 2); + } + n = _65; + if (!rt.u64Gt(n, 100)) { + continue l6; + } else { + steps = 1; + } + } else { + steps = 0; + } + rt.byteVecPush(out, steps); + count = 0; + iter3 = new rt.RangeInclusive(0, 3, rt.u8Step); + while (true) { + _84 = iter3.next(); + if (_84 === rt.DONE) { + i3 = 10; + while (true) { + if (!(i3 > -3)) { + rt.byteVecPush(out, count); + _96 = rt.usizeRem(data.length, 4) | 0; + lo = rt.i32Neg(_96); + r = new rt.Range(lo, rt.i32Add(lo, 3)); + first = r.start < r.end ? r.start++ : undefined; + r.end = r.start; + second = r.start < r.end ? r.start++ : undefined; + if (first !== undefined) { + _114 = rt.i32ToBeBytes(first); + rt.byteVecExtendFromSlice(out, _114); + } + if (second !== undefined) { + _120 = rt.i32ToBeBytes(second); + rt.byteVecExtendFromSlice(out, _120); + } + iter4 = new rt.Range(lo, 2); + while (true) { + _124Some = iter4.start < iter4.end; + if (_124Some) { + _124 = iter4.start++; + } + if (!_124Some) { + iter5 = new rt.Range(rt.i8Sub(124, (lo << 24) >> 24), 127); + while (true) { + _136Some = iter5.start < iter5.end; + if (_136Some) { + _136 = iter5.start++; + } + if (!_136Some) { + rt.byteVecPush(out, firstRepeat(data)); + _147 = rt.u16ToBeBytes(tailBreak(data)); + rt.byteVecExtendFromSlice(out, _147); + rt.byteVecPush(out, armLoop(data)); + _154 = rt.u32ToBeBytes(position$u8(data, 0) as rt.u32); + rt.byteVecExtendFromSlice(out, _154); + const part = rt.u8Mul(data.length & 0xff, 7); + rt.byteVecPush(out, _158(part)); + drain(data, out); + rt.byteVecPush(out, returnedLoop(data)); + branchLoops(data, out); + diverging(data, out); + return; + } else { + rt.byteVecPush(out, _136 & 0xff); + } + } + } else { + rt.byteVecPush(out, _124 & 0xff); + } + } + } else { + i3 = rt.i8Sub(i3, 4); + count = rt.u8Add(count, 1); + } + } + } else { + count = rt.u8Add(count, 1); + } + } } - x3 = rt.u8Div(x3, 3); } - }; - rt.byteVecPush(out, settle(rt.u8Mul(data.length & 0xff, 7))); - drain(data, out); - rt.byteVecPush(out, returnedLoop(data)); - branchLoops(data, out); - diverging(data, out); + } } /** @@ -421,22 +844,29 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { * inputs run every case to its end. */ export function diverging(data: Uint8Array, out: rt.ByteVec): void { - const head = rt.sliceRange(data, 0, rt.min(data.length, 2)); - const b = rt.optionUnwrapOr(rt.sliceFirst(head), 0); - rt.byteVecPush(out, returnedNever(b, data.length)); - rt.byteVecPush(out, brokenNever(head)); - const check = (b2: rt.u8): rt.u8 => { - if (b2 === 0xfd) { - rt.panicFmt(["closure ", (f: rt.Formatter) => rt.u8Display(b2, f)]); + let head!: Uint8Array; + let b!: rt.u8; + let _15!: (a0: rt.u8) => rt.u8; + _15 = (b2: rt.u8): rt.u8 => { + let args!: [rt.u8]; + if (!(b2 === 253)) { + return rt.u8Div(b2, 3); + } else { + args = [b2] as [rt.u8]; + const arg = args[0]; + rt.panicFmt(["closure ", (f: rt.Formatter) => rt.u8Display(arg, f)]); } - return rt.u8Div(b2, 3); }; - rt.byteVecPush(out, check(b)); + head = rt.sliceRange(data, 0, rt.min(data.length, 2)); + b = rt.optionUnwrapOr(rt.sliceFirst(head), 0); + rt.byteVecPush(out, returnedNever(b, data.length)); + rt.byteVecPush(out, brokenNever(head)); + rt.byteVecPush(out, _15(b)); rt.byteVecPush(out, guardedReturn(head)); - const found = boundNever(head, out); - rt.byteVecPush(out, found); + rt.byteVecPush(out, boundNever(head, out)); rt.byteVecPush(out, closureNever(b)); genericNever(b, data.length); + return; } /** @@ -444,34 +874,46 @@ export function diverging(data: Uint8Array, out: rt.ByteVec): void { * function made: a statement, a bound value, and the tail. */ export function closureNever(b: rt.u8): rt.u8 { - const fail: (a0: rt.u8) => never = (b2: rt.u8): never => { - rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(b2, f))]); + let x!: rt.u8; + let _2!: (a0: rt.u8) => never; + let ptr!: (a0: rt.u8) => never; + let _4!: (a0: rt.u8) => never; + _2 = (b2: rt.u8): never => { + let args!: [rt.u8]; + args = [b2] as [rt.u8]; + const arg = args[0]; + rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(arg, f))]); }; - const ptr: (a0: rt.u8) => never = bail; - const made: (a0: rt.u8) => never = madeNever(); - if (b === 0xf5) { - fail(b); - } - let x: rt.u8; - if (b === 0xf4) { - ptr(b); - } else { - x = rt.u8Div(b, 5); - } - if (b === 243) { - fail(b); - } else if (b === 250) { - made(b); + _4 = madeNever(); + ptr = bail; + if (!(b === 245)) { + if (!(b === 244)) { + x = rt.u8Div(b, 5); + if (b === 243) { + _2(b); + } else if (b === 250) { + _4(b); + } else { + return x; + } + } else { + ptr(b); + } } else { - return x; + _2(b); } } /** A closure that never returns, made by a function. */ export function madeNever(): (a0: rt.u8) => never { - return (b: rt.u8): never => { - rt.panicFmt(["made ", (f: rt.Formatter) => rt.u8Display(b, f)]); + let _0!: (a0: rt.u8) => never; + _0 = (b: rt.u8): never => { + let args!: [rt.u8]; + args = [b] as [rt.u8]; + const arg = args[0]; + rt.panicFmt(["made ", (f: rt.Formatter) => rt.u8Display(arg, f)]); }; + return _0; } /** @@ -479,104 +921,145 @@ export function madeNever(): (a0: rt.u8) => never { * never exists: given one, and given an `Option` of none, which then calls one. */ export function genericNever(b: rt.u8, len: rt.usize): void { - if (b === 0xf1) { - pass$never(bail(b)); - } - if (b === 0xf6) { - let value: never; - rt.panicFmt(["passed ", (f: rt.Formatter) => rt.u8Display(b, f)]); - pass$never(value); - } - if (b === 0xf9) { - let o: never | undefined; - if (len > 1) { - o = undefined; + let args!: [rt.u8]; + let args3!: [rt.u8]; + if (!(b === 241)) { + if (!(b === 246)) { + if (!(b === 249)) { + return; + } else if (!(len > 1)) { + args3 = [b] as [rt.u8]; + const arg2 = args3[0]; + rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); + } else { + unwrapOrBail$never(undefined, b); + } } else { - let value2: never; - rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(b, f)]); - o = value2; + args = [b] as [rt.u8]; + const arg = args[0]; + rt.panicFmt(["passed ", (f: rt.Formatter) => rt.u8Display(arg, f)]); } - unwrapOrBail$never(o, b); + } else { + bail(b); } } -export function pass$never(x: never): never { - rt.unreachable(x); +export function pass$never(_: never): never { + rt.unreachable(undefined); } export function unwrapOrBail$never(o: never | undefined, b: rt.u8): never { - if (o !== undefined) { - const x = o; - pass$never(rt.unreachable(x)); - } else { + if (o === undefined) { bail(b); + } else { + pass$never(rt.unreachable(undefined)); + rt.unreachable(undefined); } } /** A function that never returns. */ export function bail(b: rt.u8): never { - rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(b, f))]); + let args!: [rt.u8]; + args = [b] as [rt.u8]; + const arg = args[0]; + rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(arg, f))]); } /** `return`, and `break` out of the function's labeled block, with values that never exist. */ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { + let args!: [rt.u8]; + let args3!: [rt.u8]; if (b === 247) { - rt.panicFmt(["returned ", (f: rt.Formatter) => rt.u8Display(b, f)]); + args = [b] as [rt.u8]; + const arg2 = args[0]; + rt.panicFmt(["returned ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); } else if (b === 248) { - if (rt.usizeRem(len, 2) === 0) { - rt.panicFmt(["then ", (f: rt.Formatter) => rt.u8Display(b, f)]); - } else { - bail(b); - } - } - { - if (b === 0xfe) { + if (!(rt.usizeRem(len, 2) === 0)) { bail(b); + } else { + args3 = [b] as [rt.u8]; + const arg = args3[0]; + rt.panicFmt(["then ", (f: rt.Formatter) => rt.u8Display(arg, f)]); } - return b ^ 0x11; + } else if (!(b === 254)) { + return b ^ 17; + } else { + bail(b); } } /** A `return` of a `match` that guards, whose arms fall through to the next. */ export function guardedReturn(data: Uint8Array): rt.u8 { - if (!((data.length === 0))) { - arms: { + let _0!: rt.u8; + let a!: rt.u8; + let b!: rt.u8; + let _13!: rt.u8; + let a2!: rt.u8; + b0: { + if (!((data.length === 0))) { if (data.length === 2) { - const a = data[0]; - const b = data[1]; - if (a > b) { - return rt.u8Sub(a, b); + a = data[0]; + b = data[1]; + _13 = b; + if (a > _13) { + _0 = rt.u8Sub(a, b); + break b0; } } if (data.length >= 1) { - const a2 = data[0]; - if (a2 > 0x80) { - return 1; + a2 = data[0]; + if (a2 > 128) { + _0 = 1; + break b0; } } - return 2; + _0 = 2; + } else { + _0 = 3; } } - return 3; + return _0; } /** A loop ending the function, left by `break` with values that never exist. */ export function brokenNever(data: Uint8Array): rt.u8 { - let i: rt.usize = 0; - while (true) { - if (i >= data.length) { - return 0xcc; - } - const value = data[rt.idx(data, i)]; - if (value === 251) { - rt.panicFmt(["broken at ", (f: rt.Formatter) => rt.usizeDisplay(i, f)]); - } else if (value === 252) { - bail(rt.at(data, i)); - } else if (value === 0) { - return i & 0xff; + let _0!: rt.u8; + let i!: rt.usize; + let _6!: rt.usize; + let _7!: rt.usize; + let args!: [rt.usize]; + let _19!: rt.usize; + let _20!: rt.usize; + i = 0; + l0: while (true) { + if (!(i >= data.length)) { + _6 = i; + _7 = data.length; + if (!(_6 < _7)) { + rt.panic("index out of bounds: the len is " + _7 + " but the index is " + _6); + } + const value = data[_6]; + if (value === 251) { + args = [i] as [rt.usize]; + const arg = args[0]; + rt.panicFmt(["broken at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); + } else if (value === 252) { + _19 = i; + _20 = data.length; + if (!(_19 < _20)) { + rt.panic("index out of bounds: the len is " + _20 + " but the index is " + _19); + } + bail(data[_19]); + } else if (value === 0) { + _0 = i & 0xff; + } else { + i = rt.usizeAdd(i, 1); + continue l0; + } } else { - i = rt.usizeAdd(i, 1); + _0 = 204; } + return _0; } } @@ -584,352 +1067,525 @@ export function brokenNever(data: Uint8Array): rt.u8 { * Values that never exist where a value is needed: bound, and passed. A loop that * only `return` leaves gives the function's result. */ -export function boundNever(data: Uint8Array, out: rt.ByteVec): rt.u8 { - let i: rt.usize = 0; - let found: rt.u8; - while (true) { - if (i >= data.length) { - return 0xbb; - } - const value = data[rt.idx(data, i)]; - if (value === 239) { - let x: rt.u8; - rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(i, f)]); - rt.byteVecPush(out, x); - } else if (value === 240) { - const arg = out; - let value2: rt.u8; - bail(rt.at(data, i)); - rt.byteVecPush(arg, value2); - } else if (value === 0) { - const arg2 = out; - let value3: rt.u8; - return i & 0xff; - rt.byteVecPush(arg2, value3); - } else if (value === 128) { - const arg3 = out; - let value4: rt.u8; - while (true) { - i = rt.usizeAdd(i, 1); - if (i >= data.length || rt.at(data, i) < 0x80) { - return i & 0xff; +export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { + let _0!: rt.u8; + let i!: rt.usize; + let _8!: rt.usize; + let _9!: rt.usize; + let args!: [rt.usize]; + let _22!: rt.usize; + let _23!: rt.usize; + let _32!: rt.usize; + let _33!: rt.usize; + i = 0; + l0: while (true) { + b1: { + if (!(i >= data.length)) { + _8 = i; + _9 = data.length; + if (!(_8 < _9)) { + rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); + } + const value = data[_8]; + if (value === 239) { + args = [i] as [rt.usize]; + const arg = args[0]; + rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); + } else if (value === 240) { + _22 = i; + _23 = data.length; + if (!(_22 < _23)) { + rt.panic("index out of bounds: the len is " + _23 + " but the index is " + _22); + } + bail(data[_22]); + } else if (value === 0) { + _0 = i & 0xff; + } else if (value === 128) { + l2: while (true) { + i = rt.usizeAdd(i, 1); + if (!(i >= data.length)) { + _32 = i; + _33 = data.length; + if (!(_32 < _33)) { + rt.panic("index out of bounds: the len is " + _33 + " but the index is " + _32); + } + if (!(data[_32] < 128)) { + continue l2; + } + } + _0 = i & 0xff; + break b1; + } + } else { + i = rt.usizeAdd(i, 1); + continue l0; } + } else { + _0 = 187; } - rt.byteVecPush(arg3, value4); } - i = rt.usizeAdd(i, 1); + return _0; } - return found; } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { - let i: rt.usize = 0; - while (rt.usizeAdd(i, 1) < data.length) { - const w = rt.sliceRange(data, i, rt.usizeAdd(i, 2)); - i = rt.usizeAdd(i, 2); - arms: { - if (w.length === 2) { - const a = w[0]; - const b = w[1]; - if (a > b) { - let n: rt.u8 = a; - while (true) { - if (n <= b) { - break; + let i!: rt.usize; + let w!: Uint8Array; + let a!: rt.u8; + let b!: rt.u8; + let _27!: rt.u8; + let n!: rt.u8; + let n2!: rt.u8; + i = 0; + l0: while (true) { + if (!(rt.usizeAdd(i, 1) < data.length)) { + return; + } else { + w = rt.sliceRange(data, i, rt.usizeAdd(i, 2)); + b1: { + i = rt.usizeAdd(i, 2); + if (w.length === 2) { + a = w[0]; + b = w[1]; + _27 = b; + if (a > _27) { + n = a; + while (true) { + if (!(n <= b)) { + n = rt.u8Sub(n, 1); + rt.byteVecPush(out, n); + } else { + break b1; + } } - n = rt.u8Sub(n, 1); - rt.byteVecPush(out, n); } - break arms; + } + if (w.length >= 1) { + rt.byteVecPush(out, w[0]); } } - if (w.length >= 1) { - const a2 = w[0]; - rt.byteVecPush(out, a2); - break arms; - } - } - chain: { if (w.length === 2) { - const a3 = w[0]; - const b2 = w[1]; - if (rt.u8Rem(a3, 3) === rt.u8Rem(b2, 3)) { - let n2: rt.u8 = a3; + if (rt.u8Rem(w[0], 3) === rt.u8Rem(w[1], 3)) { + n2 = w[0]; while (true) { n2 = rt.u8Div(n2, 2); rt.byteVecPush(out, n2); if (n2 < 4) { - break; + continue l0; } } - break chain; } } - rt.byteVecPush(out, 0xaa); + rt.byteVecPush(out, 170); } } } /** A loop that only `return` leaves, returned itself, around loops that `break`. */ export function returnedLoop(data: Uint8Array): rt.u8 { - let i: rt.usize = 0; - while (true) { - if (i >= data.length) { - return 0xdd; - } - for (const item of rt.sliceRange(data, i)) { - const b = item; - if (b === 0) { - break; - } - if (b > 0xf0) { - return b ^ (i & 0xff); + let _0!: rt.u8; + let i!: rt.usize; + let iter!: rt.Iter; + let _11!: rt.u8 | rt.Done; + let b!: rt.u8; + i = 0; + l0: while (true) { + b1: { + if (!(i >= data.length)) { + iter = rt.iterSlice(rt.sliceRange(data, i)); + l2: while (true) { + _11 = iter.next(); + if (_11 !== rt.DONE) { + b = _11; + if (!(b === 0)) { + if (!(b > 240)) { + continue l2; + } else { + _0 = b ^ (i & 0xff); + break b1; + } + } + } + i = rt.usizeAdd(i, 1); + continue l0; + } + } else { + _0 = 221; } } - i = rt.usizeAdd(i, 1); + return _0; } } /** A loop that ends the function, left only by `return` from nested scopes. */ export function firstRepeat(data: Uint8Array): rt.u8 { - let i: rt.usize = 0; - loop: while (true) { - if (i >= data.length) { - return 0xff; - } - let j: rt.usize = rt.usizeAdd(i, 1); - while (j < data.length) { - if (rt.at(data, j) === 0) { - i = rt.usizeAdd(j, 1); - continue loop; - } - if (rt.at(data, i) === rt.at(data, j)) { - return rt.at(data, j) ^ (i & 0xff); + let _0!: rt.u8; + let i!: rt.usize; + let j!: rt.usize; + let _14!: rt.usize; + let _15!: rt.usize; + let _20!: rt.u8; + let _21!: rt.usize; + let _22!: rt.usize; + let _25!: rt.usize; + let _26!: rt.usize; + let _29!: rt.usize; + let _30!: rt.usize; + i = 0; + l0: while (true) { + b1: { + if (!(i >= data.length)) { + j = rt.usizeAdd(i, 1); + while (true) { + if (!(j < data.length)) { + i = rt.usizeAdd(i, 1); + continue l0; + } else { + _14 = j; + _15 = data.length; + if (!(_14 < _15)) { + rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); + } + if (!(data[_14] === 0)) { + _21 = i; + _22 = data.length; + if (!(_21 < _22)) { + rt.panic("index out of bounds: the len is " + _22 + " but the index is " + _21); + } + _20 = data[_21]; + _25 = j; + _26 = data.length; + if (!(_25 < _26)) { + rt.panic("index out of bounds: the len is " + _26 + " but the index is " + _25); + } + if (!(_20 === data[_25])) { + j = rt.usizeAdd(j, 1); + } else { + _29 = j; + _30 = data.length; + if (!(_29 < _30)) { + rt.panic("index out of bounds: the len is " + _30 + " but the index is " + _29); + } + _0 = data[_29] ^ (i & 0xff); + break b1; + } + } else { + i = rt.usizeAdd(j, 1); + continue l0; + } + } + } + } else { + _0 = 255; } - j = rt.usizeAdd(j, 1); } - i = rt.usizeAdd(i, 1); + return _0; } } /** A loop that ends the function, left by `break` with a value from nested scopes. */ export function tailBreak(data: Uint8Array): rt.u16 { - let i: rt.usize = 0; - while (true) { - if (i >= data.length) { - return 0x100; - } - const b = rt.at(data, i); - i = rt.usizeAdd(i, 1); - const value = rt.u8Rem(b, 4); - if (value === 0) { - continue; - } else if (value === 1) { - for (const item of rt.sliceRange(data, i)) { - const c = item; - if (c === b) { - return rt.u16Mul(c as rt.u16, 2); + let _0!: rt.u16; + let i!: rt.usize; + let b!: rt.u8; + let _7!: rt.usize; + let _8!: rt.usize; + let _11!: rt.u8; + let iter!: rt.Iter; + let _18!: rt.u8 | rt.Done; + let c!: rt.u8; + let n!: rt.u8; + i = 0; + l0: while (true) { + b1: { + if (!(i >= data.length)) { + _7 = i; + _8 = data.length; + if (!(_7 < _8)) { + rt.panic("index out of bounds: the len is " + _8 + " but the index is " + _7); } - } - } else if (value === 2 && b > 100) { - return rt.u16Add(b as rt.u16, i & 0xffff); - } else { - let n: rt.u8 = b; - while (true) { - if (n < 10) { - break; + b = data[_7]; + i = rt.usizeAdd(i, 1); + _11 = rt.u8Rem(b, 4); + if (_11 === 0) { + continue l0; + } else if (_11 === 1) { + iter = rt.iterSlice(rt.sliceRange(data, i)); + while (true) { + _18 = iter.next(); + if (_18 === rt.DONE) { + continue l0; + } else { + c = _18; + if (c === b) { + _0 = rt.u16Mul(c as rt.u16, 2); + break b1; + } + } + } + } else if (_11 === 2) { + if (b > 100) { + _0 = rt.u16Add(b as rt.u16, i & 0xffff); + break b1; + } } - n = rt.u8Div(n, 3); - if (n === 7) { - return 7; + n = b; + while (true) { + if (!(n < 10)) { + n = rt.u8Div(n, 3); + if (n === 7) { + _0 = 7; + break b1; + } + } else { + continue l0; + } } + } else { + _0 = 256; } } + return _0; } } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ export function armLoop(data: Uint8Array): rt.u8 { - let k: rt.usize = 0; - let start: rt.u8; - const first = rt.sliceFirst(data); - arms: { - if (first !== undefined) { - const b = first; - if (b >= 0x80) { - start = b; - break arms; + let _0!: rt.u8; + let k!: rt.usize; + let _3!: rt.u8 | undefined; + let _13!: rt.usize; + let _14!: rt.usize; + let _17!: rt.usize; + let _18!: rt.usize; + k = 0; + _3 = rt.sliceFirst(data); + b0: { + if (_3 !== undefined) { + if (_3 >= 128) { + _0 = rt.u8Div(_3, 2); + break b0; } } while (true) { - if (k >= data.length) { - return 0xee; - } - if (rt.at(data, k) >= 0x80) { - return rt.u8Sub(rt.at(data, k), 0x80); + if (!(k >= data.length)) { + _13 = k; + _14 = data.length; + if (!(_13 < _14)) { + rt.panic("index out of bounds: the len is " + _14 + " but the index is " + _13); + } + if (!(data[_13] >= 128)) { + k = rt.usizeAdd(k, 1); + } else { + _17 = k; + _18 = data.length; + if (!(_17 < _18)) { + rt.panic("index out of bounds: the len is " + _18 + " but the index is " + _17); + } + _0 = rt.u8Sub(data[_17], 128); + break b0; + } + } else { + _0 = 238; + break b0; } - k = rt.usizeAdd(k, 1); } } - return rt.u8Div(start, 2); + return _0; } /** A generic function ending in a loop. */ export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { - let i: rt.usize = 0; - while (true) { - if (i === items.length || items[rt.idx(items, i)] === want) { - return i; + let i!: rt.usize; + let _9!: rt.usize; + let _10!: rt.usize; + i = 0; + l0: while (true) { + if (!(i === items.length)) { + _9 = i; + _10 = items.length; + if (!(_9 < _10)) { + rt.panic("index out of bounds: the len is " + _10 + " but the index is " + _9); + } + if (!((items[_9] === want))) { + i = rt.usizeAdd(i, 1); + continue l0; + } } - i = rt.usizeAdd(i, 1); + return i; } } /** A unit function ending in a loop. */ export function drain(data: Uint8Array, out: rt.ByteVec): void { - let i: rt.usize = 0; + let i!: rt.usize; + let _10!: rt.usize; + let _11!: rt.usize; + i = 0; while (true) { - if (i >= data.length) { + if (!(i >= data.length)) { + _10 = i; + _11 = data.length; + if (!(_10 < _11)) { + rt.panic("index out of bounds: the len is " + _11 + " but the index is " + _10); + } + rt.byteVecPush(out, data[_10] ^ 90); + i = rt.usizeAdd(i, 2); + } else { return; } - rt.byteVecPush(out, rt.at(data, i) ^ 0x5a); - i = rt.usizeAdd(i, 2); } } /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ export function patterns(data: Uint8Array, out: rt.ByteVec): void { - arms: { - if (data.length === 0) { - rt.byteVecPush(out, 0); - break arms; - } - if (data.length === 1) { - const one = data[0]; - rt.byteVecPush(out, one); - break arms; - } - if (data.length >= 2) { - const first = data[0]; - const last = data[data.length - 1]; - if (first === last) { - rt.byteVecPush(out, 2); - break arms; + let first!: rt.u8; + let last!: rt.u8; + let iter!: rt.Iter; + let _33!: rt.u8 | rt.Done; + let b!: rt.u8; + let class_!: rt.u8; + let _56!: Dir.Dir | undefined; + let d!: Dir.Dir; + let shape_!: Shape.Shape; + let area!: rt.i64; + let x!: rt.i32; + let _74!: rt.i64; + let width2!: rt.u16; + let height!: rt.u16; + let _79!: rt.i64; + let a!: Point.Point; + let b2!: Point.Point; + let _100!: Uint8Array; + let bytes!: Uint8Array; + let _107!: rt.usize; + let _116!: Shape.Shape[]; + let _125!: Uint8Array; + let parsed!: rt.Result; + let a2!: rt.u8; + let b3!: rt.u8; + let _138!: Uint8Array; + let _143!: string; + let args!: [rt.Result]; + if (!(data.length === 0)) { + if (!(data.length === 1)) { + if (!(data.length >= 2)) { + rt.unreachable(undefined); + } else { + first = data[0]; + last = data[data.length - 1]; + if (!((first === last))) { + rt.byteVecPush(out, data[0] ^ data[1]); + rt.byteVecPush(out, data.subarray(2, data.length - 0).length & 0xff); + } else { + rt.byteVecPush(out, 2); + } } + } else { + rt.byteVecPush(out, data[0]); } - const first2 = data[0]; - const second = data[1]; - const rest = data.subarray(2, data.length - 0); - rt.byteVecPush(out, first2 ^ second); - rt.byteVecPush(out, rest.length & 0xff); + } else { + rt.byteVecPush(out, 0); } - for (const item of rt.sliceRange(data, 0, rt.min(data.length, 4))) { - const b = item; - let class_: rt.u8; - arms2: { - if (b === 0) { - class_ = 0; - break arms2; - } - if (1 <= b && b <= 9) { - class_ = 1; - break arms2; - } - if (b === 10 || b === 20 || b === 30) { - class_ = 2; - break arms2; + iter = rt.iterSlice(rt.sliceRange(data, 0, rt.min(data.length, 4))); + while (true) { + _33 = iter.next(); + if (_33 === rt.DONE) { + b6: { + if (data.length >= 2) { + _56 = dir(data[0]); + if (_56 !== undefined) { + d = _56; + if (data[1] > 10) { + rt.byteVecPush(out, from$From_Dir_u8(d)); + break b6; + } + } + } + rt.byteVecPush(out, 238); } - if (100 <= b && b < 200) { - const n = b; - if (rt.u8Rem(n, 2) === 0) { - class_ = 3; - break arms2; + shape_ = shape(data); + b8: { + if (shape_.tag !== "Dot") { + if (shape_.tag === "Line") { + a = shape_._0; + b2 = shape_._1; + area = rt.i64Mul(rt.i32Sub(a.x, b2.x) as rt.i64, rt.i32Sub(a.y, b2.y) as rt.i64); + break b8; + } else if (shape_.width !== 0) { + if (!(shape_.corner.x > 0)) { + width2 = shape_.width; + height = shape_.height; + _79 = rt.i64Mul(width2 as rt.i64, height as rt.i64); + area = rt.i64Neg(_79); + break b8; + } else { + x = shape_.corner.x; + _74 = shape_.width as rt.i64; + area = rt.i64Mul(_74, x as rt.i64); + break b8; + } + } } + area = 0; } - const n2 = b; - if (n2 >= 250) { - class_ = 4; - break arms2; + _100 = rt.i64ToBeBytes(area); + rt.byteVecExtendFromSlice(out, _100); + bytes = Uint8Array.of(data.length & 0xff, 1, 2); + _107 = 0; + if (!(_107 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _107); } - class_ = 5; - } - rt.byteVecPush(out, class_); - } - chain: { - if (data.length >= 2) { - const a = data[0]; - const b2 = data[1]; - const dir_ = dir(a); - if (dir_ !== undefined) { - const d = dir_; - if (b2 > 10) { - rt.byteVecPush(out, from$From_Dir_u8(d)); - break chain; + bytes.subarray(1, 3)[_107] = 9; + rt.byteVecExtendFromSlice(out, bytes); + _116 = [shape_, { tag: "Dot" } as Shape.Shape]; + _125 = rt.u64ToBeBytes(rt.u64Add(total$Shape(_116, out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out))); + rt.byteVecExtendFromSlice(out, _125); + parsed = rt.Ok(data.length & 0xff); + a2 = (parsed as { ok: true; value: rt.u8 }).value; + b3 = (parsed as { ok: true; value: rt.u8 }).value; + _138 = Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2)); + rt.byteVecExtendFromSlice(out, _138); + args = [parsed] as [rt.Result]; + const arg = args[0]; + _143 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_143)); + return; + } else { + b2: { + b = _33; + if (b === 0) { + class_ = 0; + break b2; + } else if (!(b === 10 || b === 20 || b === 30)) { + if (1 <= b) { + if (b <= 9) { + class_ = 1; + break b2; + } + } + if (100 <= b) { + if (b < 200) { + if (rt.u8Rem(b, 2) === 0) { + class_ = 3; + break b2; + } + } + } + if (!(b >= 250)) { + class_ = 5; + break b2; + } else { + class_ = 4; + break b2; + } } + class_ = 2; } + rt.byteVecPush(out, class_); } - rt.byteVecPush(out, 0xee); - } - const shape_ = shape(data); - let area: rt.i64; - arms3: { - if ((shape_.tag === "Rect" && shape_.width === 0) || shape_.tag === "Dot") { - area = 0; - break arms3; - } - if (shape_.tag === "Rect") { - const x = shape_.corner.x; - const width = shape_.width; - if (x > 0) { - area = rt.i64Mul(width as rt.i64, x as rt.i64); - break arms3; - } - } - if (shape_.tag === "Rect") { - const width2 = shape_.width; - const height = shape_.height; - area = rt.i64Neg(rt.i64Mul(width2 as rt.i64, height as rt.i64)); - break arms3; - } - const a2 = rt.copy(shape_._0); - const b3 = rt.copy(shape_._1); - area = rt.i64Mul(rt.i32Sub(a2.x, b3.x) as rt.i64, rt.i32Sub(a2.y, b3.y) as rt.i64); - } - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); - let bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); - const tail = bytes.subarray(1, 3); - tail[0] = 9; - rt.byteVecExtendFromSlice(out, bytes); - const total = rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total)); - const parsed = rt.Ok(data.length & 0xff); - let a3: rt.u8; - if (parsed.ok) { - const v = parsed.value; - a3 = v; - } else { - const e = parsed.error; - a3 = absurd([e, 1]); } - let b4: rt.u8; - if (parsed.ok) { - const v2 = parsed.value; - b4 = v2; - } else { - const e2 = parsed.error; - rt.unreachable(e2); - } - let c: rt.u8; - const v3 = parsed.value; - c = v3; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a3, b4, c, early(a3))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([(f: rt.Formatter) => rt.fmtResult(parsed, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]))); -} - -/** A value holding a `Void` can't exist either. */ -export function absurd(v: [Void.Void, rt.u8]): rt.u8 { - rt.unreachable(rt.copy(v)); } /** A `match` without arms on a scrutinee that diverges, not on an empty type. */ @@ -939,42 +1595,82 @@ export function early(n: rt.u8): rt.u8 { /** Closures capturing by reference and by move, and functions as values. */ export function closures(data: Uint8Array, out: rt.ByteVec): void { - let sum: rt.u32 = 0; - let add: (a0: rt.u8) => void = (v: rt.u8): void => { - const value = v as rt.u32; - sum = rt.u32Add(sum, value); + let sum!: rt.u32; + let add!: (a0: rt.u8) => void; + let iter!: rt.Iter; + let _8!: rt.u8 | rt.Done; + let _18!: Uint8Array; + let _26!: Uint8Array; + let whole!: Uint8Array; + let _36!: rt.usize; + let parsed!: Array; + let iter2!: rt.Iter; + let _41!: rt.u8 | rt.Done; + let _47!: Dir.Dir | undefined; + let tags!: rt.ByteVec; + let iter3!: rt.Iter; + let _52!: Dir.Dir | undefined | rt.Done; + let _58!: rt.u8; + sum = 0; + add = (v: rt.u8): void => { + sum = rt.u32Add(sum, v as rt.u32); + return; }; - for (const item of data) { - const b = item; - add(b); - } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); - const base = data.length as rt.u32; - const scale = (v2: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Mul(v2, 3), base); - }; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1(scale, sum))); - let whole: Uint8Array = Uint8Array.of(data.length & 0xff); - overwrite(whole); - rt.byteVecPush(out, whole[0]); - let parsed: Array = []; - for (const item2 of data) { - const b2 = item2; - parsed.push(dir(b2)); - } - let tags: rt.ByteVec = new rt.ByteVec(); - for (const d of parsed) { - rt.byteVecPush(tags, rt.optionUnwrapOr(rt.optionMap(d, from$From_Dir_u8), 0)); + iter = rt.iterSlice(data); + while (true) { + _8 = iter.next(); + if (_8 === rt.DONE) { + _18 = rt.u32ToBeBytes(sum); + rt.byteVecExtendFromSlice(out, _18); + const captured = data.length as rt.u32; + _26 = rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { + return rt.u32Add(rt.u32Mul(v2, 3), captured); + }, sum)); + rt.byteVecExtendFromSlice(out, _26); + whole = Uint8Array.of(data.length & 0xff); + overwrite(whole); + _36 = 0; + if (!(_36 < 1)) { + rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _36); + } + rt.byteVecPush(out, whole[_36]); + parsed = []; + iter2 = rt.iterSlice(data); + while (true) { + _41 = iter2.next(); + if (_41 === rt.DONE) { + tags = new rt.ByteVec(); + iter3 = rt.iterSlice(parsed); + while (true) { + _52 = iter3.next(); + if (_52 === rt.DONE) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); + return; + } else { + _58 = rt.optionUnwrapOr(rt.optionMap(_52, from$From_Dir_u8), 0); + rt.byteVecPush(tags, _58); + } + } + } else { + _47 = dir(_41); + parsed.push(_47); + } + } + } else { + add(_8); + } } - rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); } /** Replaces `a` whole from a closure. */ export function overwrite(a: Uint8Array): void { - let write: () => void = (): void => { + let write!: () => void; + write = (): void => { a.set(Uint8Array.of(9)); + return; }; write(); + return; } export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): rt.u32 { @@ -983,50 +1679,63 @@ export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): r /** Options, results, `?`, and strings. */ export function library(data: Uint8Array, out: rt.ByteVec): void { - const checked = (a: rt.u8, b: rt.u8): rt.u8 | undefined => { - const checkedAdd = rt.u8CheckedAdd(a, b); - if (checkedAdd === undefined) { - return undefined; - } - const sum = checkedAdd; - const checkedMul = rt.u8CheckedMul(sum, 2); - if (checkedMul === undefined) { - return undefined; + let _3!: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined; + let a!: rt.u8; + let parsed!: rt.Result; + let mapped!: rt.Result; + let _25!: Uint8Array; + let _29!: Uint8Array; + let _30!: rt.Result; + let s!: string; + let _38!: Uint8Array; + _3 = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { + let _0!: rt.u8 | undefined; + let _4!: rt.u8 | undefined; + let _82!: rt.u8 | undefined; + _4 = rt.u8CheckedAdd(a2, b2); + if (_4 !== undefined) { + _82 = rt.u8CheckedMul(_4, 2); + if (_82 !== undefined) { + _0 = rt.u8Sub(_82, 1); + } else { + _0 = undefined; + } + } else { + _0 = undefined; } - const doubled = checkedMul; - return rt.u8Sub(doubled, 1); + return _0; }; - const a2 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b2 = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); - rt.byteVecPush(out, rt.optionUnwrapOr(checked(a2, b2), 0xff)); - let parsed: rt.Result; - if (a2 === 0) { + a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + const part = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); + rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, part), 255)); + if (a === 0) { parsed = rt.Err("zero"); } else { - const n = a2; - parsed = rt.Ok(n); + parsed = rt.Ok(a); } - const mapped = rt.resultMapErr(rt.resultMap(parsed, (n2: rt.u8): rt.u8 => { - return rt.u8Div(n2, 2); + mapped = rt.resultMapErr(rt.resultMap(parsed, (n3: rt.u8): rt.u8 => { + return rt.u8Div(n3, 2); }), (e: string): rt.u8 => { return rt.stringLen(e) & 0xff; }); if (mapped.ok) { - const n3 = mapped.value; - rt.byteVecExtendFromSlice(out, Uint8Array.of(0, n3)); + _25 = Uint8Array.of(0, mapped.value); + rt.byteVecExtendFromSlice(out, _25); } else { - const n4 = mapped.error; - rt.byteVecExtendFromSlice(out, Uint8Array.of(1, n4)); + _29 = Uint8Array.of(1, mapped.error); + rt.byteVecExtendFromSlice(out, _29); } - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(data)); - if (fromUtf8.ok) { - const s = fromUtf8.value; + _30 = rt.stringFromUtf8(rt.sliceToByteVec(data)); + if (_30.ok) { + s = _30.value; rt.byteVecPush(out, 1); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.stringLen(s) as rt.u32)); + _38 = rt.u32ToBeBytes(rt.stringLen(s) as rt.u32); + rt.byteVecExtendFromSlice(out, _38); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); } else { rt.byteVecPush(out, 0); } + return; } //# sourceMappingURL=shapes.ts.map diff --git a/ts/fixtures/reject/census.md b/ts/fixtures/reject/census.md index 1a122a86e..95d7cec41 100644 --- a/ts/fixtures/reject/census.md +++ b/ts/fixtures/reject/census.md @@ -1,6 +1,6 @@ # Census of `reject-fixture` -- Refusals: 80 +- Refusals: 61 - Function instances: 69 - Generic functions no instance reached, lowered over their type parameters: 3 @@ -8,56 +8,40 @@ | Count | Construct | First | | ---: | --- | --- | -| 6 | unsupported type `_` | fixtures/reject/src/lib.rs:6:1 | -| 4 | replacing the `_` behind a reference, whose JS object is shared or private | fixtures/reject/src/lib.rs:218:2 | -| 4 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:161:17 | +| 6 | an assignment through a reference to `_` | fixtures/reject/src/lib.rs:20:2 | +| 5 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:19:1 | +| 4 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:1 | | 4 | unsupported call to `_` | fixtures/reject/src/lib.rs:36:4 | -| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:15 | -| 3 | a `_` binding: a JS value of `_` is a copy, so it can't change | fixtures/reject/src/lib.rs:19:13 | -| 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:364:4 | -| 3 | dropping `_`, which is not supported yet | fixtures/reject/src/lib.rs:59:31 | -| 2 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:19:13 | -| 2 | a `for` loop over values that drop, which is not supported yet | fixtures/reject/src/lib.rs:69:6 | -| 2 | a `match` on a temporary that drops, which it doesn't move out of whole | fixtures/reject/src/lib.rs:210:2 | -| 2 | a closure that copies a mutable variable | fixtures/reject/src/lib.rs:142:18 | +| 4 | unsupported type `_` | fixtures/reject/src/lib.rs:6:1 | +| 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:69:2 | +| 3 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:161:2 | +| 2 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:222:1 | | 2 | a field of `_` | fixtures/reject/src/lib.rs:441:7 | -| 2 | a field of a temporary that drops: bind it to a variable first | fixtures/reject/src/lib.rs:55:2 | | 2 | an iterator of the crate implementing `_`, which is not supported yet | fixtures/reject/src/lib.rs:302:1 | +| 2 | constructing `_` from another crate | fixtures/reject/src/lib.rs:288:23 | | 2 | overriding `_`, which std's adaptors call in place of `next` or beside it | fixtures/reject/src/lib.rs:282:2 | | 1 | `Binary` formatting, as in `{:b}`, is not supported | fixtures/reject/src/lib.rs:125:3 | | 1 | `LowerExp` formatting, as in `{:e}`, is not supported | fixtures/reject/src/lib.rs:127:3 | | 1 | `Octal` formatting, as in `{:o}`, is not supported | fixtures/reject/src/lib.rs:126:3 | | 1 | `Pointer` formatting, as in `{:p}`, is not supported | fixtures/reject/src/lib.rs:130:3 | | 1 | `_` is generic and implements `Drop`, which is not supported yet | fixtures/reject/src/lib.rs:90:1 | -| 1 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:222:20 | -| 1 | a `let` on a temporary that drops, which it doesn't move out of whole | fixtures/reject/src/lib.rs:193:2 | +| 1 | a `_` cast from `_` to `_` | fixtures/reject/src/lib.rs:172:2 | | 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | fixtures/reject/src/lib.rs:315:51 | | 1 | a cast from `_` | fixtures/reject/src/lib.rs:11:2 | -| 1 | a cast to `_` | fixtures/reject/src/lib.rs:172:2 | -| 1 | a closure of type `_` | fixtures/reject/src/lib.rs:114:10 | -| 1 | a closure that captures a value that drops, which is not supported yet | fixtures/reject/src/lib.rs:61:23 | +| 1 | a constant of type `_` | fixtures/reject/src/lib.rs:156:2 | +| 1 | a copy of a closure that changes what it captured | fixtures/reject/src/lib.rs:435:14 | | 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | fixtures/reject/src/lib.rs:404:13 | -| 1 | a mutable reference to `_`, which is no object it can change in place | fixtures/reject/src/lib.rs:137:17 | -| 1 | a parameter that drops bound by a pattern, which is not supported yet | fixtures/reject/src/lib.rs:76:21 | | 1 | a precision, as in `{:.2}`, is not supported | fixtures/reject/src/lib.rs:122:3 | | 1 | a printable type must implement `Display` or `Debug` | fixtures/reject/src/lib.rs:168:1 | -| 1 | a rest pattern that moves values that drop out of a place, which is not supported yet | fixtures/reject/src/lib.rs:398:14 | -| 1 | a variable from outside the function | fixtures/reject/src/lib.rs:77:2 | +| 1 | a scalar constant of type `_` | fixtures/reject/src/lib.rs:7:2 | | 1 | a width or precision from an argument, as in `{:1$}`, is not supported | fixtures/reject/src/lib.rs:129:3 | -| 1 | an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first | fixtures/reject/src/lib.rs:183:13 | -| 1 | an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first | fixtures/reject/src/lib.rs:200:2 | -| 1 | an `if let` on a temporary that drops, which it doesn't move out of whole | fixtures/reject/src/lib.rs:234:9 | -| 1 | an array repeat of a value that drops, which is not supported yet | fixtures/reject/src/lib.rs:417:14 | -| 1 | an async body returning `_` is not supported: its `Ready` could be pending | fixtures/reject/src/lib.rs:238:54 | -| 1 | an async body that borrows `_` mutably, which is no object it can change in place | fixtures/reject/src/lib.rs:106:3 | -| 1 | an or-pattern with bindings | fixtures/reject/src/lib.rs:149:3 | +| 1 | a zero-sized constant of type `_` | fixtures/reject/src/lib.rs:115:2 | | 1 | arithmetic on `_` | fixtures/reject/src/lib.rs:7:2 | +| 1 | dropping `_`, which is not supported yet | fixtures/reject/src/lib.rs:179:1 | | 1 | hex `Debug`, as in `{:x?}`, is not supported | fixtures/reject/src/lib.rs:128:3 | | 1 | passing `_`, which drops, to `_`, which is not supported yet | fixtures/reject/src/lib.rs:393:4 | | 1 | the `+` flag of a format spec is not supported | fixtures/reject/src/lib.rs:123:3 | | 1 | the `-` flag of a format spec is not supported | fixtures/reject/src/lib.rs:124:3 | -| 1 | unsupported expression: StaticRef | fixtures/reject/src/lib.rs:156:2 | -| 1 | unsupported literal of type `_` | fixtures/reject/src/lib.rs:7:6 | ## By API @@ -65,25 +49,29 @@ The type or module each refused type or path belongs to. | Count | API | First | | ---: | --- | --- | -| 6 | `f64` | fixtures/reject/src/lib.rs:6:1 | -| 4 | `Option` | fixtures/reject/src/lib.rs:31:15 | -| 4 | `std::string::String` | fixtures/reject/src/lib.rs:135:16 | -| 4 | `u32` | fixtures/reject/src/lib.rs:19:13 | -| 3 | `Meters` | fixtures/reject/src/lib.rs:161:17 | +| 5 | `Option` | fixtures/reject/src/lib.rs:31:1 | +| 5 | `f64` | fixtures/reject/src/lib.rs:6:1 | +| 4 | `u32` | fixtures/reject/src/lib.rs:19:1 | +| 3 | `u8` | fixtures/reject/src/lib.rs:105:10 | | 2 | `Iterator` | fixtures/reject/src/lib.rs:282:2 | -| 2 | `Noisy` | fixtures/reject/src/lib.rs:364:16 | -| 2 | `char` | fixtures/reject/src/lib.rs:10:18 | +| 2 | `Meters` | fixtures/reject/src/lib.rs:161:2 | +| 2 | `Poll` | fixtures/reject/src/lib.rs:222:1 | +| 2 | `char` | fixtures/reject/src/lib.rs:10:1 | | 2 | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | -| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:176:42 | -| 2 | `{async closure}` | fixtures/reject/src/lib.rs:114:6 | +| 2 | `std::string::String` | fixtures/reject/src/lib.rs:135:1 | +| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:179:1 | +| 2 | `std::vec::Vec` | fixtures/reject/src/lib.rs:69:2 | | 1 | `Boxed` | fixtures/reject/src/lib.rs:90:1 | | 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:302:1 | | 1 | `FusedIterator` | fixtures/reject/src/lib.rs:356:1 | -| 1 | `Poll` | fixtures/reject/src/lib.rs:222:20 | -| 1 | `Slot` | fixtures/reject/src/lib.rs:86:1 | -| 1 | `[u8; 1]` | fixtures/reject/src/lib.rs:424:45 | -| 1 | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:16 | +| 1 | `IntToFloat` | fixtures/reject/src/lib.rs:172:2 | +| 1 | `Noisy` | fixtures/reject/src/lib.rs:369:20 | +| 1 | `Slot` | fixtures/reject/src/lib.rs:88:1 | +| 1 | `[u8; 1]` | fixtures/reject/src/lib.rs:424:22 | +| 1 | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:1 | | 1 | `std::iter::Chain` | fixtures/reject/src/lib.rs:315:51 | +| 1 | `std::iter::Map` | fixtures/reject/src/lib.rs:288:23 | +| 1 | `std::iter::Rev` | fixtures/reject/src/lib.rs:309:14 | | 1 | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:441:48 | | 1 | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:441:7 | | 1 | `std::ops::Range` | fixtures/reject/src/lib.rs:323:8 | @@ -91,86 +79,84 @@ The type or module each refused type or path belongs to. | 1 | `std::slice::Iter` | fixtures/reject/src/lib.rs:269:11 | | 1 | `std::slice` | fixtures/reject/src/lib.rs:36:4 | | 1 | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | -| 1 | `std::task::Poll` | fixtures/reject/src/lib.rs:238:54 | -| 1 | `std::vec::Vec` | fixtures/reject/src/lib.rs:364:4 | -| 1 | `u8` | fixtures/reject/src/lib.rs:106:3 | -| 1 | `{closure}` | fixtures/reject/src/lib.rs:59:31 | +| 1 | `u64` | fixtures/reject/src/lib.rs:172:2 | +| 1 | `{async closure}` | fixtures/reject/src/lib.rs:115:2 | ## By type or path | Count | Construct | Type or path | First | | ---: | --- | --- | --- | -| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:15 | -| 3 | replacing the value behind a reference to `_` | `Meters` | fixtures/reject/src/lib.rs:161:17 | -| 3 | unsupported type `_` | `f64` | fixtures/reject/src/lib.rs:6:1 | -| 2 | a `_` binding: a JS value of `_` is a copy, so it can't change | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:13 | -| 2 | an iterator that owns `_`, which drops, which is not supported yet | `Noisy` | fixtures/reject/src/lib.rs:364:16 | -| 2 | replacing the `_` behind a reference, whose JS object is shared or private | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | +| 4 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:1 | +| 2 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:222:1 | +| 2 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:1 | +| 2 | an assignment through a reference to `_` | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | +| 2 | an iterator that owns `_`, which drops, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:69:2 | +| 2 | replacing the value behind a reference to `_` | `Meters` | fixtures/reject/src/lib.rs:161:2 | +| 2 | unsupported type `_` | `f64` | fixtures/reject/src/lib.rs:6:1 | | 1 | `_` is generic and implements `Drop`, which is not supported yet | `Boxed` | fixtures/reject/src/lib.rs:90:1 | -| 1 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:222:20 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:135:16 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:13 | -| 1 | a `_` binding: a JS value of `_` is a copy, so it can't change | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:135:16 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut Slot`, `Slot` | fixtures/reject/src/lib.rs:88:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:135:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u8`, `u8` | fixtures/reject/src/lib.rs:105:10 | +| 1 | a `_` cast from `_` to `_` | `IntToFloat`, `u64`, `f64` | fixtures/reject/src/lib.rs:172:2 | | 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | `std::iter::Chain` | fixtures/reject/src/lib.rs:315:51 | | 1 | a cast from `_` | `char` | fixtures/reject/src/lib.rs:11:2 | -| 1 | a cast to `_` | `f64` | fixtures/reject/src/lib.rs:172:2 | -| 1 | a closure of type `_` | `{async closure}` | fixtures/reject/src/lib.rs:114:10 | +| 1 | a constant of type `_` | `&u8` | fixtures/reject/src/lib.rs:156:2 | | 1 | a field of `_` | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:441:48 | | 1 | a field of `_` | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:441:7 | | 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | `u32` | fixtures/reject/src/lib.rs:404:13 | -| 1 | a mutable reference to `_`, which is no object it can change in place | `std::string::String` | fixtures/reject/src/lib.rs:137:17 | -| 1 | an async body returning `_` is not supported: its `Ready` could be pending | `std::task::Poll` | fixtures/reject/src/lib.rs:238:54 | -| 1 | an async body that borrows `_` mutably, which is no object it can change in place | `u8` | fixtures/reject/src/lib.rs:106:3 | +| 1 | a scalar constant of type `_` | `f64` | fixtures/reject/src/lib.rs:7:2 | +| 1 | a zero-sized constant of type `_` | `{async closure}` | fixtures/reject/src/lib.rs:115:2 | +| 1 | an assignment through a reference to `_` | `std::sync::Arc` | fixtures/reject/src/lib.rs:218:2 | +| 1 | an assignment through a reference to `_` | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | +| 1 | an assignment through a reference to `_` | `u32` | fixtures/reject/src/lib.rs:20:2 | +| 1 | an assignment through a reference to `_` | `u8` | fixtures/reject/src/lib.rs:106:3 | | 1 | an iterator of the crate implementing `_`, which is not supported yet | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:302:1 | | 1 | an iterator of the crate implementing `_`, which is not supported yet | `FusedIterator` | fixtures/reject/src/lib.rs:356:1 | -| 1 | an iterator that owns `_`, which drops, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:364:4 | +| 1 | an iterator that owns `_`, which drops, which is not supported yet | `Noisy` | fixtures/reject/src/lib.rs:369:20 | | 1 | arithmetic on `_` | `f64` | fixtures/reject/src/lib.rs:7:2 | -| 1 | dropping `_`, which is not supported yet | `Slot` | fixtures/reject/src/lib.rs:86:1 | -| 1 | dropping `_`, which is not supported yet | `std::sync::Arc` | fixtures/reject/src/lib.rs:176:42 | -| 1 | dropping `_`, which is not supported yet | `{closure}` | fixtures/reject/src/lib.rs:59:31 | +| 1 | constructing `_` from another crate | `std::iter::Map` | fixtures/reject/src/lib.rs:288:23 | +| 1 | constructing `_` from another crate | `std::iter::Rev` | fixtures/reject/src/lib.rs:309:14 | +| 1 | dropping `_`, which is not supported yet | `std::sync::Arc` | fixtures/reject/src/lib.rs:179:1 | | 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::fold` | fixtures/reject/src/lib.rs:282:2 | | 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::size_hint` | fixtures/reject/src/lib.rs:336:2 | | 1 | passing `_`, which drops, to `_`, which is not supported yet | `std::option::Option`, `Option::unwrap_or` | fixtures/reject/src/lib.rs:393:4 | -| 1 | replacing the `_` behind a reference, whose JS object is shared or private | `std::sync::Arc` | fixtures/reject/src/lib.rs:218:2 | -| 1 | replacing the `_` behind a reference, whose JS object is shared or private | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | -| 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:424:45 | +| 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:424:22 | | 1 | unsupported call to `_` | `::cycle` | fixtures/reject/src/lib.rs:269:11 | | 1 | unsupported call to `_` | `::write_fmt` | fixtures/reject/src/lib.rs:137:10 | | 1 | unsupported call to `_` | `std::ops::Range::contains` | fixtures/reject/src/lib.rs:323:8 | | 1 | unsupported call to `_` | `std::slice::sort` | fixtures/reject/src/lib.rs:36:4 | -| 1 | unsupported literal of type `_` | `f64` | fixtures/reject/src/lib.rs:7:6 | -| 1 | unsupported type `_` | `char` | fixtures/reject/src/lib.rs:10:18 | -| 1 | unsupported type `_` | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:16 | -| 1 | unsupported type `_` | `{async closure}` | fixtures/reject/src/lib.rs:114:6 | +| 1 | unsupported type `_` | `char` | fixtures/reject/src/lib.rs:10:1 | +| 1 | unsupported type `_` | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:1 | ## Spans -
unsupported type `_` (6) +
an assignment through a reference to `_` (6) -- fixtures/reject/src/lib.rs:6:1: unsupported type `f64` -- fixtures/reject/src/lib.rs:6:14: unsupported type `f64` -- fixtures/reject/src/lib.rs:10:18: unsupported type `char` -- fixtures/reject/src/lib.rs:14:16: unsupported type `dyn std::ops::Fn(u8) -> u8` -- fixtures/reject/src/lib.rs:114:6: unsupported type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` -- fixtures/reject/src/lib.rs:170:1: unsupported type `f64` +- fixtures/reject/src/lib.rs:20:2: an assignment through a reference to `u32` +- fixtures/reject/src/lib.rs:106:3: an assignment through a reference to `u8` +- fixtures/reject/src/lib.rs:218:2: an assignment through a reference to `std::sync::Arc` +- fixtures/reject/src/lib.rs:254:2: an assignment through a reference to `std::pin::Pin>` +- fixtures/reject/src/lib.rs:264:2: an assignment through a reference to `std::sync::MutexGuard<'_, u8>` +- fixtures/reject/src/lib.rs:412:2: an assignment through a reference to `std::pin::Pin<&mut Noisy>`
-
replacing the `_` behind a reference, whose JS object is shared or private (4) +
`_`: a JS value of `_` is a copy, so a reference can't change it (5) -- fixtures/reject/src/lib.rs:218:2: replacing the `std::sync::Arc` behind a reference, whose JS object is shared or private -- fixtures/reject/src/lib.rs:254:2: replacing the `std::pin::Pin>` behind a reference, whose JS object is shared or private -- fixtures/reject/src/lib.rs:264:2: replacing the `std::sync::MutexGuard<'_, u8>` behind a reference, whose JS object is shared or private -- fixtures/reject/src/lib.rs:412:2: replacing the `std::pin::Pin<&mut Noisy>` behind a reference, whose JS object is shared or private +- fixtures/reject/src/lib.rs:19:1: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:24:1: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:88:1: `&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:105:10: `&mut u8`: a JS value of `u8` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:135:1: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it
-
replacing the value behind a reference to `_` (4) +
`_` is not supported: its `None` and `Some` would both be `undefined` (4) -- fixtures/reject/src/lib.rs:161:17: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:161:20: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:165:25: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:424:45: replacing the value behind a reference to `[u8; 1]` +- fixtures/reject/src/lib.rs:31:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:39:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:40:42: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:227:1: `Option>` is not supported: its `None` and `Some` would both be `undefined`
@@ -183,63 +169,35 @@ The type or module each refused type or path belongs to.
-
`_` is not supported: its `None` and `Some` would both be `undefined` (3) - -- fixtures/reject/src/lib.rs:31:15: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:40:42: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:227:19: `Option>` is not supported: its `None` and `Some` would both be `undefined` - -
- -
a `_` binding: a JS value of `_` is a copy, so it can't change (3) +
unsupported type `_` (4) -- fixtures/reject/src/lib.rs:19:13: a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change -- fixtures/reject/src/lib.rs:25:6: a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change -- fixtures/reject/src/lib.rs:135:16: a `&mut std::string::String` binding: a JS value of `std::string::String` is a copy, so it can't change +- fixtures/reject/src/lib.rs:6:1: unsupported type `f64` +- fixtures/reject/src/lib.rs:10:1: unsupported type `char` +- fixtures/reject/src/lib.rs:14:1: unsupported type `dyn std::ops::Fn(u8) -> u8` +- fixtures/reject/src/lib.rs:170:1: unsupported type `f64`
an iterator that owns `_`, which drops, which is not supported yet (3) +- fixtures/reject/src/lib.rs:69:2: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet - fixtures/reject/src/lib.rs:364:4: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet -- fixtures/reject/src/lib.rs:364:16: an iterator that owns `Noisy`, which drops, which is not supported yet - fixtures/reject/src/lib.rs:369:20: an iterator that owns `Noisy`, which drops, which is not supported yet
-
dropping `_`, which is not supported yet (3) - -- fixtures/reject/src/lib.rs:59:31: dropping `{closure@fixtures/reject/src/lib.rs:61:10: 61:17}`, which is not supported yet -- fixtures/reject/src/lib.rs:86:1: dropping `Slot`, which is not supported yet -- fixtures/reject/src/lib.rs:176:42: dropping `std::sync::Arc<&Noisy>`, which is not supported yet - -
- -
`_`: a JS value of `_` is a copy, so a reference can't change it (2) - -- fixtures/reject/src/lib.rs:19:13: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it -- fixtures/reject/src/lib.rs:135:16: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it - -
- -
a `for` loop over values that drop, which is not supported yet (2) - -- fixtures/reject/src/lib.rs:69:6: a `for` loop over values that drop, which is not supported yet -- fixtures/reject/src/lib.rs:385:6: a `for` loop over values that drop, which is not supported yet - -
- -
a `match` on a temporary that drops, which it doesn't move out of whole (2) +
replacing the value behind a reference to `_` (3) -- fixtures/reject/src/lib.rs:210:2: a `match` on a temporary that drops, which it doesn't move out of whole -- fixtures/reject/src/lib.rs:245:16: a `match` on a temporary that drops, which it doesn't move out of whole +- fixtures/reject/src/lib.rs:161:2: replacing the value behind a reference to `Meters` +- fixtures/reject/src/lib.rs:165:2: replacing the value behind a reference to `Meters` +- fixtures/reject/src/lib.rs:424:22: replacing the value behind a reference to `[u8; 1]`
-
a closure that copies a mutable variable (2) +
`_` is not supported: it would be pending two ways with one value (2) -- fixtures/reject/src/lib.rs:142:18: a closure that copies a mutable variable -- fixtures/reject/src/lib.rs:432:3: a closure that copies a mutable variable +- fixtures/reject/src/lib.rs:222:1: `Poll>>` is not supported: it would be pending two ways with one value +- fixtures/reject/src/lib.rs:238:54: `Poll>` is not supported: it would be pending two ways with one value
@@ -250,17 +208,17 @@ The type or module each refused type or path belongs to.
-
a field of a temporary that drops: bind it to a variable first (2) +
an iterator of the crate implementing `_`, which is not supported yet (2) -- fixtures/reject/src/lib.rs:55:2: a field of a temporary that drops: bind it to a variable first -- fixtures/reject/src/lib.rs:259:2: a field of a temporary that drops: bind it to a variable first +- fixtures/reject/src/lib.rs:302:1: an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet +- fixtures/reject/src/lib.rs:356:1: an iterator of the crate implementing `FusedIterator`, which is not supported yet
-
an iterator of the crate implementing `_`, which is not supported yet (2) +
constructing `_` from another crate (2) -- fixtures/reject/src/lib.rs:302:1: an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet -- fixtures/reject/src/lib.rs:356:1: an iterator of the crate implementing `FusedIterator`, which is not supported yet +- fixtures/reject/src/lib.rs:288:23: constructing `std::iter::Map` from another crate +- fixtures/reject/src/lib.rs:309:14: constructing `std::iter::Rev` from another crate
@@ -301,15 +259,9 @@ The type or module each refused type or path belongs to.
-
`_` is not supported: it would be pending two ways with one value (1) - -- fixtures/reject/src/lib.rs:222:20: `Poll>>` is not supported: it would be pending two ways with one value - -
- -
a `let` on a temporary that drops, which it doesn't move out of whole (1) +
a `_` cast from `_` to `_` (1) -- fixtures/reject/src/lib.rs:193:2: a `let` on a temporary that drops, which it doesn't move out of whole +- fixtures/reject/src/lib.rs:172:2: a `IntToFloat` cast from `u64` to `f64`
@@ -325,21 +277,15 @@ The type or module each refused type or path belongs to.
-
a cast to `_` (1) - -- fixtures/reject/src/lib.rs:172:2: a cast to `f64` - -
- -
a closure of type `_` (1) +
a constant of type `_` (1) -- fixtures/reject/src/lib.rs:114:10: a closure of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` +- fixtures/reject/src/lib.rs:156:2: a constant of type `&u8`
-
a closure that captures a value that drops, which is not supported yet (1) +
a copy of a closure that changes what it captured (1) -- fixtures/reject/src/lib.rs:61:23: a closure that captures a value that drops, which is not supported yet +- fixtures/reject/src/lib.rs:435:14: a copy of a closure that changes what it captured
@@ -349,18 +295,6 @@ The type or module each refused type or path belongs to.
-
a mutable reference to `_`, which is no object it can change in place (1) - -- fixtures/reject/src/lib.rs:137:17: a mutable reference to `std::string::String`, which is no object it can change in place - -
- -
a parameter that drops bound by a pattern, which is not supported yet (1) - -- fixtures/reject/src/lib.rs:76:21: a parameter that drops bound by a pattern, which is not supported yet - -
-
a precision, as in `{:.2}`, is not supported (1) - fixtures/reject/src/lib.rs:122:3: a precision, as in `{:.2}`, is not supported @@ -373,15 +307,9 @@ The type or module each refused type or path belongs to.
-
a rest pattern that moves values that drop out of a place, which is not supported yet (1) - -- fixtures/reject/src/lib.rs:398:14: a rest pattern that moves values that drop out of a place, which is not supported yet - -
- -
a variable from outside the function (1) +
a scalar constant of type `_` (1) -- fixtures/reject/src/lib.rs:77:2: a variable from outside the function +- fixtures/reject/src/lib.rs:7:2: a scalar constant of type `f64`
@@ -391,51 +319,21 @@ The type or module each refused type or path belongs to.
-
an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first (1) - -- fixtures/reject/src/lib.rs:183:13: an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first - -
- -
an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first (1) - -- fixtures/reject/src/lib.rs:200:2: an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first - -
- -
an `if let` on a temporary that drops, which it doesn't move out of whole (1) - -- fixtures/reject/src/lib.rs:234:9: an `if let` on a temporary that drops, which it doesn't move out of whole - -
- -
an array repeat of a value that drops, which is not supported yet (1) +
a zero-sized constant of type `_` (1) -- fixtures/reject/src/lib.rs:417:14: an array repeat of a value that drops, which is not supported yet +- fixtures/reject/src/lib.rs:115:2: a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}`
-
an async body returning `_` is not supported: its `Ready` could be pending (1) - -- fixtures/reject/src/lib.rs:238:54: an async body returning `std::task::Poll` is not supported: its `Ready` could be pending - -
- -
an async body that borrows `_` mutably, which is no object it can change in place (1) - -- fixtures/reject/src/lib.rs:106:3: an async body that borrows `u8` mutably, which is no object it can change in place - -
- -
an or-pattern with bindings (1) +
arithmetic on `_` (1) -- fixtures/reject/src/lib.rs:149:3: an or-pattern with bindings +- fixtures/reject/src/lib.rs:7:2: arithmetic on `f64`
-
arithmetic on `_` (1) +
dropping `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:7:2: arithmetic on `f64` +- fixtures/reject/src/lib.rs:179:1: dropping `std::sync::Arc<&Noisy>`, which is not supported yet
@@ -462,15 +360,3 @@ The type or module each refused type or path belongs to. - fixtures/reject/src/lib.rs:124:3: the `-` flag of a format spec is not supported
- -
unsupported expression: StaticRef (1) - -- fixtures/reject/src/lib.rs:156:2: unsupported expression: StaticRef - -
- -
unsupported literal of type `_` (1) - -- fixtures/reject/src/lib.rs:7:6: unsupported literal of type `f64` - -
diff --git a/ts/fixtures/reject/expected-mir.txt b/ts/fixtures/reject/expected-mir.txt deleted file mode 100644 index 2d82152d9..000000000 --- a/ts/fixtures/reject/expected-mir.txt +++ /dev/null @@ -1,62 +0,0 @@ -a root must not be generic at fixtures/reject/src/lib.rs:170:1 -no item `missing` in the crate -a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:168:1 -unsupported type `f64` at fixtures/reject/src/lib.rs:6:1 -a scalar constant of type `f64` at fixtures/reject/src/lib.rs:7:2 -arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 -unsupported type `char` at fixtures/reject/src/lib.rs:10:1 -a cast from `char` at fixtures/reject/src/lib.rs:11:2 -unsupported type `dyn std::ops::Fn(u8) -> u8` at fixtures/reject/src/lib.rs:14:1 -`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:19:1 -an assignment through a reference to `u32` at fixtures/reject/src/lib.rs:20:2 -`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:24:1 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:1 -unsupported call to `std::slice::::sort` at fixtures/reject/src/lib.rs:36:4 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:40:42 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:39:1 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:69:11 -`&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:88:1 -`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:10 -`&mut u8`: a JS value of `u8` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:105:10 -an assignment through a reference to `u8` at fixtures/reject/src/lib.rs:106:3 -a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:115:2 -a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:122:3 -the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:123:3 -the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:124:3 -formatting by `new_binary` is not supported at fixtures/reject/src/lib.rs:125:12 -formatting by `new_octal` is not supported at fixtures/reject/src/lib.rs:126:12 -formatting by `new_lower_exp` is not supported at fixtures/reject/src/lib.rs:127:12 -hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:128:3 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:15 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:3 -formatting by `new_pointer` is not supported at fixtures/reject/src/lib.rs:130:12 -`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:135:1 -unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:137:10 -a constant of type `&u8` at fixtures/reject/src/lib.rs:156:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:165:2 -dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:179:1 -an assignment through a reference to `std::sync::Arc` at fixtures/reject/src/lib.rs:218:2 -`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:222:1 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:227:1 -`Poll>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:238:54 -an assignment through a reference to `std::pin::Pin>` at fixtures/reject/src/lib.rs:254:2 -an assignment through a reference to `std::sync::MutexGuard<'_, u8>` at fixtures/reject/src/lib.rs:264:2 -unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:269:11 -constructing `std::iter::Map` from another crate at fixtures/reject/src/lib.rs:288:23 -constructing `std::iter::Rev` from another crate at fixtures/reject/src/lib.rs:309:14 -a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:315:51 -unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:323:8 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:4 -an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:369:20 -passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:393:4 -a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:404:13 -an assignment through a reference to `std::pin::Pin<&mut Noisy>` at fixtures/reject/src/lib.rs:412:2 -replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:424:22 -a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:435:14 -a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:441:7 -a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:441:48 -overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:282:2 -an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:302:1 -overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:336:2 -an iterator of the crate implementing `FusedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:356:1 diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 207091037..2953b1888 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -1,77 +1,59 @@ a root must not be generic at fixtures/reject/src/lib.rs:170:1 no item `missing` in the crate a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:168:1 -unsupported type `f64` at fixtures/reject/src/lib.rs:6:14 -unsupported literal of type `f64` at fixtures/reject/src/lib.rs:7:6 -arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 unsupported type `f64` at fixtures/reject/src/lib.rs:6:1 -unsupported type `char` at fixtures/reject/src/lib.rs:10:18 +a scalar constant of type `f64` at fixtures/reject/src/lib.rs:7:2 +arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 +unsupported type `char` at fixtures/reject/src/lib.rs:10:1 a cast from `char` at fixtures/reject/src/lib.rs:11:2 -unsupported type `dyn std::ops::Fn(u8) -> u8` at fixtures/reject/src/lib.rs:14:16 -a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change at fixtures/reject/src/lib.rs:19:13 -`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:19:13 -a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change at fixtures/reject/src/lib.rs:25:6 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:15 +unsupported type `dyn std::ops::Fn(u8) -> u8` at fixtures/reject/src/lib.rs:14:1 +`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:19:1 +an assignment through a reference to `u32` at fixtures/reject/src/lib.rs:20:2 +`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:24:1 +`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:1 unsupported call to `std::slice::::sort` at fixtures/reject/src/lib.rs:36:4 `Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:40:42 -a field of a temporary that drops: bind it to a variable first at fixtures/reject/src/lib.rs:55:2 -a closure that captures a value that drops, which is not supported yet at fixtures/reject/src/lib.rs:61:23 -dropping `{closure@fixtures/reject/src/lib.rs:61:10: 61:17}`, which is not supported yet at fixtures/reject/src/lib.rs:59:31 -a `for` loop over values that drop, which is not supported yet at fixtures/reject/src/lib.rs:69:6 -a parameter that drops bound by a pattern, which is not supported yet at fixtures/reject/src/lib.rs:76:21 -a variable from outside the function at fixtures/reject/src/lib.rs:77:2 -dropping `Slot`, which is not supported yet at fixtures/reject/src/lib.rs:86:1 -`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:6 -an async body that borrows `u8` mutably, which is no object it can change in place at fixtures/reject/src/lib.rs:106:3 -unsupported type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:114:6 -a closure of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:114:10 +`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:39:1 +an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:69:11 +`&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:88:1 +`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:10 +`&mut u8`: a JS value of `u8` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:105:10 +an assignment through a reference to `u8` at fixtures/reject/src/lib.rs:106:3 +a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:115:2 a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:122:3 the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:123:3 the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:124:3 -`Binary` formatting, as in `{:b}`, is not supported at fixtures/reject/src/lib.rs:125:3 -`Octal` formatting, as in `{:o}`, is not supported at fixtures/reject/src/lib.rs:126:3 -`LowerExp` formatting, as in `{:e}`, is not supported at fixtures/reject/src/lib.rs:127:3 +`Binary` formatting, as in `{:b}`, is not supported at fixtures/reject/src/lib.rs:125:12 +`Octal` formatting, as in `{:o}`, is not supported at fixtures/reject/src/lib.rs:126:12 +`LowerExp` formatting, as in `{:e}`, is not supported at fixtures/reject/src/lib.rs:127:12 hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:128:3 +a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:15 a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:3 -`Pointer` formatting, as in `{:p}`, is not supported at fixtures/reject/src/lib.rs:130:3 -a `&mut std::string::String` binding: a JS value of `std::string::String` is a copy, so it can't change at fixtures/reject/src/lib.rs:135:16 -`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:135:16 -a mutable reference to `std::string::String`, which is no object it can change in place at fixtures/reject/src/lib.rs:137:17 +`Pointer` formatting, as in `{:p}`, is not supported at fixtures/reject/src/lib.rs:130:12 +`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:135:1 unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:137:10 -a closure that copies a mutable variable at fixtures/reject/src/lib.rs:142:18 -an or-pattern with bindings at fixtures/reject/src/lib.rs:149:3 -unsupported expression: StaticRef at fixtures/reject/src/lib.rs:156:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:17 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:20 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:165:25 -dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:176:42 -an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first at fixtures/reject/src/lib.rs:183:13 -a `let` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:193:2 -an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first at fixtures/reject/src/lib.rs:200:2 -a `match` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:210:2 -replacing the `std::sync::Arc` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:218:2 -`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:222:20 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:227:19 -an `if let` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:234:9 -an async body returning `std::task::Poll` is not supported: its `Ready` could be pending at fixtures/reject/src/lib.rs:238:54 -a `match` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:245:16 -replacing the `std::pin::Pin>` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:254:2 -a field of a temporary that drops: bind it to a variable first at fixtures/reject/src/lib.rs:259:2 -replacing the `std::sync::MutexGuard<'_, u8>` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:264:2 +a constant of type `&u8` at fixtures/reject/src/lib.rs:156:2 +replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:2 +replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:165:2 +dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:179:1 +an assignment through a reference to `std::sync::Arc` at fixtures/reject/src/lib.rs:218:2 +`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:222:1 +`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:227:1 +`Poll>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:238:54 +an assignment through a reference to `std::pin::Pin>` at fixtures/reject/src/lib.rs:254:2 +an assignment through a reference to `std::sync::MutexGuard<'_, u8>` at fixtures/reject/src/lib.rs:264:2 unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:269:11 +constructing `std::iter::Map` from another crate at fixtures/reject/src/lib.rs:288:23 +constructing `std::iter::Rev` from another crate at fixtures/reject/src/lib.rs:309:14 a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:315:51 unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:323:8 -an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:16 an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:4 an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:369:20 -a `for` loop over values that drop, which is not supported yet at fixtures/reject/src/lib.rs:385:6 passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:393:4 -a rest pattern that moves values that drop out of a place, which is not supported yet at fixtures/reject/src/lib.rs:398:14 a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:404:13 -replacing the `std::pin::Pin<&mut Noisy>` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:412:2 -an array repeat of a value that drops, which is not supported yet at fixtures/reject/src/lib.rs:417:14 -replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:424:45 -a closure that copies a mutable variable at fixtures/reject/src/lib.rs:432:3 +an assignment through a reference to `std::pin::Pin<&mut Noisy>` at fixtures/reject/src/lib.rs:412:2 +replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:424:22 +a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:435:14 a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:441:7 a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:441:48 overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:282:2 diff --git a/ts/fixtures/task/expected/kio.Consumer.ts b/ts/fixtures/task/expected/kio.Consumer.ts index 4a9c2784a..17bb246b2 100644 --- a/ts/fixtures/task/expected/kio.Consumer.ts +++ b/ts/fixtures/task/expected/kio.Consumer.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { recvBody } from "./kio.ts"; +import { recvFuture } from "./kio.ts"; import type * as State from "./kio.State.ts"; import * as Waiter from "./kio.Waiter.ts"; @@ -26,22 +26,41 @@ export class Consumer { /** The next value, or `None` once the channel closed and every value was read. */ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll { - let state: rt.Mutex = self.state.value; - if (self.next < state.value.queue.length) { - const value = rt.at(state.value.queue, self.next); - self.next = rt.usizeAdd(self.next, 1); - return value; + let _0!: rt.Poll; + let state!: rt.Mutex; + let _8!: rt.usize; + let _11!: State.State; + let value!: rt.u64; + let _16!: State.State; + let _18!: rt.usize; + let _19!: rt.usize; + let _27!: State.State; + state = self.state.value; + _8 = self.next; + _11 = state.value; + if (!(_8 < _11.queue.length)) { + if (!state.value.closed) { + _27 = state.value; + Waiter.register(waiter, _27.waiters); + _0 = rt.Pending; + } else { + _0 = undefined; + } + } else { + _16 = state.value; + _18 = self.next; + const at = rt.idx(_16.queue, _18); + value = _16.queue[at]; + _19 = rt.usizeAdd(self.next, 1); + self.next = _19; + _0 = value; } - if (state.value.closed) { - return undefined; - } - Waiter.register(waiter, state.value.waiters); - return rt.Pending; + return _0; } /** kio's one-line wrapper over a `poll_*` method. */ export function recv(self: Consumer): rt.Future { - return rt.future(recvBody, undefined, self); + return new recvFuture(self); } //# sourceMappingURL=kio.Consumer.ts.map diff --git a/ts/fixtures/task/expected/kio.Park.ts b/ts/fixtures/task/expected/kio.Park.ts index ab1292b01..6820dd6af 100644 --- a/ts/fixtures/task/expected/kio.Park.ts +++ b/ts/fixtures/task/expected/kio.Park.ts @@ -25,17 +25,17 @@ export class Park { * dropping the old and so its registrations. */ export function hold(self: Park, cx: rt.Context): Waiter.Waiter { - let reuse: boolean; - if (self._0 !== undefined) { - const waiter = self._0; - reuse = cx.willWake(waiter.waker); - } else { + let reuse!: boolean; + let _10!: Waiter.Waiter | undefined; + if (self._0 === undefined) { reuse = false; + } else { + reuse = cx.willWake(self._0.waker); } if (!reuse) { - const value = Waiter.new(cx.clone()); + _10 = Waiter.new(cx.clone()); rt.drop(self._0); - self._0 = value; + self._0 = _10; } return rt.optionUnwrap(self._0); } diff --git a/ts/fixtures/task/expected/kio.Pending.ts b/ts/fixtures/task/expected/kio.Pending.ts index 5eb0ca08f..fce8c486e 100644 --- a/ts/fixtures/task/expected/kio.Pending.ts +++ b/ts/fixtures/task/expected/kio.Pending.ts @@ -21,9 +21,9 @@ export class Pending { } export function poll$Future_recv_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_ = self; - const waiter = Park.hold(this_.park, cx); - return this_.poll(waiter); + let this_!: Pending<(a0: Waiter.Waiter) => rt.Poll>; + this_ = self; + return this_.poll(Park.hold(this_.park, cx)); } //# sourceMappingURL=kio.Pending.ts.map diff --git a/ts/fixtures/task/expected/kio.Producer.ts b/ts/fixtures/task/expected/kio.Producer.ts index a7b184ac0..cd9c972a5 100644 --- a/ts/fixtures/task/expected/kio.Producer.ts +++ b/ts/fixtures/task/expected/kio.Producer.ts @@ -20,16 +20,24 @@ export class Producer { } function new_(): Producer { - const state = { queue: [], closed: false, producers: 1, waiters: WaiterList.new() }; - return new Producer({ state: new rt.Arc(new rt.Mutex(state)) }); + let _2!: rt.u64[]; + _2 = []; + return new Producer({ state: new rt.Arc(new rt.Mutex({ queue: _2, closed: false, producers: 1, waiters: WaiterList.new() })) }); } /** Queue `value` and wake every consumer, after releasing the lock. */ export function send(self: Producer, value: rt.u64): void { - let state: rt.Mutex = self.state.value; - state.value.queue.push(value); - let waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); + let waiters!: WaiterList.WaiterList; + let state!: rt.Mutex; + let _10!: State.State; + let _13!: State.State; + state = self.state.value; + _10 = state.value; + _10.queue.push(value); + _13 = state.value; + waiters = WaiterList.take(_13.waiters); WaiterList.wake(waiters); + return; } export function consume(self: Producer): Consumer.Consumer { @@ -37,19 +45,33 @@ export function consume(self: Producer): Consumer.Consumer { } export function clone$Clone(self: Producer): Producer { - self.state.value.value.producers = rt.usizeAdd(self.state.value.value.producers, 1); + let _2!: State.State; + let _4!: rt.Mutex; + let _8!: rt.usize; + _4 = self.state.value; + _2 = _4.value; + _8 = rt.usizeAdd(_2.producers, 1); + _2.producers = _8; return new Producer({ state: rt.arcClone(self.state) }); } export function drop$Drop(self: Producer): void { - let state: rt.Mutex = self.state.value; - state.value.producers = rt.usizeSub(state.value.producers, 1); - if (state.value.producers > 0) { - return; + let waiters!: WaiterList.WaiterList; + let state!: rt.Mutex; + let _7!: State.State; + let _9!: rt.usize; + let _17!: State.State; + state = self.state.value; + _7 = state.value; + _9 = rt.usizeSub(_7.producers, 1); + _7.producers = _9; + if (!(state.value.producers > 0)) { + state.value.closed = true; + _17 = state.value; + waiters = WaiterList.take(_17.waiters); + WaiterList.wake(waiters); } - state.value.closed = true; - let waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); - WaiterList.wake(waiters); + return; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/kio.Waiter.ts b/ts/fixtures/task/expected/kio.Waiter.ts index aa363482f..2b4856409 100644 --- a/ts/fixtures/task/expected/kio.Waiter.ts +++ b/ts/fixtures/task/expected/kio.Waiter.ts @@ -20,26 +20,27 @@ export class Waiter { } function new_(waker: rt.Waker): Waiter { + let shared!: rt.Arc; + let _5!: rt.Waker; + let unwind: number = 0; try { - let shared = new rt.Arc(waker.clone()); - try { - const waker2 = waker; - waker = undefined!; - const arg = waker2; - const shared2 = shared; - shared = undefined!; - return new Waiter({ waker: arg, shared: shared2 }); - } finally { - rt.drop(shared); + unwind = 4; + shared = new rt.Arc(waker.clone()); + _5 = waker; + return new Waiter({ waker: _5, shared }); + } catch (e) { + if (unwind === 0) { + throw e; } - } finally { rt.drop(waker); + throw e; } } /** Register with `list`, a no-op while the list still holds this waiter. */ export function register(self: Waiter, list: WaiterList.WaiterList): void { WaiterList.register(list, self); + return; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index d25b4a3d4..a778f36eb 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -15,35 +15,78 @@ function new_(): WaiterList { } export function register(self: WaiterList, waiter: Waiter.Waiter): void { - const weak = new rt.Weak(waiter.shared); - for (const entry of self.entries) { - if (entry.arc === weak.arc) { - return; - } - } - let probes: rt.usize = rt.min(self.entries.length, 2); - while (probes > 0) { - if (rt.at(self.entries, self.cursor).arc.strong === 0) { - const value = weak; - self.entries[rt.idx(self.entries, self.cursor)] = value; - return; - } - self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.length); - probes = rt.usizeSub(probes, 1); - } - if (self.entries.length >= 4) { - let live: rt.Weak[] = []; - const taken = self.entries; - self.entries = []; - for (const entry2 of taken) { - if (entry2.arc.strong > 0) { - live.push(entry2); + let weak!: rt.Weak; + let iter!: rt.Iter>; + let _8!: rt.Weak | rt.Done; + let probes!: rt.usize; + let _23!: rt.usize; + let _24!: rt.Weak; + let _27!: rt.usize; + let _28!: rt.usize; + let _31!: rt.usize; + let live!: rt.Weak[]; + let iter2!: rt.Iter>; + let _43!: rt.Weak | rt.Done; + let entry!: rt.Weak; + let _53!: rt.Weak[]; + weak = new rt.Weak(waiter.shared); + iter = rt.iterSlice(self.entries); + l0: while (true) { + _8 = iter.next(); + b1: { + b2: { + if (_8 === rt.DONE) { + probes = rt.min(self.entries.length, 2); + while (true) { + if (!(probes > 0)) { + b4: { + if (self.entries.length >= 4) { + live = []; + const taken = self.entries; + self.entries = []; + iter2 = rt.iterSlice(taken); + while (true) { + _43 = iter2.next(); + if (_43 === rt.DONE) { + _53 = live; + self.entries = _53; + self.cursor = 0; + break b4; + } else { + entry = _43; + if (entry.arc.strong > 0) { + live.push(entry); + } + } + } + } + } + self.entries.push(weak); + break b1; + } else { + _23 = self.cursor; + const at = rt.idx(self.entries, _23); + if (!(self.entries[at].arc.strong === 0)) { + _28 = rt.usizeAdd(self.cursor, 1); + _31 = self.entries.length; + self.cursor = rt.usizeRem(_28, _31); + probes = rt.usizeSub(probes, 1); + } else { + _24 = weak; + _27 = self.cursor; + const at2 = rt.idx(self.entries, _27); + self.entries[at2] = _24; + break b2; + } + } + } + } else if (!((_8.arc === weak.arc))) { + continue l0; + } } } - self.entries = live; - self.cursor = 0; + return; } - self.entries.push(weak); } /** Drain every entry into a new list, leaving this one empty. */ @@ -56,19 +99,40 @@ export function take(self: WaiterList): WaiterList { /** Wake every live waiter, draining the list. */ export function wake(self: WaiterList): void { - self.cursor = 0; - const taken = self.entries; - self.entries = []; - for (const entry of taken) { - const upgrade = rt.weakUpgrade(entry); - if (upgrade !== undefined) { - const waker = upgrade; - try { - waker.value.wakeByRef(); - } finally { - rt.drop(waker); + let iter!: rt.Iter>; + let _6!: rt.Weak | rt.Done; + let entry!: rt.Weak; + let _10!: rt.Arc | undefined; + let waker!: rt.Arc; + let unwind: number = 0; + try { + self.cursor = 0; + const taken = self.entries; + self.entries = []; + iter = rt.iterSlice(taken); + while (true) { + _6 = iter.next(); + if (_6 === rt.DONE) { + return; + } else { + unwind = 0; + entry = _6; + _10 = rt.weakUpgrade(entry); + if (_10 !== undefined) { + unwind = 15; + waker = _10; + waker.value.wakeByRef(); + unwind = 0; + rt.drop(waker); + } } } + } catch (e) { + if (unwind === 0) { + throw e; + } + rt.drop(waker); + throw e; } } diff --git a/ts/fixtures/task/expected/kio.ts b/ts/fixtures/task/expected/kio.ts index 5618f5f14..c7445bda8 100644 --- a/ts/fixtures/task/expected/kio.ts +++ b/ts/fixtures/task/expected/kio.ts @@ -8,25 +8,79 @@ import type * as Waiter from "./kio.Waiter.ts"; /** A future from a poll function that receives a [`Waiter`]. */ export function wait$recv_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { - return new Pending.Pending({ poll, park: Park.default$Default() }); + let _2!: (a0: Waiter.Waiter) => rt.Poll; + _2 = poll; + return new Pending.Pending({ poll: _2, park: Park.default$Default() }); } -export function* recvBody(_taskContext: rt.Context, self: Consumer.Consumer): Generator { - const self2 = self; - let __awaitee: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> = wait$recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { - return Consumer.pollRecv(self2, waiter); - }); - try { - while (true) { - const poll = Pending.poll$Future_recv_closure0_closure0(__awaitee, _taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class recvFuture { + state: number = 0; + self: Consumer.Consumer; + __awaitee_!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + + constructor(self: Consumer.Consumer) { + this.self = self; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let self!: Consumer.Consumer; + let _4!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + let _7!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + self = this.self; + _4 = wait$recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { + return Consumer.pollRecv(self, waiter); + }); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _7 = Pending.poll$Future_recv_closure0_closure0(this.__awaitee_, _taskContext); + if (_7 !== rt.Pending) { + unwind = 12; + result = _7; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 5cf8c6122..68f583fa1 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -25,18 +25,34 @@ function new_(): Log { /** Append one event. */ export function note(self: Log, event: string): void { - self._0.value.value.push(event); + let _4!: string[]; + let _6!: rt.Mutex; + _6 = self._0.value; + _4 = _6.value; + _4.push(event); + return; } /** Every event so far, one per line. */ export function text(self: Log): rt.ByteVec { - const events = self._0.value; - let out: rt.ByteVec = new rt.ByteVec(); - for (const event of events.value) { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(event)); - rt.byteVecPush(out, 10); + let events!: rt.Mutex; + let out!: rt.ByteVec; + let iter!: rt.Iter; + let _13!: string | rt.Done; + let _19!: Uint8Array; + events = self._0.value; + out = new rt.ByteVec(); + iter = rt.iterSlice(events.value); + while (true) { + _13 = iter.next(); + if (_13 === rt.DONE) { + return out; + } else { + _19 = rt.stringAsBytes(_13); + rt.byteVecExtendFromSlice(out, _19); + rt.byteVecPush(out, 10); + } } - return out; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/model.Channel.ts b/ts/fixtures/task/expected/model.Channel.ts index 79a136086..0f562cd69 100644 --- a/ts/fixtures/task/expected/model.Channel.ts +++ b/ts/fixtures/task/expected/model.Channel.ts @@ -21,30 +21,42 @@ export class Channel { } export function open(): Channel { - let producer = Producer.new(); + let _0!: Channel; + let producer!: Producer.Producer; + let consumer_!: Consumer.Consumer; + let producers!: Producer.Producer[]; + let _10!: boolean; + let unwind: number = 0; try { - let consumer_ = Producer.consume(producer); - try { - let producers: Producer.Producer[] = []; - try { - const arg = producers; - const producer2 = producer; - producer = undefined!; - arg.push(producer2); - const producers2 = producers; - producers = undefined!; - const arg2 = producers2; - const consumer2 = consumer_; - consumer_ = undefined!; - return new Channel({ producers: arg2, consumer: consumer2 }); - } finally { + _10 = false; + _10 = true; + producer = Producer.new(); + unwind = 10; + consumer_ = Producer.consume(producer); + unwind = 7; + producers = []; + unwind = 6; + _10 = false; + producers.push(producer); + _0 = new Channel({ producers, consumer: consumer_ }); + _10 = false; + return _0; + } catch (e) { + b0: { + if (unwind === 0) { + throw e; + } + if (unwind === 6) { rt.dropAll(producers); + } else if (unwind !== 7) { + break b0; } - } finally { rt.drop(consumer_); } - } finally { - rt.drop(producer); + if (_10) { + rt.drop(producer); + } + throw e; } } @@ -55,53 +67,46 @@ export function consumer(self: Channel): Consumer.Consumer { /** Send `value` through the first producer, if one is open. */ export function send(self: Channel, value: rt.u64): boolean { - const first = rt.sliceFirst(self.producers); - if (first !== undefined) { - const producer = first; - Producer.send(producer, value); - return true; + let _0!: boolean; + let _3!: Producer.Producer | undefined; + _3 = rt.sliceFirst(self.producers); + if (_3 === undefined) { + _0 = false; } else { - return false; + Producer.send(_3, value); + _0 = true; } + return _0; } /** Drop the last producer, if one is open: the last closes the channel. */ export function close(self: Channel): boolean { - const pop = self.producers.pop(); - if (pop !== undefined) { - let producer = pop; - try { - const producer2 = producer; - producer = undefined!; - rt.drop(producer2); - return true; - } finally { - rt.drop(producer); - } + let _0!: boolean; + let _2!: Producer.Producer | undefined; + _2 = self.producers.pop(); + if (_2 === undefined) { + _0 = false; } else { - return false; + rt.drop(_2); + _0 = true; } + return _0; } /** Open another producer, if one is open to clone. */ export function cloneProducer(self: Channel): boolean { - let clone: Producer.Producer = undefined!; - try { - const first = rt.sliceFirst(self.producers); - if (first !== undefined) { - const producer = first; - clone = Producer.clone$Clone(producer); - } else { - return false; - } - const arg = self.producers; - const clone2 = clone; - clone = undefined!; - arg.push(clone2); - return true; - } finally { - rt.drop(clone); + let _0!: boolean; + let clone!: Producer.Producer; + let _3!: Producer.Producer | undefined; + _3 = rt.sliceFirst(self.producers); + if (_3 === undefined) { + _0 = false; + } else { + clone = Producer.clone$Clone(_3); + self.producers.push(clone); + _0 = true; } + return _0; } //# sourceMappingURL=model.Channel.ts.map diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index 6d3d45fc5..addf2f603 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -20,33 +20,45 @@ export class Guard { } function new_(id: rt.u32, log: Log.Log): Guard { - try { - const arg = id; - const log2 = log; - log = undefined!; - return new Guard({ id: arg, log: log2 }); - } finally { - rt.drop(log); - } + return new Guard({ id, log }); } /** Log `event` as this guard's. */ export function note(self: Guard, event: string): void { - Log.note(self.log, rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " ", (f: rt.Formatter) => rt.fmtPad(f, event)])); + let _5!: string; + _5 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " ", (f: rt.Formatter) => rt.fmtPad(f, event)]); + Log.note(self.log, _5); + return; } /** Log `event`, then drop: `self`, taken by value, drops as the call returns. */ export function finish(self: Guard, event: string): rt.u32 { + let _0!: rt.u32; + let unwind: number = 0; try { + unwind = 4; note(self, event); - return self.id; - } finally { + unwind = 0; + _0 = self.id; + rt.drop(self); + return _0; + } catch (e) { + if (unwind === 0) { + throw e; + } rt.drop(self); + throw e; } } export function drop$Drop(self: Guard): void { - Log.note(self.log, rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " drop"])); + let _4!: string; + let args!: [rt.u32]; + args = [self.id] as [rt.u32]; + const arg = args[0]; + _4 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " drop"]); + Log.note(self.log, _4); + return; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index 664611f1c..33540d952 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -14,61 +14,187 @@ import type * as Tally from "./model.Tally.ts"; * each await beside the one it was given. It panics on 99. */ export function sum(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { - return rt.future(sumBody, sumDrop, rx, guard); + return new sumFuture(rx, guard); } -export function* sumBody(_taskContext: rt.Context, rx: Consumer.Consumer, guard: Guard.Guard): Generator { - let rx2: Consumer.Consumer = rx; - rx = undefined!; - try { - const guard2 = guard; - guard = undefined!; +export class sumFuture { + state: number = 0; + rx: Consumer.Consumer; + guard: Guard.Guard; + rx_!: Consumer.Consumer; + guard_!: Guard.Guard; + inner_!: Guard.Guard; + total_!: rt.u64; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer, guard: Guard.Guard) { + this.rx = rx; + this.guard = guard; + } + + [Symbol.dispose](): void { + let unwind: number = 0; try { - const inner = Guard.new(rt.u32Add(guard2.id, 100), Log.clone$Clone(guard2.log)); - try { - let total: rt.u64 = 0; - while (true) { - let option: rt.u64 | undefined; - let __awaitee: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - option = result; - break; - } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee); + if (this.state === 0) { + unwind = 17; + rt.drop(this.rx); + unwind = 0; + rt.drop(this.guard); + return; + } else if (this.state === 3) { + unwind = 10; + rt.drop(this.__awaitee_); + unwind = 12; + rt.drop(this.inner_); + unwind = 13; + rt.drop(this.guard_); + unwind = 0; + rt.drop(this.rx_); + return; + } else { + return; + } + } catch (e) { + b0: { + b1: { + if (unwind === 0) { + throw e; } - if (option !== undefined) { - const value = option; - if (value === 99) { - rt.panicFmt(["g", (f: rt.Formatter) => rt.u32Display(guard2.id, f), " poisoned"]); + if (unwind === 10) { + rt.drop(this.inner_); + } else if (unwind !== 12) { + if (unwind === 13) { + break b1; + } else { + rt.drop(this.guard); + break b0; } - Log.note(inner.log, rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(guard2.id, f), " got ", (f: rt.Formatter) => rt.u64Display(value, f)])); - total = rt.u64Add(total, value); - } else { - break; } + rt.drop(this.guard_); } - return total; - } finally { - rt.drop(inner); + rt.drop(this.rx_); } - } finally { - rt.drop(guard2); + throw e; } - } finally { - rt.drop(rx2); } -} -export function sumDrop(rx: Consumer.Consumer, guard: Guard.Guard): void { - rt.drop(rx); - rt.drop(guard); + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _3!: rt.u32; + let _6!: Log.Log; + let _8!: rt.Future; + let _11!: rt.Poll; + let result!: rt.u64 | undefined; + let value!: rt.u64; + let args!: [rt.u32]; + let _32!: string; + let _43!: rt.u64; + let _47!: rt.u64; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + let bb0: number = 0; + l0: while (true) { + switch (bb0) { + case 0: + _taskContext = _2; + if (this.state === 0) { + unwind = 33; + this.rx_ = this.rx; + this.guard_ = this.guard; + _3 = rt.u32Add(this.guard_.id, 100); + _6 = Log.clone$Clone(this.guard_.log); + this.inner_ = Guard.new(_3, _6); + this.total_ = 0; + bb0 = 4; + continue l0; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } else { + bb0 = 7; + continue l0; + } + case 4: + unwind = 32; + _8 = Consumer.recv(this.rx_); + this.__awaitee_ = _8; + bb0 = 7; + continue l0; + case 7: + unwind = 31; + _11 = this.__awaitee_.poll(_taskContext); + if (_11 !== rt.Pending) { + unwind = 32; + result = _11; + rt.drop(this.__awaitee_); + if (result !== undefined) { + value = result; + if (!(value !== 99)) { + unwind = 32; + args = [this.guard_.id] as [rt.u32]; + const arg = args[0]; + rt.panicFmt(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " poisoned"]); + } else { + unwind = 32; + _32 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(this.guard_.id, f), " got ", (f: rt.Formatter) => rt.u64Display(value, f)]); + Log.note(this.inner_.log, _32); + unwind = 32; + _43 = rt.u64Add(this.total_, value); + this.total_ = _43; + bb0 = 4; + continue l0; + } + } else { + unwind = 33; + _47 = this.total_; + rt.drop(this.inner_); + unwind = 34; + rt.drop(this.guard_); + unwind = 35; + rt.drop(this.rx_); + _0 = _47; + this.state = 1; + return _0; + } + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } + } + } catch (e) { + b1: { + b2: { + b3: { + if (unwind === 0) { + throw e; + } + if (unwind === 31) { + rt.drop(this.__awaitee_); + } else if (unwind !== 32) { + if (unwind === 33) { + break b3; + } else if (unwind === 34) { + break b2; + } else { + break b1; + } + } + rt.drop(this.inner_); + } + rt.drop(this.guard_); + } + rt.drop(this.rx_); + } + this.state = 2; + throw e; + } + } } /** @@ -79,221 +205,717 @@ export function sumDrop(rx: Consumer.Consumer, guard: Guard.Guard): void { * returns or is cancelled. Between them, a value of two types that hold each other. */ export function blocks(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): rt.Future { - return rt.future(blocksBody, blocksDrop, rx, guard, moves); + return new blocksFuture(rx, guard, moves); } -export function* blocksBody(_taskContext: rt.Context, rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): Generator { - let rx2: Consumer.Consumer = rx; - rx = undefined!; - try { - let guard2 = guard; - guard = undefined!; +export class blocksFuture { + state: number = 0; + rx: Consumer.Consumer; + guard: Guard.Guard; + moves: boolean; + rx_!: Consumer.Consumer; + guard_!: Guard.Guard; + moves_!: boolean; + first_!: Guard.Guard; + second_!: Guard.Guard; + tally_!: Tally.Tally; + saved!: Guard.Guard; + _saved!: rt.u32; + __awaitee_!: rt.Future; + mark_!: Mark.Mark; + replaced_!: rt.u32; + ___awaitee_!: rt.Future; + _nested_!: Inner.Inner; + chosen_!: Guard.Guard; + ___awaitee_$2!: rt.Future; + _saved$2!: boolean; + _saved$3!: boolean; + _saved$4!: boolean; + _saved$5!: boolean; + _saved$6!: boolean; + + constructor(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean) { + this.rx = rx; + this.guard = guard; + this.moves = moves; + } + + [Symbol.dispose](): void { + let unwind: number = 0; try { - const moves2 = moves; - let first = Guard.new(rt.u32Add(guard2.id, 200), Log.clone$Clone(guard2.log)); - try { - let second = Guard.new(rt.u32Add(guard2.id, 300), Log.clone$Clone(guard2.log)); - try { - rt.drop(rt.future(blocksBody$2, undefined, first)); - turns(guard2.log, rt.u32Rem(guard2.id, 5)); - let tally: Tally.Tally = { n: guard2.id }; - let seen = rt.future(blocksBody$3, undefined, rt.copy(tally)); - try { - tally.n = rt.u32Add(tally.n, 1000); - const arg2 = guard2; - const arg = tally.n; - let value: rt.u32; - const seen2 = seen; - seen = undefined!; - let __awaitee: rt.Future = seen2; - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - value = result; - break; + if (this.state === 0) { + unwind = 62; + rt.drop(this.rx); + unwind = 0; + rt.drop(this.guard); + return; + } else if (this.state === 3) { + unwind = 36; + rt.drop(this.__awaitee_); + } else if (this.state === 4) { + unwind = 33; + rt.drop(this.___awaitee_); + } else if (this.state === 5) { + unwind = 26; + rt.drop(this.___awaitee_$2); + unwind = 29; + rt.drop(this.chosen_); + unwind = 31; + rt.drop(this._nested_); + } else { + return; + } + this._saved$6 = false; + if (this._saved$3) { + unwind = 40; + rt.drop(this.second_); + } + this._saved$3 = false; + if (this._saved$4) { + unwind = 41; + rt.drop(this.first_); + } + this._saved$4 = false; + if (this._saved$2) { + unwind = 42; + rt.drop(this.guard_); + } + this._saved$2 = false; + if (this._saved$5) { + unwind = 0; + rt.drop(this.rx_); + } + this._saved$5 = false; + return; + } catch (e) { + b6: { + b7: { + b8: { + b9: { + b10: { + b11: { + b12: { + if (unwind === 0) { + throw e; + } + if (unwind === 26) { + rt.drop(this.chosen_); + } else if (unwind !== 29) { + if (unwind === 31) { + break b12; + } else if (unwind === 33) { + break b11; + } else if (unwind === 36) { + break b10; + } else if (unwind === 40) { + break b9; + } else if (unwind === 41) { + break b8; + } else if (unwind === 42) { + break b7; + } else { + rt.drop(this.guard); + break b6; + } + } + rt.drop(this._nested_); + } } - _taskContext = yield; } - } finally { - rt.drop(__awaitee); - } - Guard.note(arg2, rt.fmtFormat(["tally ", (f: rt.Formatter) => rt.u32Display(arg, f), " then ", (f: rt.Formatter) => rt.u32Display(value, f)])); - let mark: Mark.Mark = { n: 1 }; - let replaced: rt.u32; - let __awaitee2: rt.Future = rt.future(blocksBody$4, undefined, mark); - try { - while (true) { - const poll2 = __awaitee2.poll(_taskContext); - if (poll2 !== rt.Pending) { - const result2 = poll2; - replaced = result2; - break; - } - _taskContext = yield; + this._saved$6 = false; + if (this._saved$3) { + rt.drop(this.second_); } - } finally { - rt.drop(__awaitee2); } - Guard.note(guard2, rt.fmtFormat(["mark ", (f: rt.Formatter) => rt.u32Display(replaced, f), " ", (f: rt.Formatter) => rt.u32Display(mark.n, f)])); - let cycle = new Outer.Outer({ inner: undefined, guard: Guard.new(rt.u32Add(guard2.id, 800), Log.clone$Clone(guard2.log)) }); - try { - const cycle2 = cycle; - cycle = undefined!; - const _nested = new Inner.Inner({ outer: cycle2 }); - try { - let third = Guard.new(rt.u32Add(guard2.id, 400), Log.clone$Clone(guard2.log)); - try { - let chosen: Guard.Guard = undefined!; - try { - if (moves2) { - const third2 = third; - third = undefined!; - chosen = third2; + this._saved$3 = false; + if (this._saved$4) { + rt.drop(this.first_); + } + } + this._saved$4 = false; + if (this._saved$2) { + rt.drop(this.guard_); + } + } + this._saved$2 = false; + if (this._saved$5) { + rt.drop(this.rx_); + } + this._saved$5 = false; + } + throw e; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _3!: rt.u32; + let _6!: Log.Log; + let _8!: rt.u32; + let _11!: Log.Log; + let _18!: rt.u32; + let seen!: rt.Future; + let _23!: rt.u32; + let _25!: string; + let _27!: string; + let _32!: rt.u32; + let _33!: rt.Future; + let _35!: rt.Poll; + let _48!: rt.Future; + let _51!: rt.Poll; + let _61!: string; + let _63!: string; + let _75!: Inner.Inner | undefined; + let _76!: Guard.Guard; + let _83!: Outer.Outer; + let third!: Guard.Guard; + let _97!: rt.Future; + let _98!: rt.Poll; + let result3!: rt.u64; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + b0: { + b1: { + _taskContext = _2; + if (this.state === 0) { + unwind = 76; + this._saved$5 = false; + this._saved$2 = false; + this._saved$4 = false; + this._saved$3 = false; + this._saved$6 = false; + this._saved$5 = true; + this.rx_ = this.rx; + this._saved$2 = true; + this.guard_ = this.guard; + this.moves_ = this.moves; + _3 = rt.u32Add(this.guard_.id, 200); + _6 = Log.clone$Clone(this.guard_.log); + this.first_ = Guard.new(_3, _6); + unwind = 75; + this._saved$4 = true; + _8 = rt.u32Add(this.guard_.id, 300); + _11 = Log.clone$Clone(this.guard_.log); + this.second_ = Guard.new(_8, _11); + unwind = 83; + this._saved$3 = true; + rt.drop(new blocksFuture$2(this.first_)); + _18 = rt.u32Rem(this.guard_.id, 5); + turns(this.guard_.log, _18); + unwind = 81; + this.tally_ = { n: this.guard_.id }; + this._saved$6 = true; + seen = new blocksFuture$3(rt.copy(this.tally_)); + _23 = rt.u32Add(this.tally_.n, 1000); + this.tally_.n = _23; + this.saved = this.guard_; + this._saved = this.tally_.n; + this._saved$6 = false; + _33 = seen; + this.__awaitee_ = _33; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } else if (this.state === 3) { + } else if (this.state === 4) { + break b1; + } else { + break b0; + } + unwind = 73; + _35 = this.__awaitee_.poll(_taskContext); + if (_35 !== rt.Pending) { + unwind = 81; + _32 = _35; + rt.drop(this.__awaitee_); + _27 = rt.fmtFormat(["tally ", (f: rt.Formatter) => rt.u32Display(this._saved, f), " then ", (f: rt.Formatter) => rt.u32Display(_32, f)]); + unwind = 72; + _25 = _27; + Guard.note(this.saved, _25); + unwind = 81; + this.mark_ = { n: 1 }; + _48 = new blocksFuture$4(this.mark_); + this.___awaitee_ = _48; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } + unwind = 71; + _51 = this.___awaitee_.poll(_taskContext); + if (_51 !== rt.Pending) { + unwind = 81; + this.replaced_ = _51; + rt.drop(this.___awaitee_); + _63 = rt.fmtFormat(["mark ", (f: rt.Formatter) => rt.u32Display(this.replaced_, f), " ", (f: rt.Formatter) => rt.u32Display(this.mark_.n, f)]); + unwind = 70; + _61 = _63; + Guard.note(this.guard_, _61); + unwind = 69; + _75 = undefined; + _76 = Guard.new(rt.u32Add(this.guard_.id, 800), Log.clone$Clone(this.guard_.log)); + unwind = 81; + _83 = new Outer.Outer({ inner: _75, guard: _76 }); + unwind = 68; + this._nested_ = new Inner.Inner({ outer: _83 }); + third = Guard.new(rt.u32Add(this.guard_.id, 400), Log.clone$Clone(this.guard_.log)); + if (!this.moves_) { + this.chosen_ = third; + } else { + this.chosen_ = third; + } + unwind = 67; + Guard.note(this.chosen_, "chosen"); + if (this.moves_) { + unwind = 67; + this._saved$2 = false; + rt.drop(new blocksFuture$5(this.guard_)); + } + unwind = 67; + this._saved$4 = false; + this._saved$3 = false; + this._saved$5 = false; + _97 = new blocksFuture$6(this.first_, this.second_, this.rx_); + this.___awaitee_$2 = _97; + } else { + _0 = rt.Pending; + this.state = 4; + return _0; + } + } + unwind = 66; + _98 = this.___awaitee_$2.poll(_taskContext); + if (_98 !== rt.Pending) { + unwind = 67; + result3 = _98; + rt.drop(this.___awaitee_$2); + unwind = 68; + rt.drop(this.chosen_); + unwind = 81; + rt.drop(this._nested_); + this._saved$6 = false; + this._saved$3 = false; + this._saved$4 = false; + if (this._saved$2) { + unwind = 77; + rt.drop(this.guard_); + } + this._saved$2 = false; + this._saved$5 = false; + _0 = result3; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 5; + return _0; + } + } catch (e) { + b6: { + b7: { + b8: { + b9: { + b10: { + b11: { + if (unwind === 0) { + throw e; + } + if (unwind === 66) { + rt.drop(this.___awaitee_$2); + } else if (unwind !== 67) { + if (unwind === 68) { + break b11; + } else if (unwind === 69) { + rt.drop(_75); + break b10; + } else if (unwind === 70) { + break b10; + } else if (unwind === 71) { + rt.drop(this.___awaitee_); + break b10; + } else if (unwind === 72) { + break b10; + } else if (unwind === 73) { + rt.drop(this.__awaitee_); + break b10; + } else if (unwind === 75) { + break b8; + } else if (unwind === 76) { + break b7; + } else if (unwind === 77) { + break b6; + } else if (unwind === 81) { + break b10; } else { - const third3 = third; - third = undefined!; - chosen = third3; - } - Guard.note(chosen, "chosen"); - if (moves2) { - const guard22 = guard2; - guard2 = undefined!; - rt.drop(rt.future(blocksBody$5, blocksDrop$2, guard22)); - } - const first2 = first; - first = undefined!; - const second2 = second; - second = undefined!; - const rx22 = rx2; - rx2 = undefined!; - let read_ = rt.future(blocksBody$6, blocksDrop$3, first2, second2, rx22); - try { - const read2 = read_; - read_ = undefined!; - let __awaitee4: rt.Future = read2; - try { - while (true) { - const poll4 = __awaitee4.poll(_taskContext); - if (poll4 !== rt.Pending) { - const result4 = poll4; - return result4; - } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee4); - } - } finally { - rt.drop(read_); + break b9; } - } finally { - rt.drop(chosen); } - } finally { - rt.drop(third); + rt.drop(this.chosen_); } - } finally { - rt.drop(_nested); + rt.drop(this._nested_); } - } finally { - rt.drop(cycle); + if (this._saved$6) { + rt.drop(seen); + } + this._saved$6 = false; + } + if (this._saved$3) { + rt.drop(this.second_); } - } finally { - rt.drop(seen); } - } finally { - rt.drop(second); + this._saved$3 = false; + if (this._saved$4) { + rt.drop(this.first_); + } } - } finally { - rt.drop(first); + this._saved$4 = false; + if (this._saved$2) { + rt.drop(this.guard_); + } + } + this._saved$2 = false; + if (this._saved$5) { + rt.drop(this.rx_); } - } finally { - rt.drop(guard2); + this._saved$5 = false; + this.state = 2; + throw e; } - } finally { - rt.drop(rx2); } } -export function blocksDrop(rx: Consumer.Consumer, guard: Guard.Guard, _moves: boolean): void { - rt.drop(rx); - rt.drop(guard); -} +export class blocksFuture$2 { + state: number = 0; + first: Guard.Guard; -export function* blocksBody$2(_taskContext2: rt.Context, first: Guard.Guard): Generator { - Guard.note(first, "borrowed"); -} + constructor(first: Guard.Guard) { + this.first = first; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else { + return; + } + } -export function* blocksBody$3(_taskContext3: rt.Context, tally: Tally.Tally): Generator { - return read(rt.copy(tally)); + poll(_2: rt.Context): rt.Poll { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 3; + Guard.note(this.first, "borrowed"); + this.state = 1; + return undefined; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + } catch (e) { + if (unwind === 0) { + throw e; + } + this.state = 2; + throw e; + } + } } -export function* blocksBody$4(_taskContext4: rt.Context, mark: Mark.Mark): Generator { - Object.assign(mark, { n: 2 }); - return mark.n; +export class blocksFuture$3 { + state: number = 0; + tally: Tally.Tally; + + constructor(tally: Tally.Tally) { + this.tally = tally; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 3; + _0 = read(this.tally); + this.state = 1; + return _0; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + } catch (e) { + if (unwind === 0) { + throw e; + } + this.state = 2; + throw e; + } + } } -export function* blocksBody$5(_taskContext5: rt.Context, guard2: Guard.Guard): Generator { - try { - Guard.note(guard2, "moved"); - } finally { - rt.drop(guard2); +export class blocksFuture$4 { + state: number = 0; + mark: Mark.Mark; + + constructor(mark: Mark.Mark) { + this.mark = mark; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _3!: Mark.Mark; + let _4!: Mark.Mark; + if (this.state === 0) { + _3 = { n: 2 }; + _4 = this.mark; + Object.assign(_4, _3); + _0 = this.mark.n; + this.state = 1; + return _0; + } else { + rt.panic("`async fn` resumed after completion"); + } } } -export function blocksDrop$2(guard2: Guard.Guard): void { - rt.drop(guard2); +export class blocksFuture$5 { + state: number = 0; + guard: Guard.Guard; + + constructor(guard: Guard.Guard) { + this.guard = guard; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + rt.drop(this.guard); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 4; + Guard.note(this.guard, "moved"); + unwind = 5; + rt.drop(this.guard); + this.state = 1; + return undefined; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 4) { + rt.drop(this.guard); + } + this.state = 2; + throw e; + } + } } -export function* blocksBody$6(_taskContext6: rt.Context, first: Guard.Guard, second: Guard.Guard, rx2: Consumer.Consumer): Generator { - try { +export class blocksFuture$6 { + state: number = 0; + first: Guard.Guard; + second: Guard.Guard; + rx: Consumer.Consumer; + _held_!: Guard.Guard; + __awaitee_!: rt.Future; + + constructor(first: Guard.Guard, second: Guard.Guard, rx: Consumer.Consumer) { + this.first = first; + this.second = second; + this.rx = rx; + } + + [Symbol.dispose](): void { + let unwind: number = 0; try { - try { - Guard.note(first, "reads"); - Guard.note(second, "reads"); - const _held = Guard.new(rt.u32Add(second.id, 100), Log.clone$Clone(second.log)); - try { - let option: rt.u64 | undefined; - let __awaitee3: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll3 = __awaitee3.poll(_taskContext6); - if (poll3 !== rt.Pending) { - const result3 = poll3; - option = result3; - break; - } - _taskContext6 = yield; + if (this.state === 0) { + unwind = 22; + rt.drop(this.first); + unwind = 21; + rt.drop(this.second); + unwind = 0; + rt.drop(this.rx); + return; + } else if (this.state === 3) { + unwind = 8; + rt.drop(this.__awaitee_); + unwind = 10; + rt.drop(this._held_); + unwind = 14; + rt.drop(this.first); + unwind = 13; + rt.drop(this.second); + unwind = 0; + rt.drop(this.rx); + return; + } else { + return; + } + } catch (e) { + b0: { + b1: { + b2: { + if (unwind === 0) { + throw e; } - } finally { - rt.drop(__awaitee3); - } - if (option !== undefined) { - const value2 = option; - return value2; - } else { - return 0; + if (unwind === 8) { + rt.drop(this._held_); + break b1; + } else if (unwind === 10) { + break b1; + } else if (unwind === 13) { + break b2; + } else if (unwind === 14) { + rt.drop(this.second); + break b2; + } else if (unwind !== 21) { + rt.drop(this.second); + } + rt.drop(this.rx); + break b0; } - } finally { - rt.drop(_held); + rt.drop(this.rx); + break b0; } - } finally { - rt.drop(first); + rt.drop(this.first); + rt.drop(this.second); + rt.drop(this.rx); } - } finally { - rt.drop(second); + throw e; } - } finally { - rt.drop(rx2); } -} -export function blocksDrop$3(first: Guard.Guard, second: Guard.Guard, rx2: Consumer.Consumer): void { - rt.drop(first); - rt.drop(second); - rt.drop(rx2); + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _9!: rt.u32; + let _12!: Log.Log; + let _14!: rt.Future; + let _17!: rt.Poll; + let result!: rt.u64 | undefined; + let _27!: rt.u64; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 30; + Guard.note(this.first, "reads"); + Guard.note(this.second, "reads"); + _9 = rt.u32Add(this.second.id, 100); + _12 = Log.clone$Clone(this.second.log); + this._held_ = Guard.new(_9, _12); + unwind = 21; + _14 = Consumer.recv(this.rx); + this.__awaitee_ = _14; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 20; + _17 = this.__awaitee_.poll(_taskContext); + if (_17 !== rt.Pending) { + unwind = 21; + result = _17; + rt.drop(this.__awaitee_); + if (result === undefined) { + _27 = 0; + } else { + _27 = result; + } + unwind = 30; + rt.drop(this._held_); + unwind = 24; + rt.drop(this.first); + unwind = 23; + rt.drop(this.second); + unwind = 22; + rt.drop(this.rx); + _0 = _27; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + b2: { + b3: { + b4: { + if (unwind === 0) { + throw e; + } + if (unwind === 20) { + rt.drop(this.__awaitee_); + break b4; + } else if (unwind === 21) { + break b4; + } else if (unwind === 22) { + break b2; + } else if (unwind !== 23) { + if (unwind === 24) { + rt.drop(this.second); + } else { + break b3; + } + } + rt.drop(this.rx); + break b2; + } + rt.drop(this._held_); + } + rt.drop(this.first); + rt.drop(this.second); + rt.drop(this.rx); + } + this.state = 2; + throw e; + } + } } export function read(t: Tally.Tally): rt.u32 { @@ -302,7 +924,10 @@ export function read(t: Tally.Tally): rt.u32 { /** `i`, noted as picked. */ export function pick(log: Log.Log, i: rt.usize): rt.usize { - Log.note(log, rt.fmtFormat(["pick ", (f: rt.Formatter) => rt.usizeDisplay(i, f)])); + let args!: [rt.usize]; + args = [i] as [rt.usize]; + const arg = args[0]; + Log.note(log, rt.fmtFormat(["pick ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)])); return i; } @@ -316,85 +941,159 @@ export function pick(log: Log.Log, i: rt.usize): rt.usize { * guard a method takes by value, which drops inside it. */ export function turns(log: Log.Log, count: rt.u32): void { - const pair = [Guard.new(rt.u32Add(count, 10), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 20), Log.clone$Clone(log))]; + let pair!: Guard.Guard[]; + let _4!: Guard.Guard; + let _8!: Guard.Guard; + let kept!: Guard.Guard; + let pinned!: Guard.Guard; + let held!: Guard.Guard; + let _34!: Guard.Guard; + let scoped!: rt.u32; + let _42!: Guard.Guard; + let args!: [rt.u32]; + let boxed!: Guard.Guard; + let once!: rt.u32; + let finished!: rt.u32; + let args5!: [rt.u32]; + let spares!: Guard.Guard[]; + let _91!: Guard.Guard; + let _95!: Guard.Guard; + let _99!: rt.usize; + let left!: rt.u32; + let turn!: Guard.Guard; + let _119!: rt.u32; + let unwind: number = 0; try { - const kept = pair[0]; - pair[0] = undefined!; - try { - Guard.note(kept, "kept"); - const pinned = Guard.new(rt.u32Add(count, 40), Log.clone$Clone(log)); - try { - Guard.note(pinned, "pinned"); - const held = Guard.new(rt.u32Add(count, 50), Log.clone$Clone(log)); - try { - const borrowed = held; - Guard.note(borrowed, "borrowed"); - const extended = Guard.new(rt.u32Add(count, 60), Log.clone$Clone(log)); - try { - Guard.note(extended, "extended"); - let value: rt.u32; - const inner = Guard.new(rt.u32Add(count, 90), Log.clone$Clone(log)); - try { - value = inner.id; - } finally { - rt.drop(inner); - } - const scoped = value; - Log.note(log, rt.fmtFormat(["after ", (f: rt.Formatter) => rt.u32Display(scoped, f)])); - const boxed = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); - try { - const once = boxed.id; - Log.note(log, rt.fmtFormat(["boxed ", (f: rt.Formatter) => rt.u32Display(once, f), " ", (f: rt.Formatter) => rt.u32Display(boxed.id, f)])); - const finished = Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); - Log.note(log, rt.fmtFormat(["finished ", (f: rt.Formatter) => rt.u32Display(finished, f)])); - const spares = [Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 80), Log.clone$Clone(log))]; - try { - const index = pick(log, rt.usizeRem(count as rt.usize, 2)); - spares[rt.idx(spares, index)]; - arms: { - if (count === 0) { - Log.note(log, "no turns"); - break arms; + _4 = Guard.new(rt.u32Add(count, 10), Log.clone$Clone(log)); + unwind = 94; + _8 = Guard.new(rt.u32Add(count, 20), Log.clone$Clone(log)); + unwind = 93; + pair = [_4, _8]; + kept = pair[0]; + Guard.note(kept, "kept"); + pinned = Guard.new(rt.u32Add(count, 40), Log.clone$Clone(log)); + unwind = 92; + Guard.note(pinned, "pinned"); + held = Guard.new(rt.u32Add(count, 50), Log.clone$Clone(log)); + unwind = 91; + Guard.note(held, "borrowed"); + _34 = Guard.new(rt.u32Add(count, 60), Log.clone$Clone(log)); + unwind = 90; + Guard.note(_34, "extended"); + _42 = Guard.new(rt.u32Add(count, 90), Log.clone$Clone(log)); + scoped = _42.id; + rt.drop(_42); + args = [scoped] as [rt.u32]; + const arg = args[0]; + Log.note(log, rt.fmtFormat(["after ", (f: rt.Formatter) => rt.u32Display(arg, f)])); + boxed = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); + unwind = 89; + once = boxed.id; + Log.note(log, rt.fmtFormat(["boxed ", (f: rt.Formatter) => rt.u32Display(once, f), " ", (f: rt.Formatter) => rt.u32Display(boxed.id, f)])); + finished = Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); + args5 = [finished] as [rt.u32]; + const arg2 = args5[0]; + Log.note(log, rt.fmtFormat(["finished ", (f: rt.Formatter) => rt.u32Display(arg2, f)])); + _91 = Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)); + unwind = 88; + _95 = Guard.new(rt.u32Add(count, 80), Log.clone$Clone(log)); + unwind = 87; + spares = [_91, _95]; + _99 = pick(log, rt.usizeRem(count as rt.usize, 2)); + if (!(_99 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _99); + } + b0: { + if (count === 0) { + unwind = 87; + Log.note(log, rt.fmtFormat(["no turns"])); + } else if (!(count < 4)) { + unwind = 87; + Log.note(log, rt.fmtFormat(["many turns"])); + } else { + left = count; + while (true) { + unwind = 87; + turn = Guard.new(left, Log.clone$Clone(log)); + if (!(left === 1)) { + unwind = 86; + Guard.note(turn, "turn"); + _119 = rt.u32Sub(left, 1); + unwind = 87; + left = _119; + rt.drop(turn); + } else { + unwind = 87; + rt.drop(turn); + break b0; + } + } + } + } + unwind = 89; + rt.dropAll(spares); + unwind = 90; + rt.drop(boxed); + unwind = 91; + rt.drop(_34); + unwind = 92; + rt.drop(held); + unwind = 93; + rt.drop(pinned); + unwind = 96; + rt.drop(kept); + unwind = 0; + rt.dropAll(pair.slice(1, 2)); + return; + } catch (e) { + b2: { + b3: { + b4: { + b5: { + b6: { + b7: { + b8: { + if (unwind === 0) { + throw e; } - const n = count; - if (n < 4) { - let left: rt.u32 = n; - while (true) { - const turn = Guard.new(left, Log.clone$Clone(log)); - try { - if (left === 1) { - break; - } - Guard.note(turn, "turn"); - left = rt.u32Sub(left, 1); - } finally { - rt.drop(turn); - } + if (unwind === 86) { + rt.drop(turn); + } else if (unwind !== 87) { + if (unwind === 88) { + rt.drop(_91); + break b8; + } else if (unwind === 89) { + break b8; + } else if (unwind === 90) { + break b7; + } else if (unwind === 91) { + break b6; + } else if (unwind === 92) { + break b5; + } else if (unwind === 93) { + break b4; + } else if (unwind === 94) { + rt.drop(_4); + break b2; + } else { + break b3; } - break arms; } - Log.note(log, "many turns"); + rt.dropAll(spares); } - } finally { - rt.dropAll(spares); + rt.drop(boxed); } - } finally { - rt.drop(boxed); + rt.drop(_34); } - } finally { - rt.drop(extended); + rt.drop(held); } - } finally { - rt.drop(held); + rt.drop(pinned); } - } finally { - rt.drop(pinned); + rt.drop(kept); } - } finally { - rt.drop(kept); + rt.dropAll(pair.slice(1, 2)); } - } finally { - rt.dropAll(pair); + throw e; } } @@ -403,392 +1102,1260 @@ export function turns(log: Log.Log, count: rt.u32): void { * deep: 1, 4, or 16. */ export function drain(rx: Consumer.Consumer, depth: rt.u32): rt.Future { - return rt.future(drainBody, drainDrop, rx, depth); + return new drainFuture(rx, depth); } -export function* drainBody(_taskContext: rt.Context, rx: Consumer.Consumer, depth: rt.u32): Generator { - let rx2: Consumer.Consumer = rx; - rx = undefined!; - try { - const depth2 = depth; - let total: rt.u64 = 0; - while (true) { - let next: rt.u64 | undefined; - if (depth2 === 1) { - let __awaitee: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - next = result; - break; +export class drainFuture { + state: number = 0; + rx: Consumer.Consumer; + depth: rt.u32; + rx_!: Consumer.Consumer; + depth_!: rt.u32; + total_!: rt.u64; + __awaitee_!: rt.Future; + ___awaitee_!: rt.Future; + ___awaitee_$2!: rt.Future; + + constructor(rx: Consumer.Consumer, depth: rt.u32) { + this.rx = rx; + this.depth = depth; + } + + [Symbol.dispose](): void { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 0; + rt.drop(this.rx); + return; + } else if (this.state === 3) { + unwind = 19; + rt.drop(this.__awaitee_); + } else if (this.state === 4) { + unwind = 17; + rt.drop(this.___awaitee_); + } else if (this.state === 5) { + unwind = 15; + rt.drop(this.___awaitee_$2); + } else { + return; + } + unwind = 0; + rt.drop(this.rx_); + return; + } catch (e) { + if (unwind === 0) { + throw e; + } + rt.drop(this.rx_); + throw e; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let next!: rt.u64 | undefined; + let _4!: rt.Future; + let _7!: rt.Poll; + let _15!: rt.Future; + let _18!: rt.Poll; + let _26!: rt.Future; + let _29!: rt.Poll; + let _39!: rt.u64; + let _40!: rt.u64; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + let bb0: number = 0; + l0: while (true) { + switch (bb0) { + case 0: + _taskContext = _2; + if (this.state === 0) { + this.rx_ = this.rx; + this.depth_ = this.depth; + this.total_ = 0; + bb0 = 1; + continue l0; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } else if (this.state === 3) { + bb0 = 7; + continue l0; + } else if (this.state === 4) { + bb0 = 15; + continue l0; + } else { + bb0 = 22; + continue l0; } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee); - } - } else if (depth2 === 4) { - let __awaitee2: rt.Future = level3(rx2); - try { - while (true) { - const poll2 = __awaitee2.poll(_taskContext); - if (poll2 !== rt.Pending) { - const result2 = poll2; - next = result2; - break; + case 1: + if (this.depth_ === 1) { + unwind = 36; + _4 = Consumer.recv(this.rx_); + this.__awaitee_ = _4; + bb0 = 7; + continue l0; + } else if (this.depth_ === 4) { + unwind = 36; + _15 = level3(this.rx_); + this.___awaitee_ = _15; + bb0 = 15; + continue l0; + } else { + unwind = 36; + _26 = level15(this.rx_); + this.___awaitee_$2 = _26; + bb0 = 22; + continue l0; } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee2); - } - } else { - let __awaitee3: rt.Future = level15(rx2); - try { - while (true) { - const poll3 = __awaitee3.poll(_taskContext); - if (poll3 !== rt.Pending) { - const result3 = poll3; - next = result3; - break; + case 22: + unwind = 33; + _29 = this.___awaitee_$2.poll(_taskContext); + if (_29 !== rt.Pending) { + unwind = 36; + next = _29; + rt.drop(this.___awaitee_$2); + bb0 = 27; + continue l0; + } else { + _0 = rt.Pending; + this.state = 5; + return _0; + } + case 15: + unwind = 34; + _18 = this.___awaitee_.poll(_taskContext); + if (_18 !== rt.Pending) { + unwind = 36; + next = _18; + rt.drop(this.___awaitee_); + bb0 = 27; + continue l0; + } else { + _0 = rt.Pending; + this.state = 4; + return _0; + } + case 7: + unwind = 35; + _7 = this.__awaitee_.poll(_taskContext); + if (_7 !== rt.Pending) { + unwind = 36; + next = _7; + rt.drop(this.__awaitee_); + bb0 = 27; + continue l0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + case 27: + if (next === undefined) { + unwind = 37; + _40 = this.total_; + rt.drop(this.rx_); + _0 = _40; + this.state = 1; + return _0; + } else { + unwind = 36; + _39 = rt.u64Add(this.total_, next); + this.total_ = _39; + bb0 = 1; + continue l0; } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee3); } } - if (next !== undefined) { - const value = next; - total = rt.u64Add(total, value); - } else { - break; + } catch (e) { + b1: { + if (unwind === 0) { + throw e; + } + if (unwind === 33) { + rt.drop(this.___awaitee_$2); + } else if (unwind === 34) { + rt.drop(this.___awaitee_); + } else if (unwind === 35) { + rt.drop(this.__awaitee_); + } else if (unwind !== 36) { + break b1; + } + rt.drop(this.rx_); } + this.state = 2; + throw e; } - return total; - } finally { - rt.drop(rx2); } } -export function drainDrop(rx: Consumer.Consumer, _depth: rt.u32): void { - rt.drop(rx); -} - export function level1(rx: Consumer.Consumer): rt.Future { - return rt.future(level1Body, undefined, rx); + return new level1Future(rx); } -export function* level1Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level1Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = Consumer.recv(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level10(rx: Consumer.Consumer): rt.Future { - return rt.future(level10Body, undefined, rx); + return new level10Future(rx); } -export function* level10Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level9(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level10Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level9(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; } - _taskContext = yield; + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level11(rx: Consumer.Consumer): rt.Future { - return rt.future(level11Body, undefined, rx); + return new level11Future(rx); } -export function* level11Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level10(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level11Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level10(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; } - _taskContext = yield; + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level12(rx: Consumer.Consumer): rt.Future { - return rt.future(level12Body, undefined, rx); + return new level12Future(rx); } -export function* level12Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level11(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level12Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level11(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level13(rx: Consumer.Consumer): rt.Future { - return rt.future(level13Body, undefined, rx); + return new level13Future(rx); } -export function* level13Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level12(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level13Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level12(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); } - _taskContext = yield; + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level14(rx: Consumer.Consumer): rt.Future { - return rt.future(level14Body, undefined, rx); + return new level14Future(rx); } -export function* level14Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level13(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level14Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level13(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); } - _taskContext = yield; + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level15(rx: Consumer.Consumer): rt.Future { - return rt.future(level15Body, undefined, rx); + return new level15Future(rx); } -export function* level15Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level14(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level15Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level14(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; } - _taskContext = yield; + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level2(rx: Consumer.Consumer): rt.Future { - return rt.future(level2Body, undefined, rx); + return new level2Future(rx); } -export function* level2Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level1(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level2Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level1(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level3(rx: Consumer.Consumer): rt.Future { - return rt.future(level3Body, undefined, rx); + return new level3Future(rx); } -export function* level3Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level2(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level3Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level2(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level4(rx: Consumer.Consumer): rt.Future { - return rt.future(level4Body, undefined, rx); + return new level4Future(rx); } -export function* level4Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level3(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level4Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level3(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; } - _taskContext = yield; + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level5(rx: Consumer.Consumer): rt.Future { - return rt.future(level5Body, undefined, rx); + return new level5Future(rx); } -export function* level5Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level4(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level5Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level4(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; } - _taskContext = yield; + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level6(rx: Consumer.Consumer): rt.Future { - return rt.future(level6Body, undefined, rx); + return new level6Future(rx); } -export function* level6Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level5(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level6Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level5(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level7(rx: Consumer.Consumer): rt.Future { - return rt.future(level7Body, undefined, rx); + return new level7Future(rx); } -export function* level7Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level6(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level7Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level6(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); } - _taskContext = yield; + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level8(rx: Consumer.Consumer): rt.Future { - return rt.future(level8Body, undefined, rx); + return new level8Future(rx); } -export function* level8Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level7(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level8Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level7(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); } - _taskContext = yield; + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level9(rx: Consumer.Consumer): rt.Future { - return rt.future(level9Body, undefined, rx); + return new level9Future(rx); } -export function* level9Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level8(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level9Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + return; + } else if (this.state === 3) { + rt.drop(this.__awaitee_); + return; + } else { + return; + } + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _4!: rt.Future; + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _taskContext!: rt.Context; + let unwind: number = 0; + try { + _taskContext = _2; + if (this.state === 0) { + unwind = 12; + _4 = level8(this.rx); + this.__awaitee_ = _4; + } else if (this.state === 1) { + unwind = 0; + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + unwind = 0; + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_taskContext); + if (_6 !== rt.Pending) { + unwind = 12; + result = _6; + rt.drop(this.__awaitee_); + _0 = result; + this.state = 1; + return _0; + } else { + _0 = rt.Pending; + this.state = 3; + return _0; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index f4e0dbc11..026498b78 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -2,9 +2,9 @@ // futures do that plain JS does not. `rt.ts` re-exports all of it. // // A value whose drop JS can observe has `[Symbol.dispose]`, which runs its `Drop` impl -// and drops its fields. A moved-out place holds `undefined`, which drops as nothing. +// and drops its fields. `None` is `undefined`, which drops as nothing. -import { Panic, panic } from "../rt.ts"; +import { Panic } from "../rt.ts"; // Drops @@ -101,78 +101,6 @@ export interface Future extends Disposable { poll(cx: Context): Poll; } -/** - * The body of an `async fn` or block, a generator of what it captured: it yields at - * each `.await` that is pending. - */ -export type Body = (cx: Context, ...upvars: A) => Generator; - -const Unresumed = 0; -const Suspended = 1; -const Returned = 2; -const Panicked = 3; - -/** - * An `async fn`'s future, around its body as a generator. Nothing runs until the first - * poll. Dropping it unresumed drops what it captured, and suspended runs the `finally` - * blocks that drop its live locals. - */ -class Async implements Future { - #state = Unresumed; - #body: Body; - #drop: ((...upvars: A) => void) | undefined; - #upvars: A | undefined; - #gen: Generator | undefined; - - constructor(body: Body, drop: ((...upvars: A) => void) | undefined, upvars: A) { - this.#body = body; - this.#drop = drop; - this.#upvars = upvars; - } - - poll(cx: Context): Poll { - const state = this.#state; - if (state === Returned) panic("`async fn` resumed after completion"); - if (state === Panicked) panic("`async fn` resumed after panicking"); - this.#state = Panicked; - let next: IteratorResult; - if (state === Unresumed) { - const gen = this.#body(cx, ...this.#upvars!); - this.#upvars = undefined; - this.#gen = gen; - next = gen.next(); - } else { - next = this.#gen!.next(cx); - } - if (next.done) { - this.#state = Returned; - this.#gen = undefined; - return next.value; - } - this.#state = Suspended; - return Pending; - } - - [Symbol.dispose](): void { - const state = this.#state; - this.#state = Returned; - if (state === Unresumed) this.#drop?.(...this.#upvars!); - else if (state === Suspended) this.#gen!.return(undefined as T); - } -} - -/** - * An `async fn`'s future: `body` runs on what it captured at the first poll, and `drop` - * drops that if it never does. - */ -export function future( - body: Body, - drop: ((...upvars: A) => void) | undefined, - ...upvars: A -): Future { - return new Async(body, drop, upvars); -} - // Executor /** diff --git a/ts/src/cli.rs b/ts/src/cli.rs index 86ce71cb4..bba1152c9 100644 --- a/ts/src/cli.rs +++ b/ts/src/cli.rs @@ -10,17 +10,14 @@ use crate::config::{self, Config}; /// holds exactly, and its `cfg`s are the browser's. const TARGET: &str = "wasm32-unknown-unknown"; -const USAGE: &str = "usage: rust2-ts --config (--out | --census ) [--manifest-path ] [--lower thir|mir] [-- ] +const USAGE: &str = "usage: rust2-ts --config (--out | --census ) [--manifest-path ] [-- ] Translates the library of the package that ts.toml names to TypeScript in . The package's Cargo.toml is beside ts.toml unless --manifest-path says where. Cargo args, such as --features, are passed to `cargo check`. --census writes a Markdown report of every construct translation refuses in the library, -reached from each of its items as if each were a root, instead of translating it. - ---lower picks what function bodies lower from: THIR, the default, or MIR, the spike's -prototype."; +reached from each of its items as if each were a root, instead of translating it."; pub fn run(args: &[String]) -> ExitCode { match try_run(args) { @@ -33,7 +30,7 @@ pub fn run(args: &[String]) -> ExitCode { } fn try_run(args: &[String]) -> Result { - let Some(args) = Args::parse(args, USAGE, &["--lower"])? else { + let Some(args) = Args::parse(args, USAGE)? else { return Ok(ExitCode::SUCCESS); }; let config = Config::load(&args.config)?; @@ -41,13 +38,7 @@ fn try_run(args: &[String]) -> Result { Output::Dir(out) => (config::env::OUT, out.as_os_str()), Output::Census(census) => (config::env::CENSUS, census.as_os_str()), }; - let mut env = vec![(config::env::CONFIG, args.config.as_os_str()), output]; - for (_, lower) in &args.options { - if !matches!(lower.as_str(), "thir" | "mir") { - return Err(format!("--lower takes thir or mir, not {lower}\n\n{USAGE}")); - } - env.push((config::env::LOWER, lower.as_ref())); - } + let env = [(config::env::CONFIG, args.config.as_os_str()), output]; Check { tool: "rust2-ts", manifest: &args.manifest, diff --git a/ts/src/config.rs b/ts/src/config.rs index 88abccf4c..f5f65437e 100644 --- a/ts/src/config.rs +++ b/ts/src/config.rs @@ -38,6 +38,4 @@ pub mod env { pub const OUT: &str = "RUST2_TS_OUT"; /// Where to write a census instead of translating, absolute. pub const CENSUS: &str = "RUST2_TS_CENSUS"; - /// What bodies lower from: `thir`, the default, or `mir`. - pub const LOWER: &str = "RUST2_TS_LOWER"; } diff --git a/ts/src/driver.rs b/ts/src/driver.rs index d9a39e1d2..3269071f0 100644 --- a/ts/src/driver.rs +++ b/ts/src/driver.rs @@ -19,11 +19,9 @@ pub fn run(args: Vec) -> ExitCode { // pointers, such as a box's: JS has no pointers to check. And with the cleanups a // panic unwinds through, which wasm32's default of aborting leaves out: a JS caller // can catch a panic and go on. - if job.as_ref().is_some_and(|job| job.mir) { + if job.is_some() { args.push("-Zub-checks=no".into()); - if std::env::var_os("RUST2_TS_ABORT").is_none() { - args.push("-Cpanic=unwind".into()); - } + args.push("-Cpanic=unwind".into()); } Ok(job.map(|job| Box::new(job) as rust2_driver::rustc::Job)) }) @@ -33,8 +31,6 @@ pub fn run(args: Vec) -> ExitCode { struct Translate { config: Config, output: Output, - /// Whether bodies lower from MIR rather than THIR. - mir: bool, } /// What the job writes. @@ -69,30 +65,23 @@ impl Translate { )); } }; - let mir = match std::env::var(config::env::LOWER).as_deref() { - Ok("mir") => true, - Ok("thir") | Err(_) => false, - Ok(other) => return Err(format!("{} must be thir or mir, not {other}", config::env::LOWER)), - }; - Ok(Some(Self { config, output, mir })) + Ok(Some(Self { config, output })) } } impl Callbacks for Translate { fn after_expansion<'tcx>(&mut self, _compiler: &Compiler, tcx: TyCtxt<'tcx>) -> Compilation { - // Copy each body's THIR before borrow checking steals it. - let bodies = lower::Bodies::collect(tcx); tcx.ensure_ok().analysis(()); if tcx.dcx().has_errors().is_some() { return Compilation::Stop; } // Only a program rustc accepts is translated. let written = match &self.output { - Output::Dir(out) => match lower::translate(tcx, &self.config, &bodies, self.mir) { + Output::Dir(out) => match lower::translate(tcx, &self.config) { Some(program) if tcx.dcx().has_errors().is_none() => program.write(out), _ => Ok(()), }, - Output::Census(path) => match lower::census(tcx, &self.config, &bodies, self.mir) { + Output::Census(path) => match lower::census(tcx, &self.config) { Some(census) => program::write_file(path, &census.render(&self.config.package)), None => Ok(()), }, diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 52011157e..46f5e8799 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -1,191 +1,28 @@ -//! Function bodies: THIR expressions to TypeScript statements and expressions. -//! -//! Rust is all expressions and JS is not, so each expression lowers either for its -//! value (`expr`), which may first push statements, or into a destination (`stmt`), -//! which lets control flow return or assign from each branch directly. Statements -//! pushed ahead of a value keep Rust's evaluation order: an earlier operand with an -//! effect is saved to a temporary first. +//! A function body being lowered: its names, and the calls the library mappings make +//! through it, to the crate's own functions, constructors, and std's. -use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use rustc_hir::{HirId, MatchSource}; -use rustc_middle::middle::region; -use rustc_middle::mir::BorrowKind; -use rustc_middle::thir::{self, ArmId, BlockId, ExprId, ExprKind, LocalVarId, Pat, PatKind, StmtId, Thir}; -use rustc_middle::ty::adjustment::PointerCoercion; +use rustc_data_structures::fx::FxHashSet; use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TypeVisitableExt}; -use rustc_span::{Span, Symbol}; +use rustc_span::Span; -use super::drop::Owned; -use super::library::{self, Args}; -use super::{AdtRepr, ObjectKind, Translator, camel, escape}; -use crate::program::SymKind; -use crate::ts::{self, Expr, Key, Param, Stmt, StmtKind, Target, Type}; - -/// Translate one function instance's body. -pub fn function<'a, 'tcx>( - t: &mut Translator<'a, 'tcx>, - instance: Instance<'tcx>, - thir: &'a Thir<'tcx>, - expr: ExprId, -) -> Option { - let tcx = t.tcx; - let def_id = instance.def_id(); - let sig = tcx.instantiate_bound_regions_with_erased(tcx.fn_sig(def_id).skip_binder()); - let sig = t.subst(instance.args, sig); - let mut b = Body { - t, - thir, - args: instance.args, - locals: FxHashMap::default(), - names: FxHashSet::default(), - read: reads(tcx, thir), - breakables: Vec::new(), - ret: sig.output(), - visited: FxHashSet::default(), - scopes: Vec::new(), - moved: FxHashSet::default(), - borrowed: FxHashSet::default(), - yields: 0, - done: super::iter::is_next(tcx, def_id), - }; - let span = tcx.def_span(def_id); - if b.done { - super::iter::check_impl(b.t, def_id); - } - let mut body = Vec::new(); - let mut params = Vec::new(); - b.open_scope(); - for param in thir.params.iter() { - let ty = b.subst(param.ty); - match ¶m.pat { - Some(pat) => { - let name = b.param(pat, &mut body); - let ty = b.t.ty(ty, pat.span); - params.push(Param { name, ty: Some(ty) }); - } - None => { - let name = b.fresh("arg"); - let ty = b.t.ty(ty, span); - params.push(Param { name, ty: Some(ty) }); - } - } - } - let ret = b.ret; - let dest = match ret.is_unit() || ret.is_never() { - true => Dest::Discard, - false => Dest::Return, - }; - b.stmt(expr, dest, &mut body); - b.close_scope(&mut body, 0, span); - // A `self` the body never names, such as a unit struct's derived `Display`, takes a `_` - // so it passes `noUnusedParameters`. - if let Some(param) = params.first_mut() - && param.name == "self" - && !ts::mentions(&body, "self") - { - param.name = "_self".into(); - } - let ret = match (b.done, ret.kind()) { - (true, ty::Adt(_, args)) => Type::Union(vec![b.t.ty(args.type_at(0), span), Type::Rt("Done", Vec::new())]), - _ => b.t.ret_ty(ret, span), - }; - Some(ts::Function { - sym: 0, - params, - ret, - body, - loc: None, - doc: None, - generator: false, - }) -} - -/// Where a lowered value goes. -#[derive(Clone, Debug)] -pub enum Dest { - /// Nowhere: only its effects run. - Discard, - /// Returned from the function or closure. - Return, - /// Assigned to a declared variable. - Assign(String), -} - -#[derive(Clone)] -enum Local { - Name { - name: String, - mutable: bool, - }, - /// A function item, which is a type and no value: calls name it statically. - FnItem, -} - -/// A loop or labeled block that `break` can target. -struct Breakable { - scope: region::Scope, - label: String, - used: bool, - dest: Dest, - is_loop: bool, -} +use super::library; +use super::{AdtRepr, Translator, escape}; +use crate::ts::{Expr, Key, Param, Stmt, StmtKind}; pub struct Body<'b, 'a, 'tcx> { pub t: &'b mut Translator<'a, 'tcx>, - pub thir: &'a Thir<'tcx>, + /// The instance's generic arguments. pub args: GenericArgsRef<'tcx>, - locals: FxHashMap, - /// Every name in the function, closures included, so none shadows another. + /// Every name in the function, so none shadows another. names: FxHashSet, - /// Every variable the function and its closures read. - read: FxHashSet, - breakables: Vec, - /// The return type of the function or closure being lowered. - ret: Ty<'tcx>, - /// Expressions lowered so far, by THIR and id, so a refused call lowers only the - /// arguments its mapping did not. - visited: FxHashSet<(*const Thir<'tcx>, ExprId)>, - /// The variables each open scope drops when it closes, innermost last. - pub(super) scopes: Vec>>, - /// The variables a move left `undefined`, which are declared `let` for it. - pub(super) moved: FxHashSet, - /// The variables a generator lowered so far borrows mutably: each is a parameter - /// holding the caller's object, so replacing it whole must change that object. - borrowed: FxHashSet, - /// How many `yield`s are lowered so far, so an operand can tell whether it awaits. - yields: usize, - /// Whether this is an `Iterator::next`, which returns an item or `rt.DONE` rather - /// than an `Option`: its closures are not. - done: bool, -} - -/// One `&&`-joined part of an `if` condition. -enum CondPart<'a, 'tcx> { - Bool(ExprId), - Let(ExprId, &'a Pat<'tcx>), } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// A body with no THIR of its own: what a MIR lowering calls the library mappings - /// through, passing their arguments already lowered. It names the locals. - pub fn detached(t: &'b mut Translator<'a, 'tcx>, args: GenericArgsRef<'tcx>, ret: Ty<'tcx>) -> Self { - let bodies: &'a super::Bodies<'tcx> = t.bodies; - let thir = &bodies.empty; + pub fn new(t: &'b mut Translator<'a, 'tcx>, args: GenericArgsRef<'tcx>) -> Self { Body { t, - thir, args, - locals: FxHashMap::default(), names: FxHashSet::default(), - read: FxHashSet::default(), - breakables: Vec::new(), - ret, - visited: FxHashSet::default(), - scopes: Vec::new(), - moved: FxHashSet::default(), - borrowed: FxHashSet::default(), - yields: 0, - done: false, } } @@ -193,1811 +30,47 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { self.t.subst(self.args, value) } - pub fn ty_of(&self, id: ExprId) -> Ty<'tcx> { - self.subst(self.thir[id].ty) - } - - /// Record that `id` is lowered, or is being. - pub fn visit(&mut self, id: ExprId) { - self.visited.insert((std::ptr::from_ref(self.thir), id)); - } - - fn visited(&self, id: ExprId) -> bool { - self.visited.contains(&(std::ptr::from_ref(self.thir), id)) - } - - pub fn span(&self, id: ExprId) -> Span { - self.thir[id].span - } - pub fn err(&mut self, span: Span, msg: impl Into) -> Expr { self.t.err(span, msg); Expr::undefined() } - /// Whether anything reads `var`, so its binding is worth declaring. - pub fn is_read(&self, var: LocalVarId) -> bool { - self.read.contains(&var.0) - } - - /// A name no other binding in the function has. - pub fn fresh(&mut self, base: &str) -> String { - let base = escape(base); - let mut name = base.clone(); - let mut n = 2; - while !self.names.insert(name.clone()) { - name = format!("{base}{n}"); - n += 1; - } - name - } - - /// A temporary named after what it holds. - pub fn temp_for(&mut self, id: ExprId) -> String { - let base = self.temp_base(id); - self.fresh(&base) - } - - fn temp_base(&self, id: ExprId) -> String { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } | ExprKind::Borrow { arg: value, .. } => self.temp_base(*value), - ExprKind::Call { ty, .. } => match self.subst(*ty).kind() { - ty::FnDef(def_id, _) => camel(self.t.tcx.item_name(*def_id).as_str()), - _ => "value".into(), - }, - _ => match self.ty_of(id).kind() { - ty::Adt(adt, _) => { - let name = self.t.tcx.item_name(adt.did()).to_string(); - let mut chars = name.chars(); - chars - .next() - .map_or(name.clone(), |c| c.to_lowercase().chain(chars).collect()) - } - _ => "value".into(), - }, - } - } - - /// Declare a binding for a Rust variable of type `ty`, which its scope drops if it - /// `owns` the value rather than borrowing it. - pub(super) fn bind_var( - &mut self, - var: LocalVarId, - name: Symbol, - mutable: bool, - ty: Ty<'tcx>, - span: Span, - owns: bool, - ) -> String { - // A JS variable holding a number is a copy: writing through it reaches nothing. - if let ty::Ref(_, inner, rustc_ast::Mutability::Mut) = self.subst(ty).kind() - && self.t.object_kind(*inner).is_none() - { - self.t.err( - span, - format!("a `&mut {inner}` binding: a JS value of `{inner}` is a copy, so it can't change"), - ); - } - let name = self.fresh(&camel(name.as_str())); - self.locals.insert( - var.0, - Local::Name { - name: name.clone(), - mutable, - }, - ); - if owns { - let ty = self.subst(ty); - self.own(&name, ty); - } - name - } - - /// A parameter's name, declaring its pattern's bindings at the top of the body. - fn param(&mut self, pat: &Pat<'tcx>, out: &mut Vec) -> String { - match &pat.kind { - PatKind::Binding { - name, - var, - mode, - subpattern: None, - .. - } if mode.0 == rustc_hir::ByRef::No => { - let mutable = mode.1 == rustc_ast::Mutability::Mut; - // A parameter nothing reads, such as `other` in a derived `eq` of two - // `struct E {}`, takes a `_` so it passes `noUnusedParameters`. - let name = match self.is_read(*var) || name.as_str().starts_with('_') { - true => *name, - false => Symbol::intern(&format!("_{name}")), - }; - self.bind_var(*var, name, mutable, pat.ty, pat.span, true) - } - _ if self.t.drops(self.subst(pat.ty)) => { - self.t.err( - pat.span, - "a parameter that drops bound by a pattern, which is not supported yet", - ); - self.fresh("arg") - } - PatKind::Wild => self.fresh("_"), - _ => { - let name = self.fresh("arg"); - let scrut = Expr::ident(&name); - if self.pat_test(pat, &scrut).is_some() { - self.t.err(pat.span, "a refutable parameter pattern"); - } - self.pat_bind(pat, &scrut, false, out); - name - } - } - } - - fn local(&mut self, var: HirId, span: Span) -> Expr { - match self.locals.get(&var) { - Some(Local::Name { name, .. }) => Expr::ident(name), - Some(Local::FnItem) => self.err(span, "a function item read as a value"), - None => self.err(span, "a variable from outside the function"), - } - } - - // Statements - - fn push(&mut self, out: &mut Vec, kind: StmtKind, span: Span) { - let loc = self.t.loc(span); - out.push(kind.at(loc)); - } - - /// Deliver an already-lowered value to `dest`. - fn deliver(&mut self, value: Expr, dest: &Dest, span: Span, out: &mut Vec) { - match dest { - Dest::Discard => { - if !value.is_path() { - self.push(out, StmtKind::Expr(value), span); - } - } - Dest::Return if self.done => { - if let ty::Adt(_, args) = self.ret.kind() { - super::iter::option_ok(self, args.type_at(0), span); - } - let value = Expr::rt("iterFromOption", vec![value]); - self.push(out, StmtKind::Return(Some(value)), span); - } - Dest::Return => self.push(out, StmtKind::Return(Some(value.typed())), span), - Dest::Assign(name) => self.push(out, StmtKind::Expr(Expr::ident(name).assign(value.typed())), span), - } - } - - /// Lower `id` so its value goes to `dest`. - pub fn stmt(&mut self, id: ExprId, dest: Dest, out: &mut Vec) { - self.visit(id); - let e = &self.thir[id]; - let span = e.span; - let ty = self.ty_of(id); - if self.t.ignored_macro(span) { - if !ty.is_unit() { - self.t.err(span, "an ignored macro must evaluate to `()`"); - } - return; - } - let dest = match ty.is_unit() || ty.is_never() { - true => Dest::Discard, - false => dest, - }; - match &e.kind { - ExprKind::Scope { - value, region_scope, .. - } => match self.scoped_loop(*value) { - Some(body) => self.lp(*region_scope, body, dest, out), - None => self.stmt(*value, dest, out), - }, - ExprKind::ValueTypeAscription { source, .. } | ExprKind::ValueExpr { source } => { - self.stmt(*source, dest, out) - } - ExprKind::NeverToAny { source } => self.stmt(*source, Dest::Discard, out), - ExprKind::Block { block } => self.block(*block, dest, out), - ExprKind::If { - cond, then, else_opt, .. - } => self.if_(*cond, *then, *else_opt, dest, span, out), - ExprKind::Match { - scrutinee, - arms, - match_source, - } if !arms.is_empty() => self.match_(id, *scrutinee, arms, *match_source, dest, out), - ExprKind::Loop { .. } => { - self.err(span, "a loop outside a scope"); - } - ExprKind::Break { label, value } => self.break_(*label, *value, span, out), - ExprKind::Continue { label } => { - let label = self.target(*label, true); - self.push(out, StmtKind::Continue(label), span); - } - ExprKind::Return { value } => match value { - // `stmt` returns from every branch that makes a value; a `!` value makes none. - Some(value) if !self.ty_of(*value).is_unit() => self.stmt(*value, Dest::Return, out), - Some(value) => { - self.stmt(*value, Dest::Discard, out); - self.push(out, StmtKind::Return(None), span); - } - None => self.push(out, StmtKind::Return(None), span), - }, - ExprKind::Assign { lhs, rhs } => self.assign(*lhs, *rhs, span, out), - ExprKind::AssignOp { op, lhs, rhs } => self.assign_op(*op, *lhs, *rhs, span, out), - _ => { - if self.done - && let Dest::Return = dest - && let Some(value) = self.done_value(id, out) - { - self.push(out, StmtKind::Return(Some(value)), span); - return; - } - let value = self.expr(id, out); - // A value that goes nowhere drops here. - if let Dest::Discard = dest - && let Some(dropped) = self.t.drop_value(value.clone(), ty, span) - { - self.push(out, StmtKind::Expr(dropped), span); - return; - } - self.deliver(value, &dest, span, out); - } - } - } - - /// What an `Iterator::next` returns for `id` without an `Option` between: `rt.DONE` - /// for `None`, the item for `Some(item)`, and another iterator's `next` as is. - fn done_value(&mut self, id: ExprId, out: &mut Vec) -> Option { - match &self.thir[id].kind { - ExprKind::Adt(adt) if library::Std::of(self.t.tcx, adt.adt_def.did()) == Some(library::Std::Option) => { - self.visit(id); - Some(match adt.fields.first() { - None => Expr::Rt("DONE".into()), - Some(field) => self.operand(field.expr, out).typed(), - }) - } - _ => self.raw_next(id, out), - } - } - - /// `id` lowered by the iterator protocol if it is a call to `Iterator::next`: an item - /// or `rt.DONE`, rather than an `Option`. - fn raw_next(&mut self, id: ExprId, out: &mut Vec) -> Option { - let ExprKind::Call { ty, args, .. } = &self.thir[self.strip(id)].kind else { - return None; - }; - let ty::FnDef(def_id, _) = *self.subst(*ty).kind() else { - return None; - }; - if !super::iter::is_next(self.t.tcx, def_id) { - return None; - } - self.visit(id); - let recv_ty = self.ty_of(args[0]); - let recv = self.operand(args[0], out); - Some(super::iter::next(self, recv_ty, recv)) - } - - fn block(&mut self, id: BlockId, dest: Dest, out: &mut Vec) { - let block = &self.thir[id]; - if block.targeted_by_break { - let label = self.fresh("block"); - self.breakables.push(Breakable { - scope: block.region_scope, - label, - used: false, - dest: dest.clone(), - is_loop: false, - }); - let mut body = Vec::new(); - self.block_body(id, dest, &mut body); - let breakable = self.breakables.pop().unwrap(); - let label = breakable.used.then_some(breakable.label); - let span = block.span; - self.push(out, StmtKind::Block { label, body }, span); - return; - } - self.block_body(id, dest, out); - } - - fn block_body(&mut self, id: BlockId, dest: Dest, out: &mut Vec) { - let block = &self.thir[id]; - let start = out.len(); - self.open_scope(); - for &stmt in &block.stmts { - self.stmt_item(stmt, out); - } - if let Some(expr) = block.expr { - self.stmt(expr, dest, out); - } - self.close_scope(out, start, block.span); - } - - fn stmt_item(&mut self, id: StmtId, out: &mut Vec) { - match &self.thir[id].kind { - thir::StmtKind::Expr { expr, .. } => self.stmt(*expr, Dest::Discard, out), - thir::StmtKind::Let { - pattern, - initializer, - else_block, - span, - .. - } => self.let_(pattern, *initializer, *else_block, *span, out), - } - } - - fn let_( - &mut self, - pat: &'a Pat<'tcx>, - init: Option, - els: Option, - span: Span, - out: &mut Vec, - ) { - let pat_ty = self.subst(pat.ty); - if let Some(init) = init - && self.t.ignored_macro(self.span(init)) - { - self.t.err(span, "a binding of an ignored macro"); - return; - } - // A simple binding. - if let PatKind::Binding { - name, - var, - mode, - subpattern: None, - .. - } = &pat.kind - && els.is_none() - { - if matches!(pat_ty.kind(), ty::FnDef(..)) { - if let Some(init) = init - && !self.simple(init) - { - self.stmt(init, Dest::Discard, out); - } - self.locals.insert(var.0, Local::FnItem); - return; - } - if mode.0 != rustc_hir::ByRef::No { - self.ref_binding(mode.0, pat_ty, pat.span); - } - let mutable = mode.1 == rustc_ast::Mutability::Mut; - let by_value = mode.0 == rustc_hir::ByRef::No; - let ty = self.t.ty(pat_ty, pat.span); - let Some(init) = init else { - let name = self.bind_var(*var, *name, true, pat_ty, pat.span, by_value); - self.push(out, StmtKind::decl(true, name, Some(ty), None), span); - return; - }; - // A `ref` binding borrows a place where it is, and keeps a temporary alive to the - // end of the block, which then drops it as it would a variable. - let borrows = !by_value && self.is_place(init); - let owns = !borrows; - if self.needs_dest(init) { - let name = self.bind_var(*var, *name, true, pat_ty, pat.span, owns); - self.push(out, StmtKind::decl(true, name.clone(), Some(ty), None), span); - self.stmt(init, Dest::Assign(name), out); - return; - } - // A move from another variable or field: it is left `undefined`. - if by_value && self.moves(init) { - let place = self.place(init, out); - let name = self.bind_var(*var, *name, mutable, pat_ty, pat.span, owns); - let annotate = mutable || diverges_when_called(pat_ty); - self.push( - out, - StmtKind::decl(mutable, name, annotate.then_some(ty), Some(place.clone())), - span, - ); - self.clear(place, out); - return; - } - let value = match borrows { - true => self.place(init, out), - false => self.operand(init, out), - }; - let name = self.bind_var(*var, *name, mutable, pat_ty, pat.span, owns); - let annotate = mutable || needs_annotation(&value) || diverges_when_called(pat_ty); - self.push( - out, - StmtKind::decl(mutable, name, annotate.then_some(ty), Some(value)), - span, - ); - return; - } - - let Some(init) = init else { - // `let _: T;`, as derives write to assert a bound, binds nothing. - if !matches!(pat.kind, PatKind::Wild) { - self.t.err(span, "a pattern binding without an initializer"); - } - return; - }; - // `let _ = value;` drops a value at once, and evaluates a place without moving it: - // an index still runs, and checks its bounds. - if let PatKind::Wild = pat.kind - && els.is_none() - && self.t.drops(pat_ty) - { - match self.is_place(init) { - true => { - let place = self.place(init, out); - if !place.is_path() { - self.push(out, StmtKind::Expr(place), span); - } - } - false => { - let value = self.operand(init, out); - if let Some(dropped) = self.t.drop_value(value, pat_ty, span) { - self.push(out, StmtKind::Expr(dropped), span); - } - } - } - return; - } - // What the pattern leaves unbound drops with its place, or at the end of the - // statement from a temporary, which nothing marks. The shortcut below would move a - // place out whole, so a place binds part by part instead. - let leaves = self.leaves_drop(pat); - if leaves && !self.is_place(init) { - self.t.err( - span, - "a `let` on a temporary that drops, which it doesn't move out of whole", - ); - } - // `const [a, b] = ...` for a tuple or array of plain bindings. - if els.is_none() && !leaves && self.destructurable(pat, true) { - let value = self.operand(init, out); - let mut mutable = false; - let target = self.destructure(pat, &mut mutable); - self.push( - out, - StmtKind::Decl { - mutable, - target, - ty: None, - init: Some(value), - }, - span, - ); - return; - } - - let owned = !self.is_place(init); - let value = match owned { - true => self.operand(init, out), - false => self.place(init, out), - }; - let scrut = self.path(value, init, out); - if let Some(els) = els { - match self.pat_test(pat, &scrut) { - Some(test) => { - let mut body = Vec::new(); - self.block(els, Dest::Discard, &mut body); - self.push( - out, - StmtKind::If { - cond: test.not(), - then: body, - els: Vec::new(), - }, - span, - ); - } - None => self.t.err(span, "`let ... else` with an irrefutable pattern"), - } - } else if self.pat_test(pat, &scrut).is_some() { - self.t.err(span, "a refutable pattern in `let`"); - } - self.pat_bind(pat, &scrut, owned, out); - } - - /// Whether binding `pat` by value leaves part of a value that drops unbound: under a - /// `_` or a `..`, in a field it doesn't name, or in another variant than the one it - /// matches. - fn leaves_drop(&mut self, pat: &Pat<'tcx>) -> bool { - let ty = self.subst(pat.ty); - if !self.t.drops(ty) { - return false; - } - let tcx = self.t.tcx; - match &pat.kind { - PatKind::Binding { - mode, subpattern: None, .. - } => mode.0 != rustc_hir::ByRef::No, - PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => { - let (variant, others) = match (ty.kind(), &pat.kind) { - (ty::Tuple(tys), _) => (tys.to_vec(), Vec::new()), - (ty::Adt(adt, args), PatKind::Variant { variant_index, .. }) => { - let fields = |v: &ty::VariantDef| -> Vec> { - v.fields.iter().map(|f| f.ty(tcx, args).skip_norm_wip()).collect() - }; - let others = adt - .variants() - .iter_enumerated() - .filter(|(i, _)| i != variant_index) - .flat_map(|(_, v)| fields(v)) - .collect(); - (fields(adt.variant(*variant_index)), others) - } - (ty::Adt(adt, args), _) => ( - adt.non_enum_variant() - .fields - .iter() - .map(|f| f.ty(tcx, args).skip_norm_wip()) - .collect(), - Vec::new(), - ), - _ => return true, - }; - others.into_iter().any(|t| self.t.drops(t)) - || variant.into_iter().enumerate().any(|(i, field)| { - match subpatterns.iter().find(|f| f.field.index() == i) { - Some(f) => self.leaves_drop(&f.pattern), - None => self.t.drops(field), - } - }) - } - PatKind::Array { - prefix, - slice: None, - suffix, - } => prefix.iter().chain(suffix.iter()).any(|p| self.leaves_drop(p)), - _ => true, - } - } - - /// Whether `pat` is a tuple or array of plain bindings, which JS destructures. - fn destructurable(&self, pat: &Pat<'tcx>, top: bool) -> bool { - let ty = self.subst(pat.ty); - match &pat.kind { - PatKind::Deref { subpattern, .. } => self.destructurable(subpattern, top), - PatKind::Leaf { subpatterns } if matches!(ty.kind(), ty::Tuple(_)) => { - // Every field, in order. - let arity = match ty.kind() { - ty::Tuple(tys) => tys.len(), - _ => unreachable!(), - }; - subpatterns.len() == arity - && subpatterns - .iter() - .enumerate() - .all(|(i, f)| f.field.index() == i && self.destructurable(&f.pattern, false)) - } - // Bytes are a `Uint8Array`, which JS destructures through its iterator: indexing - // reads them faster. - PatKind::Array { - prefix, - slice: None, - suffix, - } => { - !matches!(ty.kind(), ty::Array(elem, _) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8))) - && suffix.is_empty() - && prefix.iter().all(|p| self.destructurable(p, false)) - } - PatKind::Binding { - mode, subpattern: None, .. - } if !top => match mode.0 { - rustc_hir::ByRef::No => !self.needs_copy(ty), - // A shared reference to a primitive reads as its value. - rustc_hir::ByRef::Yes(_, rustc_ast::Mutability::Not) => { - matches!(ty.peel_refs().kind(), ty::Bool | ty::Int(_) | ty::Uint(_)) - } - _ => false, - }, - PatKind::Wild => !top, - _ => false, - } - } - - /// The destructuring target of a [`Self::destructurable`] pattern, binding its names. - fn destructure(&mut self, pat: &Pat<'tcx>, mutable: &mut bool) -> Target { - match &pat.kind { - PatKind::Deref { subpattern, .. } => self.destructure(subpattern, mutable), - PatKind::Leaf { subpatterns } => Target::Array( - subpatterns - .iter() - .map(|f| self.destructure_elem(&f.pattern, mutable)) - .collect(), - ), - PatKind::Array { prefix, .. } => { - Target::Array(prefix.iter().map(|p| self.destructure_elem(p, mutable)).collect()) - } - PatKind::Binding { name, var, mode, .. } => { - let is_mut = mode.1 == rustc_ast::Mutability::Mut; - *mutable |= is_mut; - Target::Name(self.bind_var(*var, *name, is_mut, pat.ty, pat.span, mode.0 == rustc_hir::ByRef::No)) - } - _ => unreachable!("checked by destructurable"), - } - } - - fn destructure_elem(&mut self, pat: &Pat<'tcx>, mutable: &mut bool) -> Option { - match pat.kind { - PatKind::Wild => None, - _ => Some(self.destructure(pat, mutable)), - } - } - - /// Whether `id` is control flow that reads best delivering into a variable. One that - /// never makes a value leaves the variable unassigned. - fn needs_dest(&mut self, id: ExprId) -> bool { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } => self.needs_dest(*value), - ExprKind::If { - then, else_opt, cond, .. - } => !(self.simple(*then) && else_opt.is_some_and(|e| self.simple(e)) && self.simple(*cond)), - ExprKind::Match { match_source, .. } => { - !matches!(match_source, MatchSource::TryDesugar(_)) && !self.ternary_match(id) - } - ExprKind::Loop { .. } | ExprKind::NeverToAny { .. } => true, - _ => false, - } - } - - /// Whether `id` lowers to an expression with no statements before it. - fn simple(&mut self, id: ExprId) -> bool { - self.simple_at(id, false) - } - - /// [`Self::simple`], for `id` read as a place, which a move out of would clear. - fn simple_at(&mut self, id: ExprId, place: bool) -> bool { - // A move leaves `undefined` behind with a statement of its own. - if !place && self.moves(id) { - return false; - } - match &self.thir[id].kind { - ExprKind::Scope { value, .. } - | ExprKind::ValueTypeAscription { source: value, .. } - | ExprKind::PlaceTypeAscription { source: value, .. } => self.simple_at(*value, place), - ExprKind::Borrow { arg: value, .. } - | ExprKind::Deref { arg: value } - | ExprKind::Field { lhs: value, .. } => self.simple_at(*value, true), - ExprKind::Cast { source: value } - | ExprKind::PointerCoercion { source: value, .. } - | ExprKind::Unary { arg: value, .. } => self.simple(*value), - ExprKind::Block { block } => { - let block = &self.thir[*block]; - block.stmts.is_empty() && !block.targeted_by_break && block.expr.is_some_and(|e| self.simple(e)) - } - ExprKind::Binary { lhs, rhs, .. } => self.simple(*lhs) && self.simple(*rhs), - ExprKind::Index { lhs, index } => self.simple_at(*lhs, true) && self.simple(*index), - ExprKind::LogicalOp { lhs, rhs, .. } => self.simple(*lhs) && self.simple(*rhs), - ExprKind::Call { args, fun, .. } => self.simple(*fun) && args.iter().all(|a| self.simple(*a)), - ExprKind::Tuple { fields } | ExprKind::Array { fields } => fields.iter().all(|f| self.simple(*f)), - // Fields written out of declaration order may be spilled to keep their order. - ExprKind::Adt(adt) => { - adt.fields.iter().all(|f| self.simple(f.expr)) - && adt.fields.is_sorted_by_key(|f| f.name) - && matches!(adt.base, thir::AdtExprBase::None) - } - ExprKind::VarRef { .. } - | ExprKind::UpvarRef { .. } - | ExprKind::Literal { .. } - | ExprKind::NonHirLiteral { .. } - | ExprKind::ZstLiteral { .. } - | ExprKind::NamedConst { .. } - | ExprKind::ConstParam { .. } => true, - _ => false, - } - } - - fn break_(&mut self, label: region::Scope, value: Option, span: Span, out: &mut Vec) { - let Some(index) = self.breakables.iter().rposition(|b| b.scope == label) else { - self.t.err(span, "a `break` out of the function"); - return; - }; - let dest = self.breakables[index].dest.clone(); - if let Some(value) = value { - self.stmt(value, dest.clone(), out); - // `stmt` returned from every branch that makes a value; a `!` value makes none. - if matches!(dest, Dest::Return) { - return; - } - } - let label = self.target(label, false); - self.push(out, StmtKind::Break(label), span); - } - - /// The JS label a `break` or `continue` to `scope` needs, if any. - fn target(&mut self, scope: region::Scope, continues: bool) -> Option { - let index = self.breakables.iter().rposition(|b| b.scope == scope)?; - let innermost_loop = self.breakables.iter().rposition(|b| b.is_loop); - let needs_label = !self.breakables[index].is_loop || innermost_loop != Some(index); - debug_assert!(!continues || self.breakables[index].is_loop); - if !needs_label { - return None; - } - self.breakables[index].used = true; - Some(self.breakables[index].label.clone()) - } - - fn lp(&mut self, scope: region::Scope, body: ExprId, dest: Dest, out: &mut Vec) { - let span = self.span(body); - let label = self.fresh("loop"); - self.breakables.push(Breakable { - scope, - label, - used: false, - dest, - is_loop: true, - }); - // `while c { .. }` arrives as `loop { if c { .. } else { break } }`. - let mut stmts = Vec::new(); - let mut cond = None; - if let Some((c, then)) = self.while_shape(scope, body) { - let mut pre = Vec::new(); - let test = self.expr(c, &mut pre); - if pre.is_empty() { - cond = Some(test); - self.stmt(then, Dest::Discard, &mut stmts); - } - } - let cond = match cond { - Some(cond) => cond, - None => { - stmts.clear(); - self.stmt(body, Dest::Discard, &mut stmts); - Expr::lit("true") - } - }; - let breakable = self.breakables.pop().unwrap(); - let label = breakable.used.then_some(breakable.label); - self.push( - out, - StmtKind::While { - label, - cond, - body: stmts, - }, - span, - ); - } - - /// The body of the loop a scope holds, if it holds one. A loop that only `return` - /// leaves has type `!`, coerced to whatever its place needs. - fn scoped_loop(&self, value: ExprId) -> Option { - let value = match self.thir[value].kind { - ExprKind::NeverToAny { source } => source, - _ => value, - }; - match self.thir[value].kind { - ExprKind::Loop { body } => Some(body), - _ => None, - } - } - - /// The condition and body of a `while` loop's desugaring. - fn while_shape(&self, scope: region::Scope, body: ExprId) -> Option<(ExprId, ExprId)> { - let block = match self.thir[self.strip(body)].kind { - ExprKind::Block { block } => &self.thir[block], - _ => return None, - }; - if !block.stmts.is_empty() || block.targeted_by_break { - return None; - } - let ExprKind::If { - cond, - then, - else_opt: Some(els), - .. - } = self.thir[self.strip(block.expr?)].kind - else { - return None; - }; - if self.has_let(cond) { - return None; - } - let ExprKind::Block { block: els } = self.thir[self.strip(els)].kind else { - return None; - }; - let els = &self.thir[els]; - let only = match (els.stmts.as_ref(), els.expr) { - ([], Some(e)) => e, - ([s], None) => match self.thir[*s].kind { - thir::StmtKind::Expr { expr, .. } => expr, - _ => return None, - }, - _ => return None, - }; - match self.thir[self.strip(only)].kind { - ExprKind::Break { label, value: None } if label == scope => Some((cond, then)), - _ => None, - } - } - - /// `id` without the wrappers that change nothing. - pub fn strip(&self, id: ExprId) -> ExprId { - match self.thir[id].kind { - ExprKind::Scope { value, .. } | ExprKind::NeverToAny { source: value } => self.strip(value), - _ => id, - } - } - - fn has_let(&self, id: ExprId) -> bool { - match &self.thir[self.strip(id)].kind { - ExprKind::Let { .. } => true, - ExprKind::LogicalOp { - op: thir::LogicalOp::And, - lhs, - rhs, - } => self.has_let(*lhs) || self.has_let(*rhs), - _ => false, - } - } - - fn cond_parts(&self, id: ExprId, parts: &mut Vec>) { - let id = self.strip(id); - let thir: &'a Thir<'tcx> = self.thir; - match &thir[id].kind { - ExprKind::Let { expr, pat } => parts.push(CondPart::Let(*expr, pat)), - ExprKind::LogicalOp { - op: thir::LogicalOp::And, - lhs, - rhs, - } if self.has_let(id) => { - self.cond_parts(*lhs, parts); - self.cond_parts(*rhs, parts); - } - _ => parts.push(CondPart::Bool(id)), - } - } - - /// Lower one part of a condition: its statements to `pre`, the bindings a `let` - /// makes once it passed to `binds`, and the test, if it can fail. - fn cond_part(&mut self, part: &CondPart<'a, 'tcx>, pre: &mut Vec, binds: &mut Vec) -> Option { - match part { - CondPart::Bool(id) => Some(self.expr(*id, pre)), - CondPart::Let(expr, pat) => { - // A failed test leaves the value whole, so the pattern must take all of it - // from every variant: a `let` with no other arm to take the rest. - if !self.is_place(*expr) && self.leaves_drop(pat) { - self.t.err( - pat.span, - "an `if let` on a temporary that drops, which it doesn't move out of whole", - ); - } - let reads = self.test_reads(pat) + bindings(pat); - let (scrut, owned) = self.scrutinee(*expr, reads, pre); - let test = self.pat_test(pat, &scrut); - self.pat_bind(pat, &scrut, owned, binds); - test - } - } - } - - /// A match's scrutinee, which its patterns read `reads` times: as a path they can - /// read repeatedly, or as is when they read it at most once, first. Also whether it - /// is a temporary. - fn scrutinee(&mut self, id: ExprId, reads: usize, out: &mut Vec) -> (Expr, bool) { - let owned = !self.is_place(id); - let value = match owned { - true => self.operand(id, out), - false => self.place(id, out), - }; - match reads { - // Unread, it still runs. - 0 if !value.is_path() => { - out.push(StmtKind::Expr(value).at(None)); - (Expr::undefined(), owned) - } - 0 | 1 => (value, owned), - _ => (self.path(value, id, out), owned), - } - } - - /// How many times the test of `pat` reads its scrutinee. - fn test_reads(&self, pat: &Pat<'tcx>) -> usize { - match &pat.kind { - PatKind::Wild | PatKind::Missing => 0, - PatKind::Binding { subpattern, .. } => subpattern.as_ref().map_or(0, |p| self.test_reads(p)), - PatKind::Deref { subpattern, .. } => self.test_reads(subpattern), - PatKind::Leaf { subpatterns } => subpatterns.iter().map(|f| self.test_reads(&f.pattern)).sum(), - PatKind::Variant { subpatterns, .. } => { - 1 + subpatterns.iter().map(|f| self.test_reads(&f.pattern)).sum::() - } - PatKind::Or { pats } => pats.iter().map(|p| self.test_reads(p)).sum(), - PatKind::Array { prefix, suffix, .. } => { - prefix.iter().chain(suffix.iter()).map(|p| self.test_reads(p)).sum() - } - PatKind::Constant { .. } => 1, - PatKind::Range(range) => usize::from(range.lo.is_finite()) + usize::from(range.hi.is_finite()), - // Ranges, slices, and anything else: assume more than once. - _ => 2, - } - } - - fn if_(&mut self, cond: ExprId, then: ExprId, els: Option, dest: Dest, span: Span, out: &mut Vec) { - let mut parts = Vec::new(); - self.cond_parts(cond, &mut parts); - - // One condition, as JS writes it. - if let [part] = parts.as_slice() { - let mut then_stmts = Vec::new(); - self.open_scope(); - let test = self.cond_part(part, out, &mut then_stmts); - self.stmt(then, dest.clone(), &mut then_stmts); - self.close_scope(&mut then_stmts, 0, span); - let mut else_stmts = Vec::new(); - if let Some(els) = els { - self.stmt(els, dest, &mut else_stmts); - } - match test { - Some(test) => self.push( - out, - StmtKind::If { - cond: test, - then: then_stmts, - els: else_stmts, - }, - span, - ), - // An irrefutable `let`: the else never runs. - None => out.extend(then_stmts), - } - return; - } - - // A let chain: each part nests in the last, and any failing runs the else. - let label = self.fresh("chain"); - let mut levels = Vec::new(); - self.open_scope(); - for part in &parts { - let mut pre = Vec::new(); - let mut binds = Vec::new(); - let test = self.cond_part(part, &mut pre, &mut binds); - levels.push((pre, test, binds)); - } - if self.scope_owns() { - self.t.err(span, "a let chain that binds a value that drops"); - } - self.scopes.pop(); - let mut then_stmts = Vec::new(); - self.stmt(then, dest.clone(), &mut then_stmts); - let mut else_stmts = Vec::new(); - if let Some(els) = els { - self.stmt(els, dest, &mut else_stmts); - } - let has_else = !else_stmts.is_empty(); - if has_else && !ts::diverges(&then_stmts) { - then_stmts.push(StmtKind::Break(Some(label.clone())).at(None)); - } - let mut body = then_stmts; - for (pre, test, binds) in levels.into_iter().rev() { - let mut inner = binds; - inner.extend(body); - let mut wrapped = pre; - match test { - Some(test) => wrapped.push( - StmtKind::If { - cond: test, - then: inner, - els: Vec::new(), - } - .at(None), - ), - None => wrapped.extend(inner), - } - body = wrapped; - } - match has_else { - true => { - body.extend(else_stmts); - self.push( - out, - StmtKind::Block { - label: Some(label), - body, - }, - span, - ); - } - false => out.extend(body), - } - } - - fn match_( - &mut self, - id: ExprId, - scrutinee: ExprId, - arms: &[ArmId], - source: MatchSource, - dest: Dest, - out: &mut Vec, - ) { - let span = self.span(id); - match source { - MatchSource::TryDesugar(_) => { - let value = self.try_(scrutinee, span, out); - self.deliver(value, &dest, span, out); - return; - } - MatchSource::ForLoopDesugar => { - self.for_(scrutinee, arms, span, out); - return; - } - _ => {} - } - - let thir: &'a Thir<'tcx> = self.thir; - // One arm binding the whole value, as `.await` desugars to, is a `let` scoped to it. - if let [arm] = arms - && thir[*arm].guard.is_none() - && let PatKind::Binding { - mode, subpattern: None, .. - } = thir[*arm].pattern.kind - && mode.0 == rustc_hir::ByRef::No - { - let start = out.len(); - self.open_scope(); - self.let_(&thir[*arm].pattern, Some(scrutinee), None, span, out); - self.stmt(thir[*arm].body, dest, out); - self.close_scope(out, start, span); - return; - } - if !self.is_place(scrutinee) - && self.t.drops(self.ty_of(scrutinee)) - && !arms - .iter() - .all(|&arm| thir[arm].guard.is_none() && takes_all(&thir[arm].pattern)) - { - self.t.err( - span, - "a `match` on a temporary that drops, which it doesn't move out of whole", - ); - } - let pats: Vec<&Pat<'tcx>> = arms.iter().map(|&arm| &*thir[arm].pattern).collect(); - // The last arm is the else, whose test never runs, unless it is guarded. - let tested = match arms.last().is_some_and(|&arm| thir[arm].guard.is_none()) { - true => pats.len() - 1, - false => pats.len(), - }; - let first_reads = pats.first().map_or(0, |p| self.test_reads(p)); - let later_reads: usize = pats.iter().take(tested).skip(1).map(|p| self.test_reads(p)).sum(); - let binds: usize = pats.iter().map(|p| bindings(p)).sum(); - let reads = match first_reads <= 1 && later_reads == 0 && binds == 0 { - true => first_reads, - false => 2, - }; - let (scrut, owned) = self.scrutinee(scrutinee, reads, out); - - struct Lowered { - test: Option, - binds: Vec, - guard: Option<(Vec, Expr)>, - body: Vec, - } - let mut lowered = Vec::new(); - for &arm in arms { - let arm = &self.thir[arm]; - let test = self.pat_test(&arm.pattern, &scrut); - let mut binds = Vec::new(); - self.open_scope(); - self.pat_bind(&arm.pattern, &scrut, owned, &mut binds); - let guard = arm.guard.map(|g| { - let mut pre = Vec::new(); - let e = self.expr(g, &mut pre); - (pre, e) - }); - let mut body = Vec::new(); - self.stmt(arm.body, dest.clone(), &mut body); - // What the arm binds that drops is dropped around its bindings and body. - if self.scope_owns() { - if guard.is_some() { - self.t.err(arm.span, "a guarded arm that binds a value that drops"); - } - binds.append(&mut body); - body = std::mem::take(&mut binds); - } - self.close_scope(&mut body, 0, arm.span); - lowered.push(Lowered { - test, - binds, - guard, - body, - }); - } - - // Arms that all do nothing, such as logging left out. - if lowered.iter().all(|arm| arm.body.is_empty() && arm.guard.is_none()) { - return; - } - - let chain = lowered.iter().all(|arm| match &arm.guard { - None => true, - Some((pre, _)) => pre.is_empty() && arm.binds.is_empty(), - }); - if chain { - // An if-else chain; the last arm is what Rust proved is left. - let mut els: Vec = Vec::new(); - let count = lowered.len(); - for (i, arm) in lowered.into_iter().enumerate().rev() { - let last = i + 1 == count; - let cond = match (arm.test, arm.guard) { - (t, Some((_, g))) => Some(match t { - Some(t) => t.and(g), - None => g, - }), - (Some(_), None) if last => None, - (t, None) => t, - }; - let mut then = arm.binds; - then.extend(arm.body); - els = match cond { - Some(cond) => vec![StmtKind::If { cond, then, els }.at(None)], - None => then, - }; - } - let loc = self.t.loc(span); - if let Some(first) = els.first_mut() - && first.loc.is_none() - { - first.loc = loc; - } - out.extend(els); - return; - } - - // Guards that read the arm's bindings: each arm tests, binds, then guards. - let label = self.fresh("arms"); - let mut body = Vec::new(); - let count = lowered.len(); - for (i, arm) in lowered.into_iter().enumerate() { - let guard_free = arm.guard.is_none(); - let mut inner = arm.binds; - let mut taken = arm.body; - if i + 1 < count && !ts::diverges(&taken) { - taken.push(StmtKind::Break(Some(label.clone())).at(None)); - } - match arm.guard { - Some((pre, g)) => { - inner.extend(pre); - inner.push( - StmtKind::If { - cond: g, - then: taken, - els: Vec::new(), - } - .at(None), - ); - } - None => inner.extend(taken), - } - // The last arm without a guard is what Rust proved is left. - let test = match i + 1 == count && guard_free { - true => None, - false => arm.test, - }; - match test { - Some(test) => body.push( - StmtKind::If { - cond: test, - then: inner, - els: Vec::new(), - } - .at(None), - ), - None => body.extend(inner), - } - } - self.push( - out, - StmtKind::Block { - label: Some(label), - body, - }, - span, - ); - } - - /// Whether a `match` reads as a ternary chain: no bindings or guards, and arms that - /// are each a simple value. - fn ternary_match(&mut self, id: ExprId) -> bool { - let ExprKind::Match { arms, .. } = &self.thir[self.strip(id)].kind else { - return false; - }; - arms.iter().all(|&arm| { - let arm = &self.thir[arm]; - arm.guard.is_none() && !has_bindings(&arm.pattern) && self.simple(arm.body) - }) - } - - /// `expr?`: the value, returning early on `Err` or `None`. - fn try_(&mut self, scrutinee: ExprId, span: Span, out: &mut Vec) -> Expr { - // The scrutinee is `Try::branch(expr)`. - let ExprKind::Call { args, .. } = &self.thir[self.strip(scrutinee)].kind else { - return self.err(span, "an unexpected `?` desugaring"); - }; - let inner = args[0]; - let inner_ty = self.ty_of(inner); - // `it.next()?` tests for the end itself, so its item may be an `Option`. - let raw = self.raw_next(inner, out); - let none = match raw { - Some(_) => Expr::Rt("DONE".into()), - None => Expr::undefined(), - }; - let value = match raw { - Some(value) => value, - None => self.operand(inner, out), - }; - let name = match value { - Expr::Ident(ref name) => name.clone(), - value => { - let name = self.temp_for(inner); - self.push(out, StmtKind::decl(false, name.clone(), None, Some(value)), span); - name - } - }; - let t = Expr::ident(&name); - let ty::Adt(adt, adt_args) = inner_ty.kind() else { - return self.err(span, format!("`?` on `{inner_ty}`")); - }; - match library::Std::of(self.t.tcx, adt.did()) { - Some(library::Std::Option) => { - let ret = self.ret; - let ty::Adt(ret_adt, _) = ret.kind() else { - return self.err(span, "`?` on an `Option` in a function that returns no `Option`"); - }; - if library::Std::of(self.t.tcx, ret_adt.did()) != Some(library::Std::Option) { - return self.err(span, "`?` on an `Option` in a function that returns no `Option`"); - } - self.push( - out, - StmtKind::If { - cond: t.clone().binary("===", none), - then: vec![ - StmtKind::Return(Some(match self.done { - true => Expr::Rt("DONE".into()), - false => Expr::undefined(), - })) - .at(None), - ], - els: Vec::new(), - }, - span, - ); - t - } - Some(library::Std::Result) => { - let from = adt_args.type_at(1); - let ret = self.ret; - let to = match ret.kind() { - ty::Adt(ret_adt, ret_args) - if library::Std::of(self.t.tcx, ret_adt.did()) == Some(library::Std::Result) => - { - ret_args.type_at(1) - } - _ => return self.err(span, "`?` on a `Result` in a function that returns no `Result`"), - }; - let error = t.clone().member("error"); - let converted = self.convert(error, from, to, span, out); - self.push( - out, - StmtKind::If { - cond: t.clone().member("ok").not(), - then: vec![StmtKind::Return(Some(Expr::rt("Err", vec![converted]))).at(None)], - els: Vec::new(), - }, - span, - ); - t.member("value") - } - _ => self.err(span, format!("`?` on `{inner_ty}`")), - } - } - - /// `From::from(value)`, converting a `from` into a `to`. - pub fn convert(&mut self, value: Expr, from: Ty<'tcx>, to: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { - if from == to { - return value; - } - let tcx = self.t.tcx; - let Some(from_trait) = tcx.get_diagnostic_item(rustc_span::sym::From) else { - return self.err(span, "no `From` trait"); - }; - let Some(from_fn) = tcx - .associated_items(from_trait) - .in_definition_order() - .find(|i| i.is_fn()) - else { - return self.err(span, "no `From::from`"); - }; - let args = tcx.mk_args(&[to.into(), from.into()]); - self.call_def(from_fn.def_id, args, Args::Values(vec![value]), span, out) - } - - /// `for pat in iter { body }`, from its desugaring. - fn for_(&mut self, scrutinee: ExprId, arms: &[ArmId], span: Span, out: &mut Vec) { - // match IntoIterator::into_iter(iter) { mut it => loop { match next(&mut it) { - // None => break, Some(pat) => body } } } - let bad = |b: &mut Self| { - b.t.err(span, "an unexpected `for` desugaring"); - }; - let ExprKind::Call { args, .. } = &self.thir[self.strip(scrutinee)].kind else { - return bad(self); - }; - let iterable = args[0]; - let [arm] = arms else { - return bad(self); - }; - let arm = &self.thir[*arm]; - let ExprKind::Scope { - region_scope, value, .. - } = self.thir[arm.body].kind - else { - return bad(self); - }; - let ExprKind::Loop { body } = self.thir[value].kind else { - return bad(self); - }; - let ExprKind::Block { block } = self.thir[self.strip(body)].kind else { - return bad(self); - }; - let next = match (self.thir[block].stmts.as_ref(), self.thir[block].expr) { - ([s], None) => match self.thir[*s].kind { - thir::StmtKind::Expr { expr, .. } => expr, - _ => return bad(self), - }, - ([], Some(e)) => e, - _ => return bad(self), - }; - let ExprKind::Match { arms: next_arms, .. } = &self.thir[self.strip(next)].kind else { - return bad(self); - }; - let Some(some_arm) = next_arms - .iter() - .map(|a| &self.thir[*a]) - .find(|a| matches!(a.pattern.kind, PatKind::Variant { variant_index, .. } if variant_index.index() == 1)) - else { - return bad(self); - }; - let PatKind::Variant { subpatterns, .. } = &some_arm.pattern.kind else { - return bad(self); - }; - let pat = &subpatterns[0].pattern; - let loop_body = some_arm.body; - - let iter_ty = self.ty_of(iterable); - let source = match self.iterable(iterable, iter_ty, span, out) { - Some(source) => source, - // Refused, but what the iterable and the body refuse is reported too. - None => Iterable::Of(self.operand(iterable, out)), - }; - - let label = self.fresh("loop"); - self.breakables.push(Breakable { - scope: region_scope, - label, - used: false, - dest: Dest::Discard, - is_loop: true, - }); - let mut stmts = Vec::new(); - // The iterator drops after the loop, with what it did not yield. - if self.t.drops(self.subst(pat.ty)) || self.t.drops(iter_ty) { - self.t.err( - pat.span, - "a `for` loop over values that drop, which is not supported yet", - ); - } - self.open_scope(); - let simple_name = match &pat.kind { - PatKind::Binding { - name, - var, - mode, - subpattern: None, - .. - } if mode.1 == rustc_ast::Mutability::Not && !self.needs_copy(self.subst(pat.ty)) => { - Some(self.bind_var(*var, *name, false, pat.ty, pat.span, mode.0 == rustc_hir::ByRef::No)) - } - PatKind::Wild => Some(self.fresh("_")), - _ => None, - }; - let name = match simple_name { - Some(name) => name, - None => { - let name = self.fresh("item"); - let scrut = Expr::ident(&name); - if self.pat_test(pat, &scrut).is_some() { - self.t.err(pat.span, "a refutable `for` pattern"); - } - self.pat_bind(pat, &scrut, true, &mut stmts); - name - } - }; - self.stmt(loop_body, Dest::Discard, &mut stmts); - self.close_scope(&mut stmts, 0, span); - let breakable = self.breakables.pop().unwrap(); - let label = breakable.used.then_some(breakable.label); - let kind = match source { - Iterable::Range { start, end, inclusive } => StmtKind::ForRange { - label, - name, - start, - end, - inclusive, - body: stmts, - }, - Iterable::Of(iter) => StmtKind::ForOf { - label, - name, - iter, - body: stmts, - }, - // `while (true) { const x = iter.next(); if (x === rt.DONE) break; ... }` - Iterable::Next(next) => { - let mut body = vec![ - StmtKind::decl(false, name.clone(), None, Some(next)).at(None), - StmtKind::If { - cond: Expr::ident(&name).binary("===", Expr::Rt("DONE".into())), - then: vec![StmtKind::Break(None).at(None)], - els: Vec::new(), - } - .at(None), - ]; - body.extend(stmts); - StmtKind::While { - label, - cond: Expr::lit("true"), - body, - } - } - }; - self.push(out, kind, span); - } - - /// What a `for` loop iterates. - fn iterable(&mut self, id: ExprId, ty: Ty<'tcx>, span: Span, out: &mut Vec) -> Option { - let tcx = self.t.tcx; - match ty.kind() { - ty::Adt(adt, _) if tcx.is_lang_item(adt.did(), rustc_attr_ir::LangItem::Range) => { - let ExprKind::Adt(range) = &self.thir[self.strip(id)].kind else { - self.t - .err(span, "a `for` loop over a range that is not written in place"); - return None; - }; - let mut written = self.written(range, ty, span, out); - // `end` is read on every turn, so unless constant it is spilled, after what - // evaluates before it. - let end_at = written.iter().position(|(i, _)| *i == 1).expect("a range has an end"); - if !written[end_at].1.is_constant() { - for (i, value) in written.iter_mut().take(end_at + 1) { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, if *i == 1 { "end" } else { "start" }, out); - } - } - } - written.sort_by_key(|(i, _)| *i); - let [(_, start), (_, end)] = <[_; 2]>::try_from(written).expect("a range has two fields"); - Some(range_of(ty, start, end, false)) - } - ty::Adt(adt, _) if tcx.is_lang_item(adt.did(), rustc_attr_ir::LangItem::RangeInclusiveStruct) => { - // `a..=b` is `RangeInclusive::new(a, b)`. - let ExprKind::Call { args, .. } = &self.thir[self.strip(id)].kind else { - self.t - .err(span, "a `for` loop over a range that is not written in place"); - return None; - }; - let args = args.clone(); - let mut values = self.operands(&args, out); - let end = values.pop().unwrap(); - let mut start = values.pop().unwrap(); - let end = match end.is_constant() { - true => end, - false => { - if !start.is_constant() { - start = self.spill(start, "start", out); - } - self.spill(end, "end", out) - } - }; - Some(range_of(ty, start, end, true)) - } - // An array by value iterates its elements, already copied. - ty::Array(..) => Some(Iterable::Of(self.operand(id, out))), - ty::Ref(_, inner, _) if matches!(inner.kind(), ty::Slice(_) | ty::Array(..)) => { - Some(Iterable::Of(self.operand(id, out))) - } - ty::Ref(_, inner, _) if self.is_vec(*inner) => { - let v = self.operand(id, out); - Some(Iterable::Of(library::vec_view(v, *inner))) - } - ty::Adt(..) if self.is_vec(ty) => { - let v = self.operand(id, out); - Some(Iterable::Of(library::vec_view(v, ty))) - } - // `slice.iter()` iterates as the slice itself does. - _ if let Some(slice) = library::iterated_slice(self, id) => { - self.visit(id); - Some(Iterable::Of(self.operand(slice, out))) - } - // Any other iterator, by the protocol. - _ => { - let value = self.operand(id, out); - let iterator = self.t.iter_item(ty).is_some(); - let value = match iterator { - true => value, - false => match super::iter::into_iter(self, ty, value, span) { - Some(value) => value, - None => { - self.t.err(span, format!("a `for` loop over `{ty}`")); - return None; - } - }, - }; - let iter = match value.is_path() { - true => value, - false => self.spill(value, "iter", out), - }; - Some(Iterable::Next(match iterator { - true => super::iter::next(self, ty, iter), - false => iter.member("next").call(Vec::new()), - })) - } - } - } - - fn is_vec(&self, ty: Ty<'tcx>) -> bool { - matches!(ty.kind(), ty::Adt(adt, _) if library::Std::of(self.t.tcx, adt.did()) == Some(library::Std::Vec)) - } - - pub fn spill(&mut self, value: Expr, base: &str, out: &mut Vec) -> Expr { - let name = self.fresh(base); - out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); - Expr::ident(name) - } - - /// Fields' values by index, from the order they are written to declaration order. - /// Each that would then evaluate after one written later is spilled first, unless - /// constant, so they still evaluate as written. - pub fn declared(&mut self, mut written: Vec<(usize, Expr)>, out: &mut Vec) -> Vec<(usize, Expr)> { - // The longest tail already in declaration order evaluates in place, after the rest. - let mut tail = written.len().saturating_sub(1); - while tail > 0 && written[tail - 1].0 < written[tail].0 { - tail -= 1; - } - for (_, value) in &mut written[..tail] { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "field", out); - } - } - written.sort_by_key(|(i, _)| *i); - written - } - - /// `value`, from `id`, as something patterns can read more than once. - fn path(&mut self, value: Expr, id: ExprId, out: &mut Vec) -> Expr { - if value.is_path() { - return value; - } - let name = self.temp_for(id); - out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); - Expr::ident(name) - } - - fn assign(&mut self, lhs: ExprId, rhs: ExprId, span: Span, out: &mut Vec) { - let mut value = self.operand(rhs, out); - let mut pre = Vec::new(); - let yields = self.yields; - let target = self.place(lhs, &mut pre); - // The value waits out the `.await` where no scope drops it if the future is cancelled. - if self.yields != yields && self.t.drops(self.ty_of(rhs)) { - self.t.err( - self.span(lhs), - "an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first", - ); - } - if (!pre.is_empty() || !target.is_path()) && !value.is_constant() { - value = self.spill(value, "value", out); - } - out.extend(pre); - // The old value drops once the new one is made. - let lty = self.ty_of(lhs); - if self.t.drops(lty) { - if !target.is_path() && !matches!(target, Expr::Index(..)) { - self.t - .err(span, "an assignment that drops the old value of a computed place"); - return; - } - if !value.is_path() && !value.is_constant() { - value = self.spill(value, "value", out); - } - if let Some(dropped) = self.t.drop_value(target.clone(), lty, span) { - self.push(out, StmtKind::Expr(dropped), span); - } - } - // `*r = v` through a reference replaces what it points to, as does replacing a - // variable a generator borrows mutably. - let through_ref = match self.thir[self.strip(lhs)].kind { - ExprKind::Deref { arg } => matches!(self.ty_of(arg).kind(), ty::Ref(..)) && self.is_place(arg), - ExprKind::UpvarRef { var_hir_id, .. } => self.borrowed.contains(&var_hir_id.0), - _ => false, - }; - if through_ref { - let pointee = self.ty_of(lhs); - // Every clone of an `Arc` or waker is one JS object, a guard is its mutex, a - // reference is its referent, and a future keeps its state private: copying fields - // in would change the other handles, or nothing. A `Pin` or `Box` is its pointee - // in JS. - let mut erased = pointee; - while let ty::Adt(adt, args) = erased.kind() - && matches!( - library::Std::of(self.t.tcx, adt.did()), - Some(library::Std::Pin | library::Std::Box) - ) { - erased = args.type_at(0); - } - let shared = match erased.kind() { - ty::Adt(adt, _) => matches!( - library::Std::of(self.t.tcx, adt.did()), - Some(library::Std::Arc | library::Std::Waker | library::Std::Context | library::Std::MutexGuard) - ), - ty::Ref(..) | ty::Coroutine(..) => true, - _ => false, - }; - match self.t.object_kind(pointee) { - Some(ObjectKind::Class) if shared => { - self.t.err( - span, - format!("replacing the `{pointee}` behind a reference, whose JS object is shared or private"), - ); - } - Some(ObjectKind::Class) => { - let e = Expr::ident("Object").member("assign").call(vec![target, value]); - self.push(out, StmtKind::Expr(e), span); - } - Some(ObjectKind::Bytes) => { - let e = target.member("set").call(vec![value]); - self.push(out, StmtKind::Expr(e), span); - } - _ => { - self.t - .err(span, format!("an assignment through a reference to `{pointee}`")); - } - } - return; - } - self.push(out, StmtKind::Expr(target.assign(value)), span); - } - - fn assign_op( - &mut self, - op: rustc_middle::mir::AssignOp, - lhs: ExprId, - rhs: ExprId, - span: Span, - out: &mut Vec, - ) { - // The value evaluates first, so it is saved before the place reads it again or - // runs statements of its own. - let mut value = self.operand(rhs, out); - let mut pre = Vec::new(); - let target = self.place(lhs, &mut pre); - if (!pre.is_empty() || !value.is_path()) && !value.is_constant() { - value = self.spill(value, "value", out); - } - out.extend(pre); - if !target.is_path() && !matches!(target, Expr::Index(..)) { - self.t.err(span, "a compound assignment to a computed place"); - return; - } - let lty = self.ty_of(lhs); - let rty = self.ty_of(rhs); - let op = rustc_middle::mir::BinOp::from(op); - let lhs_value = super::num::Operand { - expr: target.clone(), - value: None, - }; - let rhs_value = super::num::Operand { - expr: value, - value: None, - }; - let result = super::num::binary(self, op, lhs_value, rhs_value, lty, rty, span); - self.push(out, StmtKind::Expr(target.assign(result)), span); - } - - // Expressions - - /// Lower `id` as an operand: its value, copied if it is a `Copy` aggregate read - /// from a place, so a later write to either side does not reach the other. - pub fn operand(&mut self, id: ExprId, out: &mut Vec) -> Expr { - self.expr(id, out) - } - - /// Lower operands left to right, saving earlier ones that a later one's statements - /// could change. - pub fn operands(&mut self, ids: &[ExprId], out: &mut Vec) -> Vec { - let mut values: Vec = Vec::with_capacity(ids.len()); - // Whether an earlier operand is a value that drops, which a later `.await` would - // hold where no scope drops it if the future is cancelled. - let mut holds = false; - for &id in ids { - let mut pre = Vec::new(); - let yields = self.yields; - let value = self.operand(id, &mut pre); - if holds && self.yields != yields { - self.t.err( - self.span(id), - "an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first", - ); - } - holds |= self.t.drops(self.ty_of(id)); - self.after(&mut values, pre, out); - values.push(value); - } - values - } - - /// Emit `pre`, the statements of an operand that evaluates after `earlier`, saving - /// `earlier` first if there are any, so they cannot change it. - pub fn after(&mut self, earlier: &mut [Expr], pre: Vec, out: &mut Vec) { - if !pre.is_empty() { - for value in earlier.iter_mut().filter(|v| !v.is_constant()) { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "arg", out); - } - } - out.extend(pre); - } - - /// Whether `id` names a place, rather than making a temporary value. - pub fn is_place(&self, id: ExprId) -> bool { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } | ExprKind::PlaceTypeAscription { source: value, .. } => { - self.is_place(*value) - } - ExprKind::VarRef { .. } | ExprKind::UpvarRef { .. } | ExprKind::Field { .. } | ExprKind::Index { .. } => { - true - } - // What a `Box` made in place points at is part of that temporary. - ExprKind::Deref { arg } => matches!(self.ty_of(*arg).kind(), ty::Ref(..)) || self.is_place(*arg), - _ => false, + /// A name no other binding in the function has. + pub fn fresh(&mut self, base: &str) -> String { + let base = escape(base); + let mut name = base.clone(); + let mut n = 2; + while !self.names.insert(name.clone()) { + name = format!("{base}{n}"); + n += 1; } + name } - /// Whether `id` makes a temporary that drops, which only a statement could drop. - fn temporary_drops(&mut self, id: ExprId) -> bool { - !self.is_place(id) && self.t.drops(self.ty_of(id)) - } - - /// Whether lowering `id` for its value moves it out of a place that drops it. - pub fn moves(&mut self, id: ExprId) -> bool { - let ty = self.ty_of(id); - self.is_place(id) && !self.t.is_copy(ty) && self.t.drops(ty) + pub fn spill(&mut self, value: Expr, base: &str, out: &mut Vec) -> Expr { + let name = self.fresh(base); + out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); + Expr::ident(name) } - /// Whether a block binds a variable that drops, so its value can't outlive it. - fn block_owns(&mut self, id: BlockId) -> bool { - let thir: &'a Thir<'tcx> = self.thir; - let mut owns = false; - for &stmt in &thir[id].stmts { - if let thir::StmtKind::Let { - pattern, initializer, .. - } = &thir[stmt].kind - { - // A `ref` binding keeps a temporary alive to the end of the block. - if let PatKind::Binding { - mode, subpattern: None, .. - } = pattern.kind - && mode.0 != rustc_hir::ByRef::No - && let Some(init) = *initializer - && !self.is_place(init) - { - owns |= self.t.drops(self.ty_of(init)); - } - pattern.walk_always(|p| { - if let PatKind::Binding { mode, ty, .. } = p.kind - && mode.0 == rustc_hir::ByRef::No - { - owns |= self.t.drops(self.t.subst(self.args, ty)); - } - }); - } + /// `From::from(value)`, converting a `from` into a `to`. + pub fn convert(&mut self, value: Expr, from: Ty<'tcx>, to: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { + if from == to { + return value; } - owns + let tcx = self.t.tcx; + let Some(from_trait) = tcx.get_diagnostic_item(rustc_span::sym::From) else { + return self.err(span, "no `From` trait"); + }; + let Some(from_fn) = tcx + .associated_items(from_trait) + .in_definition_order() + .find(|i| i.is_fn()) + else { + return self.err(span, "no `From::from`"); + }; + let args = tcx.mk_args(&[to.into(), from.into()]); + self.call_def(from_fn.def_id, args, vec![value], span, out) } pub fn needs_copy(&self, ty: Ty<'tcx>) -> bool { @@ -2022,312 +95,6 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } - pub(super) fn ref_binding(&mut self, by_ref: rustc_hir::ByRef, ty: Ty<'tcx>, span: Span) { - if let rustc_hir::ByRef::Yes(_, rustc_ast::Mutability::Mut) = by_ref { - let pointee = match ty.kind() { - ty::Ref(_, inner, _) => *inner, - _ => ty, - }; - if self.t.object_kind(pointee).is_none() { - self.t.err( - span, - format!("a `ref mut` binding to `{pointee}`, which is no object a reference can change"), - ); - } - } - } - - /// Lower `id` for its value. - pub fn expr(&mut self, id: ExprId, out: &mut Vec) -> Expr { - self.visit(id); - let e = &self.thir[id]; - let span = e.span; - let ty = self.ty_of(id); - if self.t.ignored_macro(span) { - if !ty.is_unit() { - return self.err(span, "an ignored macro must evaluate to `()`"); - } - return Expr::undefined(); - } - if self.is_format_args(id) { - return self.format_args(id, out); - } - match &e.kind { - ExprKind::Scope { value, .. } => match self.scoped_loop(*value) { - Some(_) => self.via_temp(id, ty, span, out), - None => self.expr(*value, out), - }, - ExprKind::ValueTypeAscription { source, .. } | ExprKind::ValueExpr { source } => self.expr(*source, out), - // The temp is never assigned: control never gets past the source. - ExprKind::NeverToAny { .. } => self.via_temp(id, ty, span, out), - // A block of type `!` without a value, such as `panic!(..)`, goes through a temp. - ExprKind::Block { block } - if !self.thir[*block].targeted_by_break - && !self.block_owns(*block) - && (self.thir[*block].expr.is_some() || !ty.is_never()) => - { - let block = &self.thir[*block]; - for &stmt in &block.stmts { - self.stmt_item(stmt, out); - } - match block.expr { - Some(expr) => self.expr(expr, out), - None => Expr::undefined(), - } - } - ExprKind::If { - cond, then, else_opt, .. - } if self.simple(*then) && else_opt.is_some_and(|e| self.simple(e)) && !self.has_let(*cond) => { - let c = self.expr(*cond, out); - let mut pre = Vec::new(); - let a = self.expr(*then, &mut pre); - let b = self.expr(else_opt.unwrap(), &mut pre); - if !pre.is_empty() { - out.extend(pre); - return self.err(span, "an `if` that was simple and became not"); - } - Expr::Cond(Box::new(c), Box::new(a), Box::new(b)) - } - ExprKind::Match { - scrutinee, - match_source: MatchSource::TryDesugar(_), - .. - } => self.try_(*scrutinee, span, out), - // A scrutinee that diverges, such as `match return x {}`, has no value to pass. - ExprKind::Match { scrutinee, arms, .. } if arms.is_empty() && self.ty_of(*scrutinee).is_never() => { - self.stmt(*scrutinee, Dest::Discard, out); - Expr::undefined() - } - // A value of a type without values: native code never gets here. - ExprKind::Match { scrutinee, arms, .. } if arms.is_empty() => { - let value = self.operand(*scrutinee, out); - Expr::rt("unreachable", vec![value]) - } - ExprKind::Match { .. } if self.ternary_match(id) => self.ternary(id, out), - ExprKind::Block { .. } | ExprKind::If { .. } | ExprKind::Match { .. } | ExprKind::Loop { .. } => { - self.via_temp(id, ty, span, out) - } - ExprKind::Call { - ty: fn_ty, - fun, - args, - fn_span, - .. - } => { - let call = self.call(*fn_ty, *fun, args, *fn_span, out); - match self.t.loc(span) { - Some(loc) => Expr::Located(loc, Box::new(call)), - None => call, - } - } - // A place of type `!`, as in a generic instantiated at `!`, which native code never - // reads: `tsc` sees that through `rt.unreachable`. - ExprKind::VarRef { .. } - | ExprKind::UpvarRef { .. } - | ExprKind::Field { .. } - | ExprKind::Index { .. } - | ExprKind::Deref { .. } - | ExprKind::PlaceTypeAscription { .. } - if ty.is_never() => - { - let place = self.place(id, out); - Expr::rt("unreachable", vec![place]) - } - ExprKind::VarRef { .. } - | ExprKind::UpvarRef { .. } - | ExprKind::Field { .. } - | ExprKind::Index { .. } - | ExprKind::Deref { .. } - | ExprKind::PlaceTypeAscription { .. } => { - if let ExprKind::Index { lhs, index } = &e.kind { - let base = self.place(*lhs, out); - let base = self.path(base, *lhs, out); - let index_ty = self.ty_of(*lhs); - let i = self.operand(*index, out); - let value = match self.const_index(index_ty, *index) { - true => base.index(i), - false => Expr::rt("at", vec![base, i]), - }; - return self.copied(value, ty); - } - if matches!(self.ty_of(id).kind(), ty::FnDef(..)) - && let ExprKind::VarRef { .. } | ExprKind::UpvarRef { .. } = e.kind - { - let ty::FnDef(def_id, args) = *ty.kind() else { - unreachable!() - }; - return self.fn_value(def_id, args.skip_binder(), span); - } - if self.moves(id) { - let place = self.place(id, out); - return self.move_out(place, span, out); - } - let value = self.place(id, out); - self.copied(value, ty) - } - ExprKind::Borrow { borrow_kind, arg } => { - if self.temporary_drops(*arg) { - return self.err(span, "a borrow of a temporary that drops: bind it to a variable first"); - } - if let BorrowKind::Mut { .. } = borrow_kind { - let pointee = self.ty_of(*arg); - if self.t.object_kind(pointee).is_none() - && !matches!(pointee.kind(), ty::Ref(_, _, rustc_ast::Mutability::Mut)) - { - return self.err( - span, - format!("a mutable reference to `{pointee}`, which is no object it can change in place"), - ); - } - } - self.place(*arg, out) - } - ExprKind::RawBorrow { .. } => self.err(span, "raw pointers are not supported"), - ExprKind::Binary { op, lhs, rhs } => { - let (lty, rty) = (self.ty_of(*lhs), self.ty_of(*rhs)); - let values = self.operands(&[*lhs, *rhs], out); - let [l, r] = <[Expr; 2]>::try_from(values).unwrap(); - let l = super::num::Operand { - expr: l, - value: self.const_int(*lhs), - }; - let r = super::num::Operand { - expr: r, - value: self.const_int(*rhs), - }; - super::num::binary(self, *op, l, r, lty, rty, span) - } - ExprKind::LogicalOp { op, lhs, rhs } => { - let l = self.expr(*lhs, out); - let mut pre = Vec::new(); - let r = self.expr(*rhs, &mut pre); - let js = match op { - thir::LogicalOp::And => "&&", - thir::LogicalOp::Or => "||", - }; - if pre.is_empty() { - return l.binary(js, r); - } - // The right side needs statements: run them only when it is evaluated. - let name = self.fresh("cond"); - out.push(StmtKind::decl(true, name.clone(), Some(Type::Builtin("boolean")), Some(l)).at(None)); - pre.push(StmtKind::Expr(Expr::ident(&name).assign(r)).at(None)); - let cond = match op { - thir::LogicalOp::And => Expr::ident(&name), - thir::LogicalOp::Or => Expr::ident(&name).not(), - }; - out.push( - StmtKind::If { - cond, - then: pre, - els: Vec::new(), - } - .at(None), - ); - Expr::ident(name) - } - ExprKind::Unary { op, arg } => { - let aty = self.ty_of(*arg); - let value = self.operand(*arg, out); - super::num::unary(self, *op, value, aty, span) - } - ExprKind::Cast { source } => { - let from = self.ty_of(*source); - let value = self.operand(*source, out); - let operand = super::num::Operand { - expr: value, - value: self.const_int(*source), - }; - super::num::cast(self, operand, from, ty, span) - } - ExprKind::PointerCoercion { cast, source, .. } => match cast { - // `&T` to `&dyn Debug`: a function writing the value. - PointerCoercion::Unsize if let Some(tr) = self.fmt_object(ty) => { - let source_ty = self.ty_of(*source); - let value = self.operand(*source, out); - self.fmt_value(tr, source_ty, value, span, out) - } - PointerCoercion::Unsize if self.trait_object(ty) => self.err(span, format!("a coercion to `{ty}`")), - PointerCoercion::Unsize | PointerCoercion::ReifyFnPointer(_) | PointerCoercion::ClosureFnPointer(_) => { - self.expr(*source, out) - } - _ => self.err(span, format!("unsupported pointer coercion {cast:?}")), - }, - ExprKind::Literal { .. } - | ExprKind::NonHirLiteral { .. } - | ExprKind::ZstLiteral { .. } - | ExprKind::NamedConst { .. } - | ExprKind::ConstParam { .. } - | ExprKind::ConstBlock { .. } => self.constant(id), - ExprKind::Tuple { fields } if fields.is_empty() => Expr::undefined(), - ExprKind::Tuple { fields } => { - let values = self.operands(fields, out); - // TypeScript widens an array literal to an array of the union. - let ts_ty = self.t.ty(ty, span); - Expr::As(Box::new(Expr::Array(values)), ts_ty) - } - ExprKind::Array { fields } => { - let values = self.operands(fields, out); - match ty.kind() { - ty::Array(elem, _) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => { - Expr::ident("Uint8Array").member("of").call(values) - } - _ => Expr::Array(values), - } - } - ExprKind::Repeat { value, count } => { - let n = match count.try_to_target_usize(self.t.tcx) { - Some(n) => n, - None => return self.err(span, "an array length that is not a constant"), - }; - let elem_ty = self.ty_of(*value); - // `[v; 0]` drops `v` at once, which no element of the array would. - if self.t.drops(elem_ty) { - return self.err( - span, - "an array repeat of a value that drops, which is not supported yet", - ); - } - let v = self.operand(*value, out); - match elem_ty.kind() { - ty::Uint(ty::UintTy::U8) => { - let array = Expr::rt("bytes", vec![Expr::lit(n.to_string())]); - match &v { - Expr::Lit(text) if text == "0" => array, - _ => array.member("fill").call(vec![v]), - } - } - _ => { - let v = self.path(v, *value, out); - let item = self.copied(v, elem_ty); - let item_ty = self.t.ty(elem_ty, span); - Expr::ident("Array").member("from").call(vec![ - Expr::Object(vec![(Key::Name("length".into()), Expr::lit(n.to_string()))]), - Expr::Arrow(Vec::new(), item_ty, vec![StmtKind::Return(Some(item.typed())).at(None)]), - ]) - } - } - } - ExprKind::Adt(adt) => self.adt_expr(adt, ty, span, out), - ExprKind::Closure(closure) => self.closure(closure.closure_id, span, out), - ExprKind::Assign { .. } - | ExprKind::AssignOp { .. } - | ExprKind::Break { .. } - | ExprKind::Continue { .. } - | ExprKind::Return { .. } => { - self.stmt(id, Dest::Discard, out); - Expr::undefined() - } - ExprKind::Let { .. } => self.err(span, "a `let` outside an `if` condition"), - ExprKind::Yield { value } => { - self.stmt(*value, Dest::Discard, out); - self.yields += 1; - Expr::Yield - } - kind => self.err(span, format!("unsupported expression: {}", kind_name(kind))), - } - } - /// `value`, copied if `ty` is a `Copy` aggregate. pub fn copied(&mut self, value: Expr, ty: Ty<'tcx>) -> Expr { match self.needs_copy(ty) { @@ -2336,562 +103,12 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } - /// Whether indexing a `ty` at `index` is in bounds by construction: a constant index - /// into an array long enough. - fn const_index(&self, ty: Ty<'tcx>, index: ExprId) -> bool { - let ty::Array(_, len) = ty.peel_refs().kind() else { - return false; - }; - let (Some(len), Some(i)) = (len.try_to_target_usize(self.t.tcx), self.const_int(index)) else { - return false; - }; - i >= 0 && (i as u64) < len - } - - /// `id` assigned to a new variable, which a value of type `!` leaves unassigned: control - /// never gets past it. - fn via_temp(&mut self, id: ExprId, ty: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { - if ty.is_unit() { - self.stmt(id, Dest::Discard, out); - return Expr::undefined(); - } - let name = self.temp_for(id); - let ts_ty = self.t.ty(ty, span); - out.push(StmtKind::decl(true, name.clone(), Some(ts_ty), None).at(None)); - self.stmt(id, Dest::Assign(name.clone()), out); - Expr::ident(name) - } - - /// A `match` of simple arms as a chain of `?:`. - fn ternary(&mut self, id: ExprId, out: &mut Vec) -> Expr { - let ExprKind::Match { scrutinee, arms, .. } = &self.thir[self.strip(id)].kind else { - unreachable!() - }; - let thir: &'a Thir<'tcx> = self.thir; - // Its arms bind nothing, so a temporary that drops is left for nothing to drop. - if self.temporary_drops(*scrutinee) { - return self.err( - self.span(id), - "a `match` on a temporary that drops, which it doesn't move out of whole", - ); - } - let reads: usize = arms - .iter() - .take(arms.len().saturating_sub(1)) - .map(|&arm| self.test_reads(&thir[arm].pattern)) - .sum(); - let (scrut, _) = self.scrutinee(*scrutinee, reads.min(2), out); - let mut chain: Vec<(Option, Expr)> = Vec::new(); - for &arm in arms.iter() { - let arm = &self.thir[arm]; - let test = self.pat_test(&arm.pattern, &scrut); - let mut pre = Vec::new(); - let value = self.expr(arm.body, &mut pre); - out.extend(pre); - chain.push((test, value)); - } - let (_, mut result) = chain.pop().unwrap(); - while let Some((test, value)) = chain.pop() { - result = match (test, value, result) { - (None, value, _) => value, - (Some(test), Expr::Lit(a), Expr::Lit(b)) if a == "true" && b == "false" => test, - (Some(test), Expr::Lit(a), Expr::Lit(b)) if a == "false" && b == "true" => test.not(), - (Some(test), value, result) => Expr::Cond(Box::new(test), Box::new(value), Box::new(result)), - }; - } - result - } - - /// Lower `id` as a place: no copy is made of what it names. - pub fn place(&mut self, id: ExprId, out: &mut Vec) -> Expr { - self.visit(id); - let e = &self.thir[id]; - let span = e.span; - match &e.kind { - ExprKind::Scope { value, .. } | ExprKind::PlaceTypeAscription { source: value, .. } => { - self.place(*value, out) - } - ExprKind::VarRef { id: var } => self.local(var.0, span), - ExprKind::UpvarRef { var_hir_id, .. } => self.local(var_hir_id.0, span), - // Reading through a `Box` that drops reads its pointee: the box stays where it is. - ExprKind::Deref { arg } if self.is_place(*arg) && self.t.drops(self.ty_of(*arg)) => self.place(*arg, out), - ExprKind::Deref { arg } => self.expr(*arg, out), - ExprKind::Field { - lhs, - variant_index, - name, - } => { - if self.temporary_drops(*lhs) { - return self.err(span, "a field of a temporary that drops: bind it to a variable first"); - } - // A field of a tuple made in place, `(a, b).0`: its other fields still run. - if let ExprKind::Tuple { fields } = &self.thir[self.strip(*lhs)].kind { - let fields = fields.clone(); - let mut values = self.operands(&fields, out); - let index = name.index(); - let later_effects = values[index + 1..].iter().any(|v| !v.is_path()); - let mut field = std::mem::replace(&mut values[index], Expr::undefined()); - if later_effects && !field.is_constant() { - field = self.spill(field, "field", out); - } - for (i, value) in values.into_iter().enumerate() { - if i != index && !value.is_path() { - out.push(StmtKind::Expr(value).at(None)); - } - } - return field; - } - let base = self.place(*lhs, out); - let lty = self.ty_of(*lhs); - self.project(base, lty, *variant_index, *name, span) - } - ExprKind::Index { lhs, index } => { - if self.temporary_drops(*lhs) { - return self.err( - span, - "an index into a temporary that drops: bind it to a variable first", - ); - } - let base = self.place(*lhs, out); - let base = self.path(base, *lhs, out); - let lty = self.ty_of(*lhs); - let i = self.operand(*index, out); - match self.const_index(lty, *index) { - true => base.index(i), - false => { - let i = match i.is_path() { - true => i, - false => self.spill(i, "index", out), - }; - base.clone().index(Expr::rt("idx", vec![base, i])) - } - } - } - _ => self.expr(id, out), - } - } - - /// A field of `base`, a `ty`. - pub fn project( - &mut self, - base: Expr, - ty: Ty<'tcx>, - variant: rustc_abi::VariantIdx, - field: rustc_abi::FieldIdx, - span: Span, - ) -> Expr { - let ty = ty.peel_refs(); - match ty.kind() { - ty::Tuple(_) => base.index(Expr::lit(field.index().to_string())), - ty::Adt(adt, _) => match library::Std::of(self.t.tcx, adt.did()) { - Some(library::Std::Option | library::Std::Poll) => base, - Some(library::Std::Result) => match variant.index() { - 0 => base.member("value"), - _ => base.member("error"), - }, - Some(library::Std::Box) => base, - Some(library::Std::Range) => base.member(adt.non_enum_variant().fields[field].name.as_str()), - None if adt.did().is_local() => { - let info = self.t.adt(*adt, span); - match info.repr { - AdtRepr::Struct { fields, .. } => base.field(fields[field.index()]), - AdtRepr::Union | AdtRepr::Tags => { - let def = &adt.variant(variant).fields[field]; - base.member(super::field_name(def.name.as_str(), field.index())) - } - } - } - _ => self.err(span, format!("a field of `{ty}`")), - }, - _ => self.err(span, format!("a field of `{ty}`")), - } - } - - /// A struct expression's fields by index, in the order they evaluate: those written, - /// then those `..base` fills, read from the base after it. - pub fn written( - &mut self, - adt: &thir::AdtExpr<'tcx>, - ty: Ty<'tcx>, - span: Span, - out: &mut Vec, - ) -> Vec<(usize, Expr)> { - let ids: Vec = adt.fields.iter().map(|f| f.expr).collect(); - let mut values = self.operands(&ids, out); - let base = match &adt.base { - thir::AdtExprBase::None => None, - thir::AdtExprBase::Base(fru) if self.t.drops(self.ty_of(fru.base)) => { - self.t.err(span, "struct update syntax from a value that drops"); - None - } - thir::AdtExprBase::Base(fru) => { - // The base is read after the fields, so earlier fields are saved first. - let mut pre = Vec::new(); - let base = self.operand(fru.base, &mut pre); - if !pre.is_empty() || !base.is_path() { - for value in values.iter_mut() { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "field", out); - } - } - } - out.extend(pre); - Some(self.path(base, fru.base, out)) - } - thir::AdtExprBase::DefaultFields(_) => { - self.t.err(span, "default field values are not supported"); - None - } - }; - let mut written: Vec<(usize, Expr)> = adt.fields.iter().map(|f| f.name.index()).zip(values).collect(); - if let Some(base) = base { - let variant = adt.adt_def.variant(adt.variant_index); - for (i, field) in variant.fields.iter_enumerated() { - if adt.fields.iter().any(|f| f.name == i) { - continue; - } - let field_ty = self.subst(field.ty(self.t.tcx, adt.args).skip_norm_wip()); - let value = self.project(base.clone(), ty, adt.variant_index, i, span); - written.push((i.index(), self.copied(value, field_ty))); - } - } - written - } - - fn adt_expr(&mut self, adt: &thir::AdtExpr<'tcx>, ty: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { - let tcx = self.t.tcx; - let def = adt.adt_def; - let variant = def.variant(adt.variant_index); - let written = self.written(adt, ty, span, out); - if let Some(std) = library::Std::of(tcx, def.did()) { - let mut values: Vec = self.declared(written, out).into_iter().map(|(_, v)| v).collect(); - return match (std, adt.variant_index.index()) { - (library::Std::Option, 0) | (library::Std::Poll, 1) => match std { - library::Std::Poll => Expr::Rt("Pending".into()), - _ => Expr::undefined(), - }, - (library::Std::Option | library::Std::Poll, _) => values.pop().unwrap(), - (library::Std::Result, 0) => Expr::rt("Ok", values), - (library::Std::Result, _) => Expr::rt("Err", values), - (library::Std::FmtError, _) => Expr::New(Box::new(Expr::Rt("FmtError".into())), Vec::new()), - (library::Std::RangeFull, _) => Expr::undefined(), - (library::Std::Range, _) => { - // A wide range steps past 2^53 through its type. - let ty::Adt(_, gargs) = ty.kind() else { - unreachable!("a range is a struct") - }; - if let Some(int) = super::num::Int::of(gargs.type_at(0)) - && int.big() - { - values.push(int.func("step")); - } - Expr::New(Box::new(Expr::Rt("Range".into())), values) - } - (library::Std::AssertKind, _) => match variant.name.as_str() { - "Eq" => Expr::Str("==".into()), - "Ne" => Expr::Str("!=".into()), - _ => self.err(span, format!("constructing `{ty}`")), - }, - _ => self.err(span, format!("constructing `{ty}`")), - }; - } - if !def.did().is_local() { - return self.err(span, format!("constructing `{ty}` from another crate")); - } - let info = self.t.adt(def, span); - match info.repr { - AdtRepr::Struct { ctor, fields } => { - let written: Vec<(usize, Expr)> = written - .into_iter() - .map(|(i, value)| { - ( - i, - field_arg(tcx, &variant.fields[rustc_abi::FieldIdx::from_usize(i)], value), - ) - }) - .collect(); - match ctor { - ts::Ctor::Unit => self.t.construct(info.sym, &ts::Ctor::Unit, &fields, Vec::new()), - // A class takes its named fields as an object, which evaluates them as written. - ts::Ctor::Named if !self.t.plain(info.sym) => { - let props = written.into_iter().map(|(i, v)| (Key::Field(fields[i]), v)).collect(); - Expr::New(Box::new(Expr::Sym(info.sym)), vec![Expr::Object(props)]) - } - // A plain object's properties go in declaration order, so every value of the - // struct shares one shape. - _ => { - let args = self.declared(written, out).into_iter().map(|(_, v)| v).collect(); - self.t.construct(info.sym, &ctor, &fields, args) - } - } - } - AdtRepr::Tags => { - let ts_ty = self.t.ty(ty, span); - Expr::As(Box::new(Expr::Str(variant.name.to_string())), ts_ty) - } - AdtRepr::Union => { - let mut props = vec![(Key::Name("tag".into()), Expr::Str(variant.name.to_string()))]; - for (i, value) in self.declared(written, out) { - let name = super::field_name(variant.fields[rustc_abi::FieldIdx::from_usize(i)].name.as_str(), i); - props.push((Key::Name(name), value)); - } - let ts_ty = self.t.ty(ty, span); - Expr::As(Box::new(Expr::Object(props)), ts_ty) - } - } - } - - /// A closure as an arrow function, or an `async` body as a future around a generator. - /// - /// The generator is a function of its own, taking its upvars as parameters: a - /// generator function made per call costs V8 a prototype object and a new shape for - /// each generator, about 25 times what one made once does. - fn closure(&mut self, local: rustc_hir::def_id::LocalDefId, span: Span, out: &mut Vec) -> Expr { - let tcx = self.t.tcx; - let Some((thir, body)) = self.t.body(local) else { - return self.err(span, "no body for a closure"); - }; - let closure_ty = self.subst(tcx.type_of(local).instantiate_identity().skip_norm_wip()); - let (ret, coroutine) = match closure_ty.kind() { - ty::Closure(_, args) => ( - tcx.instantiate_bound_regions_with_erased(args.as_closure().sig()) - .output(), - false, - ), - ty::Coroutine(_, args) if tcx.coroutine_is_async(local.to_def_id()) => { - (args.as_coroutine().return_ty(), true) - } - _ => return self.err(span, format!("a closure of type `{closure_ty}`")), - }; - if coroutine && self.t.erases_to(ret).pending { - self.t.err( - span, - format!("an async body returning `{ret}` is not supported: its `Ready` could be pending"), - ); - } - // An async fn's body is this block alone, which rustc starts by moving each argument - // into a local: the function gives its arguments up whole, and those locals drop - // them. A block moves what it owns out of its place, as any move does, and drops it. - let fn_body = matches!( - tcx.coroutine_kind(local), - Some(rustc_hir::CoroutineKind::Desugared(_, rustc_hir::CoroutineSource::Fn)) - ); - // A generator's upvars, each a parameter: its name, its value here, its type, and - // whether the future owns it and so drops it. - let mut upvars: Vec<(String, Expr, Ty<'tcx>, bool)> = Vec::new(); - for capture in tcx.closure_captures(local) { - let var = capture.get_root_variable(); - let ty = self.subst(capture.place.ty()); - let by_value = matches!(capture.info.capture_kind, ty::UpvarCapture::ByValue); - let mutable = matches!(self.locals.get(&var), Some(Local::Name { mutable: true, .. })); - // A copy captured by `move` would be shared in JS: refuse one that can change. - if !coroutine && by_value && mutable && self.t.is_copy(ty) { - self.t - .err(capture.get_path_span(tcx), "a closure that copies a mutable variable"); - } - if !coroutine { - if by_value && self.t.drops(ty) { - self.t.err( - capture.get_path_span(tcx), - "a closure that captures a value that drops, which is not supported yet", - ); - } - continue; - } - if !capture.place.projections.is_empty() { - self.t.err( - capture.get_path_span(tcx), - "an async body that captures part of a variable", - ); - continue; - } - // Its generator takes the value: a change through the borrow would change a copy. - if let ty::UpvarCapture::ByRef(kind) = capture.info.capture_kind - && kind != ty::BorrowKind::Immutable - { - if self.t.object_kind(ty).is_none() { - self.t.err( - capture.get_path_span(tcx), - format!("an async body that borrows `{ty}` mutably, which is no object it can change in place"), - ); - continue; - } - self.borrowed.insert(var); - } - let Some(Local::Name { name, .. }) = self.locals.get(&var).cloned() else { - self.t - .err(capture.get_path_span(tcx), "an async body capturing a function item"); - continue; - }; - let owns = by_value && self.t.drops(ty); - let place = Expr::ident(&name); - let value = match (owns, fn_body) { - (true, true) => { - self.disown(&name); - place - } - (true, false) => self.move_out(place, capture.get_path_span(tcx), out), - // A `Copy` aggregate taken by value is the future's own, as JS would share it. - (false, _) if by_value => self.copied(place, ty), - (false, _) => place, - }; - upvars.push((name, value, ty, owns)); - } - let saved_thir = std::mem::replace(&mut self.thir, thir); - self.read.extend(reads(tcx, thir)); - let saved_breakables = std::mem::take(&mut self.breakables); - let saved_ret = std::mem::replace(&mut self.ret, ret); - let saved_done = std::mem::replace(&mut self.done, false); - let mut body_stmts = Vec::new(); - let mut params = Vec::new(); - self.open_scope(); - // Upvars drop in capture order, after the locals: the first is the innermost. - for (name, _, ty, owns) in upvars.iter().rev() { - if *owns && !fn_body { - self.own(name, *ty); - } - } - // The first parameter is the closure's environment; a coroutine's second is the - // context each poll resumes it with. - for param in thir.params.iter().skip(1) { - let name = match ¶m.pat { - Some(pat) => self.param(pat, &mut body_stmts), - None => self.fresh("arg"), - }; - let ty = self.subst(param.ty); - let ty = self.t.ty(ty, span); - params.push(Param { name, ty: Some(ty) }); - } - let dest = match ret.is_unit() || ret.is_never() { - true => Dest::Discard, - false => Dest::Return, - }; - self.stmt(body, dest, &mut body_stmts); - self.close_scope(&mut body_stmts, 0, span); - let ret_ty = self.t.ret_ty(ret, span); - self.thir = saved_thir; - self.breakables = saved_breakables; - self.ret = saved_ret; - self.done = saved_done; - if !coroutine { - return Expr::Arrow(params, ret_ty, body_stmts); - } - - // `rt.future(body, drop, ...upvars)`: the body and what drops the upvars if it - // never runs, each a function of the upvars. - let parent = tcx.typeck_root_def_id(local.to_def_id()); - let base = camel(tcx.item_name(parent).as_str()); - let mut drops = Vec::new(); - for (name, _, ty, owns) in &upvars { - if *owns && let Some(dropped) = self.t.drop_value(Expr::ident(name), *ty, span) { - drops.push(StmtKind::Expr(dropped).at(None)); - } - } - let upvar_params: Vec = upvars - .iter() - .map(|(name, _, ty, _)| Param { - name: name.clone(), - ty: Some(self.t.ty(*ty, span)), - }) - .collect(); - params.extend(upvar_params.iter().cloned()); - let body_fn = self.hoist(parent, format!("{base}Body"), params, ret_ty, body_stmts, true, span); - // The drop reads only the upvars it drops: TypeScript lets the rest go unread as `_`s. - let drop_params = upvars - .iter() - .zip(upvar_params) - .map(|((_, _, _, owns), param)| match owns { - true => param, - false => Param { - name: format!("_{}", param.name), - ..param - }, - }) - .collect(); - let drop_fn = match drops.is_empty() { - true => Expr::undefined(), - false => self.hoist( - parent, - format!("{base}Drop"), - drop_params, - Type::Builtin("void"), - drops, - false, - span, - ), - }; - let mut args = vec![body_fn, drop_fn]; - args.extend(upvars.into_iter().map(|(_, value, _, _)| value)); - Expr::rt("future", args) - } - - /// A module-level function in `parent`'s module, by the name `base` and the suffix of - /// the instance of `parent` it is part of. - #[expect(clippy::too_many_arguments, reason = "a function's parts")] - fn hoist( - &mut self, - parent: rustc_hir::def_id::DefId, - base: String, - params: Vec, - ret: Type, - body: Vec, - generator: bool, - span: Span, - ) -> Expr { - let order = self.t.order(span); - let sym = self.t.program.sym(crate::program::Symbol { - module: self.t.module_of(parent), - base, - suffix: self.t.suffix(Instance::new_raw(parent, self.args)), - owner: None, - kind: SymKind::Function, - order, - instance: String::new(), - name: String::new(), - alias: None, - }); - let loc = self.t.loc(span); - self.t.program.items.push(ts::Item::Function(ts::Function { - sym, - params, - ret, - body, - loc, - doc: None, - generator, - })); - Expr::Sym(sym) - } - - // Calls - - fn call(&mut self, fn_ty: Ty<'tcx>, fun: ExprId, args: &[ExprId], span: Span, out: &mut Vec) -> Expr { - let fn_ty = self.subst(fn_ty); - match *fn_ty.kind() { - ty::FnDef(def_id, gargs) => { - // A function item is a type: evaluating `fun` only runs its effects. - if !self.simple(fun) { - self.stmt(fun, Dest::Discard, out); - } - self.call_def(def_id, gargs.skip_binder(), Args::Thir(args), span, out) - } - ty::FnPtr(..) => { - let ids: Vec = std::iter::once(fun).chain(args.iter().copied()).collect(); - let mut values = self.operands(&ids, out); - let f = values.remove(0); - f.call(values) - } - _ => self.err(span, format!("a call through `{fn_ty}`")), - } - } - /// A call of `def_id` with `gargs`, from wherever it resolves. pub fn call_def( &mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgsRef<'tcx>, - args: Args<'_>, + args: Vec, span: Span, out: &mut Vec, ) -> Expr { @@ -2900,46 +117,20 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { // A tuple struct or variant's constructor, called or passed as a value. if let rustc_hir::def::DefKind::Ctor(..) = tcx.def_kind(def_id) { - return self.ctor(def_id, gargs, args, span, out); - } - - // Calling a closure or function value: `FnOnce::call_once(f, (args,))`. - if let Some(trait_id) = tcx.trait_of_assoc(def_id) - && tcx.is_fn_trait(trait_id) - { - let callee_ty = gargs.type_at(0); - let Args::Thir(ids) = args else { - return self.err(span, "a closure call with lowered arguments"); - }; - let tupled = self.strip(ids[1]); - let ExprKind::Tuple { fields } = &self.thir[tupled].kind else { - return self.err(span, "a closure call whose arguments are not a tuple"); - }; - let fields = fields.clone(); - if let ty::FnDef(inner, inner_args) = *callee_ty.peel_refs().kind() { - return self.call_def(inner, inner_args.skip_binder(), Args::Thir(&fields), span, out); - } - let mut all = vec![ids[0]]; - all.extend(fields.iter()); - let mut values = self.operands(&all, out); - let f = values.remove(0); - return f.call(values); + return self.ctor(def_id, gargs, args, span); } let instance = match Instance::try_resolve(tcx, self.t.typing_env_pub(), def_id, gargs) { Ok(Some(instance)) => instance, // A trait method of a type parameter: each instance resolves it. - Ok(None) if self.t.polymorphic() && gargs.has_param() => { - self.args(args, out); - return Expr::undefined(); - } + Ok(None) if self.t.polymorphic() && gargs.has_param() => return Expr::undefined(), _ => return self.err(span, format!("`{}` does not resolve", tcx.def_path_str(def_id))), }; // An `async` body's `Future::poll`, which its future has itself. if let ty::InstanceKind::Item(did) = instance.def && tcx.is_coroutine(did) { - let mut values = self.args(args, out); + let mut values = args; let future = values.remove(0); return future.member("poll").call(values); } @@ -2947,7 +138,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { && did.is_local() { let sym = self.t.instance(instance); - let values: Vec = self.args(args, out).into_iter().map(Expr::typed).collect(); + let values: Vec = args.into_iter().map(Expr::typed).collect(); let call = Expr::Sym(sym).call(values); // The crate's own `next` returns an item or `rt.DONE`, and its caller an `Option`. if super::iter::is_next(tcx, did) { @@ -2962,30 +153,12 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { args: gargs, span, }; - let ids = match &args { - Args::Thir(ids) => *ids, - Args::Values(_) => &[], - }; match library::call(self, &call, args, out) { Some(e) => e, - None => { - // Refused, but what the arguments refuse is reported too. The mapping may - // have lowered some already: lowering them twice would double the work at - // each level of a nested call. - let unvisited: Vec = ids.iter().copied().filter(|&id| !self.visited(id)).collect(); - self.operands(&unvisited, out); - self.err( - span, - format!("unsupported call to `{}`", tcx.def_path_str_with_args(def_id, gargs)), - ) - } - } - } - - pub fn args(&mut self, args: Args<'_>, out: &mut Vec) -> Vec { - match args { - Args::Thir(ids) => self.operands(ids, out), - Args::Values(values) => values, + None => self.err( + span, + format!("unsupported call to `{}`", tcx.def_path_str_with_args(def_id, gargs)), + ), } } @@ -2993,12 +166,11 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { &mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgsRef<'tcx>, - args: Args<'_>, + args: Vec, span: Span, - out: &mut Vec, ) -> Expr { let tcx = self.t.tcx; - let values = self.args(args, out); + let values = args; let parent = tcx.parent(def_id); let (adt_id, variant) = match tcx.def_kind(parent) { rustc_hir::def::DefKind::Variant => ( @@ -3066,7 +238,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { return Expr::Sym(self.t.instance(instance)); } let mut body = Vec::new(); - let call = self.call_def(def_id, gargs, Args::Values(values), span, &mut body); + let call = self.call_def(def_id, gargs, values, span, &mut body); body.push(StmtKind::Return(Some(call.typed())).at(None)); let params = names .into_iter() @@ -3079,152 +251,6 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { let ret = self.t.ret_ty(sig.output(), span); Expr::Arrow(params, ret, body) } - - /// The integer a literal operand has, folding constant arithmetic. - pub fn const_int(&self, id: ExprId) -> Option { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } => self.const_int(*value), - ExprKind::Literal { lit, neg } => match lit.node { - rustc_ast::LitKind::Int(n, _) => { - let n = n.get() as i128; - Some(if *neg { -n } else { n }) - } - _ => None, - }, - ExprKind::NonHirLiteral { lit, .. } => { - let ty = self.ty_of(id); - let int = super::num::Int::of(ty)?; - let size = rustc_abi::Size::from_bits(int.bits); - Some(match int.signed { - true => lit.to_int(size), - false => lit.to_uint(size) as i128, - }) - } - ExprKind::Binary { op, lhs, rhs } => { - let ty = self.ty_of(id); - let int = super::num::Int::of(ty)?; - super::num::fold(*op, self.const_int(*lhs)?, self.const_int(*rhs)?, int) - } - _ => None, - } - } -} - -/// A range of `ty` as a `for` loop iterates it: counting in a number, or as the runtime's -/// range of a wide integer, which steps past 2^53 into limbs. -fn range_of(ty: Ty<'_>, start: Expr, end: Expr, inclusive: bool) -> Iterable { - let ty::Adt(_, args) = ty.kind() else { - unreachable!("a range is a struct") - }; - match super::num::Int::of(args.type_at(0)) { - Some(int) if int.big() => { - let class = if inclusive { "RangeInclusive" } else { "Range" }; - Iterable::Of(Expr::New( - Box::new(Expr::Rt(class.into())), - vec![start, end, int.func("step")], - )) - } - _ => Iterable::Range { start, end, inclusive }, - } -} - -enum Iterable { - Range { - start: Expr, - end: Expr, - inclusive: bool, - }, - /// A JS array or `Uint8Array`, which `for ... of` iterates. - Of(Expr), - /// An iterator, by its `next`: an item or `rt.DONE`. - Next(Expr), -} - -/// The variables `thir` reads, those its closures capture included. -fn reads<'tcx>(tcx: ty::TyCtxt<'tcx>, thir: &Thir<'tcx>) -> FxHashSet { - let mut read = FxHashSet::default(); - for expr in thir.exprs.iter() { - match &expr.kind { - ExprKind::VarRef { id } => { - read.insert(id.0); - } - ExprKind::UpvarRef { var_hir_id, .. } => { - read.insert(var_hir_id.0); - } - ExprKind::Closure(closure) => { - read.extend( - tcx.closure_captures(closure.closure_id) - .iter() - .map(|capture| capture.get_root_variable()), - ); - } - _ => {} - } - } - read -} - -/// Whether `ty` is a closure or function pointer that never returns, whose binding `tsc` -/// sees a call to diverge only through a declared type. -fn diverges_when_called(ty: Ty<'_>) -> bool { - let output = match ty.peel_refs().kind() { - ty::Closure(_, args) => args.as_closure().sig().output(), - ty::FnPtr(sig, header) => sig.with(*header).output(), - _ => return false, - }; - output.skip_binder().is_never() -} - -/// Whether a declaration's initializer is one TypeScript can't type on its own. -fn needs_annotation(value: &Expr) -> bool { - match value { - Expr::Array(items) => items.is_empty(), - Expr::Lit(text) => text == "undefined", - Expr::Arrow(..) => false, - Expr::Located(_, e) => needs_annotation(e), - _ => false, - } -} - -/// Whether matching `pat` moves its whole value into a binding, or matches only a variant -/// with nothing in it: either way nothing is left to drop. -fn takes_all(pat: &Pat<'_>) -> bool { - match &pat.kind { - PatKind::Binding { - mode, subpattern: None, .. - } => mode.0 == rustc_hir::ByRef::No, - // `Some(..)` names no field, which then stays in the temporary. - PatKind::Variant { - adt_def, - variant_index, - subpatterns, - .. - } => { - subpatterns.len() == adt_def.variant(*variant_index).fields.len() - && subpatterns.iter().all(|f| takes_all(&f.pattern)) - } - _ => false, - } -} - -pub fn has_bindings(pat: &Pat<'_>) -> bool { - bindings(pat) > 0 -} - -/// How many bindings `pat` makes, each reading the scrutinee once. -fn bindings(pat: &Pat<'_>) -> usize { - let mut count = 0; - pat.walk_always(|p| { - if let PatKind::Binding { .. } = p.kind { - count += 1; - } - }); - count -} - -fn kind_name(kind: &ExprKind<'_>) -> String { - let debug = format!("{kind:?}"); - debug.split([' ', '(', '{']).next().unwrap_or("?").to_string() } /// A field's value as a class's constructor takes it: without an outer `as` where the diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index a7c2ddcc9..d0d51c628 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -1,9 +1,7 @@ -//! Literals and constants. A named constant is evaluated by rustc and written as its -//! value at each use, as Rust inlines it. +//! Constants: rustc evaluates each, and its value is written at each use, as Rust +//! inlines it. -use rustc_middle::mir::interpret::GlobalId; -use rustc_middle::thir::{ExprId, ExprKind}; -use rustc_middle::ty::{self, Instance, Ty, ValTree}; +use rustc_middle::ty::{self, Ty, ValTree}; use rustc_span::Span; use super::AdtRepr; @@ -13,121 +11,6 @@ use super::num::Int; use crate::ts::{Expr, Key}; impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// A literal or constant expression. - pub fn constant(&mut self, id: ExprId) -> Expr { - let tcx = self.t.tcx; - let e = &self.thir[id]; - let span = e.span; - let ty = self.ty_of(id); - match &e.kind { - ExprKind::Literal { lit, neg } => match lit.node { - rustc_ast::LitKind::Int(n, _) => { - let Some(int) = Int::of(ty) else { - return self.err(span, format!("an integer literal of type `{ty}`")); - }; - let value = n.get() as i128; - let value = if *neg { -value } else { value }; - match self.literal_text(span, *neg) { - Some(text) => int.spelled(text, value), - None => int.lit(value), - } - } - rustc_ast::LitKind::Bool(b) => Expr::lit(b.to_string()), - rustc_ast::LitKind::Str(s, _) => Expr::Str(s.to_string()), - rustc_ast::LitKind::Byte(b) => Expr::lit(b.to_string()), - rustc_ast::LitKind::ByteStr(ref bytes, _) => { - let items = bytes.as_byte_str().iter().map(|b| Expr::lit(b.to_string())).collect(); - Expr::ident("Uint8Array").member("of").call(items) - } - _ => self.err(span, format!("unsupported literal of type `{ty}`")), - }, - ExprKind::NonHirLiteral { lit, .. } => match (ty.kind(), Int::of(ty)) { - (ty::Bool, _) => Expr::lit((lit.to_bits_unchecked() != 0).to_string()), - (_, Some(int)) => { - let size = rustc_abi::Size::from_bits(int.bits); - let value = match int.signed { - true => lit.to_int(size), - false => lit.to_uint(size) as i128, - }; - int.lit(value) - } - _ => self.err(span, format!("a literal of type `{ty}`")), - }, - ExprKind::ZstLiteral { .. } => match *ty.kind() { - ty::FnDef(def_id, args) => self.fn_value(def_id, args.skip_binder(), span), - ty::Tuple(tys) if tys.is_empty() => Expr::undefined(), - ty::Adt(adt, _) if adt.is_struct() && adt.did().is_local() => { - let info = self.t.adt(adt, span); - self.t.construct(info.sym, &crate::ts::Ctor::Unit, &[], Vec::new()) - } - _ => self.err(span, format!("a value of type `{ty}`")), - }, - ExprKind::NamedConst { def_id, args, .. } => { - let args = self.subst(*args); - let env = self.t.typing_env_pub(); - let instance = match Instance::try_resolve(tcx, env, *def_id, args) { - Ok(Some(instance)) => instance, - _ => return self.err(span, "a constant that does not resolve"), - }; - let cid = GlobalId { - instance, - promoted: None, - }; - match tcx.const_eval_global_id_for_typeck(env, cid, span) { - Ok(Ok(valtree)) => self.value(ty, valtree, span), - Ok(Err(_)) => self.err(span, format!("a constant of type `{ty}`, which has no value tree")), - Err(_) => self.err(span, "a constant that failed to evaluate"), - } - } - ExprKind::ConstParam { .. } | ExprKind::ConstBlock { .. } => { - self.err(span, "const generics and const blocks in expressions are not supported") - } - _ => unreachable!(), - } - } - - /// A literal as the source spells it, when that is also valid JS. - fn literal_text(&self, span: Span, neg: bool) -> Option { - if span.from_expansion() { - return None; - } - let text = self.t.tcx.sess.source_map().span_to_snippet(span).ok()?; - let text = text.trim_start_matches('-').trim(); - let (prefix, digits) = match text.get(..2) { - Some("0x" | "0o" | "0b") => text.split_at(2), - _ => ("", text), - }; - let radix = match prefix { - "0x" => 16, - "0o" => 8, - "0b" => 2, - _ => 10, - }; - // Drop a type suffix, which hex digits can't be confused with. - let end = digits - .find(|c: char| c != '_' && !c.is_digit(radix)) - .unwrap_or(digits.len()); - let digits = &digits[..end]; - // JS allows `_` only between two digits. - let chars: Vec = digits.chars().collect(); - let mut cleaned = String::new(); - for (i, &c) in chars.iter().enumerate() { - if c == '_' { - let between = i > 0 && chars[i - 1] != '_' && chars.get(i + 1).is_some_and(|n| *n != '_'); - if !between { - continue; - } - } - cleaned.push(c); - } - let cleaned = cleaned.trim_matches('_'); - if cleaned.is_empty() || cleaned.contains("__") { - return None; - } - let sign = if neg { "-" } else { "" }; - Some(format!("{sign}{prefix}{cleaned}")) - } - /// A constant's value tree as a JS value of type `ty`. pub fn value(&mut self, ty: Ty<'tcx>, valtree: ValTree<'tcx>, span: Span) -> Expr { let tcx = self.t.tcx; diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index 3245196dc..8c30b3d17 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -2,25 +2,17 @@ //! //! A type drops if dropping it does something JS can see: runs a `Drop` impl, counts an //! `Arc` down, or drops a waker. Such a value has `[Symbol.dispose]`, which a class gets -//! as drop glue: its `Drop` impl, then each field in order. A variable drops at the end -//! of its scope through a `finally`, so an early exit, a panic, or a cancelled future -//! drops it too. A move leaves `undefined` in the place it left, which drops as nothing, -//! so a variable moved on only some paths still drops on the others. +//! as drop glue: its `Drop` impl, then each field in order. Where each value drops is +//! MIR's: drop elaboration put a terminator at each drop, with a flag wherever a value is +//! moved on some paths only. use rustc_middle::ty::{self, AdtDef, Instance, Ty, TypeVisitableExt}; use rustc_span::Span; -use super::body::Body; use super::library::Std; use super::{Adt, AdtRepr, Translator}; use crate::program::{SymKind, Symbol}; -use crate::ts::{self, Expr, Stmt, StmtKind, Target, Type}; - -/// A variable its scope drops when it ends. -pub struct Owned<'tcx> { - pub name: String, - pub ty: Ty<'tcx>, -} +use crate::ts::{self, Expr, Stmt, StmtKind, Type}; impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether dropping a `ty` does something JS can see. @@ -145,11 +137,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Coroutine(..) | ty::Param(_) => true, _ => false, }; - // A MIR lowering drops an enum or tuple by the glue rustc builds for it. - if !supported - && self.mir - && let Some(sym) = super::mir::glue::shim(self, ty, span) - { + // An enum or tuple drops by the glue rustc builds for it. + if !supported && let Some(sym) = super::mir::glue::shim(self, ty, span) { return Some(super::mir::glue::call(sym, value)); } if !supported { @@ -228,123 +217,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { body, loc: None, doc: None, - generator: false, }); } } - -impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// Start a scope: the variables bound until it closes drop when it does. - pub fn open_scope(&mut self) { - self.scopes.push(Vec::new()); - } - - /// Drop `name`, a `ty`, when the innermost scope closes, if JS would see it drop. - pub fn own(&mut self, name: &str, ty: Ty<'tcx>) { - if !self.t.drops(ty) { - return; - } - if let Some(scope) = self.scopes.last_mut() { - scope.push(Owned { - name: name.to_string(), - ty, - }); - } - } - - /// Stop dropping `name` here: it moved somewhere that drops it itself. - pub fn disown(&mut self, name: &str) { - for scope in &mut self.scopes { - scope.retain(|owned| owned.name != name); - } - } - - /// Whether the innermost scope drops anything yet. - pub fn scope_owns(&self) -> bool { - self.scopes.last().is_some_and(|scope| !scope.is_empty()) - } - - /// Close the innermost scope, whose statements are `out[start..]`: each variable it - /// drops is dropped in a `finally` around the statements after its declaration, the - /// last declared innermost, or around them all for a parameter. - pub fn close_scope(&mut self, out: &mut Vec, start: usize, span: Span) { - let owned = self.scopes.pop().unwrap_or_default(); - for owned in owned.into_iter().rev() { - let Some(dropped) = self.t.drop_value(Expr::ident(&owned.name), owned.ty, span) else { - continue; - }; - let moved = self.moved.contains(&owned.name); - let mut at = start; - for (i, stmt) in out.iter_mut().enumerate().skip(start) { - if let StmtKind::Decl { - mutable, target, init, .. - } = &mut stmt.kind - && declares(target, &owned.name) - { - *mutable |= moved; - // The `finally` may run before anything assigns it. - init.get_or_insert_with(|| Expr::lit("undefined!")); - at = i + 1; - break; - } - } - // What the declaration moved from is cleared before anything can throw. - while out.get(at).is_some_and(clears) { - at += 1; - } - let body = out.split_off(at); - let dropped = StmtKind::Expr(dropped).at(None); - match body.is_empty() { - true => out.push(dropped), - false => out.push( - StmtKind::Try { - body, - finally: vec![dropped], - } - .at(None), - ), - } - } - } - - /// The value of the place `place`, a `ty` that drops, moved out: the place is left - /// `undefined`, so whatever drops it later drops nothing. - pub fn move_out(&mut self, place: Expr, span: Span, out: &mut Vec) -> Expr { - let base = match &place { - Expr::Ident(name) => name.clone(), - _ => "moved".into(), - }; - match &place { - Expr::Ident(name) => { - self.moved.insert(name.clone()); - } - Expr::Member(..) if place.is_path() => {} - _ => return self.err(span, "a move out of a place that is no variable or field"), - } - let name = self.fresh(&base); - out.push(StmtKind::decl(false, name.clone(), None, Some(place.clone())).at(None)); - self.clear(place, out); - Expr::ident(name) - } - - /// Leave `undefined` in `place`, whose value moved. - pub fn clear(&mut self, place: Expr, out: &mut Vec) { - if let Expr::Ident(name) = &place { - self.moved.insert(name.clone()); - } - out.push(StmtKind::Expr(place.assign(Expr::lit("undefined!"))).at(None)); - } -} - -/// Whether `stmt` leaves a moved-out place `undefined`. -fn clears(stmt: &Stmt) -> bool { - matches!(&stmt.kind, StmtKind::Expr(Expr::Assign(_, value)) if matches!(&**value, Expr::Lit(text) if text == "undefined!")) -} - -/// Whether `target` declares `name`. -fn declares(target: &Target, name: &str) -> bool { - match target { - Target::Name(n) => n == name, - Target::Array(items) => items.iter().flatten().any(|t| declares(t, name)), - } -} diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 693ac4229..065fadbed 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -6,12 +6,11 @@ //! call goes to the impl of the value's type directly, as monomorphization allows. use rustc_hir::def_id::DefId; -use rustc_middle::thir::{ExprId, ExprKind, StmtKind}; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span; use super::body::Body; -use super::library::{self, Args, Std}; +use super::library::{self, Std}; use super::num::Int; use crate::ts::{Expr, Key, Param, Stmt, Type}; @@ -66,8 +65,25 @@ impl Trait { } } -const UNEXPECTED: &str = "an unexpected `format_args!` lowering"; -pub const FROM_ARGUMENT: &str = "a width or precision from an argument, as in `{:1$}`,"; +/// The trait a `format_args!` argument's constructor, `Argument::new_display` and the +/// like, writes its value by, or the construct outside the subset that it is. +pub fn argument(name: &str) -> Result { + match name { + "new_display" => Ok(Trait::Display), + "new_debug" => Ok(Trait::Debug), + "new_lower_hex" => Ok(Trait::LowerHex), + "new_upper_hex" => Ok(Trait::UpperHex), + "from_usize" => Err(FROM_ARGUMENT), + "new_octal" => Err("`Octal` formatting, as in `{:o}`,"), + "new_binary" => Err("`Binary` formatting, as in `{:b}`,"), + "new_lower_exp" => Err("`LowerExp` formatting, as in `{:e}`,"), + "new_upper_exp" => Err("`UpperExp` formatting, as in `{:E}`,"), + "new_pointer" => Err("`Pointer` formatting, as in `{:p}`,"), + _ => Err("an unexpected `format_args!` lowering"), + } +} + +const FROM_ARGUMENT: &str = "a width or precision from an argument, as in `{:1$}`,"; /// A formatter's type, for the parameters of the functions written here. fn formatter() -> Type { @@ -75,26 +91,6 @@ fn formatter() -> Type { } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// Whether `id` is what `format_args!` lowers to: `Arguments::from_str(s)`, or a block - /// of two `super let`s ending in `unsafe { Arguments::new(template, &args) }`. - pub fn is_format_args(&self, id: ExprId) -> bool { - let calls = |id: ExprId, names: &[&str]| match &self.thir[self.strip(id)].kind { - ExprKind::Call { ty, .. } => self - .callee(*ty) - .is_some_and(|(owner, name)| owner == "Arguments" && names.contains(&name.as_str())), - _ => false, - }; - let tail = |id: ExprId| match &self.thir[self.strip(id)].kind { - ExprKind::Block { block } => self.thir[*block].expr, - _ => None, - }; - let block = match &self.thir[self.strip(id)].kind { - ExprKind::Block { block } => &self.thir[*block], - _ => return calls(id, &["from_str", "from_str_nonconst"]), - }; - block.stmts.len() == 2 && block.expr.and_then(tail).is_some_and(|call| calls(call, &["new"])) - } - /// The formatting trait of a `&dyn Debug` or the like. pub fn fmt_object(&self, ty: Ty<'tcx>) -> Option { let ty::Ref(_, inner, rustc_ast::Mutability::Not) = ty.kind() else { @@ -112,142 +108,6 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { .is_some_and(|pointee| matches!(pointee.kind(), ty::Dynamic(..))) } - /// The `owner::name` key of a call's callee in std. - fn callee(&self, fn_ty: Ty<'tcx>) -> Option<(String, String)> { - match *self.subst(fn_ty).kind() { - ty::FnDef(def_id, _) => library::key(self.t.tcx, def_id), - _ => None, - } - } - - /// A `fmt::Arguments`, from what `format_args!` lowers to: an array of literal pieces - /// and functions writing each placeholder's value. - pub fn format_args(&mut self, id: ExprId, out: &mut Vec) -> Expr { - let span = self.span(id); - match self.arguments(id, out) { - Ok(parts) => Expr::Array(parts), - Err(msg) if msg == UNEXPECTED => self.err(span, msg), - Err(msg) => self.err(span, format!("{msg} is not supported")), - } - } - - /// The parts of a `format_args!`, or the construct that is outside the subset. - fn arguments(&mut self, id: ExprId, out: &mut Vec) -> Result, String> { - let id = self.strip(id); - let thir = self.thir; - let block = match &thir[id].kind { - // A template without placeholders. - ExprKind::Call { args, .. } if args.len() == 1 => return Ok(vec![self.operand(args[0], out)]), - ExprKind::Block { block } => &thir[*block], - _ => return Err(UNEXPECTED.into()), - }; - // `super let args = (&a, &b); super let args = [Argument::new_display(args.0), ..];` - let [values, arguments] = block.stmts[..] else { - return Err(UNEXPECTED.into()); - }; - let binding = |stmt: rustc_middle::thir::StmtId| match &thir[stmt].kind { - StmtKind::Let { - pattern, - initializer: Some(init), - .. - } => match pattern.kind { - rustc_middle::thir::PatKind::Binding { var, .. } => Some((var, *init)), - _ => None, - }, - _ => None, - }; - let ((values_var, values), (_, arguments)) = binding(values).zip(binding(arguments)).ok_or(UNEXPECTED)?; - let ExprKind::Tuple { fields } = &thir[self.strip(values)].kind else { - return Err(UNEXPECTED.into()); - }; - // Each value is evaluated once, in order, before anything is written. - let mut values = self.operands(fields, out); - for value in &mut values { - if !value.is_path() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "arg", out); - } - } - let ExprKind::Array { fields: arguments } = &thir[self.strip(arguments)].kind else { - return Err(UNEXPECTED.into()); - }; - let mut placeholders = Vec::new(); - for &argument in arguments.iter() { - let ExprKind::Call { ty, args, .. } = &thir[self.strip(argument)].kind else { - return Err(UNEXPECTED.into()); - }; - let ty::FnDef(def_id, gargs) = *self.subst(*ty).kind() else { - return Err(UNEXPECTED.into()); - }; - let tr = match self.t.tcx.item_name(def_id).as_str() { - "new_display" => Trait::Display, - "new_debug" => Trait::Debug, - "new_lower_hex" => Trait::LowerHex, - "new_upper_hex" => Trait::UpperHex, - "from_usize" => return Err(FROM_ARGUMENT.into()), - "new_octal" => return Err("`Octal` formatting, as in `{:o}`,".into()), - "new_binary" => return Err("`Binary` formatting, as in `{:b}`,".into()), - "new_lower_exp" => return Err("`LowerExp` formatting, as in `{:e}`,".into()), - "new_upper_exp" => return Err("`UpperExp` formatting, as in `{:E}`,".into()), - "new_pointer" => return Err("`Pointer` formatting, as in `{:p}`,".into()), - _ => return Err(UNEXPECTED.into()), - }; - let field = self.tuple_field(args[0], values_var).ok_or(UNEXPECTED)?; - let ty = self.subst(gargs.skip_binder().types().next().ok_or(UNEXPECTED)?); - placeholders.push((tr, field, ty)); - } - // `unsafe { Arguments::new(template, &args) }` - let call = match &thir[self.strip(block.expr.ok_or(UNEXPECTED)?)].kind { - ExprKind::Block { block } => thir[*block].expr.ok_or(UNEXPECTED)?, - _ => return Err(UNEXPECTED.into()), - }; - let ExprKind::Call { args, .. } = &thir[self.strip(call)].kind else { - return Err(UNEXPECTED.into()); - }; - let template = self.byte_str(args[0]).ok_or(UNEXPECTED)?; - let span = self.span(id); - let mut parts = Vec::new(); - for piece in decode(&template)? { - match piece { - Piece::Lit(s) => parts.push(Expr::Str(s)), - Piece::Arg { index, spec } => { - let &(tr, field, ty) = placeholders.get(index).ok_or(UNEXPECTED)?; - let value = values.get(field).ok_or(UNEXPECTED)?.clone(); - let value = self.fmt_value(tr, ty, value, span, out); - parts.push(match spec.object() { - Some(spec) => Expr::rt("fmtSpec", vec![spec, value]), - None => value, - }); - } - } - } - Ok(parts) - } - - /// The index of `args.N`, a field of the tuple `var`, behind borrows and derefs. - fn tuple_field(&self, id: ExprId, var: rustc_middle::thir::LocalVarId) -> Option { - match &self.thir[self.strip(id)].kind { - ExprKind::Borrow { arg, .. } | ExprKind::Deref { arg } => self.tuple_field(*arg, var), - ExprKind::Field { lhs, name, .. } => match self.thir[self.strip(*lhs)].kind { - ExprKind::VarRef { id } if id == var => Some(name.index()), - _ => None, - }, - _ => None, - } - } - - /// The bytes of a byte string literal, behind borrows and derefs. - fn byte_str(&self, id: ExprId) -> Option> { - match &self.thir[self.strip(id)].kind { - ExprKind::Borrow { arg, .. } | ExprKind::Deref { arg } => self.byte_str(*arg), - ExprKind::Literal { lit, .. } => match &lit.node { - rustc_ast::LitKind::ByteStr(bytes, _) => Some(bytes.as_byte_str().to_vec()), - _ => None, - }, - _ => None, - } - } - /// `value`, a `ty`, written by `tr` to `f`, through the impl for `ty`. pub fn fmt_call(&mut self, tr: Trait, ty: Ty<'tcx>, value: Expr, f: Expr, span: Span) -> Expr { let tcx = self.t.tcx; @@ -256,7 +116,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { }; let args = tcx.mk_args(&[ty.into()]); let mut pre = Vec::new(); - let call = self.call_def(method, args, Args::Values(vec![value, f]), span, &mut pre); + let call = self.call_def(method, args, vec![value, f], span, &mut pre); match pre.is_empty() { true => call, false => self.err(span, format!("`{}` of `{ty}` needs statements", tr.name())), diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 0914334f0..4ac4aa8f4 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -10,9 +10,9 @@ use rustc_span::Span; use super::Translator; use super::body::Body; -use super::library::{self, Args, Call, Std}; +use super::library::{self, Call, Std}; use super::num::Int; -use crate::ts::{Expr, Param, Stmt, Type}; +use crate::ts::{Expr, Param, Type}; /// `Iterator::next`, and the trait's `Item`. fn trait_items(tcx: ty::TyCtxt<'_>) -> Option<(DefId, DefId)> { @@ -185,8 +185,7 @@ pub fn call<'tcx>( call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'_>, - out: &mut Vec, + mut args: Vec, ) -> Option { let tcx = b.t.tcx; let span = call.span; @@ -198,14 +197,14 @@ pub fn call<'tcx>( // Where iterators come from. match (owner, name) { ("slice", "iter" | "iter_mut") => { - return Some(Expr::rt("iterSlice", b.args(args, out))); + return Some(Expr::rt("iterSlice", args)); } ("Option", "iter" | "iter_mut") => { option_ok(b, targ(0)?, span); - return Some(Expr::rt("iterOption", b.args(args, out))); + return Some(Expr::rt("iterOption", args)); } ("IntoIterator", "into_iter") => { - let value = b.args(args, out).pop()?; + let value = args.pop()?; return into_iter(b, targ(0)?, value, span); } _ => {} @@ -213,10 +212,10 @@ pub fn call<'tcx>( match path.as_slice() { ["iter", "sources", "once", "once"] => { no_drops(b, targ(0)?, span); - return Some(Expr::rt("iterOnce", b.args(args, out))); + return Some(Expr::rt("iterOnce", args)); } ["iter", "sources", "empty", "empty"] => return Some(Expr::rt("iterEmpty", Vec::new())), - ["iter", "sources", "from_fn", "from_fn"] => return Some(Expr::rt("iterFromFn", b.args(args, out))), + ["iter", "sources", "from_fn", "from_fn"] => return Some(Expr::rt("iterFromFn", args)), _ => {} } @@ -229,7 +228,7 @@ pub fn call<'tcx>( if Std::of(tcx, adt.did()) != Some(Std::Vec) { return None; } - let [v, items] = <[Expr; 2]>::try_from(b.args(args, out)).ok()?; + let [v, items] = <[Expr; 2]>::try_from(args).ok()?; let mut items = into_iter(b, source, items, span)?; // `Extend<&T>` copies each element. if item != vec_args.type_at(0) && b.needs_copy(vec_args.type_at(0)) { @@ -256,7 +255,7 @@ pub fn call<'tcx>( if name != "by_ref" && !(name == "next" && own_next(b, self_ty).is_some()) { no_drops(b, item, span); } - let mut values = b.args(args, out).into_iter(); + let mut values = args.into_iter(); let recv = values.next()?; let rest: Vec = values.collect(); diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index fe8ca1794..c98f7b7f5 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -6,11 +6,10 @@ //! function by its module (`mem::take`). use rustc_hir::def_id::DefId; -use rustc_middle::thir::{ExprId, ExprKind}; use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TyCtxt}; use rustc_span::Span; -use super::body::{Body, Dest}; +use super::body::Body; use super::fmt; use super::num::{self, Int, Operand}; use crate::ts::{Expr, Stmt, StmtKind}; @@ -210,12 +209,6 @@ pub fn inherent_std(tcx: TyCtxt<'_>, def_id: DefId) -> Option { } } -/// A call's arguments: still THIR, or already lowered. -pub enum Args<'x> { - Thir(&'x [ExprId]), - Values(Vec), -} - pub struct Call<'tcx> { /// The function as written, before resolving a trait method to its impl. pub def_id: DefId, @@ -289,7 +282,7 @@ pub fn key(tcx: TyCtxt<'_>, def_id: DefId) -> Option<(String, String)> { Some((owner, name)) } -pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, out: &mut Vec) -> Option { +pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec, out: &mut Vec) -> Option { let tcx = b.t.tcx; // thiserror's `Display` derive reads each field through `AsDisplay`, which is the // field itself for anything but a path. @@ -297,7 +290,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, && tcx.item_name(call.def_id).as_str() == "as_display" && matches!(targ(call.args, 0).kind(), ty::Ref(..)) { - return b.args(args, out).pop(); + return args.into_iter().next_back(); } if !is_std(tcx, call.def_id) { return None; @@ -305,7 +298,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, let (owner, name) = key(tcx, call.def_id)?; let span = call.span; let gargs = call.args; - let args = match super::task::call(b, call, &owner, &name, args, out) { + let mut args = match super::task::call(b, call, &owner, &name, args) { Ok(e) => return e, Err(args) => args, }; @@ -330,21 +323,10 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "wrapping_sub" => "wrappingSub", _ => return None, }; - if let ("from_be_bytes", Args::Thir([bytes])) = (name.as_str(), &args) { - return Some(from_be_bytes(b, int, *bytes, out)); - } - let values = b.args(args, out); - return Some(int.method(method, values)); + return Some(int.method(method, args)); } let self_ty = || gargs.types().next(); - let elem = |t: Ty<'tcx>| -> Option> { - match t.peel_refs().kind() { - ty::Slice(e) | ty::Array(e, _) => Some(*e), - ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) => Some(args.type_at(0)), - _ => None, - } - }; let is_u8 = |t: Ty<'tcx>| matches!(t.kind(), ty::Uint(ty::UintTy::U8)); let range = matches!(inherent_std(tcx, call.def_id), Some(Std::Range | Std::RangeInclusive)); // A range of integers, whose comparisons and clones JS makes as Rust does. @@ -360,7 +342,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, // Conversions. ("From", "from") => { let (to, from) = (targ(gargs, 0), targ(gargs, 1)); - let mut values = b.args(args, out); + let mut values = args; let value = values.pop()?; if to == from { return Some(value); @@ -378,7 +360,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } ("Into", "into") => { let (from, to) = (targ(gargs, 0), targ(gargs, 1)); - let mut values = b.args(args, out); + let mut values = args; let value = values.pop()?; b.convert(value, from, to, span, out) } @@ -387,7 +369,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, let (Some(int), Some(_)) = (Int::of(to), Int::of(from)) else { return None; }; - let values = b.args(args, out); + let values = args; int.method("tryFrom", values) } @@ -408,23 +390,12 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, _ => rustc_middle::mir::BinOp::Shr, }; let (lty, rty) = (targ(gargs, 0), targ(gargs, 1)); - let consts = match &args { - Args::Thir(ids) => (b.const_int(ids[0]), b.const_int(ids[1])), - Args::Values(_) => (None, None), - }; - let values = b.args(args, out); - let [l, r] = <[Expr; 2]>::try_from(values).ok()?; + let [l, r] = <[Expr; 2]>::try_from(args).ok()?; num::binary( b, op, - Operand { - expr: l, - value: consts.0, - }, - Operand { - expr: r, - value: consts.1, - }, + Operand { expr: l, value: None }, + Operand { expr: r, value: None }, lty, rty, span, @@ -441,7 +412,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "gt" => ">", _ => ">=", }; - let values = b.args(args, out); + let values = args; let [l, r] = <[Expr; 2]>::try_from(values).ok()?; match Int::of(targ(gargs, 0).peel_refs()) { Some(int) => int.compare(js, l, r), @@ -449,7 +420,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } } ("Ord", "max" | "min") if let Some(int) = Int::of(targ(gargs, 0)) => { - let values = b.args(args, out); + let values = args; match int.big() { true => int.method(name.as_str(), values), false => Expr::rt(if name == "max" { "max" } else { "min" }, values), @@ -457,7 +428,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } ("Clone", "clone") => { let ty = targ(gargs, 0); - let values = b.args(args, out); + let values = args; let value = values.into_iter().next()?; match ty.kind() { ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) && is_u8(args.type_at(0)) => { @@ -474,37 +445,30 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, ("Default", "default") => default_value(b, targ(gargs, 0))?, // Options. - ("Option", "map") => rt2(b, args, out, "option", "map"), - ("Option", "map_or") => rt2(b, args, out, "option", "mapOr"), - ("Option", "unwrap_or") => rt2(b, args, out, "option", "unwrapOr"), - ("Option", "ok_or") => rt2(b, args, out, "option", "okOr"), - ("Option", "unwrap") => rt2(b, args, out, "option", "unwrap"), - ("Option", "expect") => rt2(b, args, out, "option", "expect"), - ("Option", "is_some") => b.args(args, out).pop()?.binary("!==", Expr::undefined()), - ("Option", "is_none") => b.args(args, out).pop()?.binary("===", Expr::undefined()), - ("Option", "as_ref" | "as_mut") => b.args(args, out).pop()?, + ("Option", "map") => rt2(args, "option", "map"), + ("Option", "map_or") => rt2(args, "option", "mapOr"), + ("Option", "unwrap_or") => rt2(args, "option", "unwrapOr"), + ("Option", "ok_or") => rt2(args, "option", "okOr"), + ("Option", "unwrap") => rt2(args, "option", "unwrap"), + ("Option", "expect") => rt2(args, "option", "expect"), + ("Option", "is_some") => args.pop()?.binary("!==", Expr::undefined()), + ("Option", "is_none") => args.pop()?.binary("===", Expr::undefined()), + ("Option", "as_ref" | "as_mut") => args.pop()?, ("Option", "copied" | "cloned") => { let inner = targ(gargs, 0); - let value = b.args(args, out).pop()?; + let value = args.pop()?; b.copied(value, inner) } - ("Option", "take") => { - let Args::Thir(ids) = args else { - return None; - }; - let place = borrowed_place(b, ids[0], out)?; - swap_out(b, place, Expr::undefined(), "taken", out) - } // Results. - ("Result", "map") => rt2(b, args, out, "result", "map"), - ("Result", "map_err") => rt2(b, args, out, "result", "mapErr"), - ("Result", "and_then") => rt2(b, args, out, "result", "andThen"), - ("Result", "inspect_err") => rt2(b, args, out, "result", "inspectErr"), - ("Result", "is_ok") => b.args(args, out).pop()?.member("ok"), - ("Result", "is_err") => b.args(args, out).pop()?.member("ok").not(), - ("Result", "ok") => rt2(b, args, out, "result", "ok"), - ("Result", "err") => rt2(b, args, out, "result", "err"), + ("Result", "map") => rt2(args, "result", "map"), + ("Result", "map_err") => rt2(args, "result", "mapErr"), + ("Result", "and_then") => rt2(args, "result", "andThen"), + ("Result", "inspect_err") => rt2(args, "result", "inspectErr"), + ("Result", "is_ok") => args.pop()?.member("ok"), + ("Result", "is_err") => args.pop()?.member("ok").not(), + ("Result", "ok") => rt2(args, "result", "ok"), + ("Result", "err") => rt2(args, "result", "err"), // Their panics show the other side with its `Debug`. ("Result", "unwrap" | "expect" | "unwrap_err") => { let (method, shown) = match name.as_str() { @@ -512,16 +476,16 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "expect" => ("expect", targ(gargs, 1)), _ => ("unwrapErr", targ(gargs, 0)), }; - let mut values = b.args(args, out); + let mut values = args; values.push(b.fmt_fn(fmt::Trait::Debug, shown, span)); Expr::rt_of("result", method).call(values) } - ("Result", "unwrap_or") => rt2(b, args, out, "result", "unwrapOr"), + ("Result", "unwrap_or") => rt2(args, "result", "unwrapOr"), // Ranges, which are their own iterators. // An integer range wraps within its type's bounds where std's `nth` does. ("RangeInclusive", "new") if range => { - let mut values = b.args(args, out); + let mut values = args; values.extend(self_ty().and_then(Int::of).map(|int| int.func("step"))); Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) } @@ -530,53 +494,32 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, if range && (matches!(name.as_str(), "start" | "end") || self_ty().and_then(Int::of).is_some()) => { let of = range_of(inherent_std(tcx, call.def_id)?)?; - Expr::rt_of(of, &super::camel(&name)).call(b.args(args, out)) + Expr::rt_of(of, &super::camel(&name)).call(args) } ("bool", "then_some") => { - let values = b.args(args, out); + let values = args; Expr::rt("thenSome", values) } // Slices. - ("slice", "len") => b.args(args, out).pop()?.member("length"), - ("slice", "is_empty") => b.args(args, out).pop()?.member("length").binary("===", Expr::lit("0")), - ("slice", "split_first") => rt2(b, args, out, "slice", "splitFirst"), - ("slice", "split_at") => rt2(b, args, out, "slice", "splitAt"), - ("slice", "split_at_checked") => rt2(b, args, out, "slice", "splitAtChecked"), - ("slice", "first") => rt2(b, args, out, "slice", "first"), - ("slice", "get") if Int::of(targ(gargs, 1)).is_some() => rt2(b, args, out, "slice", "get"), + ("slice", "len") => args.pop()?.member("length"), + ("slice", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("slice", "split_first") => rt2(args, "slice", "splitFirst"), + ("slice", "split_at") => rt2(args, "slice", "splitAt"), + ("slice", "split_at_checked") => rt2(args, "slice", "splitAtChecked"), + ("slice", "first") => rt2(args, "slice", "first"), + ("slice", "get") if Int::of(targ(gargs, 1)).is_some() => rt2(args, "slice", "get"), ("slice", "split_first_chunk") => { let n = gargs.consts().next()?.try_to_target_usize(tcx)?; - let mut values = b.args(args, out); + let mut values = args; values.push(Expr::lit(n.to_string())); Expr::rt("sliceSplitFirstChunk", values) } - ("slice", "copy_from_slice") if is_u8(targ(gargs, 0)) => rt2(b, args, out, "slice", "copyFromSlice"), - ("slice", "copy_within") if is_u8(targ(gargs, 0)) => { - let Args::Thir(ids) = args else { - return None; - }; - let mut s = [b.operand(ids[0], out)]; - let (start, end) = range_bounds(b, &mut s, ids[1], out)?; - let [s] = s; - let (s, end) = match end { - Some(end) => (s, end), - None => { - let s = path(b, s, "slice", out); - (s.clone(), s.member("length")) - } - }; - let mut pre = Vec::new(); - let dest = b.operand(ids[2], &mut pre); - let mut values = vec![s, start, end]; - b.after(&mut values, pre, out); - values.push(dest); - Expr::rt("sliceCopyWithin", values) - } + ("slice", "copy_from_slice") if is_u8(targ(gargs, 0)) => rt2(args, "slice", "copyFromSlice"), ("slice", "to_vec") => { let elem = targ(gargs, 0); - let values = b.args(args, out); + let values = args; match is_u8(elem) { true => Expr::rt("sliceToByteVec", values), false if b.t.is_copy(elem) => Expr::rt("sliceToVec", values), @@ -586,16 +529,16 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, ("slice", "into_vec") => { // `vec![..]`: `<[T]>::into_vec(box_new([..]))`. let elem = targ(gargs, 0); - let value = b.args(args, out).pop()?; + let value = args.pop()?; match is_u8(elem) { true => Expr::rt("byteVecFrom", vec![value]), false => value, } } - ("boxed", "box_new") | ("Box", "new") => b.args(args, out).pop()?, + ("boxed", "box_new") | ("Box", "new") => args.pop()?, ("vec", "from_elem") => { let elem = targ(gargs, 0); - let values = b.args(args, out); + let values = args; match is_u8(elem) { true => Expr::rt("byteVecOf", values), false if b.t.is_copy(elem) => { @@ -625,14 +568,11 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, false => Expr::Array(Vec::new()), }, ("Vec", "with_capacity") => match is_u8(targ(gargs, 0)) { - true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), b.args(args, out)), - false => { - b.args(args, out); - Expr::Array(Vec::new()) - } + true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), args), + false => Expr::Array(Vec::new()), }, ("Vec", "push") => { - let mut values = b.args(args, out); + let mut values = args; match is_u8(targ(gargs, 0)) { true => Expr::rt("byteVecPush", values), false => { @@ -642,21 +582,21 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } } ("Vec", "pop") => match is_u8(targ(gargs, 0)) { - true => Expr::rt("byteVecPop", b.args(args, out)), - false => b.args(args, out).pop()?.method("pop", vec![]), + true => Expr::rt("byteVecPop", args), + false => args.pop()?.method("pop", vec![]), }, - ("Vec", "len") => b.args(args, out).pop()?.member("length"), - ("Vec", "is_empty") => b.args(args, out).pop()?.member("length").binary("===", Expr::lit("0")), - ("Vec", "truncate") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecTruncate", b.args(args, out)), - ("Vec", "clear") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecClear", b.args(args, out)), - ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", b.args(args, out)), + ("Vec", "len") => args.pop()?.member("length"), + ("Vec", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("Vec", "truncate") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecTruncate", args), + ("Vec", "clear") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecClear", args), + ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), ("Vec", "as_slice" | "as_mut_slice") => { - let v = b.args(args, out).pop()?; + let v = args.pop()?; vec_view(v, targ(gargs, 0)) } ("Deref", "deref") | ("DerefMut", "deref_mut") => { let ty = targ(gargs, 0); - let v = b.args(args, out).pop()?; + let v = args.pop()?; match ty.kind() { ty::Adt(adt, _) => match Std::of(tcx, adt.did()) { Some(Std::Vec) => vec_view(v, ty), @@ -666,100 +606,29 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, _ => return None, } } - ("Index", "index") | ("IndexMut", "index_mut") => { - let Args::Thir(ids) = args else { - return None; - }; - let container = targ(gargs, 0); - let index_ty = targ(gargs, 1); - let elem_ty = elem(container)?; - let base = b.operand(ids[0], out); - let base = match container.kind() { - ty::Adt(..) => vec_view(base, container), - _ => base, - }; - match Int::of(index_ty) { - Some(_) => { - let mut pre = Vec::new(); - let i = b.operand(ids[1], &mut pre); - let mut base = [base]; - b.after(&mut base, pre, out); - let [base] = base; - match name.as_str() { - "index" => Expr::rt("at", vec![base, i]), - _ => { - let base = path(b, base, "slice", out); - let i = path(b, i, "index", out); - base.clone().index(Expr::rt("idx", vec![base, i])) - } - } - } - None => { - if name == "index_mut" && !is_u8(elem_ty) { - // A JS array has no views, so a mutable subslice would be a copy. - return None; - } - let mut base = [base]; - let (start, end) = range_bounds(b, &mut base, ids[1], out)?; - let [base] = base; - let mut values = vec![base, start]; - values.extend(end); - Expr::rt("sliceRange", values) - } - } - } // Strings. - ("String" | "str", "as_bytes") => Expr::rt("stringAsBytes", b.args(args, out)), - ("String", "from_utf8") => Expr::rt("stringFromUtf8", b.args(args, out)), - ("String" | "str", "len") => Expr::rt("stringLen", b.args(args, out)), - ("String", "as_str") => b.args(args, out).pop()?, + ("String" | "str", "as_bytes") => Expr::rt("stringAsBytes", args), + ("String", "from_utf8") => Expr::rt("stringFromUtf8", args), + ("String" | "str", "len") => Expr::rt("stringLen", args), + ("String", "as_str") => args.pop()?, ("String", "new") => Expr::Str(String::new()), ("ToString", "to_string") | ("ToOwned", "to_owned") if matches!(self_ty()?.peel_refs().kind(), ty::Str) => { - b.args(args, out).pop()? - } - - // Moving out of a place. - ("mem", "take") => { - let Args::Thir(ids) = args else { - return None; - }; - let ty = targ(gargs, 0); - let place = borrowed_place(b, ids[0], out)?; - let default = default_value(b, ty)?; - swap_out(b, place, default, "taken", out) - } - ("mem", "replace") => { - let Args::Thir(ids) = args else { - return None; - }; - let place = borrowed_place(b, ids[0], out)?; - let value = b.operand(ids[1], out); - swap_out(b, place, value, "old", out) - } - ("mem", "swap") => { - let Args::Thir(ids) = args else { - return None; - }; - let a = borrowed_place(b, ids[0], out)?; - let c = borrowed_place(b, ids[1], out)?; - let old = swap_out(b, a.clone(), c.clone(), "swapped", out); - out.push(StmtKind::Expr(c.assign(old)).at(None)); - Expr::undefined() + args.pop()? } // Panics, which format their message as std does. ("panicking", "panic_fmt") => { - let message = b.args(args, out).pop()?; + let message = args.pop()?; match literal(&message) { Some(s) => Expr::rt("panic", vec![Expr::Str(s)]), None => Expr::rt("panicFmt", vec![message]), } } - ("panicking", "panic") | ("rt", "begin_panic") => Expr::rt("panic", b.args(args, out)), + ("panicking", "panic") | ("rt", "begin_panic") => Expr::rt("panic", args), ("panicking", "panic_explicit") => Expr::rt("panic", vec![Expr::Str("explicit panic".into())]), ("panicking", "panic_display" | "unreachable_display") => { - let value = b.args(args, out).pop()?; + let value = args.pop()?; let value = b.fmt_value(fmt::Trait::Display, targ(gargs, 0), value, span, out); let mut message = vec![value]; if name == "unreachable_display" { @@ -769,7 +638,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } // `assert_eq!` and `assert_ne!`: the operator, both sides, and any message. ("panicking", "assert_failed") => { - let [kind, left, right, message] = <[Expr; 4]>::try_from(b.args(args, out)).ok()?; + let [kind, left, right, message] = <[Expr; 4]>::try_from(args).ok()?; let left = b.fmt_value(fmt::Trait::Debug, targ(gargs, 0), left, span, out); let right = b.fmt_value(fmt::Trait::Debug, targ(gargs, 1), right, span, out); let mut values = vec![kind, left, right]; @@ -780,9 +649,9 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } // Formatting. - ("hint", "must_use") => b.args(args, out).pop()?, + ("hint", "must_use") => args.pop()?, ("fmt", "format") => { - let parts = b.args(args, out).pop()?; + let parts = args.pop()?; match literal(&parts) { Some(s) => Expr::Str(s), None => Expr::rt("fmtFormat", vec![parts]), @@ -790,12 +659,12 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } ("Display" | "Debug" | "LowerHex" | "UpperHex", "fmt") => { let tr = fmt::Trait::of(tcx, tcx.trait_of_assoc(call.def_id)?)?; - let [value, f] = <[Expr; 2]>::try_from(b.args(args, out)).ok()?; + let [value, f] = <[Expr; 2]>::try_from(args).ok()?; fmt::std_impl(b, tr, targ(gargs, 0), value, f, span, out)? } ("ToString", "to_string") => { let ty = targ(gargs, 0); - let value = b.args(args, out).pop()?; + let value = args.pop()?; match ty.kind() { ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::String) => value, _ => { @@ -805,7 +674,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } } ("Formatter", "write_fmt") => { - let [f, parts] = <[Expr; 2]>::try_from(b.args(args, out)).ok()?; + let [f, parts] = <[Expr; 2]>::try_from(args).ok()?; match literal(&parts) { Some(s) => Expr::rt("fmtWriteStr", vec![f, Expr::Str(s)]), None => Expr::rt("fmtWriteFmt", vec![f, parts]), @@ -821,13 +690,13 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "DebugTuple" => "debugTuple", _ => "debugList", }; - Expr::rt_of(of, &super::camel(&name)).call(b.args(args, out)) + Expr::rt_of(of, &super::camel(&name)).call(args) } // Derived `Debug`: `debug_struct_field2_finish(f, name, "a", &a, "b", &b)`. - ("Formatter", "debug_struct_fields_finish") => Expr::rt("fmtDebugStructFields", b.args(args, out)), - ("Formatter", "debug_tuple_fields_finish") => Expr::rt("fmtDebugTupleFields", b.args(args, out)), + ("Formatter", "debug_struct_fields_finish") => Expr::rt("fmtDebugStructFields", args), + ("Formatter", "debug_tuple_fields_finish") => Expr::rt("fmtDebugTupleFields", args), ("Formatter", n) if n.starts_with("debug_struct_field") || n.starts_with("debug_tuple_field") => { - let mut values = b.args(args, out).into_iter(); + let mut values = args.into_iter(); let (f, type_name) = (values.next()?, values.next()?); let structure = n.starts_with("debug_struct"); let (of, start) = match structure { @@ -845,16 +714,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } Expr::rt_of(of, "finish").call(vec![builder]) } - ("DebugList", "entries") => { - let Args::Thir(ids) = args else { - return None; - }; - let list = b.operand(ids[0], out); - let items = items(b, ids[1], out)?; - let debug = b.fmt_fn(fmt::Trait::Debug, targ(gargs, 0), span); - Expr::rt("debugListEntries", vec![list, items, debug]) - } - _ => return super::iter::call(b, call, &owner, &name, args, out), + _ => return super::iter::call(b, call, &owner, &name, args), }; if let Some(ty) = dropping { return Some(b.err( @@ -865,22 +725,6 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, Some(e) } -/// `int::from_be_bytes(bytes)`. A number from an array written in place is its bytes -/// shifted and or-ed, with no array made. Otherwise the runtime reads the array the -/// argument names, uncopied, since the read neither keeps nor changes it. -fn from_be_bytes<'tcx>(b: &mut Body<'_, '_, 'tcx>, int: Int, bytes: ExprId, out: &mut Vec) -> Expr { - let thir = b.thir; - let fields = match &thir[b.strip(bytes)].kind { - ExprKind::Array { fields } if !int.big() => fields, - _ => { - let value = b.place(bytes, out); - return int.method("fromBeBytes", vec![value]); - } - }; - let values = b.operands(fields, out); - be_word(int, values) -} - /// A number from its big-endian bytes, each a value: shifted and or-ed. pub fn be_word(int: Int, values: Vec) -> Expr { let last = values.len() - 1; @@ -919,9 +763,8 @@ pub fn targ<'tcx>(gargs: GenericArgsRef<'tcx>, n: usize) -> Ty<'tcx> { } /// `rt.(args)`. -fn rt2<'tcx>(b: &mut Body<'_, '_, 'tcx>, args: Args<'_>, out: &mut Vec, of: &str, name: &str) -> Expr { - let values = b.args(args, out); - Expr::rt_of(of, name).call(values) +fn rt2(args: Vec, of: &str, name: &str) -> Expr { + Expr::rt_of(of, name).call(args) } /// What the runtime's functions of a std range type start with. @@ -978,95 +821,6 @@ impl MethodCall for Expr { } } -fn path<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, base: &str, out: &mut Vec) -> Expr { - if value.is_path() { - return value; - } - let name = b.fresh(base); - out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); - Expr::ident(name) -} - -/// The start and optional end of a range written in place: `a..b`, `..b`, `a..`, `..`. -/// `earlier` are the operands evaluated before it, spilled if the range needs statements. -fn range_bounds<'tcx>( - b: &mut Body<'_, '_, 'tcx>, - earlier: &mut [Expr], - id: ExprId, - out: &mut Vec, -) -> Option<(Expr, Option)> { - let tcx = b.t.tcx; - let written = id; - let id = b.strip(id); - let ty = b.ty_of(id); - let ty::Adt(adt, _) = ty.kind() else { - return None; - }; - let name = tcx.item_name(adt.did()).to_string(); - let mut pre = Vec::new(); - let mut values: Vec = match &b.thir[id].kind { - // `..` has no bounds, but what makes it still runs. - _ if name == "RangeFull" => { - b.stmt(written, Dest::Discard, &mut pre); - Vec::new() - } - ExprKind::Adt(range) => { - b.visit(written); - let values = b.written(range, ty, b.thir[id].span, &mut pre); - b.declared(values, &mut pre).into_iter().map(|(_, v)| v).collect() - } - _ => return None, - }; - b.after(earlier, pre, out); - match name.as_str() { - "Range" => { - let end = values.pop()?; - let start = values.pop()?; - Some((start, Some(end))) - } - "RangeTo" => Some((Expr::lit("0"), values.pop())), - "RangeFrom" => Some((values.pop()?, None)), - "RangeFull" => Some((Expr::lit("0"), None)), - _ => None, - } -} - -/// The place behind `&mut place`, as an assignable path. -fn borrowed_place<'tcx>(b: &mut Body<'_, '_, 'tcx>, id: ExprId, out: &mut Vec) -> Option { - let written = id; - let id = b.strip(id); - let ExprKind::Borrow { mut arg, .. } = b.thir[id].kind else { - return None; - }; - // A reborrow, `&mut *&mut place`. - while let ExprKind::Deref { arg: inner } = b.thir[b.strip(arg)].kind - && let ExprKind::Borrow { arg: place, .. } = b.thir[b.strip(inner)].kind - { - arg = place; - } - // The path to `*r` is `r` itself: assigning it would rebind the reference. - if let ExprKind::Deref { arg: pointer } = b.thir[b.strip(arg)].kind - && matches!(b.ty_of(pointer).kind(), ty::Ref(..)) - { - let pointee = b.ty_of(arg); - return Some(b.err( - b.thir[arg].span, - format!("replacing the value behind a reference to `{pointee}`"), - )); - } - b.visit(written); - let place = b.place(arg, out); - place.is_path().then_some(place) -} - -/// The value at `place`, after setting `place` to `value`. -pub fn swap_out<'tcx>(b: &mut Body<'_, '_, 'tcx>, place: Expr, value: Expr, base: &str, out: &mut Vec) -> Expr { - let name = b.fresh(base); - out.push(StmtKind::decl(false, name.clone(), None, Some(place.clone())).at(None)); - out.push(StmtKind::Expr(place.assign(value)).at(None)); - Expr::ident(name) -} - /// `Default::default()` for a standard type. pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option { let tcx = b.t.tcx; @@ -1107,38 +861,3 @@ pub fn literal(parts: &Expr) -> Option { }) .collect() } - -/// The slice `id` iterates if it is `<[T]>::iter(slice)`, which iterates as the JS array -/// or `Uint8Array` itself does. -pub fn iterated_slice(b: &Body<'_, '_, '_>, id: ExprId) -> Option { - let ExprKind::Call { ty: fn_ty, args, .. } = &b.thir[b.strip(id)].kind else { - return None; - }; - let ty::FnDef(iter, _) = *b.subst(*fn_ty).kind() else { - return None; - }; - (key(b.t.tcx, iter) == Some(("slice".into(), "iter".into()))).then(|| args[0]) -} - -/// What an `IntoIterator` iterates, as an iterable JS value: a slice, array, or `Vec` -/// itself, by value or by reference, or else an `rt.Iter`. -fn items<'tcx>(b: &mut Body<'_, '_, 'tcx>, id: ExprId, out: &mut Vec) -> Option { - let tcx = b.t.tcx; - if let Some(slice) = iterated_slice(b, id) { - b.visit(id); - return Some(b.operand(slice, out)); - } - let id = b.strip(id); - let ty = b.ty_of(id); - match ty.peel_refs().kind() { - ty::Slice(_) | ty::Array(..) => Some(b.operand(id, out)), - ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::Vec) => { - let v = b.operand(id, out); - Some(vec_view(v, ty)) - } - _ => { - let value = b.operand(id, out); - super::iter::into_iter(b, ty, value, b.span(id)) - } - } -} diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index ddab459e2..1db77086a 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -10,7 +10,7 @@ use rustc_span::{Span, Spanned}; use super::{Fx, Slot}; use crate::lower::fmt::{self, Piece}; -use crate::lower::library::{self, Args, Std}; +use crate::lower::library::{self, Std}; use crate::lower::num::Int; use crate::ts::{Expr, Stmt, StmtKind}; @@ -150,9 +150,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } }; if let ty::FnDef(inner, inner_args) = *callee_ty.peel_refs().kind() { - return self - .b - .call_def(inner, inner_args.skip_binder(), Args::Values(values), span, out); + return self.b.call_def(inner, inner_args.skip_binder(), values, span, out); } let f = self.operand(&callee.node, span, out); return f.call(values); @@ -168,7 +166,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } let values = self.operands(args, span, out); - self.b.call_def(def_id, gargs, Args::Values(values), span, out) + self.b.call_def(def_id, gargs, values, span, out) } /// Refuse a `&mut` to a value JS copies, passed on whole to code that could write @@ -272,17 +270,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // `format_args!`, as MIR builds it: each argument a function writing its value, // and a template of literal pieces and placeholders. ("Argument", name) if name.starts_with("new_") || name == "from_usize" => { - let tr = match name { - "new_display" => fmt::Trait::Display, - "new_debug" => fmt::Trait::Debug, - "new_lower_hex" => fmt::Trait::LowerHex, - "new_upper_hex" => fmt::Trait::UpperHex, - "from_usize" => { - self.err(span, format!("{} is not supported", fmt::FROM_ARGUMENT)); - return done(Expr::undefined(), false); - } - other => { - self.err(span, format!("formatting by `{other}` is not supported")); + let tr = match fmt::argument(name) { + Ok(tr) => tr, + Err(construct) => { + self.err(span, format!("{construct} is not supported")); return done(Expr::undefined(), false); } }; diff --git a/ts/src/lower/mir/cfg.rs b/ts/src/lower/mir/cfg.rs index 8ccd718b9..a67a628d4 100644 --- a/ts/src/lower/mir/cfg.rs +++ b/ts/src/lower/mir/cfg.rs @@ -395,10 +395,6 @@ pub fn simplify(stmts: &mut Vec) { cases.iter_mut().for_each(|(_, body)| simplify(body)); simplify(default); } - StmtKind::Try { body, finally } => { - simplify(body); - simplify(finally); - } StmtKind::Catch { body, handler, .. } => { simplify(body); simplify(handler); @@ -494,11 +490,7 @@ fn targets(stmts: &[Stmt], label: &str) -> bool { stmts.iter().any(|stmt| match &stmt.kind { StmtKind::Break(Some(l)) | StmtKind::Continue(Some(l)) => l == label, StmtKind::If { then, els, .. } => targets(then, label) || targets(els, label), - StmtKind::Block { body, .. } - | StmtKind::While { body, .. } - | StmtKind::ForRange { body, .. } - | StmtKind::ForOf { body, .. } => targets(body, label), - StmtKind::Try { body, finally } => targets(body, label) || targets(finally, label), + StmtKind::Block { body, .. } | StmtKind::While { body, .. } => targets(body, label), StmtKind::Catch { body, handler, .. } => targets(body, label) || targets(handler, label), StmtKind::Switch { cases, default, .. } => { cases.iter().any(|(_, body)| targets(body, label)) || targets(default, label) diff --git a/ts/src/lower/mir/coroutine.rs b/ts/src/lower/mir/coroutine.rs index f8292873f..f1b1acbb7 100644 --- a/ts/src/lower/mir/coroutine.rs +++ b/ts/src/lower/mir/coroutine.rs @@ -154,7 +154,7 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs }); if let Some(mir) = super::instance_mir(t, instance, span) { let ret = mir.return_ty(); - let mut b = Body::detached(t, args, ret); + let mut b = Body::new(t, args); let mut fx = Fx::new(&mut b, &mir, Env::Coroutine, span); let params = fx.params(); let body = fx.lower(); @@ -167,7 +167,6 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs body, loc, doc: None, - generator: false, }); } // `[Symbol.dispose]`: the drop, by the state it is in. @@ -190,7 +189,7 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs t.typing_env_pub(), EarlyBinder::bind(tcx, drop), ); - let mut b = Body::detached(t, args, tcx.types.unit); + let mut b = Body::new(t, args); let mut fx = Fx::new(&mut b, &mir, Env::Coroutine, span); fx.lower() } @@ -203,7 +202,6 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs body, loc: None, doc: None, - generator: false, }); info } diff --git a/ts/src/lower/mir/glue.rs b/ts/src/lower/mir/glue.rs index 3d45b028f..931b6234f 100644 --- a/ts/src/lower/mir/glue.rs +++ b/ts/src/lower/mir/glue.rs @@ -45,7 +45,7 @@ pub fn shim<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Opt let body = tcx.instance_mir(instance.def).clone(); let mir = instance.instantiate_mir_and_normalize_erasing_regions(tcx, t.typing_env_pub(), EarlyBinder::bind(tcx, body)); - let mut b = Body::detached(t, instance.args, tcx.types.unit); + let mut b = Body::new(t, instance.args); let mut fx = Fx::new(&mut b, &mir, Env::Shim, span); let params = fx.params(); let body = fx.lower(); @@ -64,7 +64,6 @@ pub fn shim<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Opt body, loc: None, doc: None, - generator: false, })); Some(sym) } diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index e58761d49..590a3ca37 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -1,4 +1,4 @@ -//! Function bodies from MIR: the spike's prototype, beside the THIR lowering in `body`. +//! Function bodies, from MIR. //! //! MIR is each body's control-flow graph after borrow checking. Every drop is a //! terminator where drop elaboration put it, with a flag wherever a value is moved on @@ -7,8 +7,8 @@ //! with each temporary that is assigned once and read once folded back into the //! expression that reads it, unless that would reorder an effect. //! -//! Library calls go through the THIR lowering's mappings, which take their arguments -//! lowered: a detached `Body` holds the names, and its translator everything else. +//! Library calls go through the mappings in `library`, which take their arguments +//! lowered: a `Body` holds the names, and its translator everything else. mod call; mod cfg; @@ -41,7 +41,7 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> super::iter::check_impl(t, def_id); } let ret_ty = mir.return_ty(); - let mut b = Body::detached(t, instance.args, ret_ty); + let mut b = Body::new(t, instance.args); let mut fx = Fx::new(&mut b, &mir, Env::Plain, span); let params = fx.params(); let body = fx.lower(); @@ -56,7 +56,6 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> body, loc: None, doc: None, - generator: false, }) } @@ -1772,7 +1771,7 @@ fn scan_stmt(stmt: &Stmt, reads: &mut Vec, lazy: bool) { fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { match e { Expr::Ident(name) => reads.push(Read::Ident(name.clone(), lazy)), - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| scan(e, reads, lazy)), Expr::Object(props) => props.iter().for_each(|(_, e)| scan(e, reads, lazy)), // The runtime's and the program's own items never change. @@ -1839,7 +1838,7 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { *e = value.clone(); true } - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => false, + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => false, Expr::Array(items) => items.iter_mut().any(|e| subst(e, name, value)), Expr::Object(props) => props.iter_mut().any(|(_, e)| subst(e, name, value)), Expr::Member(base, _) => subst(base, name, value), @@ -1900,17 +1899,7 @@ fn scan_reads(stmt: &Stmt, out: &mut Vec) { } default.iter().for_each(|s| scan_reads(s, out)); } - StmtKind::Try { body, finally } => body.iter().chain(finally).for_each(|s| scan_reads(s, out)), StmtKind::Catch { body, handler, .. } => body.iter().chain(handler).for_each(|s| scan_reads(s, out)), - StmtKind::ForRange { start, end, body, .. } => { - reads_of(start, out); - reads_of(end, out); - body.iter().for_each(|s| scan_reads(s, out)); - } - StmtKind::ForOf { iter, body, .. } => { - reads_of(iter, out); - body.iter().for_each(|s| scan_reads(s, out)); - } _ => {} } } @@ -1918,7 +1907,7 @@ fn scan_reads(stmt: &Stmt, out: &mut Vec) { fn reads_of(e: &Expr, out: &mut Vec) { match e { Expr::Ident(name) => out.push(name.clone()), - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| reads_of(e, out)), Expr::Object(props) => props.iter().for_each(|(_, e)| reads_of(e, out)), Expr::Member(base, _) => reads_of(base, out), @@ -1974,10 +1963,6 @@ fn strip_assignments(stmts: &mut Vec, unread: &FxHashSet) { cases.iter_mut().for_each(|(_, body)| strip_assignments(body, unread)); strip_assignments(default, unread); } - StmtKind::Try { body, finally } => { - strip_assignments(body, unread); - strip_assignments(finally, unread); - } StmtKind::Catch { body, handler, .. } => { strip_assignments(body, unread); strip_assignments(handler, unread); @@ -2126,10 +2111,6 @@ fn drop_self_assignments(stmts: &mut Vec) { cases.iter_mut().for_each(|(_, body)| drop_self_assignments(body)); drop_self_assignments(default); } - StmtKind::Try { body, finally } => { - drop_self_assignments(body); - drop_self_assignments(finally); - } StmtKind::Catch { body, handler, .. } => { drop_self_assignments(body); drop_self_assignments(handler); diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 828339d0f..29a895333 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -13,14 +13,12 @@ mod iter; mod library; mod mir; mod num; -mod pat; mod task; use std::collections::VecDeque; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_middle::thir::{ExprId, Thir}; use rustc_middle::ty::{ self, AdtDef, EarlyBinder, GenericArgsRef, Instance, InstanceKind, Ty, TyCtxt, TypeVisitableExt, TypingEnv, }; @@ -31,38 +29,9 @@ use crate::config::Config; use crate::program::{Program, Source, SymKind, Symbol}; use crate::ts::{self, Ctor, FieldId, Item, Loc, SymId, Type}; -/// Each function's THIR, copied before borrow checking steals it. -pub struct Bodies<'tcx> { - map: rustc_data_structures::fx::FxHashMap, ExprId)>, - /// No body: what a MIR lowering's library calls see, which pass their arguments lowered. - empty: Thir<'tcx>, -} - -impl<'tcx> Bodies<'tcx> { - pub fn collect(tcx: TyCtxt<'tcx>) -> Self { - let mut map = rustc_data_structures::fx::FxHashMap::default(); - for def_id in tcx.hir_body_owners() { - if !matches!(tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn | DefKind::Closure) { - continue; - } - let Ok((thir, expr)) = tcx.thir_body(def_id) else { - continue; - }; - // Constant evaluation during type checking may have built this body's MIR - // already; translating it then fails with a span instead. - if !thir.is_stolen() { - map.insert(def_id, (thir.borrow().clone(), expr)); - } - } - let empty = Thir::new(rustc_middle::thir::BodyTy::Const(tcx.types.unit)); - Self { map, empty } - } -} - /// Translate what the config's roots reach, or `None` after reporting why not. -pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx>, mir: bool) -> Option { - let mut t = Translator::new(tcx, config, bodies, None)?; - t.mir = mir; +pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config) -> Option { + let mut t = Translator::new(tcx, config, None)?; for root in &config.roots { t.root(root); } @@ -79,9 +48,8 @@ pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx> /// Every construct translation refuses in the crate, reached from each of its items /// as if each were a root. -pub fn census<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx>, mir: bool) -> Option { - let mut t = Translator::new(tcx, config, bodies, Some(Vec::new()))?; - t.mir = mir; +pub fn census<'tcx>(tcx: TyCtxt<'tcx>, config: &Config) -> Option { + let mut t = Translator::new(tcx, config, Some(Vec::new()))?; for def_id in tcx.hir_crate_items(()).definitions() { if matches!(tcx.def_kind(def_id), DefKind::Struct | DefKind::Enum | DefKind::Union) { t.adt(tcx.adt_def(def_id), tcx.def_span(def_id)); @@ -154,7 +122,6 @@ pub fn census<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx>, m pub struct Translator<'a, 'tcx> { pub tcx: TyCtxt<'tcx>, - bodies: &'a Bodies<'tcx>, config: &'a Config, pub program: Program, instances: rustc_data_structures::fx::FxHashMap, SymId>, @@ -175,11 +142,9 @@ pub struct Translator<'a, 'tcx> { drops_cycle: bool, /// The classes given drop glue. glued: rustc_data_structures::fx::FxHashSet, - /// Whether bodies lower from MIR, the spike's prototype, rather than THIR. - pub mir: bool, - /// The drop glue made from each type's drop shim, by a MIR lowering. + /// The drop glue made from each type's drop shim. pub drop_shims: rustc_data_structures::fx::FxHashMap, SymId>, - /// The class of each coroutine instance a MIR lowering made. + /// The class of each coroutine instance. pub coroutines: rustc_data_structures::fx::FxHashMap, mir::coroutine::Info<'tcx>>, } @@ -219,12 +184,7 @@ pub struct Erased { } impl<'a, 'tcx> Translator<'a, 'tcx> { - fn new( - tcx: TyCtxt<'tcx>, - config: &'a Config, - bodies: &'a Bodies<'tcx>, - refusals: Option>, - ) -> Option { + fn new(tcx: TyCtxt<'tcx>, config: &'a Config, refusals: Option>) -> Option { if tcx.data_layout.pointer_size().bits() != 32 { tcx.dcx().err( "rust2-ts: translation needs a 32-bit target, such as wasm32-unknown-unknown, so usize is a number", @@ -233,7 +193,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } Some(Self { tcx, - bodies, config, program: Program::default(), instances: Default::default(), @@ -247,7 +206,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { drops_open: Default::default(), drops_cycle: false, glued: Default::default(), - mir: false, coroutines: Default::default(), drop_shims: Default::default(), }) @@ -318,11 +276,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { self.typing_env() } - /// A closure's THIR and body expression. - pub fn body(&self, def_id: LocalDefId) -> Option<(&'a Thir<'tcx>, ExprId)> { - self.bodies.map.get(&def_id).map(|(thir, expr)| (thir, *expr)) - } - fn root(&mut self, path: &str) { let Some(def_id) = self.config_item(path) else { return; @@ -1089,27 +1042,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { self.err(span, format!("unsupported function `{}`", tcx.def_path_str(def_id))); return; }; - let Some(local) = def_id.as_local() else { + if !def_id.is_local() { self.err(span, format!("`{}` is from another crate", tcx.def_path_str(def_id))); return; - }; - let function = match self.mir { - true => mir::function(self, instance), - false => { - let Some((thir, expr)) = self.bodies.map.get(&local) else { - self.err( - span, - format!( - "no body for `{}`: constant evaluation consumed it", - tcx.def_path_str(def_id) - ), - ); - return; - }; - body::function(self, instance, thir, *expr) - } - }; - let Some(mut function) = function else { + } + let Some(mut function) = mir::function(self, instance) else { return; }; function.sym = sym; @@ -1148,22 +1085,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } None } - - /// Whether invocations of the macro that made `span` are left out. - pub fn ignored_macro(&self, mut span: Span) -> bool { - // Walk out through the macros this one was expanded inside. - while span.from_expansion() { - let data = span.ctxt().outer_expn_data(); - if let Some(def_id) = data.macro_def_id { - let path = self.tcx.def_path_str(def_id); - if self.config.ignore_macros.contains(&path) { - return true; - } - } - span = data.call_site; - } - false - } } /// A short name for a type, to tell instances apart. diff --git a/ts/src/lower/num.rs b/ts/src/lower/num.rs index 866a41655..a573df464 100644 --- a/ts/src/lower/num.rs +++ b/ts/src/lower/num.rs @@ -104,7 +104,7 @@ impl Int { /// A literal of this type spelled `text`, JS number digits of `value`. A wide value /// past 2^53 is limbs, made from a bigint: `rt.u64Of(0xffffffffffffffffn)`. - pub fn spelled(self, text: String, value: i128) -> Expr { + fn spelled(self, text: String, value: i128) -> Expr { let safe = (1 - (1i128 << 53)..(1 << 53)).contains(&value) && (self.signed || value >= 0); match safe { true => Expr::lit(text), diff --git a/ts/src/lower/pat.rs b/ts/src/lower/pat.rs deleted file mode 100644 index 8f771c04b..000000000 --- a/ts/src/lower/pat.rs +++ /dev/null @@ -1,305 +0,0 @@ -//! Patterns: a test of whether a value matches, and the bindings it makes. -//! -//! Both read the scrutinee through a path, a name or member chain that is free to -//! evaluate more than once. - -use rustc_middle::thir::{Pat, PatKind, PatRangeBoundary}; -use rustc_middle::ty::{self, Ty}; - -use super::AdtRepr; -use super::body::Body; -use super::library::Std; -use super::num::Int; -use crate::ts::{Expr, Stmt, StmtKind}; - -impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// The test `scrut` must pass to match `pat`, or `None` if it always matches. - pub fn pat_test(&mut self, pat: &Pat<'tcx>, scrut: &Expr) -> Option { - let ty = self.subst(pat.ty); - match &pat.kind { - PatKind::Wild | PatKind::Missing => None, - PatKind::Binding { subpattern, .. } => subpattern.as_ref().and_then(|p| self.pat_test(p, scrut)), - PatKind::Deref { subpattern, .. } => self.pat_test(subpattern, scrut), - PatKind::Leaf { subpatterns } => { - let tests: Vec = subpatterns - .iter() - .filter_map(|f| { - let field = self.project(scrut.clone(), ty, rustc_abi::FIRST_VARIANT, f.field, pat.span); - self.pat_test(&f.pattern, &field) - }) - .collect(); - all(tests) - } - PatKind::Variant { - adt_def, - variant_index, - subpatterns, - .. - } => { - let mut tests = Vec::new(); - match Std::of(self.t.tcx, adt_def.did()) { - Some(Std::Option) => tests.push(match variant_index.index() { - 0 => scrut.clone().binary("===", Expr::undefined()), - _ => scrut.clone().binary("!==", Expr::undefined()), - }), - Some(Std::Poll) => tests.push(match variant_index.index() { - 0 => scrut.clone().binary("!==", Expr::Rt("Pending".into())), - _ => scrut.clone().binary("===", Expr::Rt("Pending".into())), - }), - Some(Std::Result) => tests.push(match variant_index.index() { - 0 => scrut.clone().member("ok"), - _ => scrut.clone().member("ok").not(), - }), - None if adt_def.did().is_local() => { - let info = self.t.adt(*adt_def, pat.span); - let name = Expr::Str(adt_def.variant(*variant_index).name.to_string()); - match info.repr { - AdtRepr::Tags => tests.push(scrut.clone().binary("===", name)), - AdtRepr::Union => tests.push(scrut.clone().member("tag").binary("===", name)), - AdtRepr::Struct { .. } => {} - } - } - _ => { - self.t.err(pat.span, format!("a pattern on `{ty}`")); - return None; - } - } - for f in subpatterns { - let field = self.project(scrut.clone(), ty, *variant_index, f.field, pat.span); - if let Some(test) = self.pat_test(&f.pattern, &field) { - tests.push(test); - } - } - all(tests) - } - PatKind::Constant { value } => { - let constant = self.value(value.ty, value.valtree, pat.span); - match (&constant, ty.peel_refs().kind()) { - (Expr::Lit(t), ty::Bool) if t == "true" => Some(scrut.clone()), - (Expr::Lit(t), ty::Bool) if t == "false" => Some(scrut.clone().not()), - (_, ty::Int(_) | ty::Uint(_)) => { - Some(Int::of(ty.peel_refs()).unwrap().compare("===", scrut.clone(), constant)) - } - (_, ty::Bool | ty::Str) => Some(scrut.clone().binary("===", constant)), - _ => { - self.t.err(pat.span, format!("a constant pattern of type `{ty}`")); - None - } - } - } - PatKind::Range(range) => { - let mut tests = Vec::new(); - let compare = |op: &'static str, l: Expr, r: Expr| match Int::of(range.ty) { - Some(int) => int.compare(op, l, r), - None => l.binary(op, r), - }; - if let PatRangeBoundary::Finite(lo) = range.lo { - let lo = self.value(range.ty, lo, pat.span); - tests.push(compare("<=", lo, scrut.clone())); - } - if let PatRangeBoundary::Finite(hi) = range.hi { - let hi = self.value(range.ty, hi, pat.span); - let op = match range.end { - rustc_hir::RangeEnd::Included => "<=", - rustc_hir::RangeEnd::Excluded => "<", - }; - tests.push(compare(op, scrut.clone(), hi)); - } - all(tests) - } - PatKind::Slice { prefix, slice, suffix } | PatKind::Array { prefix, slice, suffix } => { - let mut tests = Vec::new(); - let fixed = matches!(pat.kind, PatKind::Array { .. }); - let n = prefix.len() + suffix.len(); - if !fixed { - let op = if slice.is_some() { ">=" } else { "===" }; - tests.push(scrut.clone().member("length").binary(op, Expr::lit(n.to_string()))); - } - for (i, p) in prefix.iter().enumerate() { - let elem = scrut.clone().index(Expr::lit(i.to_string())); - if let Some(test) = self.pat_test(p, &elem) { - tests.push(test); - } - } - for (i, p) in suffix.iter().enumerate() { - let elem = self.suffix_elem(scrut, ty, suffix.len() - i); - if let Some(test) = self.pat_test(p, &elem) { - tests.push(test); - } - } - if let Some(p) = slice - && let Some(_) = self.pat_test(p, scrut) - { - self.t.err(p.span, "a refutable pattern on a slice's rest"); - } - all(tests) - } - PatKind::Or { pats } => { - let mut tests = Vec::new(); - for p in pats.iter() { - if super::body::has_bindings(p) { - self.t.err(pat.span, "an or-pattern with bindings"); - return None; - } - tests.push(self.pat_test(p, scrut)?); - } - tests.into_iter().reduce(|a, b| a.binary("||", b)) - } - _ => { - self.t.err(pat.span, "unsupported pattern"); - None - } - } - } - - /// The element `from_end` places before the end of the slice `scrut`. - fn suffix_elem(&mut self, scrut: &Expr, ty: Ty<'tcx>, from_end: usize) -> Expr { - match ty.peel_refs().kind() { - ty::Array(_, len) if let Some(len) = len.try_to_target_usize(self.t.tcx) => { - scrut.clone().index(Expr::lit((len as usize - from_end).to_string())) - } - _ => scrut.clone().index( - scrut - .clone() - .member("length") - .binary("-", Expr::lit(from_end.to_string())), - ), - } - } - - /// Declare the bindings `pat` makes from `scrut`. An `owned` scrutinee is a - /// temporary, so a `Copy` value binds without a copy. - pub fn pat_bind(&mut self, pat: &Pat<'tcx>, scrut: &Expr, owned: bool, out: &mut Vec) { - let ty = self.subst(pat.ty); - match &pat.kind { - PatKind::Wild | PatKind::Missing | PatKind::Constant { .. } | PatKind::Range(_) => {} - // Bindings in alternatives are refused by `pat_test`; binding the first - // alternative's keeps that one error from cascading. - PatKind::Or { pats } => self.pat_bind(&pats[0], scrut, owned, out), - PatKind::Binding { - name, - var, - mode, - subpattern, - .. - } => { - let by_value = mode.0 == rustc_hir::ByRef::No; - if !by_value { - self.ref_binding(mode.0, ty, pat.span); - } - // A value that drops moves into its binding, read or not. - let moves = by_value && !self.t.is_copy(ty) && self.t.drops(ty); - // Binding has no effect in JS, and TypeScript refuses an unread local. - if subpattern.is_none() && !self.is_read(*var) && !moves { - return; - } - let mutable = mode.1 == rustc_ast::Mutability::Mut; - let value = match by_value && !owned { - true => self.copied(scrut.clone(), ty), - false => scrut.clone(), - }; - let name = self.bind_var(*var, *name, mutable, ty, pat.span, by_value); - let annotate = mutable.then(|| self.t.ty(ty, pat.span)); - out.push(StmtKind::decl(mutable, name, annotate, Some(value)).at(None)); - // Out of a place, which is left `undefined`. - if moves && !owned { - self.clear(scrut.clone(), out); - } - if let Some(sub) = subpattern { - self.pat_bind(sub, scrut, owned, out); - } - } - PatKind::Deref { subpattern, .. } => self.pat_bind(subpattern, scrut, false, out), - PatKind::Leaf { subpatterns } => { - for f in subpatterns { - let field = self.project(scrut.clone(), ty, rustc_abi::FIRST_VARIANT, f.field, pat.span); - self.pat_bind(&f.pattern, &field, owned, out); - } - } - PatKind::Variant { - variant_index, - subpatterns, - .. - } => { - // A payload changed in place would change every copy of a `Copy` enum, - // which JS shares. - let copy_enum = self.t.is_copy(ty.peel_refs()); - for f in subpatterns { - if copy_enum && binds_mut_ref(&f.pattern) { - self.t.err(f.pattern.span, "a `ref mut` binding into a `Copy` enum"); - } - let field = self.project(scrut.clone(), ty, *variant_index, f.field, pat.span); - self.pat_bind(&f.pattern, &field, owned, out); - } - } - PatKind::Slice { prefix, slice, suffix } | PatKind::Array { prefix, slice, suffix } => { - for (i, p) in prefix.iter().enumerate() { - let elem = scrut.clone().index(Expr::lit(i.to_string())); - self.pat_bind(p, &elem, owned, out); - } - for (i, p) in suffix.iter().enumerate() { - let elem = self.suffix_elem(scrut, ty, suffix.len() - i); - self.pat_bind(p, &elem, owned, out); - } - if let Some(p) = slice { - let start = Expr::lit(prefix.len().to_string()); - let end = match ty.peel_refs().kind() { - ty::Array(_, len) if let Some(len) = len.try_to_target_usize(self.t.tcx) => { - Expr::lit((len as usize - suffix.len()).to_string()) - } - _ => scrut - .clone() - .member("length") - .binary("-", Expr::lit(suffix.len().to_string())), - }; - let elem = match ty.peel_refs().kind() { - ty::Array(elem, _) | ty::Slice(elem) => *elem, - _ => { - self.t.err(pat.span, format!("a slice pattern on `{ty}`")); - return; - } - }; - let method = match elem.kind() { - ty::Uint(ty::UintTy::U8) => "subarray", - _ => "slice", - }; - if method == "slice" && binds_mut_ref(p) { - self.t.err( - p.span, - format!("a mutable borrow of a subslice of `{elem}`, which JS would copy, having no views"), - ); - } - // Its copy of the elements would drop them, and so would the place they stay in. - let rest_ty = self.subst(p.ty); - if !owned && !matches!(rest_ty.kind(), ty::Ref(..)) && self.t.drops(rest_ty) { - self.t.err( - p.span, - "a rest pattern that moves values that drop out of a place, which is not supported yet", - ); - } - let rest = scrut.clone().member(method).call(vec![start, end]); - self.pat_bind(p, &rest, true, out); - } - } - _ => { - self.t.err(pat.span, "unsupported pattern"); - } - } - } -} - -fn all(tests: Vec) -> Option { - tests.into_iter().reduce(Expr::and) -} - -fn binds_mut_ref(pat: &Pat<'_>) -> bool { - let mut found = false; - pat.walk_always(|p| { - if let PatKind::Binding { mode, .. } = p.kind - && let rustc_hir::ByRef::Yes(_, rustc_ast::Mutability::Mut) = mode.0 - { - found = true; - } - }); - found -} diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index d3466a295..f7f2a34e1 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -4,19 +4,18 @@ use rustc_middle::ty::{self, Ty}; use super::body::Body; -use super::library::{Args, Call, Std}; -use crate::ts::{Expr, Stmt}; +use super::library::{Call, Std}; +use crate::ts::Expr; /// A call of a standard library function on these types, or its arguments back if it is /// none of theirs. `Ok(None)` refuses it. -pub fn call<'tcx, 'x>( +pub fn call<'tcx>( b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'x>, - out: &mut Vec, -) -> Result, Args<'x>> { + args: Vec, +) -> Result, Vec> { let tcx = b.t.tcx; let std_of = |ty: Ty<'tcx>| match ty.peel_refs().kind() { ty::Adt(adt, _) => Std::of(tcx, adt.did()), @@ -25,47 +24,47 @@ pub fn call<'tcx, 'x>( let self_ty = call.args.types().next(); let self_std = self_ty.and_then(std_of); let e = match (owner, name) { - ("Arc", "new") => Expr::New(Box::new(Expr::Rt("Arc".into())), b.args(args, out)), - ("Arc", "downgrade") => Expr::New(Box::new(Expr::Rt("Weak".into())), b.args(args, out)), - ("Arc", "strong_count") => first(b, args, out).member("strong"), + ("Arc", "new") => Expr::New(Box::new(Expr::Rt("Arc".into())), args), + ("Arc", "downgrade") => Expr::New(Box::new(Expr::Rt("Weak".into())), args), + ("Arc", "strong_count") => first(args).member("strong"), ("Arc", "ptr_eq") => { - let [l, r] = two(b, args, out); + let [l, r] = two(args); l.binary("===", r) } - ("Weak", "upgrade") => Expr::rt("weakUpgrade", b.args(args, out)), - ("Weak", "strong_count") => first(b, args, out).member("arc").member("strong"), + ("Weak", "upgrade") => Expr::rt("weakUpgrade", args), + ("Weak", "strong_count") => first(args).member("arc").member("strong"), ("Weak", "ptr_eq") => { - let [l, r] = two(b, args, out); + let [l, r] = two(args); l.member("arc").binary("===", r.member("arc")) } - ("Clone", "clone") if self_std == Some(Std::Arc) => Expr::rt("arcClone", b.args(args, out)), - ("Clone", "clone") if self_std == Some(Std::Weak) => Expr::rt("weakClone", b.args(args, out)), + ("Clone", "clone") if self_std == Some(Std::Arc) => Expr::rt("arcClone", args), + ("Clone", "clone") if self_std == Some(Std::Weak) => Expr::rt("weakClone", args), // A waker is the executor's, whose `clone` is its own. - ("Clone", "clone") if self_std == Some(Std::Waker) => first(b, args, out).member("clone").call(vec![]), + ("Clone", "clone") if self_std == Some(Std::Waker) => first(args).member("clone").call(vec![]), ("Deref", "deref") | ("DerefMut", "deref_mut") => match self_std { - Some(Std::Arc | Std::Mutex | Std::MutexGuard) => first(b, args, out).member("value"), - Some(Std::Pin) => first(b, args, out), + Some(Std::Arc | Std::Mutex | Std::MutexGuard) => first(args).member("value"), + Some(Std::Pin) => first(args), _ => return Err(args), }, - ("Mutex", "new") => Expr::New(Box::new(Expr::Rt("Mutex".into())), b.args(args, out)), + ("Mutex", "new") => Expr::New(Box::new(Expr::Rt("Mutex".into())), args), // The mutex is its own guard, and a lock never fails on one thread. - ("Mutex", "lock") => first(b, args, out), + ("Mutex", "lock") => first(args), ("Result", "unwrap" | "expect") if call.args.types().nth(1).and_then(std_of) == Some(Std::PoisonError) => { - first(b, args, out) + first(args) } - ("Waker", "wake_by_ref") => first(b, args, out).member("wakeByRef").call(vec![]), - ("Waker", "wake") => first(b, args, out).member("wake").call(vec![]), + ("Waker", "wake_by_ref") => first(args).member("wakeByRef").call(vec![]), + ("Waker", "wake") => first(args).member("wake").call(vec![]), ("Waker", "will_wake") => { - let [l, r] = two(b, args, out); + let [l, r] = two(args); l.member("willWake").call(vec![r]) } ("Context", "waker" | "from_waker") | ("Pin", "new" | "new_unchecked" | "as_mut" | "get_mut" | "get_unchecked_mut") | ("future", "get_context") - | ("IntoFuture", "into_future") => first(b, args, out), + | ("IntoFuture", "into_future") => first(args), ("mem", "drop") => { let ty = call.args.type_at(0); - let value = first(b, args, out); + let value = first(args); match b.t.drop_value(value.clone(), ty, call.span) { Some(dropped) => dropped, None if value.is_path() => Expr::undefined(), @@ -77,12 +76,12 @@ pub fn call<'tcx, 'x>( Ok(Some(e)) } -fn first<'tcx>(b: &mut Body<'_, '_, 'tcx>, args: Args<'_>, out: &mut Vec) -> Expr { - b.args(args, out).into_iter().next().unwrap_or_else(Expr::undefined) +fn first(args: Vec) -> Expr { + args.into_iter().next().unwrap_or_else(Expr::undefined) } -fn two<'tcx>(b: &mut Body<'_, '_, 'tcx>, args: Args<'_>, out: &mut Vec) -> [Expr; 2] { - let mut values = b.args(args, out).into_iter(); +fn two(args: Vec) -> [Expr; 2] { + let mut values = args.into_iter(); [ values.next().unwrap_or_else(Expr::undefined), values.next().unwrap_or_else(Expr::undefined), diff --git a/ts/src/print.rs b/ts/src/print.rs index 653e2e378..c2a6e8216 100644 --- a/ts/src/print.rs +++ b/ts/src/print.rs @@ -7,7 +7,7 @@ use std::path::{Component, Path, PathBuf}; use oxc_sourcemap::SourceMapBuilder; use crate::program::{HEADER, ModPath, Program, SymKind, is_type_module, module_file}; -use crate::ts::{Ctor, Expr, FieldInit, Function, Item, Key, Loc, Param, Stmt, StmtKind, SymId, Target, Type}; +use crate::ts::{Ctor, Expr, FieldInit, Function, Item, Key, Loc, Param, Stmt, StmtKind, SymId, Type}; pub struct Printed { pub code: String, @@ -317,20 +317,7 @@ impl Refs { self.expr(program, cond); self.stmts(program, body); } - StmtKind::ForRange { start, end, body, .. } => { - self.expr(program, start); - self.expr(program, end); - self.stmts(program, body); - } - StmtKind::ForOf { iter, body, .. } => { - self.expr(program, iter); - self.stmts(program, body); - } StmtKind::Block { body, .. } => self.stmts(program, body), - StmtKind::Try { body, finally } => { - self.stmts(program, body); - self.stmts(program, finally); - } StmtKind::Catch { body, handler, .. } => { self.stmts(program, body); self.stmts(program, handler); @@ -354,7 +341,7 @@ impl Refs { fn expr(&mut self, program: &Program, e: &Expr) { match e { - Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Sym(id) => self.use_sym(program, *id, true), Expr::Array(es) => es.iter().for_each(|e| self.expr(program, e)), Expr::Object(props) => props.iter().for_each(|(_, e)| self.expr(program, e)), @@ -597,21 +584,16 @@ impl Printer<'_> { self.start(); self.mark(f.loc); let name = self.program.syms[f.sym].name.clone(); - let star = if f.generator { "*" } else { "" }; match (module, &self.program.syms[f.sym].alias) { (true, Some(alias)) => { self.aliases.push((name.clone(), alias.clone())); - self.write(&format!("function{star} {name}(")); + self.write(&format!("function {name}(")); } - (true, None) => self.write(&format!("export function{star} {name}(")), - (false, _) => self.write(&format!("{star}{name}(")), + (true, None) => self.write(&format!("export function {name}(")), + (false, _) => self.write(&format!("{name}(")), } self.params(&f.params); - let mut ret = self.ty(&f.ret); - if f.generator { - self.uses_rt = true; - ret = format!("Generator"); - } + let ret = self.ty(&f.ret); self.write(&format!("): {ret} {{\n")); self.block_body(&f.body); self.start(); @@ -645,27 +627,6 @@ impl Printer<'_> { self.renames.get(name).map_or(name, String::as_str) } - fn target(&mut self, target: &Target) { - match target { - Target::Name(name) => { - let name = self.local(name).to_string(); - self.write(&name); - } - Target::Array(items) => { - self.write("["); - for (i, item) in items.iter().enumerate() { - if i > 0 { - self.write(", "); - } - if let Some(item) = item { - self.target(item); - } - } - self.write("]"); - } - } - } - fn params(&mut self, params: &[Param]) { for (i, param) in params.iter().enumerate() { if i > 0 { @@ -709,12 +670,13 @@ impl Printer<'_> { } StmtKind::Decl { mutable, - target, + name, ty, init, } => { self.write(if *mutable { "let " } else { "const " }); - self.target(target); + let name = self.local(name).to_string(); + self.write(&name); if let Some(ty) = ty { let ty = self.ty(ty); self.write(&format!(": {ty}")); @@ -777,41 +739,6 @@ impl Printer<'_> { self.start(); self.write("}\n"); } - StmtKind::ForRange { - label, - name, - start, - end, - inclusive, - body, - } => { - self.label(label); - let name = self.local(name).to_string(); - self.write(&format!("for (let {name} = ")); - self.expr(start, 2); - let op = if *inclusive { "<=" } else { "<" }; - self.write(&format!("; {name} {op} ")); - self.expr(end, 13); - self.write(&format!("; {name}++) {{\n")); - self.block_body(body); - self.start(); - self.write("}\n"); - } - StmtKind::ForOf { - label, - name, - iter, - body, - } => { - self.label(label); - let name = self.local(name).to_string(); - self.write(&format!("for (const {name} of ")); - self.expr(iter, 2); - self.write(") {\n"); - self.block_body(body); - self.start(); - self.write("}\n"); - } StmtKind::Block { label, body } => { self.label(label); self.write("{\n"); @@ -819,15 +746,6 @@ impl Printer<'_> { self.start(); self.write("}\n"); } - StmtKind::Try { body, finally } => { - self.write("try {\n"); - self.block_body(body); - self.start(); - self.write("} finally {\n"); - self.block_body(finally); - self.start(); - self.write("}\n"); - } StmtKind::Catch { body, name, handler } => { self.write("try {\n"); self.block_body(body); @@ -1013,7 +931,6 @@ impl Printer<'_> { self.write("}"); } } - Expr::Yield => self.write("yield"), Expr::Lambda(params, body) => { self.write("("); self.params(params); @@ -1171,7 +1088,7 @@ fn binary_prec(op: &str) -> u8 { fn prec(e: &Expr) -> u8 { match e { - Expr::Assign(..) | Expr::Arrow(..) | Expr::Lambda(..) | Expr::Yield => 3, + Expr::Assign(..) | Expr::Arrow(..) | Expr::Lambda(..) => 3, Expr::Cond(..) => 4, Expr::Binary(_, op, _) => binary_prec(op), Expr::As(..) => 12, @@ -1209,8 +1126,8 @@ pub fn quote(s: &str) -> String { fn collect_locals(stmts: &[Stmt], out: &mut Vec) { for stmt in stmts { match &stmt.kind { - StmtKind::Decl { target, init, .. } => { - collect_target(target, out); + StmtKind::Decl { name, init, .. } => { + out.push(name.clone()); if let Some(init) = init { collect_expr_locals(init, out); } @@ -1225,24 +1142,7 @@ fn collect_locals(stmts: &[Stmt], out: &mut Vec) { collect_expr_locals(cond, out); collect_locals(body, out); } - StmtKind::ForRange { - name, start, end, body, .. - } => { - out.push(name.clone()); - collect_expr_locals(start, out); - collect_expr_locals(end, out); - collect_locals(body, out); - } - StmtKind::ForOf { name, iter, body, .. } => { - out.push(name.clone()); - collect_expr_locals(iter, out); - collect_locals(body, out); - } StmtKind::Block { body, .. } => collect_locals(body, out), - StmtKind::Try { body, finally } => { - collect_locals(body, out); - collect_locals(finally, out); - } StmtKind::Catch { body, name, handler } => { collect_locals(body, out); out.push(name.clone()); @@ -1265,13 +1165,6 @@ fn collect_locals(stmts: &[Stmt], out: &mut Vec) { } } -fn collect_target(target: &Target, out: &mut Vec) { - match target { - Target::Name(name) => out.push(name.clone()), - Target::Array(items) => items.iter().flatten().for_each(|t| collect_target(t, out)), - } -} - fn collect_expr_locals(e: &Expr, out: &mut Vec) { match e { Expr::Arrow(params, _, body) => { @@ -1300,6 +1193,6 @@ fn collect_expr_locals(e: &Expr, out: &mut Vec) { collect_expr_locals(b, out); collect_expr_locals(c, out); } - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} } } diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 6b7e04881..4d7ee48c9 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -50,8 +50,6 @@ pub enum Expr { /// `e as T`: a literal whose type TypeScript would widen, or an integer cast to /// another integer type with the same value. As(Box, Type), - /// `yield`, which a generator resumes from with the next `rt.Context`. - Yield, Located(Loc, Box), } @@ -124,10 +122,6 @@ impl Expr { } } - pub fn and(self, rhs: Expr) -> Self { - self.binary("&&", rhs) - } - /// This without an outer `as`, where the context already gives the type. pub fn typed(self) -> Self { match self { @@ -186,7 +180,7 @@ pub enum StmtKind { Expr(Expr), Decl { mutable: bool, - target: Target, + name: String, ty: Option, init: Option, }, @@ -201,32 +195,12 @@ pub enum StmtKind { cond: Expr, body: Vec, }, - /// `for (let name = start; name < end; name++)`, or `<=` if `inclusive`. - ForRange { - label: Option, - name: String, - start: Expr, - end: Expr, - inclusive: bool, - body: Vec, - }, - ForOf { - label: Option, - name: String, - iter: Expr, - body: Vec, - }, Block { label: Option, body: Vec, }, Break(Option), Continue(Option), - /// `try { body } finally { finally }`: what `finally` drops is dropped on every exit. - Try { - body: Vec, - finally: Vec, - }, /// `try { body } catch (name) { handler }`. Catch { body: Vec, @@ -263,28 +237,20 @@ impl StmtKind { }; Self::Decl { mutable, - target: Target::Name(name.into()), + name: name.into(), ty, init, } } } -/// What a declaration binds: a name, or an array destructured into names. -#[derive(Clone, Debug)] -pub enum Target { - Name(String), - /// `[a, , [b, c]]`; `None` skips an element. - Array(Vec>), -} - impl Stmt { /// Whether control never reaches the statement after this one. pub fn diverges(&self) -> bool { match &self.kind { StmtKind::Return(_) | StmtKind::Break(_) | StmtKind::Continue(_) | StmtKind::Throw(_) => true, StmtKind::If { then, els, .. } => diverges(then) && diverges(els), - StmtKind::Block { label: None, body } | StmtKind::Try { body, .. } => diverges(body), + StmtKind::Block { label: None, body } => diverges(body), StmtKind::While { label, cond: Expr::Lit(cond), @@ -304,61 +270,16 @@ fn breaks_out(stmts: &[Stmt], label: Option<&str>, nested: bool) -> bool { StmtKind::Break(Some(target)) => Some(target.as_str()) == label, StmtKind::If { then, els, .. } => breaks_out(then, label, nested) || breaks_out(els, label, nested), StmtKind::Block { body, .. } => breaks_out(body, label, nested), - StmtKind::Try { body, finally } => breaks_out(body, label, nested) || breaks_out(finally, label, nested), StmtKind::Catch { body, handler, .. } => breaks_out(body, label, nested) || breaks_out(handler, label, nested), // An unlabeled `break` in a case leaves the switch. StmtKind::Switch { cases, default, .. } => { cases.iter().any(|(_, body)| breaks_out(body, label, true)) || breaks_out(default, label, true) } - StmtKind::While { body, .. } | StmtKind::ForRange { body, .. } | StmtKind::ForOf { body, .. } => { - breaks_out(body, label, true) - } + StmtKind::While { body, .. } => breaks_out(body, label, true), _ => false, }) } -/// Whether `stmts` name the local `name` anywhere, their closures included. -pub fn mentions(stmts: &[Stmt], name: &str) -> bool { - let expr = |e: &Expr| e.mentions(name); - stmts.iter().any(|stmt| match &stmt.kind { - StmtKind::Expr(e) | StmtKind::Return(Some(e)) | StmtKind::Throw(e) => expr(e), - StmtKind::Decl { init, .. } => init.as_ref().is_some_and(expr), - StmtKind::Catch { body, handler, .. } => mentions(body, name) || mentions(handler, name), - StmtKind::Switch { - disc, cases, default, .. - } => { - expr(disc) || cases.iter().any(|(test, body)| expr(test) || mentions(body, name)) || mentions(default, name) - } - StmtKind::Declare { .. } => false, - StmtKind::If { cond, then, els } => expr(cond) || mentions(then, name) || mentions(els, name), - StmtKind::While { cond, body, .. } => expr(cond) || mentions(body, name), - StmtKind::ForRange { start, end, body, .. } => expr(start) || expr(end) || mentions(body, name), - StmtKind::ForOf { iter, body, .. } => expr(iter) || mentions(body, name), - StmtKind::Block { body, .. } => mentions(body, name), - StmtKind::Try { body, finally } => mentions(body, name) || mentions(finally, name), - StmtKind::Return(None) | StmtKind::Break(_) | StmtKind::Continue(_) => false, - }) -} - -impl Expr { - fn mentions(&self, name: &str) -> bool { - match self { - Self::Ident(ident) => ident == name, - Self::This | Self::Sym(_) | Self::Rt(_) | Self::Lit(_) | Self::Str(_) | Self::Yield => false, - Self::Array(es) => es.iter().any(|e| e.mentions(name)), - Self::Object(props) => props.iter().any(|(_, e)| e.mentions(name)), - Self::Member(e, _) | Self::Unary(_, e) | Self::Postfix(e, _) | Self::Located(_, e) | Self::As(e, _) => { - e.mentions(name) - } - Self::Index(a, b) | Self::Binary(a, _, b) | Self::Assign(a, b) => a.mentions(name) || b.mentions(name), - Self::Call(f, args) | Self::New(f, args) => f.mentions(name) || args.iter().any(|e| e.mentions(name)), - Self::Cond(a, b, c) => a.mentions(name) || b.mentions(name) || c.mentions(name), - Self::Arrow(_, _, body) => mentions(body, name), - Self::Lambda(_, body) => body.mentions(name), - } - } -} - /// Whether control never falls off the end of `stmts`. pub fn diverges(stmts: &[Stmt]) -> bool { stmts.last().is_some_and(Stmt::diverges) @@ -391,9 +312,6 @@ pub struct Function { pub body: Vec, pub loc: Option, pub doc: Option, - /// An async body, run as a generator: `function*`, returning `Generator`. - pub generator: bool, } #[derive(Clone, Debug)] diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 4e86fa754..ce462f802 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -56,25 +56,6 @@ fn translated(name: &str) -> PathBuf { out } -/// Run the driver on a fixture with bodies lowered from MIR, the spike's prototype. -fn translate_mir(name: &str) -> (PathBuf, Output) { - let out = scratch().join(name).join("mir"); - let config = fixture(name).join("ts.toml"); - let args: [&std::ffi::OsStr; 4] = ["--out".as_ref(), out.as_ref(), "--lower".as_ref(), "mir".as_ref()]; - let output = driver(name, &config, &args, "mir"); - (out, output) -} - -fn translated_mir(name: &str) -> PathBuf { - let (out, output) = translate_mir(name); - assert!( - output.status.success(), - "translating {name} from MIR failed:\n{}", - String::from_utf8_lossy(&output.stderr) - ); - out -} - /// The generated TypeScript, by path relative to `dir`, without the runtime. fn sources(dir: &Path) -> Vec<(PathBuf, String)> { let mut files = Vec::new(); @@ -271,10 +252,8 @@ fn shake(out: &Path) { "Err", "Ok", "Panic", - "at", "checked", "clamp", - "idx", "max", "panic", "sliceRange", @@ -299,14 +278,6 @@ fn shake(out: &Path) { } } -/// The codec with bodies lowered from MIR: the same differential test, without a snapshot. -#[test] -fn codec_mir() { - let out = translated_mir("codec"); - typecheck(&out); - differential("codec-fixture", &out, "harness.ts", 20_000, &[]); -} - /// Adding a root changes only the output of what it reaches: everything else keeps its /// text and order, though translation reaches it in another order. #[test] @@ -390,13 +361,6 @@ fn lang() { lang_differential(&out); } -/// The language fixture with bodies lowered from MIR. -#[test] -fn lang_mir() { - let out = translated_mir("lang"); - lang_differential(&out); -} - fn lang_differential(out: &Path) { // Hand-written callers, type-checked against the output they call: one runs it, and // one mixes integer types, which `tsc` must refuse. @@ -416,13 +380,6 @@ fn task() { task_differential(&out); } -/// Futures and drops with bodies lowered from MIR: each async body a state machine. -#[test] -fn task_mir() { - let out = translated_mir("task"); - task_differential(&out); -} - fn task_differential(out: &Path) { let harness = manifest_dir().join("tests").join("task.ts").display().to_string(); let text = format!( @@ -485,18 +442,11 @@ fn unwinding(out: &Path, entry: &str, scripts: u32) { #[test] fn reject() { let (out, output) = translate("reject"); - rejected(&out, &output, "expected.txt"); -} - -/// What lowering from MIR refuses in the same fixture. -#[test] -fn reject_mir() { - let (out, output) = translate_mir("reject"); - rejected(&out, &output, "expected-mir.txt"); + rejected(&out, &output); } -/// The errors of a failed translation, each with where it points, against `expected`. -fn rejected(out: &Path, output: &Output, expected: &str) { +/// The errors of a failed translation, each with where it points, against `expected.txt`. +fn rejected(out: &Path, output: &Output) { assert!(!output.status.success(), "translating reject succeeded"); assert!(!out.join("lib.ts").exists(), "a failed translation wrote output"); let stderr = String::from_utf8_lossy(&output.stderr); @@ -512,7 +462,7 @@ fn rejected(out: &Path, output: &Output, expected: &str) { got.push('\n'); } } - let path = fixture("reject").join(expected); + let path = fixture("reject").join("expected.txt"); if std::env::var_os("UPDATE_EXPECT").is_some() { std::fs::write(&path, &got).unwrap(); return; From 4ca3517b2e28bc1600175bf28bf7e70690d75dc7 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 16:50:06 -0700 Subject: [PATCH 03/17] perf(ts): return values in place and drop trailing void returns Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/codec/expected/bench.ts | 112 ++--- .../expected/coding/decode.DecodeError.ts | 86 ++-- .../codec/expected/coding/decode.Decoder.ts | 57 +-- .../expected/coding/encode.EncodeError.ts | 16 +- .../codec/expected/coding/encode.Encoder.ts | 143 +++--- .../codec/expected/coding/varint.Form.ts | 11 +- ts/fixtures/codec/expected/coding/varint.ts | 376 ++++++++-------- .../codec/expected/coding/version.Version.ts | 18 +- .../codec/expected/coding/version.Versions.ts | 100 ++--- ts/fixtures/codec/expected/harness.ts | 217 ++++----- .../codec/expected/lib.SessionError.ts | 12 +- .../codec/expected/lite/group.Group.ts | 85 ++-- ts/fixtures/codec/expected/lite/message.ts | 51 +-- .../codec/expected/lite/probe.Probe.ts | 106 ++--- ts/fixtures/lang/expected/fmt.Fails.ts | 8 +- ts/fixtures/lang/expected/fmt.Fault.ts | 27 +- ts/fixtures/lang/expected/fmt.Hex.ts | 6 +- ts/fixtures/lang/expected/fmt.Kind.ts | 12 +- ts/fixtures/lang/expected/fmt.Padded.ts | 13 +- ts/fixtures/lang/expected/fmt.Pair.ts | 6 +- ts/fixtures/lang/expected/fmt.Tup.ts | 6 +- ts/fixtures/lang/expected/fmt.ts | 5 - ts/fixtures/lang/expected/generics.Either.ts | 50 +-- ts/fixtures/lang/expected/generics.Wrap.ts | 8 +- ts/fixtures/lang/expected/harness.ts | 6 +- ts/fixtures/lang/expected/ints.ts | 44 -- ts/fixtures/lang/expected/iters.Countdown.ts | 6 +- ts/fixtures/lang/expected/iters.Evens.ts | 6 +- ts/fixtures/lang/expected/iters.Gaps.ts | 8 +- ts/fixtures/lang/expected/iters.Halving.ts | 6 +- ts/fixtures/lang/expected/iters.ts | 56 +-- ts/fixtures/lang/expected/shapes.Meters.ts | 1 - ts/fixtures/lang/expected/shapes.Point.ts | 7 +- ts/fixtures/lang/expected/shapes.Shape.ts | 17 +- ts/fixtures/lang/expected/shapes.ts | 420 ++++++++---------- ts/fixtures/task/expected/kio.Consumer.ts | 8 +- ts/fixtures/task/expected/kio.Producer.ts | 2 - ts/fixtures/task/expected/kio.Waiter.ts | 1 - ts/fixtures/task/expected/kio.ts | 18 +- ts/fixtures/task/expected/log.Log.ts | 1 - ts/fixtures/task/expected/model.Channel.ts | 18 +- ts/fixtures/task/expected/model.Guard.ts | 2 - ts/fixtures/task/expected/model.ts | 339 +++++--------- ts/src/lower/mir/cfg.rs | 10 + ts/src/lower/mir/mod.rs | 136 ++++++ 45 files changed, 1128 insertions(+), 1515 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index da1d3006d..79928d252 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -13,7 +13,6 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one workload. */ export function run(input: Uint8Array): rt.ByteVec { - let _0!: rt.ByteVec; let out!: rt.ByteVec; let op!: rt.u8; let _5!: [rt.u8, Uint8Array] | undefined; @@ -57,14 +56,13 @@ export function run(input: Uint8Array): rt.ByteVec { _38 = liteVersion(selector); decoded(decodeGroup(_9[1], _38, out), out); } - _0 = out; + return out; } else { - _0 = out; + return out; } } else { - _0 = out; + return out; } - return _0; } export function encoded(result: rt.Result, out: rt.ByteVec): void { @@ -73,7 +71,6 @@ export function encoded(result: rt.Result, o err = result.error; encodeError(out, err); } - return; } export function decoded(result: rt.Result, out: rt.ByteVec): void { @@ -82,12 +79,10 @@ export function decoded(result: rt.Result, o err = result.error; decodeError(out, err); } - return; } /** The same value, `count` times. */ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let count!: rt.u64; let _6!: [rt.u64, Uint8Array]; let value!: rt.u64; @@ -106,22 +101,20 @@ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVe iter.start++; } if (!_14Some) { - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { _17 = Encoder.varint(w, value); if (_17.ok) { continue l0; } else { - _0 = _17; + return _17; } } - return _0; } } /** Every varint on the wire: how many, and the last. */ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let r!: Decoder.Decoder; let count!: rt.usize; let last!: rt.u64; @@ -137,14 +130,13 @@ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVe count = rt.usizeAdd(count, 1); continue l0; } else { - _0 = _9; + return _9; } } else { putUsize(out, count); putU64(out, last); - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } - return _0; } } @@ -154,7 +146,6 @@ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVe * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let count!: rt.u64; let _6!: [rt.u64, Uint8Array]; let delta!: rt.u64; @@ -204,7 +195,7 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt _32 = iter.start++; } if (!_32Some) { - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { b2: { n = _32; @@ -229,19 +220,17 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt if (_51.ok) { continue l0; } else { - _0 = _51; + return _51; } } else { - _0 = _45; + return _45; } } - return _0; } } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let r!: Decoder.Decoder; let count!: rt.usize; let total!: rt.u64; @@ -263,18 +252,17 @@ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt count = rt.usizeAdd(count, 1); continue l0; } else { - _0 = _18; + return _18; } } else { - _0 = _12; + return _12; } } else { putUsize(out, count); putU64(out, total); putU64(out, rt.u64Cast(last)); - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } - return _0; } } @@ -308,51 +296,47 @@ export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt. last = 0; short = 0; l0: while (true) { - b1: { - if (!(end < _6[1].length)) { + if (!(end < _6[1].length)) { + if (!(start < end)) { + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + putUsize(out, short); + return rt.Ok(undefined); + } else { + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + } + } else { + end = rt.min(_6[1].length, rt.usizeAdd(end, read2)); + while (true) { if (!(start < end)) { - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - putUsize(out, short); - _0 = rt.Ok(undefined); + continue l0; } else { - _0 = rt.Err({ tag: "Short" } as DecodeError.DecodeError); - } - } else { - end = rt.min(_6[1].length, rt.usizeAdd(end, read2)); - while (true) { - if (!(start < end)) { + const slice = _6[1]; + r = Decoder.new(rt.sliceRange(slice, start, end), Form.from$From_Version(version)); + _32 = frameHeader(r); + if (_32.ok) { + delta = _32.value[0]; + size = _32.value[1]; + start = rt.usizeSub(end, Decoder.remaining(r)); + last = delta; + total = rt.u64Add(total, size); + count = rt.usizeAdd(count, 1); + } else if (_32.error.tag === "Short") { + short = rt.usizeAdd(short, 1); continue l0; } else { - const slice = _6[1]; - r = Decoder.new(rt.sliceRange(slice, start, end), Form.from$From_Version(version)); - _32 = frameHeader(r); - if (_32.ok) { - delta = _32.value[0]; - size = _32.value[1]; - start = rt.usizeSub(end, Decoder.remaining(r)); - last = delta; - total = rt.u64Add(total, size); - count = rt.usizeAdd(count, 1); - } else if (_32.error.tag === "Short") { - short = rt.usizeAdd(short, 1); - continue l0; - } else { - _0 = rt.Err(_32.error); - break b1; - } + _0 = rt.Err(_32.error); + return _0; } } } } - return _0; } } /** One FRAME header: the zigzag timestamp delta, then the size. */ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError> { - let _0!: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError>; let delta!: rt.i64; let _3!: rt.Result; let _9!: rt.Result; @@ -361,14 +345,13 @@ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], Dec delta = unzigzag(_3.value); _9 = Decoder.varint(r); if (_9.ok) { - _0 = rt.Ok([delta, _9.value] as [rt.i64, rt.u64]); + return rt.Ok([delta, _9.value] as [rt.i64, rt.u64]); } else { - _0 = _9; + return _9; } } else { - _0 = _3; + return _3; } - return _0; } /** One size-prefixed GROUP header, starting at the first frame. */ @@ -435,11 +418,9 @@ export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } } } - return; } export function decodeGroup(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let group!: Group.Group; let used!: rt.usize; let _6!: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError>; @@ -453,11 +434,10 @@ export function decodeGroup(wire: Uint8Array, version: Version.Version, out: rt. putU64(out, group.sequence); putU64(out, group.frameStart); putUsize(out, used); - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { - _0 = _6; + return _6; } - return _0; } //# sourceMappingURL=bench.ts.map diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index be4e2246a..792f59c62 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -5,7 +5,6 @@ import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import * as SessionError from "../lib.SessionError.ts"; export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Result { - let _0!: rt.Result; let __field0!: rt.u64; let args!: [rt.u64]; let size!: rt.usize; @@ -13,52 +12,51 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re let __displaySize!: rt.usize; let __displayMax!: rt.usize; if (self.tag === "Short") { - _0 = rt.fmtWriteStr(__formatter, "short buffer"); + return rt.fmtWriteStr(__formatter, "short buffer"); } else if (self.tag === "Long") { - _0 = rt.fmtWriteStr(__formatter, "long buffer"); + return rt.fmtWriteStr(__formatter, "long buffer"); } else if (self.tag === "InvalidString") { - _0 = rt.fmtWriteStr(__formatter, "invalid string"); + return rt.fmtWriteStr(__formatter, "invalid string"); } else if (self.tag === "InvalidMessage") { __field0 = ([self._0] as [rt.u64])[0]; args = [__field0] as [rt.u64]; const arg = args[0]; - _0 = rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(arg, f)]); + return rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(arg, f)]); } else if (self.tag === "InvalidSubscribeLocation") { - _0 = rt.fmtWriteStr(__formatter, "invalid subscribe location"); + return rt.fmtWriteStr(__formatter, "invalid subscribe location"); } else if (self.tag === "InvalidValue") { - _0 = rt.fmtWriteStr(__formatter, "invalid value"); + return rt.fmtWriteStr(__formatter, "invalid value"); } else if (self.tag === "TooMany") { - _0 = rt.fmtWriteStr(__formatter, "too many"); + return rt.fmtWriteStr(__formatter, "too many"); } else if (self.tag === "BoundsExceeded") { - _0 = rt.fmtWriteStr(__formatter, "bounds exceeded"); + return rt.fmtWriteStr(__formatter, "bounds exceeded"); } else if (self.tag === "ExpectedEnd") { - _0 = rt.fmtWriteStr(__formatter, "expected end"); + return rt.fmtWriteStr(__formatter, "expected end"); } else if (self.tag === "MessageTooLarge") { size = self.size; max = self.max; __displaySize = size; __displayMax = max; - _0 = rt.fmtWriteFmt(__formatter, ["message too large: ", (f: rt.Formatter) => rt.usizeDisplay(__displaySize, f), " bytes exceeds ", (f: rt.Formatter) => rt.usizeDisplay(__displayMax, f), " byte limit"]); + return rt.fmtWriteFmt(__formatter, ["message too large: ", (f: rt.Formatter) => rt.usizeDisplay(__displaySize, f), " bytes exceeds ", (f: rt.Formatter) => rt.usizeDisplay(__displayMax, f), " byte limit"]); } else if (self.tag === "ExpectedData") { - _0 = rt.fmtWriteStr(__formatter, "expected data"); + return rt.fmtWriteStr(__formatter, "expected data"); } else if (self.tag === "Duplicate") { - _0 = rt.fmtWriteStr(__formatter, "duplicate"); + return rt.fmtWriteStr(__formatter, "duplicate"); } else if (self.tag === "Missing") { - _0 = rt.fmtWriteStr(__formatter, "missing"); + return rt.fmtWriteStr(__formatter, "missing"); } else if (self.tag === "Unsupported") { - _0 = rt.fmtWriteStr(__formatter, "unsupported"); + return rt.fmtWriteStr(__formatter, "unsupported"); } else if (self.tag === "TrailingBytes") { - _0 = rt.fmtWriteStr(__formatter, "trailing bytes"); + return rt.fmtWriteStr(__formatter, "trailing bytes"); } else if (self.tag === "Version") { - _0 = rt.fmtWriteStr(__formatter, "unsupported version"); + return rt.fmtWriteStr(__formatter, "unsupported version"); } else if (self.tag === "Session") { - _0 = SessionError.fmt$Display(self._0, __formatter); + return SessionError.fmt$Display(self._0, __formatter); } else if (self.tag === "MalformedAuthToken") { - _0 = rt.fmtWriteStr(__formatter, "malformed authorization token"); + return rt.fmtWriteStr(__formatter, "malformed authorization token"); } else { - _0 = rt.fmtWriteStr(__formatter, "multiple authorization tokens"); + return rt.fmtWriteStr(__formatter, "multiple authorization tokens"); } - return _0; } export function from$From_FromUtf8Error(source: rt.FromUtf8Error): DecodeError { @@ -66,7 +64,6 @@ export function from$From_FromUtf8Error(source: rt.FromUtf8Error): DecodeError { } export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: rt.FromUtf8Error; let _7!: string; let _8!: rt.Fmt; @@ -83,29 +80,29 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result rt.fmtFromUtf8ErrorDebug(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8)); } else if (self.tag === "InvalidMessage") { __self02 = self._0; _11 = "InvalidMessage"; _12 = (f: rt.Formatter) => rt.u64Display(__self02, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _11), _12)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _11), _12)); } else if (self.tag === "InvalidSubscribeLocation") { - _0 = rt.fmtWriteStr(f, "InvalidSubscribeLocation"); + return rt.fmtWriteStr(f, "InvalidSubscribeLocation"); } else if (self.tag === "InvalidValue") { - _0 = rt.fmtWriteStr(f, "InvalidValue"); + return rt.fmtWriteStr(f, "InvalidValue"); } else if (self.tag === "TooMany") { - _0 = rt.fmtWriteStr(f, "TooMany"); + return rt.fmtWriteStr(f, "TooMany"); } else if (self.tag === "BoundsExceeded") { - _0 = rt.fmtWriteStr(f, "BoundsExceeded"); + return rt.fmtWriteStr(f, "BoundsExceeded"); } else if (self.tag === "ExpectedEnd") { - _0 = rt.fmtWriteStr(f, "ExpectedEnd"); + return rt.fmtWriteStr(f, "ExpectedEnd"); } else if (self.tag === "MessageTooLarge") { __self1 = self.max; _21 = "MessageTooLarge"; @@ -113,30 +110,29 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result rt.usizeDisplay(self.size, f); _24 = "max"; _25 = (f: rt.Formatter) => rt.usizeDisplay(__self1, f); - _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _21), _22, _23), _24, _25)); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _21), _22, _23), _24, _25)); } else if (self.tag === "ExpectedData") { - _0 = rt.fmtWriteStr(f, "ExpectedData"); + return rt.fmtWriteStr(f, "ExpectedData"); } else if (self.tag === "Duplicate") { - _0 = rt.fmtWriteStr(f, "Duplicate"); + return rt.fmtWriteStr(f, "Duplicate"); } else if (self.tag === "Missing") { - _0 = rt.fmtWriteStr(f, "Missing"); + return rt.fmtWriteStr(f, "Missing"); } else if (self.tag === "Unsupported") { - _0 = rt.fmtWriteStr(f, "Unsupported"); + return rt.fmtWriteStr(f, "Unsupported"); } else if (self.tag === "TrailingBytes") { - _0 = rt.fmtWriteStr(f, "TrailingBytes"); + return rt.fmtWriteStr(f, "TrailingBytes"); } else if (self.tag === "Version") { - _0 = rt.fmtWriteStr(f, "Version"); + return rt.fmtWriteStr(f, "Version"); } else if (self.tag === "Session") { __self03 = self._0; _34 = "Session"; _35 = (f: rt.Formatter) => SessionError.fmt$Debug(__self03, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _34), _35)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _34), _35)); } else if (self.tag === "MalformedAuthToken") { - _0 = rt.fmtWriteStr(f, "MalformedAuthToken"); + return rt.fmtWriteStr(f, "MalformedAuthToken"); } else { - _0 = rt.fmtWriteStr(f, "MultipleAuthTokens"); + return rt.fmtWriteStr(f, "MultipleAuthTokens"); } - return _0; } /** A decode error. */ @@ -163,13 +159,11 @@ export type DecodeError = /** A complete frame cannot be extended by reading more stream bytes. */ export function complete(self: DecodeError): DecodeError { - let _0!: DecodeError; if (self.tag === "Short") { - _0 = { tag: "InvalidValue" } as DecodeError; + return { tag: "InvalidValue" } as DecodeError; } else { - _0 = self; + return self; } - return _0; } export function from$From_BoundsExceeded(_1: BoundsExceeded.BoundsExceeded): DecodeError { diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 5443ae050..487ce4f2e 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -66,16 +66,14 @@ export function isEmpty(self: Decoder): boolean { /** Read `len` raw bytes. */ export function slice(self: Decoder, len: rt.usize): rt.Result { - let _0!: rt.Result; let _6!: [Uint8Array, Uint8Array] | undefined; _6 = rt.sliceSplitAtChecked(self.buf, len); if (_6 !== undefined) { self.buf = _6[1]; - _0 = rt.Ok(_6[0]); + return rt.Ok(_6[0]); } else { - _0 = rt.Err(short(self, len)); + return rt.Err(short(self, len)); } - return _0; } /** Read every remaining byte. */ @@ -87,20 +85,17 @@ export function rest(self: Decoder): Uint8Array { /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ export function sub(self: Decoder, len: rt.usize): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; _4 = slice(self, len); if (_4.ok) { - _0 = rt.Ok(new_(_4.value, self.form)); + return rt.Ok(new_(_4.value, self.form)); } else { - _0 = _4; + return _4; } - return _0; } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; let _8!: rt.usize; let _9!: rt.usize; @@ -111,16 +106,14 @@ export function u8(self: Decoder): rt.Result { if (!(_8 < _9)) { rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); } - _0 = rt.Ok(_3.value[_8]); + return rt.Ok(_3.value[_8]); } else { - _0 = _3; + return _3; } - return _0; } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - let _0!: rt.Result; let _2!: rt.Result; let _9!: rt.u8; let _10!: rt.usize; @@ -140,32 +133,29 @@ export function u16(self: Decoder): rt.Result { if (!(_14 < _15)) { rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); } - _0 = rt.Ok((_9 << 8) | _2.value[_14]); + return rt.Ok((_9 << 8) | _2.value[_14]); } else { - _0 = _2; + return _2; } - return _0; } /** Read a byte that must be 0 or 1. */ export function bool(self: Decoder): rt.Result { - let _0!: rt.Result; let _2!: rt.Result; let val!: rt.u8; _2 = u8(self); if (_2.ok) { val = _2.value; if (val === 0) { - _0 = rt.Ok(false); + return rt.Ok(false); } else if (val === 1) { - _0 = rt.Ok(true); + return rt.Ok(true); } else { - _0 = rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); } } else { - _0 = _2; + return _2; } - return _0; } /** Read a varint. */ @@ -192,20 +182,17 @@ export function varint(self: Decoder): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; _3 = varint(self); if (_3.ok) { - _0 = rt.Ok(rt.u64CheckedSub(_3.value, 1)); + return rt.Ok(rt.u64CheckedSub(_3.value, 1)); } else { - _0 = _3; + return _3; } - return _0; } /** Read a varint length, then that many raw bytes. */ export function bytes(self: Decoder): rt.Result { - let _0!: rt.Result; let start!: Uint8Array; let _3!: rt.Result; let _6!: rt.Result; @@ -216,22 +203,19 @@ export function bytes(self: Decoder): rt.Result { + return rt.resultInspectErr(slice(self, _3.value), (_22: DecodeError.DecodeError): void => { self.buf = start; - return; }); } else { - _0 = _3; + return _3; } } else { - _0 = _6; + return _6; } - return _0; } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - let _0!: rt.Result; let _2!: rt.Result; let _5!: rt.Result; let residual2!: rt.Result; @@ -239,15 +223,14 @@ export function string(self: Decoder): rt.Result { - let _0!: rt.Result; if (self === "BoundsExceeded") { - _0 = rt.fmtWriteStr(__formatter, "bounds exceeded"); + return rt.fmtWriteStr(__formatter, "bounds exceeded"); } else if (self === "TooLarge") { - _0 = rt.fmtWriteStr(__formatter, "too large"); + return rt.fmtWriteStr(__formatter, "too large"); } else if (self === "Short") { - _0 = rt.fmtWriteStr(__formatter, "short buffer"); + return rt.fmtWriteStr(__formatter, "short buffer"); } else if (self === "InvalidState") { - _0 = rt.fmtWriteStr(__formatter, "invalid state"); + return rt.fmtWriteStr(__formatter, "invalid state"); } else if (self === "TooMany") { - _0 = rt.fmtWriteStr(__formatter, "too many"); + return rt.fmtWriteStr(__formatter, "too many"); } else if (self === "Version") { - _0 = rt.fmtWriteStr(__formatter, "unsupported version"); + return rt.fmtWriteStr(__formatter, "unsupported version"); } else { - _0 = rt.fmtWriteStr(__formatter, "unsupported"); + return rt.fmtWriteStr(__formatter, "unsupported"); } - return _0; } export function fmt$Debug(self: EncodeError, f: rt.Formatter): rt.Result { diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index c98598591..3f5b61497 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -28,13 +28,11 @@ function new_(buf: rt.ByteVec, form: Form.Form): Encoder { /** Write raw bytes. */ export function slice(self: Encoder, v: Uint8Array): void { rt.byteVecExtendFromSlice(self.buf, v); - return; } /** Write a single byte. */ export function u8(self: Encoder, v: rt.u8): void { rt.byteVecPush(self.buf, v); - return; } /** Write a big-endian `u16`. */ @@ -44,63 +42,52 @@ export function u16(self: Encoder, v: rt.u16): void { _7 = self.buf; _6 = rt.u16ToBeBytes(v); rt.byteVecExtendFromSlice(_7, _6); - return; } /** Write a bool as a 0 or 1 byte. */ export function bool(self: Encoder, v: boolean): void { rt.byteVecPush(self.buf, v ? 1 : 0); - return; } /** Write a varint, or fail with [`EncodeError::BoundsExceeded`] if the form cannot carry it. */ export function varint(self: Encoder, v: rt.u64): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; _3 = write(v, self.form, self.buf); if (_3.ok) { - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { const residual = rt.Err({}); - _0 = rt.Err(EncodeError.from$From_BoundsExceeded((residual as { ok: false; error: BoundsExceeded.BoundsExceeded }).error)); + return rt.Err(EncodeError.from$From_BoundsExceeded((residual as { ok: false; error: BoundsExceeded.BoundsExceeded }).error)); } - return _0; } /** Write an optional varint: `None` as 0, and `Some(n)` as `n + 1`. */ export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { - let _0!: rt.Result; let v2!: rt.u64; let _6!: rt.Result; - b0: { - if (v === undefined) { - v2 = 0; + if (v === undefined) { + v2 = 0; + } else { + _6 = rt.optionOkOr(rt.u64CheckedAdd(v, 1), "TooLarge" as EncodeError.EncodeError); + if (_6.ok) { + v2 = _6.value; } else { - _6 = rt.optionOkOr(rt.u64CheckedAdd(v, 1), "TooLarge" as EncodeError.EncodeError); - if (_6.ok) { - v2 = _6.value; - } else { - _0 = _6; - break b0; - } + return _6; } - _0 = varint(self, v2); } - return _0; + return varint(self, v2); } /** Write a varint length, then the raw bytes. */ export function bytes(self: Encoder, v: Uint8Array): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; _3 = varint(self, v.length as rt.u64); if (_3.ok) { slice(self, v); - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { - _0 = _3; + return _3; } - return _0; } /** Write a varint length, then the UTF-8 bytes. */ @@ -144,12 +131,10 @@ export function discard(self: Encoder, prefix: Prefix.Prefix): void { start = rt.usizeSub(prefix.body, 2); } rt.byteVecTruncate(self.buf, start); - return; } /** Size a reserved prefix to everything written since. */ export function fill(self: Encoder, prefix: Prefix.Prefix): rt.Result { - let _0!: rt.Result; let body!: rt.usize; let end!: rt.usize; let _7!: rt.Result; @@ -174,66 +159,60 @@ export function fill(self: Encoder, prefix: Prefix.Prefix): rt.Result { - return "TooLarge" as EncodeError.EncodeError; - }); - if (_7.ok) { - size = _7.value; - _75 = self.buf; - const part = rt.usizeSub(body, 2); - const slice_ = rt.byteVecView(_75); - _16 = rt.sliceRange(slice_, part, body); - _22 = rt.u16ToBeBytes(size); - rt.sliceCopyFromSlice(_16, _22); - } else { - _0 = _7; - break b0; - } + const residual2 = rt.Err({}); + return rt.Err(EncodeError.from$From_BoundsExceeded((residual2 as { ok: false; error: BoundsExceeded.BoundsExceeded }).error)); + } + } else { + _7 = rt.resultMapErr(rt.u16TryFrom(rt.usizeSub(end, body)), (_2: rt.TryFromIntError): EncodeError.EncodeError => { + return "TooLarge" as EncodeError.EncodeError; + }); + if (_7.ok) { + size = _7.value; + _75 = self.buf; + const part = rt.usizeSub(body, 2); + const slice_ = rt.byteVecView(_75); + _16 = rt.sliceRange(slice_, part, body); + _22 = rt.u16ToBeBytes(size); + rt.sliceCopyFromSlice(_16, _22); + } else { + return _7; } - _0 = rt.Ok(undefined); } - return _0; + return rt.Ok(undefined); } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/varint.Form.ts b/ts/fixtures/codec/expected/coding/varint.Form.ts index 1e6399701..bc43ba703 100644 --- a/ts/fixtures/codec/expected/coding/varint.Form.ts +++ b/ts/fixtures/codec/expected/coding/varint.Form.ts @@ -6,15 +6,10 @@ import type * as Version from "../lite/version.Version.ts"; export type Form = { tag: "Quic" } | { tag: "LeadingOnes"; seven: boolean }; export function from$From_Version(version: Version.Version): Form { - let _0!: Form; - b0: { - if (!(version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06")) { - _0 = { tag: "LeadingOnes", seven: true } as Form; - break b0; - } - _0 = { tag: "Quic" } as Form; + if (!(version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06")) { + return { tag: "LeadingOnes", seven: true } as Form; } - return _0; + return { tag: "Quic" } as Form; } //# sourceMappingURL=varint.Form.ts.map diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index fa7b0d9a9..2b532eacd 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -17,84 +17,79 @@ export function fromHalves(hi: rt.u32, lo: rt.u32): rt.u64 { /** The bytes `value` takes on the wire in `form`, or [`BoundsExceeded`] if it does not fit. */ export function size(value: rt.u64, form: Form.Form): rt.Result { - let _0!: rt.Result; let hi!: rt.u32; let lo!: rt.u32; let _5!: [rt.u32, rt.u32]; let _6!: rt.usize; _5 = toHalves(value); - b0: { - b1: { - hi = _5[0]; - lo = _5[1]; - if (form.tag === "Quic") { - if (hi === 0) { - if (lo < 64) { - _6 = 1; - break b1; - } - } - if (hi === 0) { - if (lo < 16384) { - _6 = 2; - break b1; - } + b1: { + hi = _5[0]; + lo = _5[1]; + if (form.tag === "Quic") { + if (hi === 0) { + if (lo < 64) { + _6 = 1; + break b1; } - if (hi === 0) { - if (lo < 1073741824) { - _6 = 4; - break b1; - } + } + if (hi === 0) { + if (lo < 16384) { + _6 = 2; + break b1; } - if (!(hi < 1073741824)) { - _0 = rt.Err({}); - break b0; - } else { - _6 = 8; + } + if (hi === 0) { + if (lo < 1073741824) { + _6 = 4; + break b1; } + } + if (!(hi < 1073741824)) { + return rt.Err({}); } else { - if (hi === 0) { - if (lo < 128) { - _6 = 1; - break b1; - } + _6 = 8; + } + } else { + if (hi === 0) { + if (lo < 128) { + _6 = 1; + break b1; } - if (hi === 0) { - if (lo < 16384) { - _6 = 2; - break b1; - } + } + if (hi === 0) { + if (lo < 16384) { + _6 = 2; + break b1; } - if (hi === 0) { - if (lo < 2097152) { - _6 = 3; - break b1; - } + } + if (hi === 0) { + if (lo < 2097152) { + _6 = 3; + break b1; } - if (hi === 0) { - if (lo < 268435456) { - _6 = 4; - break b1; - } + } + if (hi === 0) { + if (lo < 268435456) { + _6 = 4; + break b1; } - if (!(hi < 8)) { - if (!(hi < 1024)) { - if (!(hi < 16777216)) { - _6 = 9; - } else { - _6 = 8; - } + } + if (!(hi < 8)) { + if (!(hi < 1024)) { + if (!(hi < 16777216)) { + _6 = 9; } else { - _6 = 6; + _6 = 8; } } else { - _6 = 5; + _6 = 6; } + } else { + _6 = 5; } } - _0 = rt.Ok(_6); } - return _0; + return rt.Ok(_6); } /** @@ -103,18 +98,15 @@ export function size(value: rt.u64, form: Form.Form): rt.Result { - let _0!: rt.Result; if (form.tag === "Quic") { - _0 = writeQuic(value, out); + return writeQuic(value, out); } else { writeLeadingOnes(value, out); - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } - return _0; } export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let hi!: rt.u32; let lo!: rt.u32; let _5!: [rt.u32, rt.u32]; @@ -128,47 +120,43 @@ export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result>> 0); - rt.byteVecExtendFromSlice(out, _32); - break b1; - } + } + if (hi === 0) { + if (lo < 16384) { + _21 = rt.u16ToBeBytes(16384 | (lo & 0xffff)); + rt.byteVecExtendFromSlice(out, _21); + break b1; } - if (!(hi < 1073741824)) { - _0 = rt.Err({}); - break b0; - } else { - _42 = rt.u32ToBeBytes((3221225472 | hi) >>> 0); - a = _42[0]; - b = _42[1]; - c = _42[2]; - d = _42[3]; - _48 = rt.u32ToBeBytes(lo); - _52 = Uint8Array.of(a, b, c, d, _48[0], _48[1], _48[2], _48[3]); - rt.byteVecExtendFromSlice(out, _52); + } + if (hi === 0) { + if (lo < 1073741824) { + _32 = rt.u32ToBeBytes((2147483648 | lo) >>> 0); + rt.byteVecExtendFromSlice(out, _32); + break b1; } } - _0 = rt.Ok(undefined); + if (!(hi < 1073741824)) { + return rt.Err({}); + } else { + _42 = rt.u32ToBeBytes((3221225472 | hi) >>> 0); + a = _42[0]; + b = _42[1]; + c = _42[2]; + d = _42[3]; + _48 = rt.u32ToBeBytes(lo); + _52 = Uint8Array.of(a, b, c, d, _48[0], _48[1], _48[2], _48[3]); + rt.byteVecExtendFromSlice(out, _52); + } } - return _0; + return rt.Ok(undefined); } export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { @@ -245,22 +233,18 @@ export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _54); } } - return; } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ export function read(buf: Uint8Array, form: Form.Form): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - let _0!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; if (form.tag === "Quic") { - _0 = readQuic(buf); + return readQuic(buf); } else { - _0 = readLeadingOnes(buf, form.seven); + return readLeadingOnes(buf, form.seven); } - return _0; } export function readQuic(buf: Uint8Array): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - let _0!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; let first!: rt.u8; let _5!: [rt.u8, Uint8Array] | undefined; let _14!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; @@ -279,39 +263,37 @@ export function readQuic(buf: Uint8Array): rt.Result<[rt.u64, Uint8Array], Decod if (_54.ok) { val3 = _54.value; const slice = val3[0]; - _0 = rt.Ok([fromHalves((((val3[0][0] & 63) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0, rt.u32FromBeBytes(slice.subarray(4, 8))), val3[1]] as [rt.u64, Uint8Array]); + return rt.Ok([fromHalves((((val3[0][0] & 63) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0, rt.u32FromBeBytes(slice.subarray(4, 8))), val3[1]] as [rt.u64, Uint8Array]); } else { - _0 = _54; + return _54; } } else { _33 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); if (_33.ok) { val2 = _33.value; - _0 = rt.Ok([(((val2[0][0] & 63) << 24) | (val2[0][1] << 16) | (val2[0][2] << 8) | val2[0][3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, Uint8Array]); + return rt.Ok([(((val2[0][0] & 63) << 24) | (val2[0][1] << 16) | (val2[0][2] << 8) | val2[0][3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, Uint8Array]); } else { - _0 = _33; + return _33; } } } else { _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); if (_14.ok) { val = _14.value; - _0 = rt.Ok([(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]); + return rt.Ok([(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]); } else { - _0 = _14; + return _14; } } } else { - _0 = rt.Ok([first as rt.u64, _5[1]] as [rt.u64, Uint8Array]); + return rt.Ok([first as rt.u64, _5[1]] as [rt.u64, Uint8Array]); } } else { - _0 = rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - return _0; } export function readLeadingOnes(buf: Uint8Array, seven: boolean): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - let _0!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; let first!: rt.u8; let _6!: [rt.u8, Uint8Array] | undefined; let _8!: [rt.u64, Uint8Array]; @@ -333,101 +315,89 @@ export function readLeadingOnes(buf: Uint8Array, seven: boolean): rt.Result<[rt. let _142!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; let val8!: [Uint8Array, Uint8Array]; _6 = rt.sliceSplitFirst(buf); - b0: { - if (_6 !== undefined) { - first = _6[0]; - _9 = rt.u8LeadingOnes(first); - if (_9 === 0) { - _8 = [first as rt.u64, _6[1]] as [rt.u64, Uint8Array]; - } else if (_9 === 1) { - _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (_14.ok) { - val = _14.value; - _8 = [(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _14; - break b0; - } - } else if (_9 === 2) { - _30 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); - if (_30.ok) { - val2 = _30.value; - _8 = [(((val2[0][0] & 31) << 16) | (val2[0][1] << 8) | val2[0][2]) as rt.u64, val2[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _30; - break b0; - } - } else if (_9 === 3) { - _48 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (_48.ok) { - val3 = _48.value; - _8 = [(((val3[0][0] & 15) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _48; - break b0; - } - } else if (_9 === 4) { - _65 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); - if (_65.ok) { - val4 = _65.value; - const slice5 = val4[0]; - _8 = [fromHalves(((val4[0][0] & 7)) as rt.u32, rt.u32FromBeBytes(slice5.subarray(1, 5))), val4[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _65; - break b0; - } - } else if (_9 === 5) { - _81 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); - if (_81.ok) { - val5 = _81.value; - const slice4 = val5[0]; - _8 = [fromHalves(((val5[0][0] & 3) << 8) | val5[0][1], rt.u32FromBeBytes(slice4.subarray(2, 6))), val5[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _81; - break b0; - } - } else if (_9 === 6) { - if (!seven) { - _0 = rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); - break b0; - } else { - _101 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); - if (_101.ok) { - val6 = _101.value; - const slice3 = val6[0]; - _8 = [fromHalves(((val6[0][0] & 1) << 16) | (val6[0][1] << 8) | val6[0][2], rt.u32FromBeBytes(slice3.subarray(3, 7))), val6[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _101; - break b0; - } - } - } else if (_9 === 7) { - _121 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (_121.ok) { - val7 = _121.value; - const slice2 = val7[0]; - _8 = [fromHalves((val7[0][1] << 16) | (val7[0][2] << 8) | val7[0][3], rt.u32FromBeBytes(slice2.subarray(4, 8))), val7[1]] as [rt.u64, Uint8Array]; - } else { - _0 = _121; - break b0; - } + if (_6 !== undefined) { + first = _6[0]; + _9 = rt.u8LeadingOnes(first); + if (_9 === 0) { + _8 = [first as rt.u64, _6[1]] as [rt.u64, Uint8Array]; + } else if (_9 === 1) { + _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + if (_14.ok) { + val = _14.value; + _8 = [(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]; + } else { + return _14; + } + } else if (_9 === 2) { + _30 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); + if (_30.ok) { + val2 = _30.value; + _8 = [(((val2[0][0] & 31) << 16) | (val2[0][1] << 8) | val2[0][2]) as rt.u64, val2[1]] as [rt.u64, Uint8Array]; + } else { + return _30; + } + } else if (_9 === 3) { + _48 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + if (_48.ok) { + val3 = _48.value; + _8 = [(((val3[0][0] & 15) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, Uint8Array]; + } else { + return _48; + } + } else if (_9 === 4) { + _65 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); + if (_65.ok) { + val4 = _65.value; + const slice5 = val4[0]; + _8 = [fromHalves(((val4[0][0] & 7)) as rt.u32, rt.u32FromBeBytes(slice5.subarray(1, 5))), val4[1]] as [rt.u64, Uint8Array]; + } else { + return _65; + } + } else if (_9 === 5) { + _81 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); + if (_81.ok) { + val5 = _81.value; + const slice4 = val5[0]; + _8 = [fromHalves(((val5[0][0] & 3) << 8) | val5[0][1], rt.u32FromBeBytes(slice4.subarray(2, 6))), val5[1]] as [rt.u64, Uint8Array]; + } else { + return _81; + } + } else if (_9 === 6) { + if (!seven) { + return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); } else { - _142 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); - if (_142.ok) { - val8 = _142.value; - const slice = val8[0]; - _8 = [fromHalves(rt.u32FromBeBytes(slice.subarray(1, 5)), ((val8[0][5] << 24) | (val8[0][6] << 16) | (val8[0][7] << 8) | val8[0][8]) >>> 0), val8[1]] as [rt.u64, Uint8Array]; + _101 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); + if (_101.ok) { + val6 = _101.value; + const slice3 = val6[0]; + _8 = [fromHalves(((val6[0][0] & 1) << 16) | (val6[0][1] << 8) | val6[0][2], rt.u32FromBeBytes(slice3.subarray(3, 7))), val6[1]] as [rt.u64, Uint8Array]; } else { - _0 = _142; - break b0; + return _101; } } - _0 = rt.Ok(_8); + } else if (_9 === 7) { + _121 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + if (_121.ok) { + val7 = _121.value; + const slice2 = val7[0]; + _8 = [fromHalves((val7[0][1] << 16) | (val7[0][2] << 8) | val7[0][3], rt.u32FromBeBytes(slice2.subarray(4, 8))), val7[1]] as [rt.u64, Uint8Array]; + } else { + return _121; + } } else { - _0 = rt.Err({ tag: "Short" } as DecodeError.DecodeError); + _142 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); + if (_142.ok) { + val8 = _142.value; + const slice = val8[0]; + _8 = [fromHalves(rt.u32FromBeBytes(slice.subarray(1, 5)), ((val8[0][5] << 24) | (val8[0][6] << 16) | (val8[0][7] << 8) | val8[0][8]) >>> 0), val8[1]] as [rt.u64, Uint8Array]; + } else { + return _142; + } } + return rt.Ok(_8); + } else { + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - return _0; } /** diff --git a/ts/fixtures/codec/expected/coding/version.Version.ts b/ts/fixtures/codec/expected/coding/version.Version.ts index 4799eca0a..092e3355a 100644 --- a/ts/fixtures/codec/expected/coding/version.Version.ts +++ b/ts/fixtures/codec/expected/coding/version.Version.ts @@ -15,41 +15,35 @@ export interface Version { /** Decode the version number. */ export function decode$Decode_Form(r: Decoder.Decoder, _2: Form.Form): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; _4 = Decoder.varint(r); if (_4.ok) { - _0 = rt.Ok({ _0: _4.value }); + return rt.Ok({ _0: _4.value }); } else { - _0 = _4; + return _4; } - return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Form(self: Version, w: Encoder.Encoder, _3: Form.Form): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; _4 = Encoder.varint(w, self._0); if (_4.ok) { - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { - _0 = _4; + return _4; } - return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Version, w: Encoder.Encoder, _3: version_Version.Version): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; _4 = Encoder.varint(w, self._0); if (_4.ok) { - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { - _0 = _4; + return _4; } - return _0; } //# sourceMappingURL=version.Version.ts.map diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index fce06232e..3387a71b6 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -24,10 +24,10 @@ export function decodeSlice$Decode_Form(buf: Uint8Array, version: Form.Form): rt value = val; _13 = value; _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Versions, rt.usize]); + return _0; } else { - _0 = _6; + return _6; } - return _0; } /** A list of versions in preferred order. */ @@ -37,7 +37,6 @@ export interface Versions { /** Decode the version list. */ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; let count!: rt.u64; let vs!: Version.Version[]; @@ -45,93 +44,76 @@ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.R let _12!: rt.u64 | rt.Done; let _15!: rt.Result; _3 = Decoder.varint(r); - b0: { - if (_3.ok) { - count = _3.value; - vs = []; - iter = new rt.Range(0, count, rt.u64Step); - while (true) { - _12 = iter.next(); - if (_12 === rt.DONE) { - _0 = rt.Ok({ _0: vs }); - break b0; + if (_3.ok) { + count = _3.value; + vs = []; + iter = new rt.Range(0, count, rt.u64Step); + while (true) { + _12 = iter.next(); + if (_12 === rt.DONE) { + return rt.Ok({ _0: vs }); + } else { + _15 = Version.decode$Decode_Form(r, version); + if (_15.ok) { + vs.push(_15.value); } else { - _15 = Version.decode$Decode_Form(r, version); - if (_15.ok) { - vs.push(_15.value); - } else { - _0 = _15; - break b0; - } + return _15; } } - } else { - _0 = _3; } + } else { + return _3; } - return _0; } /** Encode the version list. */ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: Form.Form): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; let iter!: rt.Iter; let _14!: Version.Version | rt.Done; let _18!: rt.Result; _4 = Encoder.varint(w, self._0.length as rt.u64); - b0: { - if (_4.ok) { - iter = rt.iterSlice(self._0); - while (true) { - _14 = iter.next(); - if (_14 === rt.DONE) { - _0 = rt.Ok(undefined); - break b0; - } else { - _18 = Version.encode$Encode_Form(_14, w, version); - if (!_18.ok) { - _0 = _18; - break b0; - } + if (_4.ok) { + iter = rt.iterSlice(self._0); + while (true) { + _14 = iter.next(); + if (_14 === rt.DONE) { + return rt.Ok(undefined); + } else { + _18 = Version.encode$Encode_Form(_14, w, version); + if (!_18.ok) { + return _18; } } - } else { - _0 = _4; } + } else { + return _4; } - return _0; } /** Encode the version list. */ export function encode$Encode_Version(self: Versions, w: Encoder.Encoder, version: version_Version.Version): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; let iter!: rt.Iter; let _14!: Version.Version | rt.Done; let _18!: rt.Result; _4 = Encoder.varint(w, self._0.length as rt.u64); - b0: { - if (_4.ok) { - iter = rt.iterSlice(self._0); - while (true) { - _14 = iter.next(); - if (_14 === rt.DONE) { - _0 = rt.Ok(undefined); - break b0; - } else { - _18 = Version.encode$Encode_Version(_14, w, version); - if (!_18.ok) { - _0 = _18; - break b0; - } + if (_4.ok) { + iter = rt.iterSlice(self._0); + while (true) { + _14 = iter.next(); + if (_14 === rt.DONE) { + return rt.Ok(undefined); + } else { + _18 = Version.encode$Encode_Version(_14, w, version); + if (!_18.ok) { + return _18; } } - } else { - _0 = _4; } + } else { + return _4; } - return _0; } export function from$From_Versions(vs: Version.Version[]): Versions { diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 3c1c710c3..e257ec233 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -17,7 +17,6 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { - let _0!: rt.ByteVec; let out!: rt.ByteVec; let _5!: [rt.u8, Uint8Array] | undefined; let _8!: rt.u8; @@ -44,59 +43,52 @@ export function run(input: Uint8Array): rt.ByteVec { } else { errors(_5[1], out); } - _0 = out; + return out; } else { - _0 = out; + return out; } - return _0; } export function form(selector: rt.u8): Form.Form { - let _0!: Form.Form; let _2!: rt.u8; _2 = rt.u8Rem(selector, 3); if (_2 === 0) { - _0 = { tag: "Quic" } as Form.Form; + return { tag: "Quic" } as Form.Form; } else if (_2 === 1) { - _0 = { tag: "LeadingOnes", seven: false } as Form.Form; + return { tag: "LeadingOnes", seven: false } as Form.Form; } else { - _0 = { tag: "LeadingOnes", seven: true } as Form.Form; + return { tag: "LeadingOnes", seven: true } as Form.Form; } - return _0; } export function liteVersion(selector: rt.u8): Version.Version { - let _0!: Version.Version; let _2!: rt.u8; _2 = rt.u8Rem(selector, 7); if (_2 === 0) { - _0 = "Lite01" as Version.Version; + return "Lite01" as Version.Version; } else if (_2 === 1) { - _0 = "Lite02" as Version.Version; + return "Lite02" as Version.Version; } else if (_2 === 2) { - _0 = "Lite03" as Version.Version; + return "Lite03" as Version.Version; } else if (_2 === 3) { - _0 = "Lite04" as Version.Version; + return "Lite04" as Version.Version; } else if (_2 === 4) { - _0 = "Lite05" as Version.Version; + return "Lite05" as Version.Version; } else if (_2 === 5) { - _0 = "Lite06" as Version.Version; + return "Lite06" as Version.Version; } else { - _0 = "Lite07" as Version.Version; + return "Lite07" as Version.Version; } - return _0; } export function putU64(out: rt.ByteVec, value: rt.u64): void { let _6!: Uint8Array; _6 = rt.u64ToBeBytes(value); rt.byteVecExtendFromSlice(out, _6); - return; } export function putUsize(out: rt.ByteVec, value: rt.usize): void { putU64(out, value as rt.u64); - return; } /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ @@ -120,7 +112,6 @@ export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): voi const arg = args[0]; _6 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Debug(arg, f)]); putText(out, _5, _6); - return; } /** An encode error's code, then its text. */ @@ -134,7 +125,6 @@ export function encodeFailed(out: rt.ByteVec, err: EncodeError.EncodeError): voi const arg = args[0]; _6 = rt.fmtFormat([(f: rt.Formatter) => EncodeError.fmt$Debug(arg, f)]); putText(out, _5, _6); - return; } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ @@ -143,7 +133,6 @@ export function putText(out: rt.ByteVec, display: string, debug: string): void { rt.byteVecPush(out, 0); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(debug)); rt.byteVecPush(out, 0); - return; } export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void { @@ -190,7 +179,6 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } else { rt.byteVecPush(out, 18); } - return; } export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void { @@ -212,7 +200,6 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void _5 = 6; } rt.byteVecPush(out, _5); - return; } /** @@ -266,11 +253,9 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { } } } - return; } export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt.Result { - let _0!: rt.Result; let _5!: rt.u8; let _7!: rt.Result; let _14!: Uint8Array; @@ -287,104 +272,91 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt let sub!: Decoder.Decoder; let _67!: rt.Result; let _76!: rt.Result; - b0: { - _5 = rt.u8Rem(step, 10); - if (_5 === 0) { - _7 = Decoder.u8(r); - if (_7.ok) { - rt.byteVecPush(out, _7.value); - } else { - _0 = _7; - break b0; - } - } else if (_5 === 1) { - _15 = Decoder.u16(r); - if (_15.ok) { - _14 = rt.u16ToBeBytes(_15.value); - rt.byteVecExtendFromSlice(out, _14); - } else { - _0 = _15; - break b0; - } - } else if (_5 === 2) { - _21 = Decoder.bool(r); - if (_21.ok) { - rt.byteVecPush(out, _21.value ? 1 : 0); - } else { - _0 = _21; - break b0; - } - } else if (_5 === 3) { - _26 = Decoder.varint(r); - if (_26.ok) { - putU64(out, _26.value); - } else { - _0 = _26; - break b0; - } - } else if (_5 === 4) { - _31 = Decoder.varintOpt(r); - if (_31.ok) { - val5 = _31.value; - if (val5 === undefined) { - rt.byteVecPush(out, 0); - } else { - v = val5; - rt.byteVecPush(out, 1); - putU64(out, v); - } - } else { - _0 = _31; - break b0; - } - } else if (_5 === 5) { - _40 = Decoder.bytes(r); - if (_40.ok) { - putUsize(out, _40.value.length); - rt.byteVecExtendFromSlice(out, _40.value); - } else { - _0 = _40; - break b0; - } - } else if (_5 === 6) { - _49 = Decoder.string(r); - if (_49.ok) { - s = _49.value; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - } else { - _0 = _49; - break b0; - } - } else if (_5 === 7) { - _57 = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); - if (_57.ok) { - rt.byteVecExtendFromSlice(out, _57.value); + _5 = rt.u8Rem(step, 10); + if (_5 === 0) { + _7 = Decoder.u8(r); + if (_7.ok) { + rt.byteVecPush(out, _7.value); + } else { + return _7; + } + } else if (_5 === 1) { + _15 = Decoder.u16(r); + if (_15.ok) { + _14 = rt.u16ToBeBytes(_15.value); + rt.byteVecExtendFromSlice(out, _14); + } else { + return _15; + } + } else if (_5 === 2) { + _21 = Decoder.bool(r); + if (_21.ok) { + rt.byteVecPush(out, _21.value ? 1 : 0); + } else { + return _21; + } + } else if (_5 === 3) { + _26 = Decoder.varint(r); + if (_26.ok) { + putU64(out, _26.value); + } else { + return _26; + } + } else if (_5 === 4) { + _31 = Decoder.varintOpt(r); + if (_31.ok) { + val5 = _31.value; + if (val5 === undefined) { + rt.byteVecPush(out, 0); } else { - _0 = _57; - break b0; + v = val5; + rt.byteVecPush(out, 1); + putU64(out, v); } - } else if (_5 === 8) { - _67 = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); - if (_67.ok) { - sub = _67.value; - _76 = Decoder.varint(sub); - if (_76.ok) { - putU64(out, _76.value); - putUsize(out, Decoder.rest(sub).length); - } else { - _0 = _76; - break b0; - } + } else { + return _31; + } + } else if (_5 === 5) { + _40 = Decoder.bytes(r); + if (_40.ok) { + putUsize(out, _40.value.length); + rt.byteVecExtendFromSlice(out, _40.value); + } else { + return _40; + } + } else if (_5 === 6) { + _49 = Decoder.string(r); + if (_49.ok) { + s = _49.value; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + } else { + return _49; + } + } else if (_5 === 7) { + _57 = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + if (_57.ok) { + rt.byteVecExtendFromSlice(out, _57.value); + } else { + return _57; + } + } else if (_5 === 8) { + _67 = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); + if (_67.ok) { + sub = _67.value; + _76 = Decoder.varint(sub); + if (_76.ok) { + putU64(out, _76.value); + putUsize(out, Decoder.rest(sub).length); } else { - _0 = _67; - break b0; + return _76; } } else { - putUsize(out, Decoder.rest(r).length); + return _67; } - _0 = rt.Ok(undefined); + } else { + putUsize(out, Decoder.rest(r).length); } - return _0; + return rt.Ok(undefined); } /** Write primitives as a script says, taking each value from the data that follows. */ @@ -532,7 +504,6 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { } } } - return; } export function zigzag(data: Uint8Array, out: rt.ByteVec): void { @@ -543,7 +514,6 @@ export function zigzag(data: Uint8Array, out: rt.ByteVec): void { putU64(out, varint_zigzag(signed)); putU64(out, rt.u64Cast(unzigzag(value))); putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); - return; } export function sizes(data: Uint8Array, out: rt.ByteVec): void { @@ -604,7 +574,6 @@ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { decodeFailed(out, err2); } } - return; } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ @@ -641,7 +610,6 @@ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { decodeFailed(out, err2); } } - return; } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ @@ -678,7 +646,6 @@ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { decodeFailed(out, err2); } } - return; } /** Encode messages built from the data, at a lite version. */ @@ -730,7 +697,6 @@ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { encodeFailed(out, err); } } - return; } export function encodeMessage$Group(msg: Group.Group, version: Version.Version, out: rt.ByteVec): void { @@ -751,7 +717,6 @@ export function encodeMessage$Group(msg: Group.Group, version: Version.Version, err = _8.error; encodeFailed(out, err); } - return; } export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, out: rt.ByteVec): void { @@ -772,7 +737,6 @@ export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, err = _8.error; encodeFailed(out, err); } - return; } /** Each error the codec can return, built from the data, as callers see it. */ @@ -834,7 +798,6 @@ export function errors(data: Uint8Array, out: rt.ByteVec): void { decodeFailed(out, err); } } - return; } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index 5dfd068c6..497c005a9 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -3,36 +3,32 @@ import * as rt from "./rt.ts"; export function fmt$Display(self: SessionError, __formatter: rt.Formatter): rt.Result { - let _0!: rt.Result; let _02!: rt.u16; let __display0!: rt.u16; let args!: [rt.u16]; if (self.tag === "ProtocolViolation") { - _0 = rt.fmtWriteStr(__formatter, "protocol violation"); + return rt.fmtWriteStr(__formatter, "protocol violation"); } else { _02 = self._0; __display0 = ([_02] as [rt.u16])[0]; args = [__display0] as [rt.u16]; const arg = args[0]; - _0 = rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(arg, f)]); + return rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(arg, f)]); } - return _0; } export function fmt$Debug(self: SessionError, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: rt.u16; let _6!: string; let _7!: rt.Fmt; if (self.tag === "ProtocolViolation") { - _0 = rt.fmtWriteStr(f, "ProtocolViolation"); + return rt.fmtWriteStr(f, "ProtocolViolation"); } else { __self0 = self._0; _6 = "App"; _7 = (f: rt.Formatter) => rt.u16Display(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } - return _0; } /** moq-net's session error, trimmed to a few variants: the codec only carries it. */ diff --git a/ts/fixtures/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index 180000943..7efaf484d 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -25,10 +25,10 @@ export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Ver value = val; _13 = value; _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Group, rt.usize]); + return _0; } else { - _0 = _6; + return _6; } - return _0; } export interface Group { @@ -39,7 +39,6 @@ export interface Group { /** Decode a message body (without size prefix). */ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; let subscribe!: rt.u64; let _8!: rt.Result; @@ -47,71 +46,60 @@ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): let frameStart!: rt.u64; let _15!: rt.Result; _3 = Decoder.varint(r); - b0: { - if (_3.ok) { - subscribe = _3.value; - _8 = Decoder.varint(r); - if (_8.ok) { - sequence = _8.value; - if (!Version.hasFrameBounds(version)) { - frameStart = 0; + if (_3.ok) { + subscribe = _3.value; + _8 = Decoder.varint(r); + if (_8.ok) { + sequence = _8.value; + if (!Version.hasFrameBounds(version)) { + frameStart = 0; + } else { + _15 = Decoder.varint(r); + if (_15.ok) { + frameStart = _15.value; } else { - _15 = Decoder.varint(r); - if (_15.ok) { - frameStart = _15.value; - } else { - _0 = _15; - break b0; - } + return _15; } - _0 = rt.Ok({ subscribe, sequence, frameStart }); - } else { - _0 = _8; } + return rt.Ok({ subscribe, sequence, frameStart }); } else { - _0 = _3; + return _8; } + } else { + return _3; } - return _0; } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Group, w: Encoder.Encoder, version: Version.Version): rt.Result { - let _0!: rt.Result; let _4!: rt.Result; let _9!: rt.Result; let _15!: rt.Result; _4 = Encoder.varint(w, self.subscribe); - b0: { - if (_4.ok) { - _9 = Encoder.varint(w, self.sequence); - if (_9.ok) { - if (!Version.hasFrameBounds(version)) { - if (self.frameStart !== 0) { - _0 = rt.Err("Version" as EncodeError.EncodeError); - break b0; - } - } else { - _15 = Encoder.varint(w, self.frameStart); - if (!_15.ok) { - _0 = _15; - break b0; - } + if (_4.ok) { + _9 = Encoder.varint(w, self.sequence); + if (_9.ok) { + if (!Version.hasFrameBounds(version)) { + if (self.frameStart !== 0) { + return rt.Err("Version" as EncodeError.EncodeError); } - _0 = rt.Ok(undefined); } else { - _0 = _9; + _15 = Encoder.varint(w, self.frameStart); + if (!_15.ok) { + return _15; + } } + return rt.Ok(undefined); } else { - _0 = _4; + return _9; } + } else { + return _4; } - return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Group, w: Encoder.Encoder, version: Version.Version): rt.Result { - let _0!: rt.Result; let prefix!: Prefix.Prefix; let _39!: rt.Result; let _49!: rt.Result; @@ -122,18 +110,17 @@ export function encode$Encode_Version(self: Group, w: Encoder.Encoder, version: _49 = Encoder.fill(w, prefix); if (_49.ok) { w.control = undefined; - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { - _0 = _49; + return _49; } } else { Encoder.discard(w, prefix); - _0 = rt.Err("TooLarge" as EncodeError.EncodeError); + return rt.Err("TooLarge" as EncodeError.EncodeError); } } else { - _0 = _39; + return _39; } - return _0; } /** Decode the value from the front of the decoder. */ diff --git a/ts/fixtures/codec/expected/lite/message.ts b/ts/fixtures/codec/expected/lite/message.ts index 68436d127..fa7d08b6f 100644 --- a/ts/fixtures/codec/expected/lite/message.ts +++ b/ts/fixtures/codec/expected/lite/message.ts @@ -9,27 +9,22 @@ import type * as Control from "../stats.Control.ts"; /** Read a lite message's varint size prefix, refusing one past `max`. */ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; let size!: rt.u64; let _8!: rt.Result; _3 = Decoder.varint(r); - b0: { - if (_3.ok) { - size = _3.value; - _8 = rt.usizeTryFrom(size); - if (_8.ok) { - if (_8.value <= max) { - _0 = rt.Ok(_8.value); - break b0; - } + if (_3.ok) { + size = _3.value; + _8 = rt.usizeTryFrom(size); + if (_8.ok) { + if (_8.value <= max) { + return rt.Ok(_8.value); } - _0 = rt.Err({ tag: "MessageTooLarge", size: rt.resultUnwrapOr(rt.usizeTryFrom(size), 4294967295), max } as DecodeError.DecodeError); - } else { - _0 = _3; } + return rt.Err({ tag: "MessageTooLarge", size: rt.resultUnwrapOr(rt.usizeTryFrom(size), 4294967295), max } as DecodeError.DecodeError); + } else { + return _3; } - return _0; } /** @@ -37,7 +32,6 @@ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.Result rt.Result): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; let body!: Decoder.Decoder; let _9!: rt.Result; @@ -48,27 +42,24 @@ export function decodeWith$Group_decode_closure0(r: Decoder.Decoder, decode: (a0 if (_9.ok) { body = _9.value; result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg2: Group.Group): rt.Result => { - let _02!: rt.Result; if (!Decoder.isEmpty(body)) { - _02 = rt.Err({ tag: "Long" } as DecodeError.DecodeError); + return rt.Err({ tag: "Long" } as DecodeError.DecodeError); } else { - _02 = rt.Ok(msg2); + return rt.Ok(msg2); } - return _02; }); if (result.ok) { } if (result.ok) { r.control = undefined; } - _0 = result; + return result; } else { - _0 = _9; + return _9; } } else { - _0 = _3; + return _3; } - return _0; } /** @@ -76,7 +67,6 @@ export function decodeWith$Group_decode_closure0(r: Decoder.Decoder, decode: (a0 * [`Message::decode_msg`], for a body whose bounds come from the session. */ export function decodeWith$Probe_decode_closure0(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rt.Result): rt.Result { - let _0!: rt.Result; let _3!: rt.Result; let body!: Decoder.Decoder; let _9!: rt.Result; @@ -87,27 +77,24 @@ export function decodeWith$Probe_decode_closure0(r: Decoder.Decoder, decode: (a0 if (_9.ok) { body = _9.value; result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg2: Probe.Probe): rt.Result => { - let _02!: rt.Result; if (!Decoder.isEmpty(body)) { - _02 = rt.Err({ tag: "Long" } as DecodeError.DecodeError); + return rt.Err({ tag: "Long" } as DecodeError.DecodeError); } else { - _02 = rt.Ok(msg2); + return rt.Ok(msg2); } - return _02; }); if (result.ok) { } if (result.ok) { r.control = "Probe" as Control.Control; } - _0 = result; + return result; } else { - _0 = _9; + return _9; } } else { - _0 = _3; + return _3; } - return _0; } //# sourceMappingURL=message.ts.map diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index a281ddffc..7d3583ca3 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -26,15 +26,14 @@ export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Ver value = val; _13 = value; _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Probe, rt.usize]); + return _0; } else { - _0 = _6; + return _6; } - return _0; } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { - let _0!: rt.Result; let prefix!: Prefix.Prefix; let _39!: rt.Result; let _49!: rt.Result; @@ -45,18 +44,17 @@ export function encode$Encode_Version(self: Probe, w: Encoder.Encoder, version: _49 = Encoder.fill(w, prefix); if (_49.ok) { w.control = "Probe" as Control.Control; - _0 = rt.Ok(undefined); + return rt.Ok(undefined); } else { - _0 = _49; + return _49; } } else { Encoder.discard(w, prefix); - _0 = rt.Err("TooLarge" as EncodeError.EncodeError); + return rt.Err("TooLarge" as EncodeError.EncodeError); } } else { - _0 = _39; + return _39; } - return _0; } /** Decode the value from the front of the decoder. */ @@ -79,81 +77,67 @@ export interface Probe { /** Decode a message body (without size prefix). */ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): rt.Result { - let _0!: rt.Result; let bitrate!: rt.u64 | undefined; let _6!: rt.Result; let val!: rt.u64; let rtt!: rt.u64 | undefined; let _13!: rt.Result; let val2!: rt.u64; - b0: { - if (!(version === "Lite01" || version === "Lite02")) { - _6 = Decoder.varint(r); - if (_6.ok) { - val = _6.value; - if (val === 0) { - bitrate = undefined; - } else { - bitrate = val; - } - if (!Version.hasProbeRtt(version)) { - rtt = undefined; - } else { - _13 = Decoder.varint(r); - if (_13.ok) { - val2 = _13.value; - if (val2 === 0) { - rtt = undefined; - } else { - rtt = val2; - } + if (!(version === "Lite01" || version === "Lite02")) { + _6 = Decoder.varint(r); + if (_6.ok) { + val = _6.value; + if (val === 0) { + bitrate = undefined; + } else { + bitrate = val; + } + if (!Version.hasProbeRtt(version)) { + rtt = undefined; + } else { + _13 = Decoder.varint(r); + if (_13.ok) { + val2 = _13.value; + if (val2 === 0) { + rtt = undefined; } else { - _0 = _13; - break b0; + rtt = val2; } + } else { + return _13; } - _0 = rt.Ok({ bitrate, rtt }); - break b0; - } else { - _0 = _6; - break b0; } + return rt.Ok({ bitrate, rtt }); + } else { + return _6; } - _0 = rt.Err({ tag: "Version" } as DecodeError.DecodeError); } - return _0; + return rt.Err({ tag: "Version" } as DecodeError.DecodeError); } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { - let _0!: rt.Result; let _9!: rt.Result; let _17!: rt.Result; - b0: { - if (!(version === "Lite01" || version === "Lite02")) { - _9 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { - return rt.u64Max(v, 1); - }), 0)); - if (_9.ok) { - if (Version.hasProbeRtt(version)) { - _17 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.rtt, (v2: rt.u64): rt.u64 => { - return rt.u64Max(v2, 1); - }), 0)); - if (!_17.ok) { - _0 = _17; - break b0; - } + if (!(version === "Lite01" || version === "Lite02")) { + _9 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { + return rt.u64Max(v, 1); + }), 0)); + if (_9.ok) { + if (Version.hasProbeRtt(version)) { + _17 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.rtt, (v2: rt.u64): rt.u64 => { + return rt.u64Max(v2, 1); + }), 0)); + if (!_17.ok) { + return _17; } - _0 = rt.Ok(undefined); - break b0; - } else { - _0 = _9; - break b0; } + return rt.Ok(undefined); + } else { + return _9; } - _0 = rt.Err("Version" as EncodeError.EncodeError); } - return _0; + return rt.Err("Version" as EncodeError.EncodeError); } //# sourceMappingURL=probe.Probe.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fails.ts b/ts/fixtures/lang/expected/fmt.Fails.ts index bbbf078f4..d9f020c70 100644 --- a/ts/fixtures/lang/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/expected/fmt.Fails.ts @@ -8,7 +8,6 @@ export interface Fails { } export function fmt$Display(self: Fails, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let _8!: rt.Result; let args!: [rt.u8]; if (!(rt.u8Rem(self._0, 2) === 0)) { @@ -16,14 +15,13 @@ export function fmt$Display(self: Fails, f: rt.Formatter): rt.Result rt.u8Display(arg, f)]); if (_8.ok) { - _0 = rt.Err(new rt.FmtError()); + return rt.Err(new rt.FmtError()); } else { - _0 = rt.Err(new rt.FmtError()); + return rt.Err(new rt.FmtError()); } } else { - _0 = rt.fmtWriteStr(f, "fine"); + return rt.fmtWriteStr(f, "fine"); } - return _0; } //# sourceMappingURL=fmt.Fails.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index 5e30e4d7f..9373975aa 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -4,7 +4,6 @@ import * as rt from "./rt.ts"; import * as Pair from "./fmt.Pair.ts"; export function fmt$Debug(self: Fault, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: rt.u16; let _6!: string; let _7!: rt.Fmt; @@ -18,12 +17,12 @@ export function fmt$Debug(self: Fault, f: rt.Formatter): rt.Result rt.u16Display(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } else if (self.tag === "TooLarge") { __self1 = self.max; _11 = "TooLarge"; @@ -31,14 +30,13 @@ export function fmt$Debug(self: Fault, f: rt.Formatter): rt.Result rt.usizeDisplay(self.size, f); _14 = "max"; _15 = (f: rt.Formatter) => rt.usizeDisplay(__self1, f); - _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _11), _12, _13), _14, _15)); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _11), _12, _13), _14, _15)); } else { __self02 = self._0; _18 = "At"; _19 = (f: rt.Formatter) => Pair.fmt$Debug(__self02, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _18), _19)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _18), _19)); } - return _0; } /** @@ -52,7 +50,6 @@ export type Fault = | { tag: "At"; _0: Pair.Pair }; export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let code!: rt.u16; let args!: [rt.u16]; let size!: rt.usize; @@ -60,23 +57,22 @@ export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); + return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); } else { pair = self._0; args5 = [pair] as [Pair.Pair]; const arg = args5[0]; - _0 = rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(arg, f)]); + return rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(arg, f)]); } - return _0; } /** The fault `data` picks. */ @@ -89,15 +85,16 @@ function new_(data: Uint8Array): Fault { }; _3 = rt.u8Rem(at(0), 4); if (_3 === 0) { - _0 = { tag: "Short" } as Fault; + return { tag: "Short" } as Fault; } else if (_3 === 1) { - _0 = { tag: "Code", _0: (at(1) << 8) | at(2) } as Fault; + return { tag: "Code", _0: (at(1) << 8) | at(2) } as Fault; } else if (_3 === 2) { _0 = { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize } as Fault; + return _0; } else { _0 = { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } } as Fault; + return _0; } - return _0; } export { new_ as new }; diff --git a/ts/fixtures/lang/expected/fmt.Hex.ts b/ts/fixtures/lang/expected/fmt.Hex.ts index 8e0af7e57..3d39a0beb 100644 --- a/ts/fixtures/lang/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/expected/fmt.Hex.ts @@ -8,19 +8,17 @@ export interface Hex { } export function fmt$Display(self: Hex, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let args!: [rt.u32]; let args3!: [rt.u32]; if (!rt.fmtAlternate(f)) { args3 = [self._0] as [rt.u32]; const arg2 = args3[0]; - _0 = rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]); + return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]); } else { args = [self._0] as [rt.u32]; const arg = args[0]; - _0 = rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(arg, f))]); + return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(arg, f))]); } - return _0; } export function fmt$Debug(self: Hex, f: rt.Formatter): rt.Result { diff --git a/ts/fixtures/lang/expected/fmt.Kind.ts b/ts/fixtures/lang/expected/fmt.Kind.ts index ee98e83de..3946443d9 100644 --- a/ts/fixtures/lang/expected/fmt.Kind.ts +++ b/ts/fixtures/lang/expected/fmt.Kind.ts @@ -3,7 +3,6 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: rt.u8; let _8!: string; let _9!: rt.Fmt; @@ -14,16 +13,16 @@ export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result rt.u8Display(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _8), _9)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _8), _9)); } else { __self1 = self.items; _13 = "Many"; @@ -31,9 +30,8 @@ export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result rt.u32Display(self.count, f); _16 = "items"; _17 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(__self1), f, rt.u8Display); - _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _13), _14, _15), _16, _17)); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _13), _14, _15), _16, _17)); } - return _0; } export type Kind = diff --git a/ts/fixtures/lang/expected/fmt.Padded.ts b/ts/fixtures/lang/expected/fmt.Padded.ts index 67449dc29..bbc08e6c2 100644 --- a/ts/fixtures/lang/expected/fmt.Padded.ts +++ b/ts/fixtures/lang/expected/fmt.Padded.ts @@ -8,19 +8,14 @@ export interface Padded { } export function fmt$Display(self: Padded, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let _3!: rt.usize | undefined; _3 = rt.fmtWidth(f); - b0: { - if (_3 !== undefined) { - if (_3 > 20) { - _0 = rt.fmtWriteStr(f, "wide"); - break b0; - } + if (_3 !== undefined) { + if (_3 > 20) { + return rt.fmtWriteStr(f, "wide"); } - _0 = rt.fmtPad(f, self._0); } - return _0; + return rt.fmtPad(f, self._0); } //# sourceMappingURL=fmt.Padded.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Pair.ts b/ts/fixtures/lang/expected/fmt.Pair.ts index f3b06dde2..2c20743a5 100644 --- a/ts/fixtures/lang/expected/fmt.Pair.ts +++ b/ts/fixtures/lang/expected/fmt.Pair.ts @@ -15,13 +15,11 @@ export function fmt$Debug(self: Pair, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let _7!: rt.DebugTuple; let _15!: rt.DebugTuple; if (self._1 === undefined) { _15 = rt.fmtDebugTuple(f, "Tup"); - _0 = rt.debugTupleFinishNonExhaustive(rt.debugTupleField(_15, (f: rt.Formatter) => rt.u8Display(self._0, f))); + return rt.debugTupleFinishNonExhaustive(rt.debugTupleField(_15, (f: rt.Formatter) => rt.u8Display(self._0, f))); } else { _7 = rt.fmtDebugTuple(f, "Tup"); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(_7, (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Display))); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(_7, (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Display))); } - return _0; } //# sourceMappingURL=fmt.Tup.ts.map diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 28e55113d..63eb0d2e4 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -21,7 +21,6 @@ import type * as Shape from "./shapes.Shape.ts"; export function put(out: rt.ByteVec, s: string): void { rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); rt.byteVecPush(out, 255); - return; } /** Integers of every width, with each spec. */ @@ -197,7 +196,6 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _412 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f)); put(out, _412); } - return; } /** Strings padded and escaped, and bytes that may not be UTF-8. */ @@ -458,7 +456,6 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { put(out, _168); _186 = Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0); rt.byteVecExtendFromSlice(out, _186); - return; } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ @@ -534,7 +531,6 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { _152 = at(8); _143 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(_152, f), " ", (f: rt.Formatter) => rt.u8Display(_148, f), " ", (f: rt.Formatter) => rt.u8Display(_148, f), " named ", rt.fmtSpec({ align: ">", width: 5 }, (f: rt.Formatter) => rt.fmtPad(f, "named"))]); put(out, _143); - return; } /** Panics, each with the message native Rust formats. */ @@ -727,7 +723,6 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _274 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); put(out, _274); } - return; } //# sourceMappingURL=fmt.ts.map diff --git a/ts/fixtures/lang/expected/generics.Either.ts b/ts/fixtures/lang/expected/generics.Either.ts index f1e5f1a9a..7e6c49881 100644 --- a/ts/fixtures/lang/expected/generics.Either.ts +++ b/ts/fixtures/lang/expected/generics.Either.ts @@ -4,7 +4,6 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug_Point_u8(self: Either, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: Point.Point; let _5!: string; let _6!: rt.Fmt; @@ -16,21 +15,19 @@ export function fmt$Debug_Point_u8(self: Either, f: rt.Forma __self0 = self._0; _5 = "Left"; _6 = (f: rt.Formatter) => Point.fmt$Debug(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { __self02 = self.value; _9 = "Right"; _10 = "value"; _11 = (f: rt.Formatter) => rt.u8Display(__self02, f); - _0 = rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { - _0 = rt.fmtWriteStr(f, "Neither"); + return rt.fmtWriteStr(f, "Neither"); } - return _0; } export function fmt$Debug_u8_Point(self: Either, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: rt.u8; let _5!: string; let _6!: rt.Fmt; @@ -42,21 +39,19 @@ export function fmt$Debug_u8_Point(self: Either, f: rt.Forma __self0 = self._0; _5 = "Left"; _6 = (f: rt.Formatter) => rt.u8Display(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { __self02 = self.value; _9 = "Right"; _10 = "value"; _11 = (f: rt.Formatter) => Point.fmt$Debug(__self02, f); - _0 = rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { - _0 = rt.fmtWriteStr(f, "Neither"); + return rt.fmtWriteStr(f, "Neither"); } - return _0; } export function fmt$Debug_u8_u16(self: Either, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self0!: rt.u8; let _5!: string; let _6!: rt.Fmt; @@ -68,62 +63,53 @@ export function fmt$Debug_u8_u16(self: Either, f: rt.Formatter): __self0 = self._0; _5 = "Left"; _6 = (f: rt.Formatter) => rt.u8Display(__self0, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { __self02 = self.value; _9 = "Right"; _10 = "value"; _11 = (f: rt.Formatter) => rt.u16Display(__self02, f); - _0 = rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { - _0 = rt.fmtWriteStr(f, "Neither"); + return rt.fmtWriteStr(f, "Neither"); } - return _0; } /** A generic enum, with a companion function per instance. */ export type Either = { tag: "Left"; _0: L } | { tag: "Right"; value: R } | { tag: "Neither" }; export function left$Point_u8(self: Either): Point.Point | undefined { - let _0!: Point.Point | undefined; if (self.tag === "Left") { - _0 = rt.copy(self._0); + return rt.copy(self._0); } else { - _0 = undefined; + return undefined; } - return _0; } export function left$u8_Point(self: Either): rt.u8 | undefined { - let _0!: rt.u8 | undefined; if (self.tag === "Left") { - _0 = self._0; + return self._0; } else { - _0 = undefined; + return undefined; } - return _0; } export function left$u8_u16(self: Either): rt.u8 | undefined { - let _0!: rt.u8 | undefined; if (self.tag === "Left") { - _0 = self._0; + return self._0; } else { - _0 = undefined; + return undefined; } - return _0; } export function flip$u8_Point(self: Either): Either { - let _0!: Either; if (self.tag === "Left") { - _0 = { tag: "Right", value: self._0 } as Either; + return { tag: "Right", value: self._0 } as Either; } else if (self.tag === "Right") { - _0 = { tag: "Left", _0: self.value } as Either; + return { tag: "Left", _0: self.value } as Either; } else { - _0 = { tag: "Neither" } as Either; + return { tag: "Neither" } as Either; } - return _0; } //# sourceMappingURL=generics.Either.ts.map diff --git a/ts/fixtures/lang/expected/generics.Wrap.ts b/ts/fixtures/lang/expected/generics.Wrap.ts index 2e5230c67..d90df59f2 100644 --- a/ts/fixtures/lang/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/expected/generics.Wrap.ts @@ -151,13 +151,11 @@ export function fmt$Debug_u8(self: Wrap, f: rt.Formatter): rt.Result, other: Wrap): boolean { - let _0!: boolean; if (!(self.count === other.count)) { - _0 = false; + return false; } else { - _0 = Pair.eq$PartialEq(self.value, other.value); + return Pair.eq$PartialEq(self.value, other.value); } - return _0; } /** A generic struct, with methods on every instance, on some, and on one. */ @@ -271,7 +269,6 @@ export function describe$Area_Meters(self: Wrap, out: rt.ByteVec) rt.byteVecPush(out, 0); _7 = rt.u64ToBeBytes(area$Area_Meters(self)); rt.byteVecExtendFromSlice(out, _7); - return; } /** A default method, monomorphized for each type. */ @@ -280,7 +277,6 @@ export function describe$Area_Shape(self: Wrap, out: rt.ByteVec): v rt.byteVecPush(out, 4); _7 = rt.u64ToBeBytes(area$Area_Shape(self)); rt.byteVecExtendFromSlice(out, _7); - return; } //# sourceMappingURL=generics.Wrap.ts.map diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 4a263de42..1894f4f4a 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -9,7 +9,6 @@ import { copies, order, discriminants, loops, patterns, closures, library } from /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { - let _0!: rt.ByteVec; let out!: rt.ByteVec; let op!: rt.u8; let kind!: rt.u8; @@ -19,7 +18,7 @@ export function run(input: Uint8Array): rt.ByteVec { let _36!: [rt.u8, Uint8Array] | undefined; out = new rt.ByteVec(); if (!(input.length >= 2)) { - _0 = out; + return out; } else { _10 = [input[0], input[1]] as [rt.u8, rt.u8]; op = _10[0]; @@ -112,9 +111,8 @@ export function run(input: Uint8Array): rt.ByteVec { } else { order(input.subarray(2, input.length - 0), out); } - _0 = out; + return out; } - return _0; } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index d9a4917f5..85377cd64 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -27,7 +27,6 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.u128ToBeBytes(v as rt.u128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { let v3!: rt.u8; @@ -40,7 +39,6 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.u128ToBeBytes(v3 as rt.u128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = Uint8Array.of(0); n = rt.min(data.length, buf.length); @@ -139,7 +137,6 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x & (~(1 << 2) & 0xff); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -167,7 +164,6 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.u128ToBeBytes(v as rt.u128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { let v3!: rt.u16; @@ -180,7 +176,6 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.u128ToBeBytes(v3 as rt.u128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(2); n = rt.min(data.length, buf.length); @@ -279,7 +274,6 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x & (~(1 << 2) & 0xffff); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -307,7 +301,6 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.u128ToBeBytes(v as rt.u128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { let v3!: rt.u32; @@ -320,7 +313,6 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.u128ToBeBytes(v3 as rt.u128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(4); n = rt.min(data.length, buf.length); @@ -419,7 +411,6 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = (x & (~(1 << 2) >>> 0)) >>> 0; _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -447,7 +438,6 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.u128ToBeBytes(rt.u128Cast(v)); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { let v3!: rt.u64; @@ -460,7 +450,6 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.u128ToBeBytes(rt.u128Cast(v3)); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(8); n = rt.min(data.length, buf.length); @@ -559,7 +548,6 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.u64And(x, rt.u64Not(4)); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -587,7 +575,6 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.u128ToBeBytes(v); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { let v3!: rt.u128; @@ -600,7 +587,6 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.u128ToBeBytes(v3); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(16); n = rt.min(data.length, buf.length); @@ -699,7 +685,6 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.u128And(x, rt.u128Not(rt.u128Shl(1, 2))); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -727,7 +712,6 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.u128ToBeBytes(v as rt.u128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { let v3!: rt.usize; @@ -740,7 +724,6 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.u128ToBeBytes(v3 as rt.u128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(4); n = rt.min(data.length, buf.length); @@ -839,7 +822,6 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = (x & (~(1 << 2) >>> 0)) >>> 0; _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -867,7 +849,6 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.i128ToBeBytes(v as rt.i128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { let v3!: rt.i8; @@ -880,7 +861,6 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.i128ToBeBytes(v3 as rt.i128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = Uint8Array.of(0); n = rt.min(data.length, buf.length); @@ -983,7 +963,6 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x & ~(1 << 2); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -1011,7 +990,6 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.i128ToBeBytes(v as rt.i128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { let v3!: rt.i16; @@ -1024,7 +1002,6 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.i128ToBeBytes(v3 as rt.i128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(2); n = rt.min(data.length, buf.length); @@ -1127,7 +1104,6 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x & ~(1 << 2); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -1155,7 +1131,6 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.i128ToBeBytes(v as rt.i128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { let v3!: rt.i32; @@ -1168,7 +1143,6 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.i128ToBeBytes(v3 as rt.i128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(4); n = rt.min(data.length, buf.length); @@ -1271,7 +1245,6 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x & ~(1 << 2); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -1299,7 +1272,6 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.i128ToBeBytes(rt.i128Cast(v)); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { let v3!: rt.i64; @@ -1312,7 +1284,6 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.i128ToBeBytes(rt.i128Cast(v3)); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(8); n = rt.min(data.length, buf.length); @@ -1415,7 +1386,6 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.i64And(x, rt.i64Not(4)); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -1443,7 +1413,6 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.i128ToBeBytes(v); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { let v3!: rt.i128; @@ -1456,7 +1425,6 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.i128ToBeBytes(v3); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(16); n = rt.min(data.length, buf.length); @@ -1559,7 +1527,6 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.i128And(x, rt.i128Not(rt.i128Shl(1, 2))); _50(out, x); } - return; } /** Apply operation `op` to operands taken from `data`. */ @@ -1587,7 +1554,6 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _7 = rt.i128ToBeBytes(v as rt.i128); rt.byteVecExtendFromSlice(out2, _7); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); - return; }; _51 = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { let v3!: rt.isize; @@ -1600,7 +1566,6 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { _106 = rt.i128ToBeBytes(v3 as rt.i128); rt.byteVecExtendFromSlice(out3, _106); } - return; }; buf = rt.bytes(4); n = rt.min(data.length, buf.length); @@ -1703,7 +1668,6 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x & ~(1 << 2); _50(out, x); } - return; } /** Negate, which overflows at the minimum. */ @@ -1718,7 +1682,6 @@ export function i8Neg(data: Uint8Array, out: rt.ByteVec): void { a = ([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]; _24 = rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128); rt.byteVecExtendFromSlice(out, _24); - return; } /** Negate, which overflows at the minimum. */ @@ -1733,7 +1696,6 @@ export function i16Neg(data: Uint8Array, out: rt.ByteVec): void { a = ([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]; _24 = rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128); rt.byteVecExtendFromSlice(out, _24); - return; } /** Negate, which overflows at the minimum. */ @@ -1748,7 +1710,6 @@ export function i32Neg(data: Uint8Array, out: rt.ByteVec): void { a = ([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]; _24 = rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128); rt.byteVecExtendFromSlice(out, _24); - return; } /** Negate, which overflows at the minimum. */ @@ -1763,7 +1724,6 @@ export function i64Neg(data: Uint8Array, out: rt.ByteVec): void { a = ([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0]; _24 = rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a))); rt.byteVecExtendFromSlice(out, _24); - return; } /** Negate, which overflows at the minimum. */ @@ -1778,7 +1738,6 @@ export function i128Neg(data: Uint8Array, out: rt.ByteVec): void { a = ([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]; _24 = rt.i128ToBeBytes(rt.i128Neg(a)); rt.byteVecExtendFromSlice(out, _24); - return; } /** Negate, which overflows at the minimum. */ @@ -1793,7 +1752,6 @@ export function isizeNeg(data: Uint8Array, out: rt.ByteVec): void { a = ([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]; _24 = rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128); rt.byteVecExtendFromSlice(out, _24); - return; } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ @@ -3229,7 +3187,6 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1685)); } } - return; } /** Conversions that check, and ones that cannot fail. */ @@ -3336,7 +3293,6 @@ export function convert(data: Uint8Array, out: rt.ByteVec): void { _138 = Uint8Array.of(d, c, b, a); _142 = rt.i32ToBeBytes(rt.i32FromBeBytes(_138)); rt.byteVecExtendFromSlice(out, _142); - return; } //# sourceMappingURL=ints.ts.map diff --git a/ts/fixtures/lang/expected/iters.Countdown.ts b/ts/fixtures/lang/expected/iters.Countdown.ts index 0ebf15570..aa1d6efcf 100644 --- a/ts/fixtures/lang/expected/iters.Countdown.ts +++ b/ts/fixtures/lang/expected/iters.Countdown.ts @@ -9,18 +9,16 @@ export interface Countdown { } export function next$Iterator(self: Countdown): rt.u8 | rt.Done { - let _0!: rt.u8 | rt.Done; let left!: rt.u8; let _3!: rt.u8; if (self.left === 0) { - _0 = rt.DONE; + return rt.DONE; } else { left = self.left; _3 = rt.u8SaturatingSub(left, self.step); self.left = _3; - _0 = left; + return left; } - return _0; } //# sourceMappingURL=iters.Countdown.ts.map diff --git a/ts/fixtures/lang/expected/iters.Evens.ts b/ts/fixtures/lang/expected/iters.Evens.ts index 74c37c71a..636ae85e4 100644 --- a/ts/fixtures/lang/expected/iters.Evens.ts +++ b/ts/fixtures/lang/expected/iters.Evens.ts @@ -8,7 +8,6 @@ export interface Evens { } export function next$Iterator(self: Evens): rt.u8 | rt.Done { - let _0!: rt.u8 | rt.Done; let _2!: rt.u8 | rt.Done; let b!: rt.u8; l0: while (true) { @@ -18,12 +17,11 @@ export function next$Iterator(self: Evens): rt.u8 | rt.Done { if (!(rt.u8Rem(b, 2) === 0)) { continue l0; } else { - _0 = b; + return b; } } else { - _0 = rt.DONE; + return rt.DONE; } - return _0; } } diff --git a/ts/fixtures/lang/expected/iters.Gaps.ts b/ts/fixtures/lang/expected/iters.Gaps.ts index 15ec88b29..23d40bfdc 100644 --- a/ts/fixtures/lang/expected/iters.Gaps.ts +++ b/ts/fixtures/lang/expected/iters.Gaps.ts @@ -9,7 +9,6 @@ export interface Gaps { } export function next$Iterator(self: Gaps): rt.u8 | undefined | rt.Done { - let _0!: rt.u8 | undefined | rt.Done; let b!: rt.u8; let _3!: rt.u8 | undefined; let _8!: rt.usize; @@ -19,14 +18,13 @@ export function next$Iterator(self: Gaps): rt.u8 | undefined | rt.Done { _8 = rt.usizeAdd(self.at, 1); self.at = _8; if (!(b === 0)) { - _0 = b; + return b; } else { - _0 = undefined; + return undefined; } } else { - _0 = rt.DONE; + return rt.DONE; } - return _0; } //# sourceMappingURL=iters.Gaps.ts.map diff --git a/ts/fixtures/lang/expected/iters.Halving.ts b/ts/fixtures/lang/expected/iters.Halving.ts index 13c996224..95fce4e88 100644 --- a/ts/fixtures/lang/expected/iters.Halving.ts +++ b/ts/fixtures/lang/expected/iters.Halving.ts @@ -19,16 +19,14 @@ export function next$Iterator_u8(self: Halving): rt.u8 | rt.Done { } export function next$Iterator_u64(self: Halving): rt.u64 | rt.Done { - let _0!: rt.u64 | rt.Done; let value!: rt.u64; if (self.value === 0) { - _0 = rt.DONE; + return rt.DONE; } else { value = self.value; self.value = rt.u64Shr(value, 1); - _0 = value; + return value; } - return _0; } //# sourceMappingURL=iters.Halving.ts.map diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 89894c462..2d8f40f4c 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -202,12 +202,10 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } } } - return; } /** The runs between zero bytes. */ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { - let _0!: rt.ByteVec[]; let words!: rt.ByteVec[]; let word!: rt.ByteVec; let iter!: rt.Iter; @@ -221,8 +219,7 @@ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { _6 = iter.next(); if (_6 === rt.DONE) { words.push(word); - _0 = words; - return _0; + return words; } else { b = _6; if (!(b === 0)) { @@ -270,7 +267,6 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void if (_5 === 0) { _9 = rt.iterInspect(rt.iterSlice(data), (_228: rt.u8): void => { rt.byteVecPush(log, _228); - return; }); rt.byteVecPush(out, rt.iterAny(_9, (_229: rt.u8): boolean => { return _229 > 240; @@ -286,22 +282,19 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } else if (_5 === 1) { _31 = rt.iterInspect(rt.iterSlice(data), (_220: rt.u8): void => { rt.byteVecPush(log, _220); - return; }); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFind(_31, (_221: rt.u8): boolean => { return rt.u8Rem(_221, 7) === 3; }), 255)); _40 = rt.iterSlice(data); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFindMap(_40, (_222: rt.u8): rt.u8 | undefined => { - let _010!: rt.u8 | undefined; let b14!: rt.u8; b14 = _222; if (!(b14 > 80)) { - _010 = undefined; + return undefined; } else { - _010 = rt.u8CheckedMul(b14, 3); + return rt.u8CheckedMul(b14, 3); } - return _010; }), 0)); _45 = rt.iterSlice(data); rt.byteVecPush(out, rt.optionMapOr(rt.iterPosition(_45, (_223: rt.u8): boolean => { @@ -327,7 +320,6 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void if (_69 === rt.DONE) { iter2 = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_226: rt.u8): void => { rt.byteVecPush(log, _226); - return; }), (b19: rt.u8): rt.u8 => { return b19; }), rt.iterSlice(short)); @@ -388,7 +380,6 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void rt.byteVecExtendFromSlice(out, _184); rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); - return; }); } else if (_5 === 4) { rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); @@ -398,15 +389,13 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void rt.byteVecExtendFromSlice(out, _198); } else { parsed = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { - let _0!: rt.Result; let b3!: rt.u8; b3 = _2; if (!(b3 < 240)) { - _0 = rt.Err(b3); + return rt.Err(b3); } else { - _0 = rt.Ok(b3); + return rt.Ok(b3); } - return _0; }), (values__: rt.Iter) => rt.iterToByteVec(values__)); if (parsed.ok) { v = parsed.value; @@ -416,7 +405,6 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_24: rt.u8): void => { rt.byteVecPush(log, _24); - return; }), (_29: rt.u8): rt.u16 | undefined => { let b5!: rt.u8; b5 = _29; @@ -427,7 +415,6 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } } rt.byteVecExtendFromSlice(out, rt.byteVecView(log)); - return; } export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { @@ -664,7 +651,6 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): /** `..`, logging that it was made. */ export function fullRange(out: rt.ByteVec): undefined { rt.byteVecPush(out, 215); - return; } /** Iterators of `Option`, which keep each `None` apart from their end. */ @@ -683,48 +669,40 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { let iter3!: Gaps.Gaps; let _70!: rt.u8 | undefined | rt.Done; all = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (b2: rt.u8): rt.u8 | undefined => { - let _0!: rt.u8 | undefined; if (!(rt.u8Rem(b2, 3) === 0)) { - _0 = b2; + return b2; } else { - _0 = undefined; + return undefined; } - return _0; })); rt.byteVecPush(out, all.length & 0xff); iter = rt.iterMap(rt.iterSlice(data), (b3: rt.u8): rt.u8 | undefined => { - let _02!: rt.u8 | undefined; if (!(rt.u8Rem(b3, 3) === 0)) { - _02 = b3; + return b3; } else { - _02 = undefined; + return undefined; } - return _02; }); while (true) { _15 = iter.next(); if (_15 === rt.DONE) { flat = rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), (b4: rt.u8): rt.u8 | undefined => { - let _03!: rt.u8 | undefined; if (!(rt.u8Rem(b4, 3) === 0)) { - _03 = b4; + return b4; } else { - _03 = undefined; + return undefined; } - return _03; }), (value: rt.u8 | undefined) => rt.iterOption(value))); rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), (b5: rt.u8): rt.u8 | undefined => { - let _05!: rt.u8 | undefined; if (!(rt.u8Rem(b5, 3) === 0)) { - _05 = b5; + return b5; } else { - _05 = undefined; + return undefined; } - return _05; })), 205)); first = rt.sliceFirst(data); iter2 = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); @@ -768,21 +746,19 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { /** The second item of an iterator of options, through `?`, which tests for its end. */ export function second$Map_Iter_u8_options_closure0(items: rt.Iter): rt.u8 | undefined { - let _0!: rt.u8 | undefined; let _2!: rt.u8 | undefined | rt.Done; let _7!: rt.u8 | undefined | rt.Done; _2 = items.next(); if (_2 !== rt.DONE) { _7 = items.next(); if (_7 !== rt.DONE) { - _0 = rt.optionUnwrapOr(_7, 171); + return rt.optionUnwrapOr(_7, 171); } else { - _0 = undefined; + return undefined; } } else { - _0 = undefined; + return undefined; } - return _0; } /** The crate's own iterators, through `for`, adaptors, and `next`. */ diff --git a/ts/fixtures/lang/expected/shapes.Meters.ts b/ts/fixtures/lang/expected/shapes.Meters.ts index 8de1e986d..d9f462d03 100644 --- a/ts/fixtures/lang/expected/shapes.Meters.ts +++ b/ts/fixtures/lang/expected/shapes.Meters.ts @@ -17,7 +17,6 @@ export function describe$Area(self: Meters, out: rt.ByteVec): void { rt.byteVecPush(out, 170); _7 = rt.u64ToBeBytes(self._0); rt.byteVecExtendFromSlice(out, _7); - return; } //# sourceMappingURL=shapes.Meters.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Point.ts b/ts/fixtures/lang/expected/shapes.Point.ts index 5827aff93..c0a8b6939 100644 --- a/ts/fixtures/lang/expected/shapes.Point.ts +++ b/ts/fixtures/lang/expected/shapes.Point.ts @@ -19,13 +19,11 @@ export function fmt$Debug(self: Point, f: rt.Formatter): rt.Result { - let _0!: rt.Result; let __self1!: Point.Point; let _7!: string; let _8!: rt.Fmt; @@ -18,13 +17,13 @@ export function fmt$Debug(self: Shape, f: rt.Formatter): rt.Result Point.fmt$Debug(self._0, f); _9 = (f: rt.Formatter) => Point.fmt$Debug(__self1, f); - _0 = rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8), _9)); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8), _9)); } else { __self2 = self.height; _14 = "Rect"; @@ -34,9 +33,8 @@ export function fmt$Debug(self: Shape, f: rt.Formatter): rt.Result rt.u16Display(self.width, f); _19 = "height"; _20 = (f: rt.Formatter) => rt.u16Display(__self2, f); - _0 = rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); } - return _0; } /** An enum with data, and one without. */ @@ -51,23 +49,20 @@ export function describe$Area(self: Shape, out: rt.ByteVec): void { rt.byteVecPush(out, 4); _7 = rt.u64ToBeBytes(area$Area(self)); rt.byteVecExtendFromSlice(out, _7); - return; } export function area$Area(self: Shape): rt.u64 { - let _0!: rt.u64; let width!: rt.u16; let height!: rt.u16; if (self.tag === "Dot") { - _0 = 0; + return 0; } else if (self.tag === "Line") { - _0 = 0; + return 0; } else { width = self.width; height = self.height; - _0 = rt.u64Mul(width as rt.u64, height as rt.u64); + return rt.u64Mul(width as rt.u64, height as rt.u64); } - return _0; } //# sourceMappingURL=shapes.Shape.ts.map diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 6aa9edc77..4071379ae 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -50,25 +50,22 @@ export function from$From_Dir_u8(dir_: Dir.Dir): rt.u8 { } export function dir(byte: rt.u8): Dir.Dir | undefined { - let _0!: Dir.Dir | undefined; let _2!: rt.u8; _2 = rt.u8Rem(byte, 5); if (_2 === 0) { - _0 = "North" as Dir.Dir; + return "North" as Dir.Dir; } else if (_2 === 1) { - _0 = "East" as Dir.Dir; + return "East" as Dir.Dir; } else if (_2 === 2) { - _0 = "South" as Dir.Dir; + return "South" as Dir.Dir; } else if (_2 === 3) { - _0 = "West" as Dir.Dir; + return "West" as Dir.Dir; } else { - _0 = undefined; + return undefined; } - return _0; } export function shape(data: Uint8Array): Shape.Shape { - let _0!: Shape.Shape; let kind!: rt.u8; let _4!: [rt.u8, Uint8Array] | undefined; let at!: (a0: rt.usize) => rt.i32; @@ -81,16 +78,15 @@ export function shape(data: Uint8Array): Shape.Shape { }; _7 = rt.u8Rem(kind, 3); if (_7 === 0) { - _0 = { tag: "Dot" } as Shape.Shape; + return { tag: "Dot" } as Shape.Shape; } else if (_7 === 1) { - _0 = { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; + return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; } else { - _0 = { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; + return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; } } else { - _0 = { tag: "Dot" } as Shape.Shape; + return { tag: "Dot" } as Shape.Shape; } - return _0; } /** `Copy` aggregates: a copy changes apart from its original. */ @@ -504,7 +500,6 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { _67 = Uint8Array.of(first, second, called, _68, slots[_71], n); rt.byteVecExtendFromSlice(out, _67); rt.byteVecExtendFromSlice(out, bytes); - return; } /** A vector of `b`, logging that it was made. */ @@ -866,7 +861,6 @@ export function diverging(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, boundNever(head, out)); rt.byteVecPush(out, closureNever(b)); genericNever(b, data.length); - return; } /** @@ -906,14 +900,12 @@ export function closureNever(b: rt.u8): rt.u8 { /** A closure that never returns, made by a function. */ export function madeNever(): (a0: rt.u8) => never { - let _0!: (a0: rt.u8) => never; - _0 = (b: rt.u8): never => { + return (b: rt.u8): never => { let args!: [rt.u8]; args = [b] as [rt.u8]; const arg = args[0]; rt.panicFmt(["made ", (f: rt.Formatter) => rt.u8Display(arg, f)]); }; - return _0; } /** @@ -925,14 +917,14 @@ export function genericNever(b: rt.u8, len: rt.usize): void { let args3!: [rt.u8]; if (!(b === 241)) { if (!(b === 246)) { - if (!(b === 249)) { - return; - } else if (!(len > 1)) { - args3 = [b] as [rt.u8]; - const arg2 = args3[0]; - rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); - } else { - unwrapOrBail$never(undefined, b); + if (b === 249) { + if (!(len > 1)) { + args3 = [b] as [rt.u8]; + const arg2 = args3[0]; + rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); + } else { + unwrapOrBail$never(undefined, b); + } } } else { args = [b] as [rt.u8]; @@ -990,35 +982,29 @@ 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: Uint8Array): rt.u8 { - let _0!: rt.u8; let a!: rt.u8; let b!: rt.u8; let _13!: rt.u8; let a2!: rt.u8; - b0: { - if (!((data.length === 0))) { - if (data.length === 2) { - a = data[0]; - b = data[1]; - _13 = b; - if (a > _13) { - _0 = rt.u8Sub(a, b); - break b0; - } + if (!((data.length === 0))) { + if (data.length === 2) { + a = data[0]; + b = data[1]; + _13 = b; + if (a > _13) { + return rt.u8Sub(a, b); } - if (data.length >= 1) { - a2 = data[0]; - if (a2 > 128) { - _0 = 1; - break b0; - } + } + if (data.length >= 1) { + a2 = data[0]; + if (a2 > 128) { + return 1; } - _0 = 2; - } else { - _0 = 3; } + return 2; + } else { + return 3; } - return _0; } /** A loop ending the function, left by `break` with values that never exist. */ @@ -1043,6 +1029,7 @@ export function brokenNever(data: Uint8Array): rt.u8 { args = [i] as [rt.usize]; const arg = args[0]; rt.panicFmt(["broken at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); + return _0; } else if (value === 252) { _19 = i; _20 = data.length; @@ -1050,16 +1037,16 @@ export function brokenNever(data: Uint8Array): rt.u8 { rt.panic("index out of bounds: the len is " + _20 + " but the index is " + _19); } bail(data[_19]); + return _0; } else if (value === 0) { - _0 = i & 0xff; + return i & 0xff; } else { i = rt.usizeAdd(i, 1); continue l0; } } else { - _0 = 204; + return 204; } - return _0; } } @@ -1079,52 +1066,50 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { let _33!: rt.usize; i = 0; l0: while (true) { - b1: { - if (!(i >= data.length)) { - _8 = i; - _9 = data.length; - if (!(_8 < _9)) { - rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); + if (!(i >= data.length)) { + _8 = i; + _9 = data.length; + if (!(_8 < _9)) { + rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); + } + const value = data[_8]; + if (value === 239) { + args = [i] as [rt.usize]; + const arg = args[0]; + rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); + return _0; + } else if (value === 240) { + _22 = i; + _23 = data.length; + if (!(_22 < _23)) { + rt.panic("index out of bounds: the len is " + _23 + " but the index is " + _22); } - const value = data[_8]; - if (value === 239) { - args = [i] as [rt.usize]; - const arg = args[0]; - rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); - } else if (value === 240) { - _22 = i; - _23 = data.length; - if (!(_22 < _23)) { - rt.panic("index out of bounds: the len is " + _23 + " but the index is " + _22); - } - bail(data[_22]); - } else if (value === 0) { - _0 = i & 0xff; - } else if (value === 128) { - l2: while (true) { - i = rt.usizeAdd(i, 1); - if (!(i >= data.length)) { - _32 = i; - _33 = data.length; - if (!(_32 < _33)) { - rt.panic("index out of bounds: the len is " + _33 + " but the index is " + _32); - } - if (!(data[_32] < 128)) { - continue l2; - } + bail(data[_22]); + return _0; + } else if (value === 0) { + return i & 0xff; + } else if (value === 128) { + l2: while (true) { + i = rt.usizeAdd(i, 1); + if (!(i >= data.length)) { + _32 = i; + _33 = data.length; + if (!(_32 < _33)) { + rt.panic("index out of bounds: the len is " + _33 + " but the index is " + _32); + } + if (!(data[_32] < 128)) { + continue l2; } - _0 = i & 0xff; - break b1; } - } else { - i = rt.usizeAdd(i, 1); - continue l0; + return i & 0xff; } } else { - _0 = 187; + i = rt.usizeAdd(i, 1); + continue l0; } + } else { + return 187; } - return _0; } } @@ -1184,43 +1169,37 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { /** A loop that only `return` leaves, returned itself, around loops that `break`. */ export function returnedLoop(data: Uint8Array): rt.u8 { - let _0!: rt.u8; let i!: rt.usize; let iter!: rt.Iter; let _11!: rt.u8 | rt.Done; let b!: rt.u8; i = 0; l0: while (true) { - b1: { - if (!(i >= data.length)) { - iter = rt.iterSlice(rt.sliceRange(data, i)); - l2: while (true) { - _11 = iter.next(); - if (_11 !== rt.DONE) { - b = _11; - if (!(b === 0)) { - if (!(b > 240)) { - continue l2; - } else { - _0 = b ^ (i & 0xff); - break b1; - } + if (!(i >= data.length)) { + iter = rt.iterSlice(rt.sliceRange(data, i)); + l2: while (true) { + _11 = iter.next(); + if (_11 !== rt.DONE) { + b = _11; + if (!(b === 0)) { + if (!(b > 240)) { + continue l2; + } else { + return b ^ (i & 0xff); } } - i = rt.usizeAdd(i, 1); - continue l0; } - } else { - _0 = 221; + i = rt.usizeAdd(i, 1); + continue l0; } + } else { + return 221; } - return _0; } } /** A loop that ends the function, left only by `return` from nested scopes. */ export function firstRepeat(data: Uint8Array): rt.u8 { - let _0!: rt.u8; let i!: rt.usize; let j!: rt.usize; let _14!: rt.usize; @@ -1234,59 +1213,54 @@ export function firstRepeat(data: Uint8Array): rt.u8 { let _30!: rt.usize; i = 0; l0: while (true) { - b1: { - if (!(i >= data.length)) { - j = rt.usizeAdd(i, 1); - while (true) { - if (!(j < data.length)) { - i = rt.usizeAdd(i, 1); - continue l0; - } else { - _14 = j; - _15 = data.length; - if (!(_14 < _15)) { - rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); + if (!(i >= data.length)) { + j = rt.usizeAdd(i, 1); + while (true) { + if (!(j < data.length)) { + i = rt.usizeAdd(i, 1); + continue l0; + } else { + _14 = j; + _15 = data.length; + if (!(_14 < _15)) { + rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); + } + if (!(data[_14] === 0)) { + _21 = i; + _22 = data.length; + if (!(_21 < _22)) { + rt.panic("index out of bounds: the len is " + _22 + " but the index is " + _21); } - if (!(data[_14] === 0)) { - _21 = i; - _22 = data.length; - if (!(_21 < _22)) { - rt.panic("index out of bounds: the len is " + _22 + " but the index is " + _21); - } - _20 = data[_21]; - _25 = j; - _26 = data.length; - if (!(_25 < _26)) { - rt.panic("index out of bounds: the len is " + _26 + " but the index is " + _25); - } - if (!(_20 === data[_25])) { - j = rt.usizeAdd(j, 1); - } else { - _29 = j; - _30 = data.length; - if (!(_29 < _30)) { - rt.panic("index out of bounds: the len is " + _30 + " but the index is " + _29); - } - _0 = data[_29] ^ (i & 0xff); - break b1; - } + _20 = data[_21]; + _25 = j; + _26 = data.length; + if (!(_25 < _26)) { + rt.panic("index out of bounds: the len is " + _26 + " but the index is " + _25); + } + if (!(_20 === data[_25])) { + j = rt.usizeAdd(j, 1); } else { - i = rt.usizeAdd(j, 1); - continue l0; + _29 = j; + _30 = data.length; + if (!(_29 < _30)) { + rt.panic("index out of bounds: the len is " + _30 + " but the index is " + _29); + } + return data[_29] ^ (i & 0xff); } + } else { + i = rt.usizeAdd(j, 1); + continue l0; } } - } else { - _0 = 255; } + } else { + return 255; } - return _0; } } /** A loop that ends the function, left by `break` with a value from nested scopes. */ export function tailBreak(data: Uint8Array): rt.u16 { - let _0!: rt.u16; let i!: rt.usize; let b!: rt.u8; let _7!: rt.usize; @@ -1298,61 +1272,54 @@ export function tailBreak(data: Uint8Array): rt.u16 { let n!: rt.u8; i = 0; l0: while (true) { - b1: { - if (!(i >= data.length)) { - _7 = i; - _8 = data.length; - if (!(_7 < _8)) { - rt.panic("index out of bounds: the len is " + _8 + " but the index is " + _7); - } - b = data[_7]; - i = rt.usizeAdd(i, 1); - _11 = rt.u8Rem(b, 4); - if (_11 === 0) { - continue l0; - } else if (_11 === 1) { - iter = rt.iterSlice(rt.sliceRange(data, i)); - while (true) { - _18 = iter.next(); - if (_18 === rt.DONE) { - continue l0; - } else { - c = _18; - if (c === b) { - _0 = rt.u16Mul(c as rt.u16, 2); - break b1; - } + if (!(i >= data.length)) { + _7 = i; + _8 = data.length; + if (!(_7 < _8)) { + rt.panic("index out of bounds: the len is " + _8 + " but the index is " + _7); + } + b = data[_7]; + i = rt.usizeAdd(i, 1); + _11 = rt.u8Rem(b, 4); + if (_11 === 0) { + continue l0; + } else if (_11 === 1) { + iter = rt.iterSlice(rt.sliceRange(data, i)); + while (true) { + _18 = iter.next(); + if (_18 === rt.DONE) { + continue l0; + } else { + c = _18; + if (c === b) { + return rt.u16Mul(c as rt.u16, 2); } } - } else if (_11 === 2) { - if (b > 100) { - _0 = rt.u16Add(b as rt.u16, i & 0xffff); - break b1; - } } - n = b; - while (true) { - if (!(n < 10)) { - n = rt.u8Div(n, 3); - if (n === 7) { - _0 = 7; - break b1; - } - } else { - continue l0; + } else if (_11 === 2) { + if (b > 100) { + return rt.u16Add(b as rt.u16, i & 0xffff); + } + } + n = b; + while (true) { + if (!(n < 10)) { + n = rt.u8Div(n, 3); + if (n === 7) { + return 7; } + } else { + continue l0; } - } else { - _0 = 256; } + } else { + return 256; } - return _0; } } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ export function armLoop(data: Uint8Array): rt.u8 { - let _0!: rt.u8; let k!: rt.usize; let _3!: rt.u8 | undefined; let _13!: rt.usize; @@ -1361,38 +1328,32 @@ export function armLoop(data: Uint8Array): rt.u8 { let _18!: rt.usize; k = 0; _3 = rt.sliceFirst(data); - b0: { - if (_3 !== undefined) { - if (_3 >= 128) { - _0 = rt.u8Div(_3, 2); - break b0; - } + if (_3 !== undefined) { + if (_3 >= 128) { + return rt.u8Div(_3, 2); } - while (true) { - if (!(k >= data.length)) { - _13 = k; - _14 = data.length; - if (!(_13 < _14)) { - rt.panic("index out of bounds: the len is " + _14 + " but the index is " + _13); - } - if (!(data[_13] >= 128)) { - k = rt.usizeAdd(k, 1); - } else { - _17 = k; - _18 = data.length; - if (!(_17 < _18)) { - rt.panic("index out of bounds: the len is " + _18 + " but the index is " + _17); - } - _0 = rt.u8Sub(data[_17], 128); - break b0; - } + } + while (true) { + if (!(k >= data.length)) { + _13 = k; + _14 = data.length; + if (!(_13 < _14)) { + rt.panic("index out of bounds: the len is " + _14 + " but the index is " + _13); + } + if (!(data[_13] >= 128)) { + k = rt.usizeAdd(k, 1); } else { - _0 = 238; - break b0; + _17 = k; + _18 = data.length; + if (!(_17 < _18)) { + rt.panic("index out of bounds: the len is " + _18 + " but the index is " + _17); + } + return rt.u8Sub(data[_17], 128); } + } else { + return 238; } } - return _0; } /** A generic function ending in a loop. */ @@ -1411,9 +1372,12 @@ export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { if (!((items[_9] === want))) { i = rt.usizeAdd(i, 1); continue l0; + } else { + return i; } + } else { + return i; } - return i; } } @@ -1614,7 +1578,6 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { sum = 0; add = (v: rt.u8): void => { sum = rt.u32Add(sum, v as rt.u32); - return; }; iter = rt.iterSlice(data); while (true) { @@ -1667,10 +1630,8 @@ export function overwrite(a: Uint8Array): void { let write!: () => void; write = (): void => { a.set(Uint8Array.of(9)); - return; }; write(); - return; } export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): rt.u32 { @@ -1689,21 +1650,19 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { let s!: string; let _38!: Uint8Array; _3 = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { - let _0!: rt.u8 | undefined; let _4!: rt.u8 | undefined; let _82!: rt.u8 | undefined; _4 = rt.u8CheckedAdd(a2, b2); if (_4 !== undefined) { _82 = rt.u8CheckedMul(_4, 2); if (_82 !== undefined) { - _0 = rt.u8Sub(_82, 1); + return rt.u8Sub(_82, 1); } else { - _0 = undefined; + return undefined; } } else { - _0 = undefined; + return undefined; } - return _0; }; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); const part = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); @@ -1735,7 +1694,6 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { } else { rt.byteVecPush(out, 0); } - return; } //# sourceMappingURL=shapes.ts.map diff --git a/ts/fixtures/task/expected/kio.Consumer.ts b/ts/fixtures/task/expected/kio.Consumer.ts index 17bb246b2..b8fc18c94 100644 --- a/ts/fixtures/task/expected/kio.Consumer.ts +++ b/ts/fixtures/task/expected/kio.Consumer.ts @@ -26,7 +26,6 @@ export class Consumer { /** The next value, or `None` once the channel closed and every value was read. */ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll { - let _0!: rt.Poll; let state!: rt.Mutex; let _8!: rt.usize; let _11!: State.State; @@ -42,9 +41,9 @@ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll { - let _0!: rt.Poll; let self!: Consumer.Consumer; let _4!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; let _7!: rt.Poll; @@ -63,13 +59,11 @@ export class recvFuture { unwind = 12; result = _7; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 68f583fa1..c910ec3bb 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -30,7 +30,6 @@ export function note(self: Log, event: string): void { _6 = self._0.value; _4 = _6.value; _4.push(event); - return; } /** Every event so far, one per line. */ diff --git a/ts/fixtures/task/expected/model.Channel.ts b/ts/fixtures/task/expected/model.Channel.ts index 0f562cd69..6f1790ecb 100644 --- a/ts/fixtures/task/expected/model.Channel.ts +++ b/ts/fixtures/task/expected/model.Channel.ts @@ -67,46 +67,40 @@ export function consumer(self: Channel): Consumer.Consumer { /** Send `value` through the first producer, if one is open. */ export function send(self: Channel, value: rt.u64): boolean { - let _0!: boolean; let _3!: Producer.Producer | undefined; _3 = rt.sliceFirst(self.producers); if (_3 === undefined) { - _0 = false; + return false; } else { Producer.send(_3, value); - _0 = true; + return true; } - return _0; } /** Drop the last producer, if one is open: the last closes the channel. */ export function close(self: Channel): boolean { - let _0!: boolean; let _2!: Producer.Producer | undefined; _2 = self.producers.pop(); if (_2 === undefined) { - _0 = false; + return false; } else { rt.drop(_2); - _0 = true; + return true; } - return _0; } /** Open another producer, if one is open to clone. */ export function cloneProducer(self: Channel): boolean { - let _0!: boolean; let clone!: Producer.Producer; let _3!: Producer.Producer | undefined; _3 = rt.sliceFirst(self.producers); if (_3 === undefined) { - _0 = false; + return false; } else { clone = Producer.clone$Clone(_3); self.producers.push(clone); - _0 = true; + return true; } - return _0; } //# sourceMappingURL=model.Channel.ts.map diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index addf2f603..bcdef7e74 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -28,7 +28,6 @@ export function note(self: Guard, event: string): void { let _5!: string; _5 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " ", (f: rt.Formatter) => rt.fmtPad(f, event)]); Log.note(self.log, _5); - return; } /** Log `event`, then drop: `self`, taken by value, drops as the call returns. */ @@ -58,7 +57,6 @@ export function drop$Drop(self: Guard): void { const arg = args[0]; _4 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " drop"]); Log.note(self.log, _4); - return; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index 33540d952..2ee4de0eb 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -40,7 +40,6 @@ export class sumFuture { rt.drop(this.rx); unwind = 0; rt.drop(this.guard); - return; } else if (this.state === 3) { unwind = 10; rt.drop(this.__awaitee_); @@ -50,9 +49,6 @@ export class sumFuture { rt.drop(this.guard_); unwind = 0; rt.drop(this.rx_); - return; - } else { - return; } } catch (e) { b0: { @@ -79,7 +75,6 @@ export class sumFuture { } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _3!: rt.u32; let _6!: Log.Log; let _8!: rt.Future; @@ -156,14 +151,12 @@ export class sumFuture { rt.drop(this.guard_); unwind = 35; rt.drop(this.rx_); - _0 = _47; this.state = 1; - return _0; + return _47; } } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } } @@ -286,7 +279,6 @@ export class blocksFuture { rt.drop(this.rx_); } this._saved$5 = false; - return; } catch (e) { b6: { b7: { @@ -348,7 +340,6 @@ export class blocksFuture { } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _3!: rt.u32; let _6!: Log.Log; let _8!: rt.u32; @@ -441,9 +432,8 @@ export class blocksFuture { _48 = new blocksFuture$4(this.mark_); this.___awaitee_ = _48; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } unwind = 71; @@ -483,9 +473,8 @@ export class blocksFuture { _97 = new blocksFuture$6(this.first_, this.second_, this.rx_); this.___awaitee_$2 = _97; } else { - _0 = rt.Pending; this.state = 4; - return _0; + return rt.Pending; } } unwind = 66; @@ -507,13 +496,11 @@ export class blocksFuture { } this._saved$2 = false; this._saved$5 = false; - _0 = result3; this.state = 1; - return _0; + return result3; } else { - _0 = rt.Pending; this.state = 5; - return _0; + return rt.Pending; } } catch (e) { b6: { @@ -598,11 +585,6 @@ export class blocksFuture$2 { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else { - return; - } } poll(_2: rt.Context): rt.Poll { @@ -639,11 +621,6 @@ export class blocksFuture$3 { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else { - return; - } } poll(_2: rt.Context): rt.Poll { @@ -681,11 +658,6 @@ export class blocksFuture$4 { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else { - return; - } } poll(_2: rt.Context): rt.Poll { @@ -716,9 +688,6 @@ export class blocksFuture$5 { [Symbol.dispose](): void { if (this.state === 0) { rt.drop(this.guard); - return; - } else { - return; } } @@ -776,7 +745,6 @@ export class blocksFuture$6 { rt.drop(this.second); unwind = 0; rt.drop(this.rx); - return; } else if (this.state === 3) { unwind = 8; rt.drop(this.__awaitee_); @@ -788,9 +756,6 @@ export class blocksFuture$6 { rt.drop(this.second); unwind = 0; rt.drop(this.rx); - return; - } else { - return; } } catch (e) { b0: { @@ -827,7 +792,6 @@ export class blocksFuture$6 { } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _9!: rt.u32; let _12!: Log.Log; let _14!: rt.Future; @@ -874,13 +838,11 @@ export class blocksFuture$6 { rt.drop(this.second); unwind = 22; rt.drop(this.rx); - _0 = _27; this.state = 1; - return _0; + return _27; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { b2: { @@ -1044,7 +1006,6 @@ export function turns(log: Log.Log, count: rt.u32): void { rt.drop(kept); unwind = 0; rt.dropAll(pair.slice(1, 2)); - return; } catch (e) { b2: { b3: { @@ -1142,7 +1103,6 @@ export class drainFuture { } unwind = 0; rt.drop(this.rx_); - return; } catch (e) { if (unwind === 0) { throw e; @@ -1153,7 +1113,6 @@ export class drainFuture { } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let next!: rt.u64 | undefined; let _4!: rt.Future; let _7!: rt.Poll; @@ -1223,9 +1182,8 @@ export class drainFuture { bb0 = 27; continue l0; } else { - _0 = rt.Pending; this.state = 5; - return _0; + return rt.Pending; } case 15: unwind = 34; @@ -1237,9 +1195,8 @@ export class drainFuture { bb0 = 27; continue l0; } else { - _0 = rt.Pending; this.state = 4; - return _0; + return rt.Pending; } case 7: unwind = 35; @@ -1251,18 +1208,16 @@ export class drainFuture { bb0 = 27; continue l0; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } case 27: if (next === undefined) { unwind = 37; _40 = this.total_; rt.drop(this.rx_); - _0 = _40; this.state = 1; - return _0; + return _40; } else { unwind = 36; _39 = rt.u64Add(this.total_, next); @@ -1308,18 +1263,14 @@ export class level1Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1344,13 +1295,11 @@ export class level1Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1379,18 +1328,14 @@ export class level10Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1415,13 +1360,11 @@ export class level10Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1450,18 +1393,14 @@ export class level11Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1486,13 +1425,11 @@ export class level11Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1521,18 +1458,14 @@ export class level12Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1557,13 +1490,11 @@ export class level12Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1592,18 +1523,14 @@ export class level13Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1628,13 +1555,11 @@ export class level13Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1663,18 +1588,14 @@ export class level14Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1699,13 +1620,11 @@ export class level14Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1734,18 +1653,14 @@ export class level15Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1770,13 +1685,11 @@ export class level15Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1805,18 +1718,14 @@ export class level2Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1841,13 +1750,11 @@ export class level2Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1876,18 +1783,14 @@ export class level3Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1912,13 +1815,11 @@ export class level3Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -1947,18 +1848,14 @@ export class level4Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -1983,13 +1880,11 @@ export class level4Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -2018,18 +1913,14 @@ export class level5Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -2054,13 +1945,11 @@ export class level5Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -2089,18 +1978,14 @@ export class level6Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -2125,13 +2010,11 @@ export class level6Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -2160,18 +2043,14 @@ export class level7Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -2196,13 +2075,11 @@ export class level7Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -2231,18 +2108,14 @@ export class level8Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -2267,13 +2140,11 @@ export class level8Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { @@ -2302,18 +2173,14 @@ export class level9Future { } [Symbol.dispose](): void { - if (this.state === 0) { - return; - } else if (this.state === 3) { - rt.drop(this.__awaitee_); - return; - } else { - return; + if (this.state !== 0) { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } } } poll(_2: rt.Context): rt.Poll { - let _0!: rt.Poll; let _4!: rt.Future; let _6!: rt.Poll; let result!: rt.u64 | undefined; @@ -2338,13 +2205,11 @@ export class level9Future { unwind = 12; result = _6; rt.drop(this.__awaitee_); - _0 = result; this.state = 1; - return _0; + return result; } else { - _0 = rt.Pending; this.state = 3; - return _0; + return rt.Pending; } } catch (e) { if (unwind === 0) { diff --git a/ts/src/lower/mir/cfg.rs b/ts/src/lower/mir/cfg.rs index a67a628d4..6802fc6a6 100644 --- a/ts/src/lower/mir/cfg.rs +++ b/ts/src/lower/mir/cfg.rs @@ -474,13 +474,23 @@ fn strip_tail(stmts: &mut Vec, jump: &StmtKind) { strip_tail(els, jump); } StmtKind::Block { body, .. } => strip_tail(body, jump), + // Falling off the `try` goes past its `catch`. + StmtKind::Catch { body, .. } => strip_tail(body, jump), _ => {} } } +/// Drop the `return;`s a function returning nothing ends with. +pub fn strip_return(stmts: &mut Vec) { + strip_tail(stmts, &StmtKind::Return(None)); + simplify(stmts); + simplify(stmts); +} + fn same_jump(a: &StmtKind, b: &StmtKind) -> bool { match (a, b) { (StmtKind::Break(x), StmtKind::Break(y)) | (StmtKind::Continue(x), StmtKind::Continue(y)) => x == y, + (StmtKind::Return(None), StmtKind::Return(None)) => true, _ => false, } } diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 590a3ca37..edbf3e83c 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -783,7 +783,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out.extend(entry); out.extend(body); drop_self_assignments(&mut out); + return_in_place(&mut out); prune_unread(&mut out); + if self.zero_sized(self.mir.local_decls[mir::RETURN_PLACE].ty) { + cfg::strip_return(&mut out); + } out } @@ -2120,6 +2124,138 @@ fn drop_self_assignments(stmts: &mut Vec) { } } +/// `x = v; ...; return x;` as `return v;`, where moving `v` past the statements between +/// changes nothing: there are none, or `v` is a constant or a name none of them assigns. +fn return_in_place(stmts: &mut Vec) { + sink_return(stmts); + for stmt in stmts.iter_mut() { + match &mut stmt.kind { + StmtKind::If { then, els, .. } => { + return_in_place(then); + return_in_place(els); + } + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => return_in_place(body), + StmtKind::Switch { cases, default, .. } => { + cases.iter_mut().for_each(|(_, body)| return_in_place(body)); + return_in_place(default); + } + StmtKind::Catch { body, handler, .. } => { + return_in_place(body); + return_in_place(handler); + } + _ => {} + } + } + let Some(Stmt { + kind: StmtKind::Return(Some(Expr::Ident(name))), + .. + }) = stmts.last() + else { + return; + }; + let name = name.clone(); + let assigns = |e: &Expr, to: &str| matches!(e, Expr::Assign(t, _) if matches!(&**t, Expr::Ident(n) if n == to)); + let mut at = None; + for i in (0..stmts.len() - 1).rev() { + let StmtKind::Expr(e) = &stmts[i].kind else { + return; + }; + if assigns(e, &name) { + at = Some(i); + break; + } + let mut reads = Vec::new(); + reads_of(e, &mut reads); + if reads.contains(&name) { + return; + } + } + let Some(at) = at else { + return; + }; + let StmtKind::Expr(Expr::Assign(_, value)) = &stmts[at].kind else { + unreachable!("found above") + }; + let between = &stmts[at + 1..stmts.len() - 1]; + let moves = between.is_empty() + || value.is_constant() + || matches!(&**value, Expr::Ident(n) if between.iter().all(|s| !matches!(&s.kind, StmtKind::Expr(e) if assigns(e, n)))); + if !moves { + return; + } + let StmtKind::Expr(Expr::Assign(_, value)) = stmts.remove(at).kind else { + unreachable!("found above") + }; + let last = stmts.last_mut().expect("the return"); + last.kind = StmtKind::Return(Some(*value)); +} + +/// Move a `return x;` that follows an `if` or a labeled block into each way out of it, so +/// each can return what it assigns `x` in place. +fn sink_return(stmts: &mut Vec) { + while stmts.len() >= 2 + && matches!( + stmts.last().map(|s| &s.kind), + Some(StmtKind::Return(Some(Expr::Ident(_)))) + ) { + let ret = stmts.pop().expect("checked above"); + let last = stmts.last_mut().expect("checked above"); + match &mut last.kind { + StmtKind::If { then, els, .. } => { + for branch in [then, els] { + if !crate::ts::diverges(branch) { + branch.push(ret.clone()); + } + } + return; + } + StmtKind::Block { + label: Some(label), + body, + } => { + let label = label.clone(); + breaks_to_return(body, &label, &ret); + if !crate::ts::diverges(body) { + body.push(ret); + } + let StmtKind::Block { body, .. } = stmts.pop().expect("checked above").kind else { + unreachable!("matched above") + }; + stmts.extend(body); + } + _ => { + stmts.push(ret); + return; + } + } + } +} + +/// Replace each `break label;` in `stmts` with `ret`. +fn breaks_to_return(stmts: &mut [Stmt], label: &str, ret: &Stmt) { + for stmt in stmts.iter_mut() { + match &mut stmt.kind { + StmtKind::Break(Some(l)) if l == label => *stmt = ret.clone(), + StmtKind::If { then, els, .. } => { + breaks_to_return(then, label, ret); + breaks_to_return(els, label, ret); + } + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => breaks_to_return(body, label, ret), + StmtKind::Switch { cases, default, .. } => { + cases + .iter_mut() + .for_each(|(_, body)| breaks_to_return(body, label, ret)); + breaks_to_return(default, label, ret); + } + StmtKind::Catch { body, handler, .. } => { + breaks_to_return(body, label, ret); + breaks_to_return(handler, label, ret); + } + _ => {} + } + } +} + /// Whether evaluating `e` does nothing at all: a path, or a literal made of them. fn inert(e: &Expr) -> bool { match e { From 687f90a2ed6dde956f8ecae58ae334091c0d7c3e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 17:11:09 -0700 Subject: [PATCH 04/17] perf(ts): step array loops in place and fold more temporaries Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- .../expected/coding/decode.DecodeError.ts | 4 +- .../codec/expected/coding/decode.Decoder.ts | 4 +- .../codec/expected/coding/encode.Encoder.ts | 28 +- .../codec/expected/coding/version.Versions.ts | 12 +- ts/fixtures/codec/expected/harness.ts | 32 +- .../codec/expected/lib.SessionError.ts | 4 +- ts/fixtures/lang/expected/fmt.Fails.ts | 4 +- ts/fixtures/lang/expected/fmt.Fault.ts | 8 +- ts/fixtures/lang/expected/fmt.Hex.ts | 8 +- ts/fixtures/lang/expected/fmt.ts | 62 +--- ts/fixtures/lang/expected/generics.Wrap.ts | 12 +- ts/fixtures/lang/expected/generics.ts | 4 +- ts/fixtures/lang/expected/iters.Countdown.ts | 4 +- ts/fixtures/lang/expected/iters.Gaps.ts | 4 +- ts/fixtures/lang/expected/iters.ts | 20 +- ts/fixtures/lang/expected/shapes.Point.ts | 8 +- ts/fixtures/lang/expected/shapes.ts | 106 ++---- ts/fixtures/task/expected/kio.Consumer.ts | 14 +- ts/fixtures/task/expected/kio.Producer.ts | 20 +- ts/fixtures/task/expected/kio.WaiterList.ts | 19 +- ts/fixtures/task/expected/kio.ts | 14 +- ts/fixtures/task/expected/model.Guard.ts | 4 +- ts/fixtures/task/expected/model.ts | 348 ++++-------------- ts/rustc-ice-2026-10-26T00_02_50-1147869.txt | 77 ++++ ts/rustc-ice-2026-10-26T00_02_52-1149919.txt | 77 ++++ ts/rustc-ice-2026-10-26T00_03_00-1156431.txt | 77 ++++ ts/rustc-ice-2026-10-26T00_03_00-1157053.txt | 77 ++++ ts/src/lower/mir/call.rs | 11 +- ts/src/lower/mir/mod.rs | 209 +++++++++-- ts/src/lower/mir/rvalue.rs | 2 +- ts/src/lower/mir/step.rs | 199 ++++++++++ 31 files changed, 910 insertions(+), 562 deletions(-) create mode 100644 ts/rustc-ice-2026-10-26T00_02_50-1147869.txt create mode 100644 ts/rustc-ice-2026-10-26T00_02_52-1149919.txt create mode 100644 ts/rustc-ice-2026-10-26T00_03_00-1156431.txt create mode 100644 ts/rustc-ice-2026-10-26T00_03_00-1157053.txt create mode 100644 ts/src/lower/mir/step.rs diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index 792f59c62..3dcc2b256 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -6,7 +6,6 @@ import * as SessionError from "../lib.SessionError.ts"; export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Result { let __field0!: rt.u64; - let args!: [rt.u64]; let size!: rt.usize; let max!: rt.usize; let __displaySize!: rt.usize; @@ -19,8 +18,7 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re return rt.fmtWriteStr(__formatter, "invalid string"); } else if (self.tag === "InvalidMessage") { __field0 = ([self._0] as [rt.u64])[0]; - args = [__field0] as [rt.u64]; - const arg = args[0]; + const arg = ([__field0] as [rt.u64])[0]; return rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(arg, f)]); } else if (self.tag === "InvalidSubscribeLocation") { return rt.fmtWriteStr(__formatter, "invalid subscribe location"); diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 487ce4f2e..b4923bedf 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -45,12 +45,10 @@ export function need(self: Decoder): rt.usize { /** Record that a read wanted `more` bytes past the current position. */ export function short(self: Decoder, more: rt.usize): DecodeError.DecodeError { let need_!: rt.usize; - let _8!: rt.usize; let _9!: rt.usize; need_ = rt.usizeSaturatingAdd(rt.usizeSub(self.len, self.buf.length), more); _9 = self.need; - _8 = rt.max(_9, need_); - self.need = _8; + self.need = rt.max(_9, need_); return { tag: "Short" } as DecodeError.DecodeError; } diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index 3f5b61497..56c8d7909 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -101,25 +101,19 @@ export function string(self: Encoder, v: string): rt.Result { let _4!: rt.Result; - let iter!: rt.Iter; + let iter!: { s: Version.Version[]; i: number }; let _14!: Version.Version | rt.Done; let _18!: rt.Result; _4 = Encoder.varint(w, self._0.length as rt.u64); if (_4.ok) { - iter = rt.iterSlice(self._0); + iter = { s: self._0, i: 0 }; while (true) { - _14 = iter.next(); + _14 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_14 === rt.DONE) { return rt.Ok(undefined); } else { @@ -94,14 +94,14 @@ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: /** Encode the version list. */ export function encode$Encode_Version(self: Versions, w: Encoder.Encoder, version: version_Version.Version): rt.Result { let _4!: rt.Result; - let iter!: rt.Iter; + let iter!: { s: Version.Version[]; i: number }; let _14!: Version.Version | rt.Done; let _18!: rt.Result; _4 = Encoder.varint(w, self._0.length as rt.u64); if (_4.ok) { - iter = rt.iterSlice(self._0); + iter = { s: self._0, i: 0 }; while (true) { - _14 = iter.next(); + _14 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_14 === rt.DONE) { return rt.Ok(undefined); } else { diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index e257ec233..15c53c1da 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -105,11 +105,9 @@ export function takeU64(data: Uint8Array): [rt.u64, Uint8Array] { export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): void { let _5!: string; let _6!: string; - let args!: [DecodeError.DecodeError]; decodeError(out, err); _5 = rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$Display(err, f)); - args = [err] as [DecodeError.DecodeError]; - const arg = args[0]; + const arg = ([err] as [DecodeError.DecodeError])[0]; _6 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Debug(arg, f)]); putText(out, _5, _6); } @@ -118,11 +116,9 @@ export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): voi export function encodeFailed(out: rt.ByteVec, err: EncodeError.EncodeError): void { let _5!: string; let _6!: string; - let args!: [EncodeError.EncodeError]; encodeError(out, err); _5 = rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$Display(err, f)); - args = [err] as [EncodeError.EncodeError]; - const arg = args[0]; + const arg = ([err] as [EncodeError.EncodeError])[0]; _6 = rt.fmtFormat([(f: rt.Formatter) => EncodeError.fmt$Debug(arg, f)]); putText(out, _5, _6); } @@ -216,7 +212,7 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { let _15!: rt.usize; let r!: Decoder.Decoder; let _18!: Form.Form; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _21!: rt.u8 | rt.Done; let _26!: rt.Result; let err!: DecodeError.DecodeError; @@ -232,9 +228,9 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { _13 = rt.sliceSplitAt(_9[1], _14); _18 = form(selector); r = Decoder.new(_13[1], _18); - iter = rt.iterSlice(_13[0]); + iter = { s: _13[0], i: 0 }; l1: while (true) { - _21 = iter.next(); + _21 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_21 !== rt.DONE) { _26 = decodeStep(r, _21, out); if (_26.ok) { @@ -373,7 +369,7 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { let w!: Encoder.Encoder; let _20!: Form.Form; let prefixes!: Prefix.Prefix[]; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _24!: rt.u8 | rt.Done; let step!: rt.u8; let value!: rt.u64; @@ -411,9 +407,9 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { _20 = form(selector); w = Encoder.new(buf, _20); prefixes = []; - iter = rt.iterSlice(_13[0]); + iter = { s: _13[0], i: 0 }; while (true) { - _24 = iter.next(); + _24 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_24 === rt.DONE) { while (true) { _98 = prefixes.pop(); @@ -749,11 +745,8 @@ export function errors(data: Uint8Array, out: rt.ByteVec): void { let _20!: rt.Result; let _26!: string; let _28!: string; - let args!: [BoundsExceeded.BoundsExceeded]; let _38!: string; - let args3!: [DecodeError.DecodeError]; let _47!: string; - let args5!: [DecodeError.DecodeError]; _5 = rt.sliceSplitFirst(data); b0: { if (_5 !== undefined) { @@ -780,19 +773,16 @@ export function errors(data: Uint8Array, out: rt.ByteVec): void { } else if (_10 === 6) { const arg = {}; _26 = rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$Display(arg, f)); - args = [{}] as [BoundsExceeded.BoundsExceeded]; - const arg2 = args[0]; + const arg2 = ([{}] as [BoundsExceeded.BoundsExceeded])[0]; _28 = rt.fmtFormat([(f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f))]); putText(out, _26, _28); break b0; } else { err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; } - args3 = [err] as [DecodeError.DecodeError]; - const arg3 = args3[0]; + const arg3 = ([err] as [DecodeError.DecodeError])[0]; _38 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Display(arg3, f), " ", rt.fmtSpec({ align: ">", width: 30 }, (f: rt.Formatter) => DecodeError.fmt$Display(arg3, f)), "|"]); - args5 = [err] as [DecodeError.DecodeError]; - const arg4 = args5[0]; + const arg4 = ([err] as [DecodeError.DecodeError])[0]; _47 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => DecodeError.fmt$Debug(arg4, f))]); putText(out, _38, _47); decodeFailed(out, err); diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index 497c005a9..81af00650 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -5,14 +5,12 @@ import * as rt from "./rt.ts"; export function fmt$Display(self: SessionError, __formatter: rt.Formatter): rt.Result { let _02!: rt.u16; let __display0!: rt.u16; - let args!: [rt.u16]; if (self.tag === "ProtocolViolation") { return rt.fmtWriteStr(__formatter, "protocol violation"); } else { _02 = self._0; __display0 = ([_02] as [rt.u16])[0]; - args = [__display0] as [rt.u16]; - const arg = args[0]; + const arg = ([__display0] as [rt.u16])[0]; return rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(arg, f)]); } } diff --git a/ts/fixtures/lang/expected/fmt.Fails.ts b/ts/fixtures/lang/expected/fmt.Fails.ts index d9f020c70..d45b8674d 100644 --- a/ts/fixtures/lang/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/expected/fmt.Fails.ts @@ -9,10 +9,8 @@ export interface Fails { export function fmt$Display(self: Fails, f: rt.Formatter): rt.Result { let _8!: rt.Result; - let args!: [rt.u8]; if (!(rt.u8Rem(self._0, 2) === 0)) { - args = [self._0] as [rt.u8]; - const arg = args[0]; + const arg = ([self._0] as [rt.u8])[0]; _8 = rt.fmtWriteFmt(f, ["half ", (f: rt.Formatter) => rt.u8Display(arg, f)]); if (_8.ok) { return rt.Err(new rt.FmtError()); diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index 9373975aa..5288dc7b4 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -51,17 +51,14 @@ export type Fault = export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result { let code!: rt.u16; - let args!: [rt.u16]; let size!: rt.usize; let max!: rt.usize; let pair!: Pair.Pair; - let args5!: [Pair.Pair]; if (self.tag === "Short") { return rt.fmtPad(f, "short buffer"); } else if (self.tag === "Code") { code = self._0; - args = [code] as [rt.u16]; - const arg2 = args[0]; + const arg2 = ([code] as [rt.u16])[0]; return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, (f: rt.Formatter) => rt.u16LowerHex(arg2, f))]); } else if (self.tag === "TooLarge") { size = self.size; @@ -69,8 +66,7 @@ export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); } else { pair = self._0; - args5 = [pair] as [Pair.Pair]; - const arg = args5[0]; + const arg = ([pair] as [Pair.Pair])[0]; return rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(arg, f)]); } } diff --git a/ts/fixtures/lang/expected/fmt.Hex.ts b/ts/fixtures/lang/expected/fmt.Hex.ts index 3d39a0beb..ddbf4dfc3 100644 --- a/ts/fixtures/lang/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/expected/fmt.Hex.ts @@ -8,15 +8,11 @@ export interface Hex { } export function fmt$Display(self: Hex, f: rt.Formatter): rt.Result { - let args!: [rt.u32]; - let args3!: [rt.u32]; if (!rt.fmtAlternate(f)) { - args3 = [self._0] as [rt.u32]; - const arg2 = args3[0]; + const arg2 = ([self._0] as [rt.u32])[0]; return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]); } else { - args = [self._0] as [rt.u32]; - const arg = args[0]; + const arg = ([self._0] as [rt.u32])[0]; return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(arg, f))]); } } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 63eb0d2e4..67af81d22 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -200,7 +200,7 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { /** Strings padded and escaped, and bytes that may not be UTF-8. */ export function strings(data: Uint8Array, out: rt.ByteVec): void { - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _9!: rt.u8 | rt.Done; let s!: string; let _15!: rt.usize; @@ -220,12 +220,11 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { let _95!: rt.Result; let v!: rt.u8; let _104!: string; - let args9!: [rt.u8]; let e2!: rt.TryFromIntError; let _116!: string; - iter = rt.iterSlice(rt.sliceRange(data, 0, rt.min(data.length, 3))); + iter = { s: rt.sliceRange(data, 0, rt.min(data.length, 3)), i: 0 }; while (true) { - _9 = iter.next(); + _9 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_9 === rt.DONE) { _36 = rt.stringFromUtf8(rt.sliceToByteVec(data)); if (_36.ok) { @@ -255,8 +254,7 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { _95 = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); if (_95.ok) { v = _95.value; - args9 = [v] as [rt.u8]; - const arg = args9[0]; + const arg = ([v] as [rt.u8])[0]; _104 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); put(out, _104); } else { @@ -282,7 +280,6 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { export function nested(data: Uint8Array): Nested.Nested { let at!: (a0: rt.usize) => rt.u8; let _3!: string; - let _4!: string[]; let _5!: rt.usize; let _6!: rt.usize; let _10!: rt.usize; @@ -311,8 +308,7 @@ export function nested(data: Uint8Array): Nested.Nested { if (!(_5 < 14)) { rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); } - _4 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"]; - _3 = _4[_5]; + _3 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_5]; _15 = { x: rt.i32Sub(at(1) as rt.i32, 128), y: -7 }; _23 = rt.u8Rem(at(2), 3); if (_23 === 0) { @@ -357,9 +353,7 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { let at!: (a0: rt.usize) => rt.u8; let value!: Nested.Nested; let _8!: string; - let args!: [Nested.Nested]; let _20!: string; - let args3!: [Nested.Nested]; let wide!: Wide.Wide; let _30!: rt.u8; let _33!: boolean; @@ -382,7 +376,6 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { let _118!: Kind.Kind; let _119!: rt.usize; let _130!: string; - let args13!: [Kind.Kind[]]; let bytes!: Uint8Array; let words!: rt.u16[]; let _148!: string; @@ -397,12 +390,10 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; value = nested(data); - args = [value] as [Nested.Nested]; - const arg = args[0]; + const arg = ([value] as [Nested.Nested])[0]; _8 = rt.fmtFormat([(f: rt.Formatter) => Nested.fmt$Debug(arg, f)]); put(out, _8); - args3 = [value] as [Nested.Nested]; - const arg2 = args3[0]; + const arg2 = ([value] as [Nested.Nested])[0]; _20 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Nested.fmt$Debug(arg2, f))]); put(out, _20); _30 = at(0); @@ -435,8 +426,7 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { _117 = _118; _112 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), " ", (f: rt.Formatter) => Kind.fmt$Debug(_117, f)]); put(out, _112); - args13 = [kinds] as [Kind.Kind[]]; - const arg5 = args13[0]; + const arg5 = ([kinds] as [Kind.Kind[]])[0]; _130 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtList(arg5, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)))]); put(out, _130); bytes = data; @@ -466,7 +456,6 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { let _27!: string; let padded!: Padded.Padded; let _33!: string; - let args3!: [Padded.Padded]; let manual!: Manual.Manual; let _43!: rt.u8; let _49!: rt.u16[]; @@ -480,10 +469,8 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { let _97!: rt.u8; let _100!: rt.u8 | undefined; let _113!: string; - let args9!: [Tup.Tup]; let fine!: Fails.Fails; let _131!: string; - let args11!: [Fails.Fails]; let _143!: string; let _148!: rt.u8; let _152!: rt.u8; @@ -496,8 +483,7 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { _27 = rt.fmtToString((f: rt.Formatter) => Hex.fmt$Display(hex, f)); put(out, _27); padded = { _0: "pad" }; - args3 = [padded] as [Padded.Padded]; - const arg = args3[0]; + const arg = ([padded] as [Padded.Padded])[0]; _33 = rt.fmtFormat([(f: rt.Formatter) => Padded.fmt$Display(arg, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|", rt.fmtSpec({ width: 30 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|"]); put(out, _33); _43 = at(1); @@ -518,13 +504,11 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { _100 = at(5); } tup = { _0: _97, _1: _100 }; - args9 = [tup] as [Tup.Tup]; - const arg2 = args9[0]; + const arg2 = ([tup] as [Tup.Tup])[0]; _113 = rt.fmtFormat([(f: rt.Formatter) => Tup.fmt$Debug(arg2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Tup.fmt$Debug(arg2, f))]); put(out, _113); fine = { _0: at(6) & (~1 & 0xff) }; - args11 = [fine] as [Fails.Fails]; - const arg3 = args11[0]; + const arg3 = ([fine] as [Fails.Fails])[0]; _131 = rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg3, f), " ", rt.fmtSpec({ align: ">", width: 9 }, (f: rt.Formatter) => Fails.fmt$Display(arg3, f))]); put(out, _131); _148 = at(7); @@ -543,7 +527,6 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let _60!: Pair.Pair; let kind3!: string; let _66!: rt.Arguments | undefined; - let args7!: [rt.u8]; let r!: rt.Result; let _94!: Uint8Array; let _98!: string; @@ -557,9 +540,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let _127!: string; let _129!: rt.u8; let _132!: string; - let args9!: [rt.u8]; let _143!: string; - let args11!: [Fails.Fails]; let _148!: Fails.Fails; let _155!: string; let _157!: Fails.Fails; @@ -574,7 +555,6 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let buf!: Uint8Array; let _202!: Uint8Array; let _211!: string; - let args17!: [Uint8Array]; let r4!: rt.Result; let _221!: rt.Result; let s!: string; @@ -586,10 +566,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let dest!: rt.usize; let _244!: Uint8Array; let _258!: string; - let args19!: [Uint8Array]; let r5!: rt.Result; let _274!: string; - let args21!: [rt.u8]; let _279!: rt.u8; n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); _7 = rt.u8Rem(kind, 19); @@ -615,9 +593,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _58 = { _0: n, _1: 1 }; _60 = { _0: n, _1: 1 }; if (Pair.eq$PartialEq(_58, _60)) { + const arg6 = ([n] as [rt.u8])[0]; kind3 = "!="; - args7 = [n] as [rt.u8]; - const arg6 = args7[0]; _66 = ["same ", (f: rt.Formatter) => rt.u8Display(arg6, f)]; rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(_58, f), (f: rt.Formatter) => Pair.fmt$Debug(_60, f), _66); } @@ -650,16 +627,14 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { put(out, _119); } else if (_7 === 10) { missing = rt.sliceGet(rest, 200); - args9 = [n] as [rt.u8]; - const arg5 = args9[0]; + const arg5 = ([n] as [rt.u8])[0]; _132 = rt.fmtFormat(["missing ", (f: rt.Formatter) => rt.u8Display(arg5, f)]); _129 = rt.optionExpect(missing, _132); _127 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_129, f)); put(out, _127); } else if (_7 === 11) { _148 = { _0: n }; - args11 = [_148] as [Fails.Fails]; - const arg4 = args11[0]; + const arg4 = ([_148] as [Fails.Fails])[0]; _143 = rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg4, f)]); put(out, _143); } else if (_7 === 12) { @@ -683,8 +658,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _202 = buf; const part3 = rt.min(rest.length, 4); rt.sliceCopyFromSlice(_202, rt.sliceRange(rest, 0, part3)); - args17 = [buf] as [Uint8Array]; - const arg3 = args17[0]; + const arg3 = ([buf] as [Uint8Array])[0]; _211 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]); put(out, _211); } else if (_7 === 16) { @@ -707,8 +681,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { dest = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); _244 = buf2; rt.sliceCopyWithin(_244, part, part2, dest); - args19 = [buf2] as [Uint8Array]; - const arg2 = args19[0]; + const arg2 = ([buf2] as [Uint8Array])[0]; _258 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Display)]); put(out, _258); } else { @@ -718,8 +691,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { r5 = rt.Err(n); } _279 = rt.resultUnwrapErr(r5, rt.u8Display); - args21 = [_279] as [rt.u8]; - const arg = args21[0]; + const arg = ([_279] as [rt.u8])[0]; _274 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); put(out, _274); } diff --git a/ts/fixtures/lang/expected/generics.Wrap.ts b/ts/fixtures/lang/expected/generics.Wrap.ts index d90df59f2..23499457a 100644 --- a/ts/fixtures/lang/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/expected/generics.Wrap.ts @@ -214,23 +214,17 @@ export function get$u8(self: Wrap): rt.u8 { } export function bump$Point(self: Wrap): rt.u8 { - let _2!: rt.u8; - _2 = rt.u8WrappingAdd(self.count, 1); - self.count = _2; + self.count = rt.u8WrappingAdd(self.count, 1); return self.count; } export function bump$Vec_u16(self: Wrap): rt.u8 { - let _2!: rt.u8; - _2 = rt.u8WrappingAdd(self.count, 1); - self.count = _2; + self.count = rt.u8WrappingAdd(self.count, 1); return self.count; } export function bump$u8(self: Wrap): rt.u8 { - let _2!: rt.u8; - _2 = rt.u8WrappingAdd(self.count, 1); - self.count = _2; + self.count = rt.u8WrappingAdd(self.count, 1); return self.count; } diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 532fb5e2b..66b4a5508 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -20,7 +20,6 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { let shape!: Wrap.Wrap; let _46!: string; let _64!: string; - let args3!: [Wrap.Wrap>]; let _76!: Uint8Array; let _91!: Uint8Array; let _97!: Uint8Array; @@ -61,8 +60,7 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { shape = Wrap.new$Shape({ tag: "Rect", corner: Wrap.intoInner$Point(point), width: at(5) as rt.u16, height: 3 } as Shape.Shape); _46 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)]); put(out, _46); - args3 = [nested] as [Wrap.Wrap>]; - const arg = args3[0]; + const arg = ([nested] as [Wrap.Wrap>])[0]; _64 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(arg, f))]); put(out, _64); _76 = rt.u16ToBeBytes(Wrap.double$u8(byte)); diff --git a/ts/fixtures/lang/expected/iters.Countdown.ts b/ts/fixtures/lang/expected/iters.Countdown.ts index aa1d6efcf..0783a2862 100644 --- a/ts/fixtures/lang/expected/iters.Countdown.ts +++ b/ts/fixtures/lang/expected/iters.Countdown.ts @@ -10,13 +10,11 @@ export interface Countdown { export function next$Iterator(self: Countdown): rt.u8 | rt.Done { let left!: rt.u8; - let _3!: rt.u8; if (self.left === 0) { return rt.DONE; } else { left = self.left; - _3 = rt.u8SaturatingSub(left, self.step); - self.left = _3; + self.left = rt.u8SaturatingSub(left, self.step); return left; } } diff --git a/ts/fixtures/lang/expected/iters.Gaps.ts b/ts/fixtures/lang/expected/iters.Gaps.ts index 23d40bfdc..995965c89 100644 --- a/ts/fixtures/lang/expected/iters.Gaps.ts +++ b/ts/fixtures/lang/expected/iters.Gaps.ts @@ -11,12 +11,10 @@ export interface Gaps { export function next$Iterator(self: Gaps): rt.u8 | undefined | rt.Done { let b!: rt.u8; let _3!: rt.u8 | undefined; - let _8!: rt.usize; _3 = rt.sliceGet(self.data, self.at); if (_3 !== undefined) { b = _3; - _8 = rt.usizeAdd(self.at, 1); - self.at = _8; + self.at = rt.usizeAdd(self.at, 1); if (!(b === 0)) { return b; } else { diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 2d8f40f4c..4411189fc 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -15,7 +15,7 @@ import * as Wrapper from "./iters.Wrapper.ts"; export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _4!: rt.u8; let doubled!: rt.ByteVec; - let iter!: rt.Iter; + let iter!: { s: rt.u16[]; i: number }; let _18!: rt.u16 | rt.Done; let _25!: Uint8Array; let iter2!: rt.Iter<[rt.usize, rt.u8]>; @@ -58,13 +58,13 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { return rt.u8Rem(b11, 3) !== 0; })); rt.byteVecExtendFromSlice(out, rt.byteVecView(doubled)); - iter = rt.iterSlice(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { + iter = { s: rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { let b12!: rt.u8; b12 = _217; return rt.thenSome(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); - }))); + })), i: 0 }; while (true) { - _18 = iter.next(); + _18 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_18 === rt.DONE) { break b0; } else { @@ -208,15 +208,15 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { let words!: rt.ByteVec[]; let word!: rt.ByteVec; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _6!: rt.u8 | rt.Done; let b!: rt.u8; let _13!: rt.ByteVec; words = []; word = new rt.ByteVec(); - iter = rt.iterSlice(self); + iter = { s: self, i: 0 }; while (true) { - _6 = iter.next(); + _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_6 === rt.DONE) { words.push(word); return words; @@ -463,7 +463,7 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { let _267!: rt.i64; let _274!: rt.i64; let _282!: Uint8Array; - let iter3!: rt.Iter; + let iter3!: { s: rt.u32[]; i: number }; let _289!: rt.u32 | rt.Done; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); @@ -558,9 +558,9 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { _274 = rt.i64Of(9007199254740992n); _282 = rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(_265, rt.i64Add(rt.i64Neg(_274), 1), rt.i64Step)), 0)); rt.byteVecExtendFromSlice(out, _282); - iter3 = rt.iterSlice(rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)))); + iter3 = { s: rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))), i: 0 }; while (true) { - _289 = iter3.next(); + _289 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; if (_289 === rt.DONE) { updates(a, b, data, out); return; diff --git a/ts/fixtures/lang/expected/shapes.Point.ts b/ts/fixtures/lang/expected/shapes.Point.ts index c0a8b6939..009abeddc 100644 --- a/ts/fixtures/lang/expected/shapes.Point.ts +++ b/ts/fixtures/lang/expected/shapes.Point.ts @@ -38,17 +38,13 @@ function new_(x: rt.i32, y: rt.i32): Point { /** Changes `self`, which a caller's copy must not see. */ export function shift(self: Point, by: rt.i32): Point { - let _3!: rt.i32; self = rt.copy(self); - _3 = rt.i32Add(self.x, by); - self.x = _3; + self.x = rt.i32Add(self.x, by); return rt.copy(self); } export function bump(self: Point): void { - let _2!: rt.i32; - _2 = rt.i32Add(self.y, 1); - self.y = _2; + self.y = rt.i32Add(self.y, 1); } export { new_ as new }; diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 4071379ae..7c4dc005c 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -13,12 +13,12 @@ import type * as Wide from "./shapes.Wide.ts"; export function total$Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { let sum!: rt.u64; - let iter!: rt.Iter; + let iter!: { s: Meters.Meters[]; i: number }; let _6!: Meters.Meters | rt.Done; sum = 0; - iter = rt.iterSlice(items); + iter = { s: items, i: 0 }; while (true) { - _6 = iter.next(); + _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_6 === rt.DONE) { return sum; } else { @@ -30,12 +30,12 @@ export function total$Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { export function total$Shape(items: Shape.Shape[], out: rt.ByteVec): rt.u64 { let sum!: rt.u64; - let iter!: rt.Iter; + let iter!: { s: Shape.Shape[]; i: number }; let _6!: Shape.Shape | rt.Done; sum = 0; - iter = rt.iterSlice(items); + iter = { s: items, i: 0 }; while (true) { - _6 = iter.next(); + _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_6 === rt.DONE) { return sum; } else { @@ -97,7 +97,6 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { let r!: Point.Point; let pair!: [Point.Point, rt.u8]; let saved!: [Point.Point, rt.u8]; - let _15!: rt.u8; let grid!: Point.Point[]; let _17!: rt.usize; let row!: Point.Point[]; @@ -159,8 +158,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { pair = [rt.copy(p), 3] as [Point.Point, rt.u8]; saved = rt.copy(pair); pair[0].y = -1; - _15 = rt.u8Add(pair[1], 1); - pair[1] = _15; + pair[1] = rt.u8Add(pair[1], 1); const item = rt.copy(p); grid = Array.from({ length: 3 }, (): Point.Point => { return rt.copy(item); @@ -448,7 +446,6 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { let slots!: Uint8Array; let _58!: rt.u8; let _59!: rt.usize; - let _63!: rt.u8; let _67!: Uint8Array; let _68!: rt.u8; let _71!: rt.usize; @@ -490,8 +487,7 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { if (!(_59 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _59); } - _63 = rt.u8Add(slots[_59], _58); - slots[_59] = _63; + slots[_59] = rt.u8Add(slots[_59], _58); _68 = f(1); _71 = 0; if (!(_71 < 2)) { @@ -561,7 +557,7 @@ export function reset(m: Moved.Moved): rt.u16 { /** Fieldless enums cast to every width, past their discriminant's range and sign. */ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _5!: rt.u8 | rt.Done; let b!: rt.u8; let wide!: Wide.Wide; @@ -574,9 +570,9 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { let _52!: Uint8Array; let _59!: Uint8Array; let _66!: Uint8Array; - iter = rt.iterSlice(data); + iter = { s: data, i: 0 }; while (true) { - _5 = iter.next(); + _5 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_5 === rt.DONE) { return; } else { @@ -843,12 +839,10 @@ export function diverging(data: Uint8Array, out: rt.ByteVec): void { let b!: rt.u8; let _15!: (a0: rt.u8) => rt.u8; _15 = (b2: rt.u8): rt.u8 => { - let args!: [rt.u8]; if (!(b2 === 253)) { return rt.u8Div(b2, 3); } else { - args = [b2] as [rt.u8]; - const arg = args[0]; + const arg = ([b2] as [rt.u8])[0]; rt.panicFmt(["closure ", (f: rt.Formatter) => rt.u8Display(arg, f)]); } }; @@ -873,9 +867,7 @@ export function closureNever(b: rt.u8): rt.u8 { let ptr!: (a0: rt.u8) => never; let _4!: (a0: rt.u8) => never; _2 = (b2: rt.u8): never => { - let args!: [rt.u8]; - args = [b2] as [rt.u8]; - const arg = args[0]; + const arg = ([b2] as [rt.u8])[0]; rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(arg, f))]); }; _4 = madeNever(); @@ -901,9 +893,7 @@ export function closureNever(b: rt.u8): rt.u8 { /** A closure that never returns, made by a function. */ export function madeNever(): (a0: rt.u8) => never { return (b: rt.u8): never => { - let args!: [rt.u8]; - args = [b] as [rt.u8]; - const arg = args[0]; + const arg = ([b] as [rt.u8])[0]; rt.panicFmt(["made ", (f: rt.Formatter) => rt.u8Display(arg, f)]); }; } @@ -913,22 +903,18 @@ export function madeNever(): (a0: rt.u8) => never { * never exists: given one, and given an `Option` of none, which then calls one. */ export function genericNever(b: rt.u8, len: rt.usize): void { - let args!: [rt.u8]; - let args3!: [rt.u8]; if (!(b === 241)) { if (!(b === 246)) { if (b === 249) { if (!(len > 1)) { - args3 = [b] as [rt.u8]; - const arg2 = args3[0]; + const arg2 = ([b] as [rt.u8])[0]; rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); } else { unwrapOrBail$never(undefined, b); } } } else { - args = [b] as [rt.u8]; - const arg = args[0]; + const arg = ([b] as [rt.u8])[0]; rt.panicFmt(["passed ", (f: rt.Formatter) => rt.u8Display(arg, f)]); } } else { @@ -951,26 +937,20 @@ export function unwrapOrBail$never(o: never | undefined, b: rt.u8): never { /** A function that never returns. */ export function bail(b: rt.u8): never { - let args!: [rt.u8]; - args = [b] as [rt.u8]; - const arg = args[0]; + const arg = ([b] as [rt.u8])[0]; rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(arg, f))]); } /** `return`, and `break` out of the function's labeled block, with values that never exist. */ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { - let args!: [rt.u8]; - let args3!: [rt.u8]; if (b === 247) { - args = [b] as [rt.u8]; - const arg2 = args[0]; + const arg2 = ([b] as [rt.u8])[0]; rt.panicFmt(["returned ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); } else if (b === 248) { if (!(rt.usizeRem(len, 2) === 0)) { bail(b); } else { - args3 = [b] as [rt.u8]; - const arg = args3[0]; + const arg = ([b] as [rt.u8])[0]; rt.panicFmt(["then ", (f: rt.Formatter) => rt.u8Display(arg, f)]); } } else if (!(b === 254)) { @@ -1013,7 +993,6 @@ export function brokenNever(data: Uint8Array): rt.u8 { let i!: rt.usize; let _6!: rt.usize; let _7!: rt.usize; - let args!: [rt.usize]; let _19!: rt.usize; let _20!: rt.usize; i = 0; @@ -1026,8 +1005,7 @@ export function brokenNever(data: Uint8Array): rt.u8 { } const value = data[_6]; if (value === 251) { - args = [i] as [rt.usize]; - const arg = args[0]; + const arg = ([i] as [rt.usize])[0]; rt.panicFmt(["broken at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); return _0; } else if (value === 252) { @@ -1059,7 +1037,6 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { let i!: rt.usize; let _8!: rt.usize; let _9!: rt.usize; - let args!: [rt.usize]; let _22!: rt.usize; let _23!: rt.usize; let _32!: rt.usize; @@ -1074,8 +1051,7 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { } const value = data[_8]; if (value === 239) { - args = [i] as [rt.usize]; - const arg = args[0]; + const arg = ([i] as [rt.usize])[0]; rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); return _0; } else if (value === 240) { @@ -1170,15 +1146,15 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { /** A loop that only `return` leaves, returned itself, around loops that `break`. */ export function returnedLoop(data: Uint8Array): rt.u8 { let i!: rt.usize; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _11!: rt.u8 | rt.Done; let b!: rt.u8; i = 0; l0: while (true) { if (!(i >= data.length)) { - iter = rt.iterSlice(rt.sliceRange(data, i)); + iter = { s: rt.sliceRange(data, i), i: 0 }; l2: while (true) { - _11 = iter.next(); + _11 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_11 !== rt.DONE) { b = _11; if (!(b === 0)) { @@ -1266,7 +1242,7 @@ export function tailBreak(data: Uint8Array): rt.u16 { let _7!: rt.usize; let _8!: rt.usize; let _11!: rt.u8; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _18!: rt.u8 | rt.Done; let c!: rt.u8; let n!: rt.u8; @@ -1284,9 +1260,9 @@ export function tailBreak(data: Uint8Array): rt.u16 { if (_11 === 0) { continue l0; } else if (_11 === 1) { - iter = rt.iterSlice(rt.sliceRange(data, i)); + iter = { s: rt.sliceRange(data, i), i: 0 }; while (true) { - _18 = iter.next(); + _18 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_18 === rt.DONE) { continue l0; } else { @@ -1406,7 +1382,7 @@ export function drain(data: Uint8Array, out: rt.ByteVec): void { export function patterns(data: Uint8Array, out: rt.ByteVec): void { let first!: rt.u8; let last!: rt.u8; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _33!: rt.u8 | rt.Done; let b!: rt.u8; let class_!: rt.u8; @@ -1431,7 +1407,6 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { let b3!: rt.u8; let _138!: Uint8Array; let _143!: string; - let args!: [rt.Result]; if (!(data.length === 0)) { if (!(data.length === 1)) { if (!(data.length >= 2)) { @@ -1452,9 +1427,9 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } else { rt.byteVecPush(out, 0); } - iter = rt.iterSlice(rt.sliceRange(data, 0, rt.min(data.length, 4))); + iter = { s: rt.sliceRange(data, 0, rt.min(data.length, 4)), i: 0 }; while (true) { - _33 = iter.next(); + _33 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_33 === rt.DONE) { b6: { if (data.length >= 2) { @@ -1511,8 +1486,7 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { b3 = (parsed as { ok: true; value: rt.u8 }).value; _138 = Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2)); rt.byteVecExtendFromSlice(out, _138); - args = [parsed] as [rt.Result]; - const arg = args[0]; + const arg = ([parsed] as [rt.Result])[0]; _143 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_143)); return; @@ -1561,27 +1535,27 @@ export function early(n: rt.u8): rt.u8 { export function closures(data: Uint8Array, out: rt.ByteVec): void { let sum!: rt.u32; let add!: (a0: rt.u8) => void; - let iter!: rt.Iter; + let iter!: { s: Uint8Array; i: number }; let _8!: rt.u8 | rt.Done; let _18!: Uint8Array; let _26!: Uint8Array; let whole!: Uint8Array; let _36!: rt.usize; let parsed!: Array; - let iter2!: rt.Iter; + let iter2!: { s: Uint8Array; i: number }; let _41!: rt.u8 | rt.Done; let _47!: Dir.Dir | undefined; let tags!: rt.ByteVec; - let iter3!: rt.Iter; + let iter3!: { s: Array; i: number }; let _52!: Dir.Dir | undefined | rt.Done; let _58!: rt.u8; sum = 0; add = (v: rt.u8): void => { sum = rt.u32Add(sum, v as rt.u32); }; - iter = rt.iterSlice(data); + iter = { s: data, i: 0 }; while (true) { - _8 = iter.next(); + _8 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_8 === rt.DONE) { _18 = rt.u32ToBeBytes(sum); rt.byteVecExtendFromSlice(out, _18); @@ -1598,14 +1572,14 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, whole[_36]); parsed = []; - iter2 = rt.iterSlice(data); + iter2 = { s: data, i: 0 }; while (true) { - _41 = iter2.next(); + _41 = iter2.i < iter2.s.length ? iter2.s[iter2.i++] : rt.DONE; if (_41 === rt.DONE) { tags = new rt.ByteVec(); - iter3 = rt.iterSlice(parsed); + iter3 = { s: parsed, i: 0 }; while (true) { - _52 = iter3.next(); + _52 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; if (_52 === rt.DONE) { rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); return; diff --git a/ts/fixtures/task/expected/kio.Consumer.ts b/ts/fixtures/task/expected/kio.Consumer.ts index b8fc18c94..919f8870d 100644 --- a/ts/fixtures/task/expected/kio.Consumer.ts +++ b/ts/fixtures/task/expected/kio.Consumer.ts @@ -27,20 +27,13 @@ export class Consumer { /** The next value, or `None` once the channel closed and every value was read. */ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll { let state!: rt.Mutex; - let _8!: rt.usize; - let _11!: State.State; let value!: rt.u64; let _16!: State.State; let _18!: rt.usize; - let _19!: rt.usize; - let _27!: State.State; state = self.state.value; - _8 = self.next; - _11 = state.value; - if (!(_8 < _11.queue.length)) { + if (!(self.next < state.value.queue.length)) { if (!state.value.closed) { - _27 = state.value; - Waiter.register(waiter, _27.waiters); + Waiter.register(waiter, state.value.waiters); return rt.Pending; } else { return undefined; @@ -50,8 +43,7 @@ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll; - let _10!: State.State; - let _13!: State.State; state = self.state.value; - _10 = state.value; - _10.queue.push(value); - _13 = state.value; - waiters = WaiterList.take(_13.waiters); + state.value.queue.push(value); + waiters = WaiterList.take(state.value.waiters); WaiterList.wake(waiters); } @@ -46,11 +42,9 @@ export function consume(self: Producer): Consumer.Consumer { export function clone$Clone(self: Producer): Producer { let _2!: State.State; let _4!: rt.Mutex; - let _8!: rt.usize; _4 = self.state.value; _2 = _4.value; - _8 = rt.usizeAdd(_2.producers, 1); - _2.producers = _8; + _2.producers = rt.usizeAdd(_2.producers, 1); return new Producer({ state: rt.arcClone(self.state) }); } @@ -58,16 +52,12 @@ export function drop$Drop(self: Producer): void { let waiters!: WaiterList.WaiterList; let state!: rt.Mutex; let _7!: State.State; - let _9!: rt.usize; - let _17!: State.State; state = self.state.value; _7 = state.value; - _9 = rt.usizeSub(_7.producers, 1); - _7.producers = _9; + _7.producers = rt.usizeSub(_7.producers, 1); if (!(state.value.producers > 0)) { state.value.closed = true; - _17 = state.value; - waiters = WaiterList.take(_17.waiters); + waiters = WaiterList.take(state.value.waiters); WaiterList.wake(waiters); } } diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index a778f36eb..e1cd13178 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -16,7 +16,7 @@ function new_(): WaiterList { export function register(self: WaiterList, waiter: Waiter.Waiter): void { let weak!: rt.Weak; - let iter!: rt.Iter>; + let iter!: { s: rt.Weak[]; i: number }; let _8!: rt.Weak | rt.Done; let probes!: rt.usize; let _23!: rt.usize; @@ -25,14 +25,14 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { let _28!: rt.usize; let _31!: rt.usize; let live!: rt.Weak[]; - let iter2!: rt.Iter>; + let iter2!: { s: rt.Weak[]; i: number }; let _43!: rt.Weak | rt.Done; let entry!: rt.Weak; let _53!: rt.Weak[]; weak = new rt.Weak(waiter.shared); - iter = rt.iterSlice(self.entries); + iter = { s: self.entries, i: 0 }; l0: while (true) { - _8 = iter.next(); + _8 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; b1: { b2: { if (_8 === rt.DONE) { @@ -44,9 +44,9 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { live = []; const taken = self.entries; self.entries = []; - iter2 = rt.iterSlice(taken); + iter2 = { s: taken, i: 0 }; while (true) { - _43 = iter2.next(); + _43 = iter2.i < iter2.s.length ? iter2.s[iter2.i++] : rt.DONE; if (_43 === rt.DONE) { _53 = live; self.entries = _53; @@ -99,7 +99,7 @@ export function take(self: WaiterList): WaiterList { /** Wake every live waiter, draining the list. */ export function wake(self: WaiterList): void { - let iter!: rt.Iter>; + let iter!: { s: rt.Weak[]; i: number }; let _6!: rt.Weak | rt.Done; let entry!: rt.Weak; let _10!: rt.Arc | undefined; @@ -109,13 +109,12 @@ export function wake(self: WaiterList): void { self.cursor = 0; const taken = self.entries; self.entries = []; - iter = rt.iterSlice(taken); + iter = { s: taken, i: 0 }; while (true) { - _6 = iter.next(); + _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_6 === rt.DONE) { return; } else { - unwind = 0; entry = _6; _10 = rt.weakUpgrade(entry); if (_10 !== undefined) { diff --git a/ts/fixtures/task/expected/kio.ts b/ts/fixtures/task/expected/kio.ts index 2c8a3d69f..33ab146f7 100644 --- a/ts/fixtures/task/expected/kio.ts +++ b/ts/fixtures/task/expected/kio.ts @@ -32,35 +32,27 @@ export class recvFuture { poll(_2: rt.Context): rt.Poll { let self!: Consumer.Consumer; - let _4!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; let _7!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; self = this.self; - _4 = wait$recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { + this.__awaitee_ = wait$recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { return Consumer.pollRecv(self, waiter); }); - this.__awaitee_ = _4; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _7 = Pending.poll$Future_recv_closure0_closure0(this.__awaitee_, _taskContext); + _7 = Pending.poll$Future_recv_closure0_closure0(this.__awaitee_, _2); if (_7 !== rt.Pending) { unwind = 12; - result = _7; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _7; } else { this.state = 3; return rt.Pending; diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index bcdef7e74..92046c3a2 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -52,9 +52,7 @@ export function finish(self: Guard, event: string): rt.u32 { export function drop$Drop(self: Guard): void { let _4!: string; - let args!: [rt.u32]; - args = [self.id] as [rt.u32]; - const arg = args[0]; + const arg = ([self.id] as [rt.u32])[0]; _4 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index 2ee4de0eb..fdeaec889 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -75,39 +75,28 @@ export class sumFuture { } poll(_2: rt.Context): rt.Poll { - let _3!: rt.u32; - let _6!: Log.Log; - let _8!: rt.Future; let _11!: rt.Poll; let result!: rt.u64 | undefined; let value!: rt.u64; - let args!: [rt.u32]; let _32!: string; - let _43!: rt.u64; let _47!: rt.u64; - let _taskContext!: rt.Context; let unwind: number = 0; try { let bb0: number = 0; l0: while (true) { switch (bb0) { case 0: - _taskContext = _2; if (this.state === 0) { unwind = 33; this.rx_ = this.rx; this.guard_ = this.guard; - _3 = rt.u32Add(this.guard_.id, 100); - _6 = Log.clone$Clone(this.guard_.log); - this.inner_ = Guard.new(_3, _6); + this.inner_ = Guard.new(rt.u32Add(this.guard_.id, 100), Log.clone$Clone(this.guard_.log)); this.total_ = 0; bb0 = 4; continue l0; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } else { bb0 = 7; @@ -115,13 +104,12 @@ export class sumFuture { } case 4: unwind = 32; - _8 = Consumer.recv(this.rx_); - this.__awaitee_ = _8; + this.__awaitee_ = Consumer.recv(this.rx_); bb0 = 7; continue l0; case 7: unwind = 31; - _11 = this.__awaitee_.poll(_taskContext); + _11 = this.__awaitee_.poll(_2); if (_11 !== rt.Pending) { unwind = 32; result = _11; @@ -129,17 +117,12 @@ export class sumFuture { if (result !== undefined) { value = result; if (!(value !== 99)) { - unwind = 32; - args = [this.guard_.id] as [rt.u32]; - const arg = args[0]; + const arg = ([this.guard_.id] as [rt.u32])[0]; rt.panicFmt(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " poisoned"]); } else { - unwind = 32; _32 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(this.guard_.id, f), " got ", (f: rt.Formatter) => rt.u64Display(value, f)]); Log.note(this.inner_.log, _32); - unwind = 32; - _43 = rt.u64Add(this.total_, value); - this.total_ = _43; + this.total_ = rt.u64Add(this.total_, value); bb0 = 4; continue l0; } @@ -340,19 +323,13 @@ export class blocksFuture { } poll(_2: rt.Context): rt.Poll { - let _3!: rt.u32; - let _6!: Log.Log; - let _8!: rt.u32; - let _11!: Log.Log; let _18!: rt.u32; let seen!: rt.Future; let _23!: rt.u32; let _25!: string; let _27!: string; let _32!: rt.u32; - let _33!: rt.Future; let _35!: rt.Poll; - let _48!: rt.Future; let _51!: rt.Poll; let _61!: string; let _63!: string; @@ -360,15 +337,12 @@ export class blocksFuture { let _76!: Guard.Guard; let _83!: Outer.Outer; let third!: Guard.Guard; - let _97!: rt.Future; let _98!: rt.Poll; let result3!: rt.u64; - let _taskContext!: rt.Context; let unwind: number = 0; try { b0: { b1: { - _taskContext = _2; if (this.state === 0) { unwind = 76; this._saved$5 = false; @@ -381,14 +355,10 @@ export class blocksFuture { this._saved$2 = true; this.guard_ = this.guard; this.moves_ = this.moves; - _3 = rt.u32Add(this.guard_.id, 200); - _6 = Log.clone$Clone(this.guard_.log); - this.first_ = Guard.new(_3, _6); + this.first_ = Guard.new(rt.u32Add(this.guard_.id, 200), Log.clone$Clone(this.guard_.log)); unwind = 75; this._saved$4 = true; - _8 = rt.u32Add(this.guard_.id, 300); - _11 = Log.clone$Clone(this.guard_.log); - this.second_ = Guard.new(_8, _11); + this.second_ = Guard.new(rt.u32Add(this.guard_.id, 300), Log.clone$Clone(this.guard_.log)); unwind = 83; this._saved$3 = true; rt.drop(new blocksFuture$2(this.first_)); @@ -403,22 +373,20 @@ export class blocksFuture { this.saved = this.guard_; this._saved = this.tally_.n; this._saved$6 = false; - _33 = seen; - this.__awaitee_ = _33; + this.__awaitee_ = seen; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); - } else if (this.state === 3) { - } else if (this.state === 4) { - break b1; - } else { - break b0; + } else if (this.state !== 3) { + if (this.state === 4) { + break b1; + } else { + break b0; + } } unwind = 73; - _35 = this.__awaitee_.poll(_taskContext); + _35 = this.__awaitee_.poll(_2); if (_35 !== rt.Pending) { unwind = 81; _32 = _35; @@ -429,15 +397,14 @@ export class blocksFuture { Guard.note(this.saved, _25); unwind = 81; this.mark_ = { n: 1 }; - _48 = new blocksFuture$4(this.mark_); - this.___awaitee_ = _48; + this.___awaitee_ = new blocksFuture$4(this.mark_); } else { this.state = 3; return rt.Pending; } } unwind = 71; - _51 = this.___awaitee_.poll(_taskContext); + _51 = this.___awaitee_.poll(_2); if (_51 !== rt.Pending) { unwind = 81; this.replaced_ = _51; @@ -462,7 +429,6 @@ export class blocksFuture { unwind = 67; Guard.note(this.chosen_, "chosen"); if (this.moves_) { - unwind = 67; this._saved$2 = false; rt.drop(new blocksFuture$5(this.guard_)); } @@ -470,15 +436,14 @@ export class blocksFuture { this._saved$4 = false; this._saved$3 = false; this._saved$5 = false; - _97 = new blocksFuture$6(this.first_, this.second_, this.rx_); - this.___awaitee_$2 = _97; + this.___awaitee_$2 = new blocksFuture$6(this.first_, this.second_, this.rx_); } else { this.state = 4; return rt.Pending; } } unwind = 66; - _98 = this.___awaitee_$2.poll(_taskContext); + _98 = this.___awaitee_$2.poll(_2); if (_98 !== rt.Pending) { unwind = 67; result3 = _98; @@ -596,10 +561,8 @@ export class blocksFuture$2 { this.state = 1; return undefined; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } } catch (e) { @@ -633,10 +596,8 @@ export class blocksFuture$3 { this.state = 1; return _0; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } } catch (e) { @@ -702,10 +663,8 @@ export class blocksFuture$5 { this.state = 1; return undefined; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } } catch (e) { @@ -792,35 +751,25 @@ export class blocksFuture$6 { } poll(_2: rt.Context): rt.Poll { - let _9!: rt.u32; - let _12!: Log.Log; - let _14!: rt.Future; let _17!: rt.Poll; let result!: rt.u64 | undefined; let _27!: rt.u64; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 30; Guard.note(this.first, "reads"); Guard.note(this.second, "reads"); - _9 = rt.u32Add(this.second.id, 100); - _12 = Log.clone$Clone(this.second.log); - this._held_ = Guard.new(_9, _12); + this._held_ = Guard.new(rt.u32Add(this.second.id, 100), Log.clone$Clone(this.second.log)); unwind = 21; - _14 = Consumer.recv(this.rx); - this.__awaitee_ = _14; + this.__awaitee_ = Consumer.recv(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 20; - _17 = this.__awaitee_.poll(_taskContext); + _17 = this.__awaitee_.poll(_2); if (_17 !== rt.Pending) { unwind = 21; result = _17; @@ -886,9 +835,7 @@ export function read(t: Tally.Tally): rt.u32 { /** `i`, noted as picked. */ export function pick(log: Log.Log, i: rt.usize): rt.usize { - let args!: [rt.usize]; - args = [i] as [rt.usize]; - const arg = args[0]; + const arg = ([i] as [rt.usize])[0]; Log.note(log, rt.fmtFormat(["pick ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)])); return i; } @@ -912,11 +859,9 @@ export function turns(log: Log.Log, count: rt.u32): void { let _34!: Guard.Guard; let scoped!: rt.u32; let _42!: Guard.Guard; - let args!: [rt.u32]; let boxed!: Guard.Guard; let once!: rt.u32; let finished!: rt.u32; - let args5!: [rt.u32]; let spares!: Guard.Guard[]; let _91!: Guard.Guard; let _95!: Guard.Guard; @@ -945,16 +890,14 @@ export function turns(log: Log.Log, count: rt.u32): void { _42 = Guard.new(rt.u32Add(count, 90), Log.clone$Clone(log)); scoped = _42.id; rt.drop(_42); - args = [scoped] as [rt.u32]; - const arg = args[0]; + const arg = ([scoped] as [rt.u32])[0]; Log.note(log, rt.fmtFormat(["after ", (f: rt.Formatter) => rt.u32Display(arg, f)])); boxed = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); unwind = 89; once = boxed.id; Log.note(log, rt.fmtFormat(["boxed ", (f: rt.Formatter) => rt.u32Display(once, f), " ", (f: rt.Formatter) => rt.u32Display(boxed.id, f)])); finished = Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); - args5 = [finished] as [rt.u32]; - const arg2 = args5[0]; + const arg2 = ([finished] as [rt.u32])[0]; Log.note(log, rt.fmtFormat(["finished ", (f: rt.Formatter) => rt.u32Display(arg2, f)])); _91 = Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)); unwind = 88; @@ -967,15 +910,12 @@ export function turns(log: Log.Log, count: rt.u32): void { } b0: { if (count === 0) { - unwind = 87; Log.note(log, rt.fmtFormat(["no turns"])); } else if (!(count < 4)) { - unwind = 87; Log.note(log, rt.fmtFormat(["many turns"])); } else { left = count; while (true) { - unwind = 87; turn = Guard.new(left, Log.clone$Clone(log)); if (!(left === 1)) { unwind = 86; @@ -985,7 +925,6 @@ export function turns(log: Log.Log, count: rt.u32): void { left = _119; rt.drop(turn); } else { - unwind = 87; rt.drop(turn); break b0; } @@ -1086,7 +1025,6 @@ export class drainFuture { let unwind: number = 0; try { if (this.state === 0) { - unwind = 0; rt.drop(this.rx); return; } else if (this.state === 3) { @@ -1114,22 +1052,16 @@ export class drainFuture { poll(_2: rt.Context): rt.Poll { let next!: rt.u64 | undefined; - let _4!: rt.Future; let _7!: rt.Poll; - let _15!: rt.Future; let _18!: rt.Poll; - let _26!: rt.Future; let _29!: rt.Poll; - let _39!: rt.u64; let _40!: rt.u64; - let _taskContext!: rt.Context; let unwind: number = 0; try { let bb0: number = 0; l0: while (true) { switch (bb0) { case 0: - _taskContext = _2; if (this.state === 0) { this.rx_ = this.rx; this.depth_ = this.depth; @@ -1137,10 +1069,8 @@ export class drainFuture { bb0 = 1; continue l0; } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } else if (this.state === 3) { bb0 = 7; @@ -1155,26 +1085,23 @@ export class drainFuture { case 1: if (this.depth_ === 1) { unwind = 36; - _4 = Consumer.recv(this.rx_); - this.__awaitee_ = _4; + this.__awaitee_ = Consumer.recv(this.rx_); bb0 = 7; continue l0; } else if (this.depth_ === 4) { unwind = 36; - _15 = level3(this.rx_); - this.___awaitee_ = _15; + this.___awaitee_ = level3(this.rx_); bb0 = 15; continue l0; } else { unwind = 36; - _26 = level15(this.rx_); - this.___awaitee_$2 = _26; + this.___awaitee_$2 = level15(this.rx_); bb0 = 22; continue l0; } case 22: unwind = 33; - _29 = this.___awaitee_$2.poll(_taskContext); + _29 = this.___awaitee_$2.poll(_2); if (_29 !== rt.Pending) { unwind = 36; next = _29; @@ -1187,7 +1114,7 @@ export class drainFuture { } case 15: unwind = 34; - _18 = this.___awaitee_.poll(_taskContext); + _18 = this.___awaitee_.poll(_2); if (_18 !== rt.Pending) { unwind = 36; next = _18; @@ -1200,7 +1127,7 @@ export class drainFuture { } case 7: unwind = 35; - _7 = this.__awaitee_.poll(_taskContext); + _7 = this.__awaitee_.poll(_2); if (_7 !== rt.Pending) { unwind = 36; next = _7; @@ -1220,8 +1147,7 @@ export class drainFuture { return _40; } else { unwind = 36; - _39 = rt.u64Add(this.total_, next); - this.total_ = _39; + this.total_ = rt.u64Add(this.total_, next); bb0 = 1; continue l0; } @@ -1271,32 +1197,24 @@ export class level1Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = Consumer.recv(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = Consumer.recv(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1336,32 +1254,24 @@ export class level10Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level9(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level9(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1401,32 +1311,24 @@ export class level11Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level10(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level10(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1466,32 +1368,24 @@ export class level12Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level11(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level11(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1531,32 +1425,24 @@ export class level13Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level12(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level12(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1596,32 +1482,24 @@ export class level14Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level13(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level13(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1661,32 +1539,24 @@ export class level15Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level14(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level14(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1726,32 +1596,24 @@ export class level2Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level1(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level1(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1791,32 +1653,24 @@ export class level3Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level2(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level2(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1856,32 +1710,24 @@ export class level4Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level3(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level3(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1921,32 +1767,24 @@ export class level5Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level4(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level4(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -1986,32 +1824,24 @@ export class level6Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level5(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level5(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -2051,32 +1881,24 @@ export class level7Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level6(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level6(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -2116,32 +1938,24 @@ export class level8Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level7(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level7(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; @@ -2181,32 +1995,24 @@ export class level9Future { } poll(_2: rt.Context): rt.Poll { - let _4!: rt.Future; let _6!: rt.Poll; - let result!: rt.u64 | undefined; - let _taskContext!: rt.Context; let unwind: number = 0; try { - _taskContext = _2; if (this.state === 0) { unwind = 12; - _4 = level8(this.rx); - this.__awaitee_ = _4; + this.__awaitee_ = level8(this.rx); } else if (this.state === 1) { - unwind = 0; rt.panic("`async fn` resumed after completion"); } else if (this.state === 2) { - unwind = 0; rt.panic("`async fn` resumed after panicking"); } unwind = 11; - _6 = this.__awaitee_.poll(_taskContext); + _6 = this.__awaitee_.poll(_2); if (_6 !== rt.Pending) { unwind = 12; - result = _6; rt.drop(this.__awaitee_); this.state = 1; - return result; + return _6; } else { this.state = 3; return rt.Pending; diff --git a/ts/rustc-ice-2026-10-26T00_02_50-1147869.txt b/ts/rustc-ice-2026-10-26T00_02_50-1147869.txt new file mode 100644 index 000000000..fd5a942a0 --- /dev/null +++ b/ts/rustc-ice-2026-10-26T00_02_50-1147869.txt @@ -0,0 +1,77 @@ +thread 'rustc' panicked at src/lower/mir/step.rs:21:95: +Box +stack backtrace: + 0: 0x7ffff4428975 - ::create + 1: 0x7ffff44288c5 - ::force_capture + 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} + 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook + 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} + 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> + 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: + 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl + 8: 0x5555559069db - >::type_at::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 + 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 + 10: 0x555555882728 - >::type_at + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 + 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 + 12: 0x55555587e6c3 - ::find_stepped::{closure#1} + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 + 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 + 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 + 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 + 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 + 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 + 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 + 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 + 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 + 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 + 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 + 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 + 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 + 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 + 26: 0x5555556a5e1e - ::find_stepped + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 + 27: 0x5555556945c0 - ::analyze + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 + 28: 0x55555568b6c5 - ::new + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 + 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 + 30: 0x555555767f1e - ::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 + 31: 0x555555761458 - ::drain + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 + 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 + 33: 0x55555591866f - ::after_expansion + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 + 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} + 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> + 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 37: 0x7ffff5d2d81b - ::new::thread_start + 38: 0x7fffeec9f751 - start_thread + 39: 0x7fffeed2ba4c - __clone3 + 40: 0x0 - + + +rustc version: 1.101.0-nightly (7df81381d 2026-10-14) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +end of query stack diff --git a/ts/rustc-ice-2026-10-26T00_02_52-1149919.txt b/ts/rustc-ice-2026-10-26T00_02_52-1149919.txt new file mode 100644 index 000000000..fd5a942a0 --- /dev/null +++ b/ts/rustc-ice-2026-10-26T00_02_52-1149919.txt @@ -0,0 +1,77 @@ +thread 'rustc' panicked at src/lower/mir/step.rs:21:95: +Box +stack backtrace: + 0: 0x7ffff4428975 - ::create + 1: 0x7ffff44288c5 - ::force_capture + 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} + 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook + 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} + 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> + 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: + 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl + 8: 0x5555559069db - >::type_at::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 + 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 + 10: 0x555555882728 - >::type_at + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 + 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 + 12: 0x55555587e6c3 - ::find_stepped::{closure#1} + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 + 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 + 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 + 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 + 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 + 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 + 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 + 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 + 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 + 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 + 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 + 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 + 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 + 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 + 26: 0x5555556a5e1e - ::find_stepped + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 + 27: 0x5555556945c0 - ::analyze + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 + 28: 0x55555568b6c5 - ::new + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 + 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 + 30: 0x555555767f1e - ::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 + 31: 0x555555761458 - ::drain + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 + 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 + 33: 0x55555591866f - ::after_expansion + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 + 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} + 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> + 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 37: 0x7ffff5d2d81b - ::new::thread_start + 38: 0x7fffeec9f751 - start_thread + 39: 0x7fffeed2ba4c - __clone3 + 40: 0x0 - + + +rustc version: 1.101.0-nightly (7df81381d 2026-10-14) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +end of query stack diff --git a/ts/rustc-ice-2026-10-26T00_03_00-1156431.txt b/ts/rustc-ice-2026-10-26T00_03_00-1156431.txt new file mode 100644 index 000000000..fd5a942a0 --- /dev/null +++ b/ts/rustc-ice-2026-10-26T00_03_00-1156431.txt @@ -0,0 +1,77 @@ +thread 'rustc' panicked at src/lower/mir/step.rs:21:95: +Box +stack backtrace: + 0: 0x7ffff4428975 - ::create + 1: 0x7ffff44288c5 - ::force_capture + 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} + 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook + 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} + 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> + 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: + 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl + 8: 0x5555559069db - >::type_at::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 + 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 + 10: 0x555555882728 - >::type_at + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 + 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 + 12: 0x55555587e6c3 - ::find_stepped::{closure#1} + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 + 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 + 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 + 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 + 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 + 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 + 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 + 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 + 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 + 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 + 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 + 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 + 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 + 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 + 26: 0x5555556a5e1e - ::find_stepped + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 + 27: 0x5555556945c0 - ::analyze + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 + 28: 0x55555568b6c5 - ::new + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 + 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 + 30: 0x555555767f1e - ::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 + 31: 0x555555761458 - ::drain + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 + 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 + 33: 0x55555591866f - ::after_expansion + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 + 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} + 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> + 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 37: 0x7ffff5d2d81b - ::new::thread_start + 38: 0x7fffeec9f751 - start_thread + 39: 0x7fffeed2ba4c - __clone3 + 40: 0x0 - + + +rustc version: 1.101.0-nightly (7df81381d 2026-10-14) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +end of query stack diff --git a/ts/rustc-ice-2026-10-26T00_03_00-1157053.txt b/ts/rustc-ice-2026-10-26T00_03_00-1157053.txt new file mode 100644 index 000000000..fd5a942a0 --- /dev/null +++ b/ts/rustc-ice-2026-10-26T00_03_00-1157053.txt @@ -0,0 +1,77 @@ +thread 'rustc' panicked at src/lower/mir/step.rs:21:95: +Box +stack backtrace: + 0: 0x7ffff4428975 - ::create + 1: 0x7ffff44288c5 - ::force_capture + 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} + 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook + 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} + 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> + 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: + 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl + 8: 0x5555559069db - >::type_at::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 + 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 + 10: 0x555555882728 - >::type_at + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 + 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 + 12: 0x55555587e6c3 - ::find_stepped::{closure#1} + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 + 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 + 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 + 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 + 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 + 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 + 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 + 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 + 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 + 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 + 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 + 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 + 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 + 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> + at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 + 26: 0x5555556a5e1e - ::find_stepped + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 + 27: 0x5555556945c0 - ::analyze + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 + 28: 0x55555568b6c5 - ::new + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 + 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 + 30: 0x555555767f1e - ::function + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 + 31: 0x555555761458 - ::drain + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 + 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 + 33: 0x55555591866f - ::after_expansion + at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 + 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} + 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> + 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 37: 0x7ffff5d2d81b - ::new::thread_start + 38: 0x7fffeec9f751 - start_thread + 39: 0x7fffeed2ba4c - __clone3 + 40: 0x0 - + + +rustc version: 1.101.0-nightly (7df81381d 2026-10-14) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +end of query stack diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 1db77086a..cd9a8b1dd 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -47,7 +47,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let name = name.to_string(); self.next_names.insert(name); } - (crate::lower::iter::next(self.b, iter_ty, recv), true) + if self.stepped_recv(&args[0].node).is_some() { + let it = self.path(recv, "iter", &mut pre); + (self.stepped_next(it), true) + } else { + (crate::lower::iter::next(self.b, iter_ty, recv), true) + } } ty::FnDef(def_id, gargs) => match self.intercept(def_id, gargs.skip_binder(), args, dest, span, &mut pre) { Some(Some(done)) => done, @@ -65,6 +70,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } _ => (self.err(span, format!("a call through `{fn_ty}`")), true), }; + let value = match dest.as_local() { + Some(local) if self.stepped.contains(&local) => self.stepped_make(value, span), + _ => value, + }; let value = match self.b.t.loc(span) { Some(loc) if effect => Expr::Located(loc, Box::new(value)), _ => value, diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index edbf3e83c..8e133208e 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -16,6 +16,7 @@ pub mod coroutine; pub mod glue; mod place; mod rvalue; +mod step; mod unwind; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -183,6 +184,17 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { range_nexts: FxHashSet, /// Their names, and their flags' names, which a switch on their variant tests. range_flags: FxHashMap, + /// Iterators over an array stepped in place, by `step`. + stepped: FxHashSet, + /// The borrows `next` steps them by, and what each borrows. + stepped_borrows: FxHashMap, + /// Statements that change nothing: a swap through a temporary nothing else names, as + /// an async body moves its context at each `await`. + noops: FxHashSet<(BasicBlock, usize)>, + /// Each block's one predecessor, if it has one. + sole_pred: FxHashMap, + /// What the cleanup variable holds as each block lowered so far leaves. + unwind_out: FxHashMap>, } impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { @@ -225,6 +237,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { next_names: FxHashSet::default(), range_nexts: FxHashSet::default(), range_flags: FxHashMap::default(), + stepped: FxHashSet::default(), + stepped_borrows: FxHashMap::default(), + noops: FxHashSet::default(), + sole_pred: FxHashMap::default(), + unwind_out: FxHashMap::default(), }; fx.analyze(); fx @@ -238,6 +255,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// Count each local's reads and assignments, and decide how each lowers. fn analyze(&mut self) { let mir = self.mir; + self.find_noops(); for (bb, data) in mir.basic_blocks.iter_enumerated() { if data.statements.iter().all(|s| { matches!( @@ -249,6 +267,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.unreachable.insert(bb); } for (i, stmt) in data.statements.iter().enumerate() { + if self.noops.contains(&(bb, i)) { + continue; + } match &stmt.kind { StatementKind::Assign(assign) => { let (place, rvalue) = &**assign; @@ -318,6 +339,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } self.find_next_results(); + self.find_stepped(); for local in mir.local_decls.indices() { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { @@ -363,6 +385,42 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } + /// Find the swaps `t = move x; x = move t;` through a `t` nothing else names. + fn find_noops(&mut self) { + use rustc_middle::mir::visit::{PlaceContext, Visitor}; + struct Mentions(IndexVec); + impl<'tcx> Visitor<'tcx> for Mentions { + fn visit_local(&mut self, local: Local, cx: PlaceContext, _: mir::Location) { + if !matches!(cx, PlaceContext::NonUse(_)) { + self.0[local] += 1; + } + } + } + let mir = self.mir; + let mut mentions = Mentions(IndexVec::from_elem_n(0, mir.local_decls.len())); + mentions.visit_body(mir); + let moved = |stmt: &mir::Statement<'tcx>| match &stmt.kind { + StatementKind::Assign(assign) => match &assign.1 { + Rvalue::Use(Operand::Move(from), _) => Some((assign.0.as_local()?, from.as_local()?)), + _ => None, + }, + _ => None, + }; + for (bb, data) in mir.basic_blocks.iter_enumerated() { + for (i, pair) in data.statements.windows(2).enumerate() { + if let (Some((t, x)), Some((x2, t2))) = (moved(&pair[0]), moved(&pair[1])) + && x == x2 + && t == t2 + && t != x + && mentions.0[t] == 2 + { + self.noops.insert((bb, i)); + self.noops.insert((bb, i + 1)); + } + } + } + } + fn def(&mut self, place: Place<'tcx>) { match place.as_local() { Some(local) => self.defs[local] += 1, @@ -479,6 +537,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let Some(rvalue) = self.def_rvalue(local) else { return false; }; + if self.context_of_arg(local) { + return true; + } match (mir.local_decls[local].ty.kind(), rvalue) { // A borrow: borrow checking keeps the place as it is but through the borrow, // unless the path to it goes through a reference held in a field or element, @@ -520,6 +581,33 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } + /// Whether `local` is the task's context an async body is resumed with, as it passes it + /// on: a parameter nothing assigns, or a local assigned it once, in another type that + /// is the context in JS too. + fn context_of_arg(&self, local: Local) -> bool { + if self.borrowed[local] || self.mutated[local] || !rvalue::context_like(self, self.mir.local_decls[local].ty) { + return false; + } + if self.is_arg(local) { + return self.defs[local] == 0; + } + if self.defs[local] != 1 { + return false; + } + let from = match self.def_rvalue(local) { + Some( + Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) + | Rvalue::Cast(mir::CastKind::Transmute, Operand::Copy(p) | Operand::Move(p), _), + ) => p, + Some(Rvalue::Aggregate(_, ops)) if ops.len() == 1 => match &ops[rustc_abi::FieldIdx::ZERO] { + Operand::Copy(p) | Operand::Move(p) => p, + Operand::Constant(_) | Operand::RuntimeChecks(_) => return false, + }, + _ => return false, + }; + from.as_local().is_some_and(|from| self.context_of_arg(from)) + } + /// Whether `place` is a field of a closure's environment, which stays put for the call. fn env_field(&self, place: Place<'tcx>) -> bool { matches!(self.env, Env::Closure(_)) @@ -753,6 +841,20 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { .collect(), }; } + let mut preds: Vec> = vec![Vec::new(); n]; + for (from, tos) in succs.iter().enumerate() { + for &to in tos { + preds[to].push(from); + } + } + for (to, from) in preds.iter().enumerate() { + if let [from] = from[..] + && from != to + { + self.sole_pred + .insert(BasicBlock::from_usize(to), BasicBlock::from_usize(from)); + } + } let graph = cfg::Graph { succs }; let mut labels = self.labels; let body = cfg::structure(&graph, self, &mut labels); @@ -783,7 +885,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out.extend(entry); out.extend(body); drop_self_assignments(&mut out); - return_in_place(&mut out); + let mut caught = Vec::new(); + handler_reads(&out, &mut caught); + return_in_place(&mut out, &caught.into_iter().collect()); prune_unread(&mut out); if self.zero_sized(self.mir.local_decls[mir::RETURN_PLACE].ty) { cfg::strip_return(&mut out); @@ -854,6 +958,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// A local's declared type: the value's, for a checked pair. fn decl_ty(&mut self, local: Local) -> Type { + if let Some(ty) = self.stepped_ty(local) { + return ty; + } let ty = self.mir.local_decls[local].ty; if self.next_results.contains(&local) && let ty::Adt(adt, args) = ty.kind() @@ -1238,12 +1345,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn block(&mut self, bb: BasicBlock, out: &mut Vec) -> Exit { let mir = self.mir; let data = &mir.basic_blocks[bb]; + // Entered only from its one predecessor, with the cleanup that left it. + if let Some(unwind) = &mut self.unwind + && let Some(from) = self.sole_pred.get(&bb) + && let Some(&known) = self.unwind_out.get(from) + { + unwind.known = known; + } self.set_unwind(data.terminator(), out); - for stmt in &data.statements { - if !self.in_ignored(stmt.source_info.span) { + for (i, stmt) in data.statements.iter().enumerate() { + if !self.in_ignored(stmt.source_info.span) && !self.noops.contains(&(bb, i)) { self.statement(stmt, out); } } + let known = self.unwind.as_ref().and_then(|u| u.known); + self.unwind_out.insert(bb, known); if let Some(&to) = self.redirect.get(&bb) { return Exit::Goto(to.as_usize()); } @@ -1293,9 +1409,17 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Rvalue::CopyForDeref(p) => self.place_expr(*p, span, out), Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) => self.place_expr(*p, span, out), Rvalue::Cast(_, Operand::Copy(p) | Operand::Move(p), _) => self.place_expr(*p, span, out), + // The task's context, wrapped. + Rvalue::Aggregate(_, ops) => match &ops[rustc_abi::FieldIdx::ZERO] { + Operand::Copy(p) | Operand::Move(p) => self.place_expr(*p, span, out), + _ => unreachable!("checked by context_of_arg"), + }, _ => unreachable!("an alias is a borrow or a copy of one"), }; - self.materialize(&target, out); + // Read once, it folds in what it reads that is held back, like any other read. + if self.uses[local] > 1 { + self.materialize(&target, out); + } self.slots[local] = Slot::Alias(Some(target)); return; } @@ -1814,9 +1938,16 @@ fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { scan(b, reads, true); } Expr::Assign(target, value) => { - // A variable assigned is not read; a place's base and index are, before the value. - if !matches!(**target, Expr::Ident(_)) { - scan(target, reads, lazy); + // A variable assigned is not read; a place's base and index are, before the value, + // but not the place itself. + match &**target { + Expr::Ident(_) => {} + Expr::Member(base, _) => scan(base, reads, lazy), + Expr::Index(base, index) => { + scan(base, reads, lazy); + scan(index, reads, lazy); + } + target => scan(target, reads, lazy), } scan(value, reads, lazy); reads.push(Read::Effect); @@ -2124,41 +2255,52 @@ fn drop_self_assignments(stmts: &mut Vec) { } } -/// `x = v; ...; return x;` as `return v;`, where moving `v` past the statements between -/// changes nothing: there are none, or `v` is a constant or a name none of them assigns. -fn return_in_place(stmts: &mut Vec) { +/// Return values in place throughout `stmts`, given the names cleanups read. +fn return_in_place(stmts: &mut Vec, caught: &FxHashSet) { sink_return(stmts); for stmt in stmts.iter_mut() { match &mut stmt.kind { StmtKind::If { then, els, .. } => { - return_in_place(then); - return_in_place(els); + return_in_place(then, caught); + return_in_place(els, caught); } - StmtKind::While { body, .. } | StmtKind::Block { body, .. } => return_in_place(body), + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => return_in_place(body, caught), StmtKind::Switch { cases, default, .. } => { - cases.iter_mut().for_each(|(_, body)| return_in_place(body)); - return_in_place(default); + cases.iter_mut().for_each(|(_, body)| return_in_place(body, caught)); + return_in_place(default, caught); } StmtKind::Catch { body, handler, .. } => { - return_in_place(body); - return_in_place(handler); + return_in_place(body, caught); + return_in_place(handler, caught); } _ => {} } } + while return_assigned(stmts, caught) {} +} + +/// `x = v; ...; return x;` at the end of `stmts` as `...; return v;`, where moving `v` +/// past the statements between changes nothing (there are none, or `v` is a constant or a +/// name none of them assigns) and no cleanup reads `x`; whether it was. +fn return_assigned(stmts: &mut Vec, caught: &FxHashSet) -> bool { let Some(Stmt { kind: StmtKind::Return(Some(Expr::Ident(name))), .. }) = stmts.last() else { - return; + return false; }; + // A cleanup reading it would run after its assignment, were the statements between to + // throw. + if caught.contains(name) { + return false; + } let name = name.clone(); let assigns = |e: &Expr, to: &str| matches!(e, Expr::Assign(t, _) if matches!(&**t, Expr::Ident(n) if n == to)); let mut at = None; for i in (0..stmts.len() - 1).rev() { let StmtKind::Expr(e) = &stmts[i].kind else { - return; + return false; }; if assigns(e, &name) { at = Some(i); @@ -2167,11 +2309,11 @@ fn return_in_place(stmts: &mut Vec) { let mut reads = Vec::new(); reads_of(e, &mut reads); if reads.contains(&name) { - return; + return false; } } let Some(at) = at else { - return; + return false; }; let StmtKind::Expr(Expr::Assign(_, value)) = &stmts[at].kind else { unreachable!("found above") @@ -2181,13 +2323,36 @@ fn return_in_place(stmts: &mut Vec) { || value.is_constant() || matches!(&**value, Expr::Ident(n) if between.iter().all(|s| !matches!(&s.kind, StmtKind::Expr(e) if assigns(e, n)))); if !moves { - return; + return false; } let StmtKind::Expr(Expr::Assign(_, value)) = stmts.remove(at).kind else { unreachable!("found above") }; let last = stmts.last_mut().expect("the return"); last.kind = StmtKind::Return(Some(*value)); + true +} + +/// The names read in each catch handler in `stmts`. +fn handler_reads(stmts: &[Stmt], out: &mut Vec) { + for stmt in stmts { + match &stmt.kind { + StmtKind::If { then, els, .. } => { + handler_reads(then, out); + handler_reads(els, out); + } + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => handler_reads(body, out), + StmtKind::Switch { cases, default, .. } => { + cases.iter().for_each(|(_, body)| handler_reads(body, out)); + handler_reads(default, out); + } + StmtKind::Catch { body, handler, .. } => { + handler_reads(body, out); + handler.iter().for_each(|s| scan_reads(s, out)); + } + _ => {} + } + } } /// Move a `return x;` that follows an `if` or a labeled block into each way out of it, so diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 0bfe9b86d..0fa0e9da2 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -425,7 +425,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// Whether a `ty`'s JS value is the task's context: `&mut Context`, or the `ResumeTy` and /// `NonNull` an async body passes it in. -fn context_like<'tcx>(fx: &Fx<'_, '_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { +pub(super) fn context_like<'tcx>(fx: &Fx<'_, '_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { let tcx = fx.tcx; match ty.kind() { ty::Ref(_, inner, _) => context_like(fx, *inner), diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs new file mode 100644 index 000000000..993b8e789 --- /dev/null +++ b/ts/src/lower/mir/step.rs @@ -0,0 +1,199 @@ +//! Iterators over an array stepped in place: a slice's or a `Vec`'s iterator that only +//! `next` reads, as a `for` loop's is, is the array and an index, `{ s, i }`, rather than +//! an `rt.Iter`, which a bundler can't shake its adaptors from. + +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_middle::mir::{self, Local, Operand, Rvalue, StatementKind, TerminatorKind}; +use rustc_middle::ty::{self, Ty, TyCtxt}; + +use super::Fx; +use crate::lower::library::{self, Std}; +use crate::ts::{Expr, Key, Type}; + +/// The item type of a slice's or a `Vec`'s iterator, if `ty` is one. +fn array_iter<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { + let ty::Adt(adt, args) = ty.kind() else { + return None; + }; + let path = library::std_path(tcx, adt.did()); + let path: Vec<&str> = path.iter().map(String::as_str).collect(); + match path.as_slice() { + ["slice", "iter", "Iter" | "IterMut"] | ["vec", "into_iter", "IntoIter"] => args.types().next(), + _ => None, + } +} + +/// Whether `ty` is what such an iterator is made from: a slice, an array, or a `Vec`. +fn array<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { + match ty.peel_refs().kind() { + ty::Slice(_) | ty::Array(..) => true, + ty::Adt(adt, _) => Std::of(tcx, adt.did()) == Some(Std::Vec), + _ => false, + } +} + +impl<'tcx> Fx<'_, '_, '_, 'tcx> { + /// Find the iterators to step in place: each made by a call from an array, or moved + /// from another, and otherwise only borrowed for `next` into a protocol local and + /// dropped. Each borrow is read only as `next`'s receiver. + pub(super) fn find_stepped(&mut self) { + let mir = self.mir; + let tcx = self.tcx; + let mut iters: Vec = mir + .local_decls + .indices() + .filter(|&l| !self.is_arg(l) && l != mir::RETURN_PLACE && self.defs[l] == 1) + .filter(|&l| array_iter(tcx, mir.local_decls[l].ty).is_some()) + .collect(); + if iters.is_empty() { + return; + } + // What each reads that is allowed: borrows for `next`, drops, moves into another. + let mut reads: FxHashMap = FxHashMap::default(); + let mut made = FxHashSet::default(); + let mut moves: Vec<(Local, Local)> = Vec::new(); + let mut borrows: FxHashMap = FxHashMap::default(); + let mut next_reads: FxHashMap = FxHashMap::default(); + for data in mir.basic_blocks.iter() { + for stmt in &data.statements { + let StatementKind::Assign(assign) = &stmt.kind else { + continue; + }; + let (place, rvalue) = &**assign; + match rvalue { + Rvalue::Ref(_, mir::BorrowKind::Mut { .. }, from) if from.as_local().is_some() => { + let from = from.as_local().unwrap(); + *reads.entry(from).or_default() += 1; + if let Some(to) = place.as_local() { + borrows.insert(to, from); + } + } + Rvalue::Use(Operand::Move(from), _) if from.as_local().is_some() => { + let from = from.as_local().unwrap(); + *reads.entry(from).or_default() += 1; + if let Some(to) = place.as_local() { + moves.push((from, to)); + } + } + _ => {} + } + } + match &data.terminator().kind { + TerminatorKind::Drop { place, .. } if let Some(local) = place.as_local() => { + *reads.entry(local).or_default() += 1; + } + TerminatorKind::Call { + func, + args, + destination, + .. + } => { + let ty::FnDef(def_id, _) = *func.ty(&mir.local_decls, tcx).kind() else { + continue; + }; + let maker = library::key(tcx, def_id).is_some_and(|(o, n)| { + matches!( + (o.as_str(), n.as_str()), + ("IntoIterator", "into_iter") | ("slice", "iter" | "iter_mut") + ) + }); + if maker + && let Some(to) = destination.as_local() + && let [arg] = &**args + && array(tcx, arg.node.ty(&mir.local_decls, tcx)) + { + made.insert(to); + } + if crate::lower::iter::is_next(tcx, def_id) + && destination.as_local().is_some_and(|l| self.next_results.contains(&l)) + && let [arg] = &**args + && let Operand::Copy(p) | Operand::Move(p) = &arg.node + && let Some(recv) = p.as_local() + { + *next_reads.entry(recv).or_default() += 1; + } + } + _ => {} + } + } + // A borrow only `next` reads, assigned once and borrowed by nothing. + let stepping = |fx: &Self, borrow: Local| { + fx.defs[borrow] == 1 + && !fx.borrowed[borrow] + && next_reads.get(&borrow).copied().unwrap_or(0) == fx.uses[borrow] + }; + let mut ok: FxHashSet = iters.drain(..).collect(); + ok.retain(|&l| reads.get(&l).copied().unwrap_or(0) == self.uses[l]); + ok.retain(|&l| made.contains(&l) || moves.iter().any(|&(_, to)| to == l)); + ok.retain(|&l| borrows.iter().all(|(&b, &from)| from != l || stepping(self, b))); + // A move joins two iterators that must both step in place, or neither. + loop { + let before = ok.len(); + for &(from, to) in &moves { + if ok.contains(&from) != ok.contains(&to) { + ok.remove(&from); + ok.remove(&to); + } + } + if ok.len() == before { + break; + } + } + for (b, from) in borrows { + if ok.contains(&from) { + self.stepped_borrows.insert(b, from); + } + } + self.stepped = ok; + } + + /// The iterator a `next` receiver `op` borrows, if it steps in place. + pub(super) fn stepped_recv(&self, op: &Operand<'tcx>) -> Option { + let (Operand::Copy(p) | Operand::Move(p)) = op else { + return None; + }; + self.stepped_borrows.get(&p.as_local()?).copied() + } + + /// `{ s, i: 0 }`, from what `into_iter` or `iter` made: `rt.iterSlice(s)`. + pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { + match value { + Expr::Call(f, mut args) if matches!(&*f, Expr::Rt(name) if name == "iterSlice") && args.len() == 1 => { + Expr::Object(vec![ + (Key::Name("s".into()), args.pop().unwrap()), + (Key::Name("i".into()), Expr::lit("0")), + ]) + } + // Refused already. + Expr::Lit(lit) if lit == "undefined" => Expr::undefined(), + _ => self.err( + span, + "an iterator stepped in place that its mapping didn't make from an array", + ), + } + } + + /// The next item of `it`, stepped in place, or `rt.DONE`. + pub(super) fn stepped_next(&self, it: Expr) -> Expr { + let s = it.clone().member("s"); + let i = it.member("i"); + Expr::Cond( + Box::new(i.clone().binary("<", s.clone().member("length"))), + Box::new(s.index(Expr::Postfix(Box::new(i), "++"))), + Box::new(Expr::Rt("DONE".into())), + ) + } + + /// The type of a local stepped in place: its array and index. + pub(super) fn stepped_ty(&mut self, local: Local) -> Option { + if !self.stepped.contains(&local) { + return None; + } + let item = array_iter(self.tcx, self.mir.local_decls[local].ty)?; + let array = self.b.t.ty(Ty::new_slice(self.tcx, item), self.span); + Some(Type::Object(vec![ + ("s".into(), array), + ("i".into(), Type::Builtin("number")), + ])) + } +} From ea9a24dc653cb30ca8139f4ff7764cf4ba5f3b7d Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 18:38:45 -0700 Subject: [PATCH 05/17] perf(ts): step ranges in place and fold arrays passed by reference Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/codec/expected/bench.ts | 26 +- .../expected/coding/decode.DecodeError.ts | 36 +- .../codec/expected/coding/encode.Encoder.ts | 12 +- ts/fixtures/codec/expected/coding/varint.ts | 40 +- ts/fixtures/codec/expected/harness.ts | 85 +- .../codec/expected/lib.SessionError.ts | 14 +- ts/fixtures/codec/expected/lite/message.ts | 12 +- ts/fixtures/lang/expected/fmt.Fails.ts | 4 +- ts/fixtures/lang/expected/fmt.Fault.ts | 40 +- ts/fixtures/lang/expected/fmt.Hex.ts | 8 +- ts/fixtures/lang/expected/fmt.Kind.ts | 8 +- ts/fixtures/lang/expected/fmt.Nested.ts | 32 +- ts/fixtures/lang/expected/fmt.Pair.ts | 6 +- ts/fixtures/lang/expected/fmt.Six.ts | 16 +- ts/fixtures/lang/expected/fmt.Wide.ts | 16 +- ts/fixtures/lang/expected/fmt.ts | 305 ++++--- ts/fixtures/lang/expected/generics.Either.ts | 24 +- ts/fixtures/lang/expected/generics.Tagged.ts | 8 +- ts/fixtures/lang/expected/generics.Wrap.ts | 62 +- ts/fixtures/lang/expected/generics.ts | 71 +- ts/fixtures/lang/expected/ints.ts | 854 +++++------------- ts/fixtures/lang/expected/iters.ts | 102 +-- ts/fixtures/lang/expected/shapes.Meters.ts | 4 +- ts/fixtures/lang/expected/shapes.Moved.ts | 6 +- ts/fixtures/lang/expected/shapes.Point.ts | 6 +- ts/fixtures/lang/expected/shapes.Shape.ts | 12 +- ts/fixtures/lang/expected/shapes.ts | 265 ++---- ts/fixtures/reject/census.md | 25 +- ts/fixtures/reject/expected.txt | 1 - ts/fixtures/task/expected/model.Guard.ts | 9 +- ts/fixtures/task/expected/model.ts | 50 +- ts/src/lower/mir/call.rs | 50 +- ts/src/lower/mir/mod.rs | 65 +- ts/src/lower/mir/step.rs | 90 +- 34 files changed, 937 insertions(+), 1427 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 79928d252..0dde4f96f 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -66,10 +66,8 @@ export function run(input: Uint8Array): rt.ByteVec { } export function encoded(result: rt.Result, out: rt.ByteVec): void { - let err!: EncodeError.EncodeError; if (!result.ok) { - err = result.error; - encodeError(out, err); + encodeError(out, result.error); } } @@ -87,20 +85,15 @@ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVe let _6!: [rt.u64, Uint8Array]; let value!: rt.u64; let w!: Encoder.Encoder; - let iter!: rt.Range; + let iter!: { start: rt.usize; end: rt.usize }; let _17!: rt.Result; - let _14Some!: boolean; _6 = takeU64(data); count = _6[0]; value = takeU64(_6[1])[0]; w = Encoder.new(out, form_); - iter = new rt.Range(0, rt.u64Low(count)); + iter = { start: 0, end: rt.u64Low(count) }; l0: while (true) { - _14Some = iter.start < iter.end; - if (_14Some) { - iter.start++; - } - if (!_14Some) { + if (!(iter.start++ < iter.end)) { return rt.Ok(undefined); } else { _17 = Encoder.varint(w, value); @@ -162,7 +155,7 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt let _23!: [rt.i64, rt.usize]; let _24!: rt.i64; let w!: Encoder.Encoder; - let iter!: rt.Range; + let iter!: { start: rt.usize; end: rt.usize }; let _32!: rt.usize; let n!: rt.usize; let delta3!: rt.i64; @@ -171,7 +164,6 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt let _45!: rt.Result; let _48!: rt.u64; let _51!: rt.Result; - let _32Some!: boolean; _6 = takeU64(data); count = _6[0]; _9 = takeU64(_6[1]); @@ -188,13 +180,9 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt delta2 = _24; keyEvery2 = _23[1]; w = Encoder.new(out, Form.from$From_Version(version)); - iter = new rt.Range(0, rt.u64Low(count)); + iter = { start: 0, end: rt.u64Low(count) }; l0: while (true) { - _32Some = iter.start < iter.end; - if (_32Some) { - _32 = iter.start++; - } - if (!_32Some) { + if (!((_32 = iter.start++) < iter.end)) { return rt.Ok(undefined); } else { b2: { diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index 3dcc2b256..80fad020f 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -5,11 +5,8 @@ import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import * as SessionError from "../lib.SessionError.ts"; export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Result { - let __field0!: rt.u64; - let size!: rt.usize; - let max!: rt.usize; - let __displaySize!: rt.usize; - let __displayMax!: rt.usize; + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; if (self.tag === "Short") { return rt.fmtWriteStr(__formatter, "short buffer"); } else if (self.tag === "Long") { @@ -17,9 +14,9 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re } else if (self.tag === "InvalidString") { return rt.fmtWriteStr(__formatter, "invalid string"); } else if (self.tag === "InvalidMessage") { - __field0 = ([self._0] as [rt.u64])[0]; - const arg = ([__field0] as [rt.u64])[0]; - return rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(arg, f)]); + const arg = ([([self._0] as [rt.u64])[0]] as [rt.u64])[0]; + args2 = [(f: rt.Formatter) => rt.u64Display(arg, f)]; + return rt.fmtWriteFmt(__formatter, ["invalid message: ", args2[0]]); } else if (self.tag === "InvalidSubscribeLocation") { return rt.fmtWriteStr(__formatter, "invalid subscribe location"); } else if (self.tag === "InvalidValue") { @@ -31,11 +28,8 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re } else if (self.tag === "ExpectedEnd") { return rt.fmtWriteStr(__formatter, "expected end"); } else if (self.tag === "MessageTooLarge") { - size = self.size; - max = self.max; - __displaySize = size; - __displayMax = max; - return rt.fmtWriteFmt(__formatter, ["message too large: ", (f: rt.Formatter) => rt.usizeDisplay(__displaySize, f), " bytes exceeds ", (f: rt.Formatter) => rt.usizeDisplay(__displayMax, f), " byte limit"]); + args4 = [(f: rt.Formatter) => rt.usizeDisplay(self.size, f), (f: rt.Formatter) => rt.usizeDisplay(self.max, f)]; + return rt.fmtWriteFmt(__formatter, ["message too large: ", args4[0], " bytes exceeds ", args4[1], " byte limit"]); } else if (self.tag === "ExpectedData") { return rt.fmtWriteStr(__formatter, "expected data"); } else if (self.tag === "Duplicate") { @@ -62,19 +56,15 @@ export function from$From_FromUtf8Error(source: rt.FromUtf8Error): DecodeError { } export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result { - let __self0!: rt.FromUtf8Error; let _7!: string; let _8!: rt.Fmt; - let __self02!: rt.u64; let _11!: string; let _12!: rt.Fmt; - let __self1!: rt.usize; let _21!: string; let _22!: string; let _23!: rt.Fmt; let _24!: string; let _25!: rt.Fmt; - let __self03!: SessionError.SessionError; let _34!: string; let _35!: rt.Fmt; if (self.tag === "Short") { @@ -82,14 +72,12 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result rt.fmtFromUtf8ErrorDebug(__self0, f); + _8 = (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8)); } else if (self.tag === "InvalidMessage") { - __self02 = self._0; _11 = "InvalidMessage"; - _12 = (f: rt.Formatter) => rt.u64Display(__self02, f); + _12 = (f: rt.Formatter) => rt.u64Display(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _11), _12)); } else if (self.tag === "InvalidSubscribeLocation") { return rt.fmtWriteStr(f, "InvalidSubscribeLocation"); @@ -102,12 +90,11 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result rt.usizeDisplay(self.size, f); _24 = "max"; - _25 = (f: rt.Formatter) => rt.usizeDisplay(__self1, f); + _25 = (f: rt.Formatter) => rt.usizeDisplay(self.max, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _21), _22, _23), _24, _25)); } else if (self.tag === "ExpectedData") { return rt.fmtWriteStr(f, "ExpectedData"); @@ -122,9 +109,8 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result SessionError.fmt$Debug(__self03, f); + _35 = (f: rt.Formatter) => SessionError.fmt$Debug(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _34), _35)); } else if (self.tag === "MalformedAuthToken") { return rt.fmtWriteStr(f, "MalformedAuthToken"); diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index 56c8d7909..9d32d3aba 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -37,11 +37,7 @@ export function u8(self: Encoder, v: rt.u8): void { /** Write a big-endian `u16`. */ export function u16(self: Encoder, v: rt.u16): void { - let _6!: Uint8Array; - let _7!: rt.ByteVec; - _7 = self.buf; - _6 = rt.u16ToBeBytes(v); - rt.byteVecExtendFromSlice(_7, _6); + rt.byteVecExtendFromSlice(self.buf, rt.u16ToBeBytes(v)); } /** Write a bool as a 0 or 1 byte. */ @@ -133,8 +129,6 @@ export function fill(self: Encoder, prefix: Prefix.Prefix): rt.Result; let size!: rt.u16; - let _16!: Uint8Array; - let _22!: Uint8Array; let _23!: rt.Result; let len!: rt.usize; let _35!: rt.u8; @@ -191,9 +185,7 @@ export function fill(self: Encoder, prefix: Prefix.Prefix): rt.Result>> 0); - rt.byteVecExtendFromSlice(out, _32); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes((2147483648 | lo) >>> 0)); break b1; } } @@ -152,8 +147,7 @@ export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result>> 8) & 0xff), hi & 0xff, a, b, c, d); - rt.byteVecExtendFromSlice(out, _64); + rt.byteVecExtendFromSlice(out, Uint8Array.of(248 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d)); } } else { - _54 = Uint8Array.of(240 | (hi & 0xff), a, b, c, d); - rt.byteVecExtendFromSlice(out, _54); + rt.byteVecExtendFromSlice(out, Uint8Array.of(240 | (hi & 0xff), a, b, c, d)); } } } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 15c53c1da..981acf058 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -82,9 +82,7 @@ export function liteVersion(selector: rt.u8): Version.Version { } export function putU64(out: rt.ByteVec, value: rt.u64): void { - let _6!: Uint8Array; - _6 = rt.u64ToBeBytes(value); - rt.byteVecExtendFromSlice(out, _6); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(value)); } export function putUsize(out: rt.ByteVec, value: rt.usize): void { @@ -105,10 +103,12 @@ export function takeU64(data: Uint8Array): [rt.u64, Uint8Array] { export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): void { let _5!: string; let _6!: string; + let args2!: rt.Fmt[]; decodeError(out, err); _5 = rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$Display(err, f)); const arg = ([err] as [DecodeError.DecodeError])[0]; - _6 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Debug(arg, f)]); + args2 = [(f: rt.Formatter) => DecodeError.fmt$Debug(arg, f)]; + _6 = rt.fmtFormat([args2[0]]); putText(out, _5, _6); } @@ -116,10 +116,12 @@ export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): voi export function encodeFailed(out: rt.ByteVec, err: EncodeError.EncodeError): void { let _5!: string; let _6!: string; + let args2!: rt.Fmt[]; encodeError(out, err); _5 = rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$Display(err, f)); const arg = ([err] as [EncodeError.EncodeError])[0]; - _6 = rt.fmtFormat([(f: rt.Formatter) => EncodeError.fmt$Debug(arg, f)]); + args2 = [(f: rt.Formatter) => EncodeError.fmt$Debug(arg, f)]; + _6 = rt.fmtFormat([args2[0]]); putText(out, _5, _6); } @@ -254,7 +256,6 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt.Result { let _5!: rt.u8; let _7!: rt.Result; - let _14!: Uint8Array; let _15!: rt.Result; let _21!: rt.Result; let _26!: rt.Result; @@ -279,8 +280,7 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt } else if (_5 === 1) { _15 = Decoder.u16(r); if (_15.ok) { - _14 = rt.u16ToBeBytes(_15.value); - rt.byteVecExtendFromSlice(out, _14); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_15.value)); } else { return _15; } @@ -381,17 +381,14 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { let _51!: Uint8Array; let _53!: Uint8Array; let _60!: rt.Result; - let _64!: Uint8Array; let s!: string; let _68!: string; let _74!: Prefix.Prefix; let _79!: Prefix.Prefix | undefined; let prefix!: Prefix.Prefix; let _88!: Prefix.Prefix | undefined; - let err!: EncodeError.EncodeError; let _98!: Prefix.Prefix | undefined; let _102!: rt.Result; - let err2!: EncodeError.EncodeError; _5 = rt.sliceSplitFirst(data); b0: { if (_5 !== undefined) { @@ -416,8 +413,7 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { if (_98 !== undefined) { _102 = Encoder.fill(w, _98); if (!_102.ok) { - err2 = _102.error; - encodeFailed(out, err2); + encodeFailed(out, _102.error); } } else { putUsize(out, buf.length); @@ -453,13 +449,12 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { } result = Encoder.varintOpt(w, _47); } else if (_33 === 5) { - _53 = rt.u64ToBeBytes(value); const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; + _53 = rt.u64ToBeBytes(value); _51 = rt.sliceRange(_53, 0, part); result = Encoder.bytes(w, _51); } else if (_33 === 6) { - _64 = rt.u64ToBeBytes(value); - _60 = rt.stringFromUtf8(rt.sliceToByteVec(_64)); + _60 = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); if (_60.ok) { s = _60.value; _68 = s; @@ -492,8 +487,7 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { result = rt.Ok(undefined); } if (!result.ok) { - err = result.error; - encodeFailed(out, err); + encodeFailed(out, result.error); } } } @@ -514,18 +508,13 @@ export function zigzag(data: Uint8Array, out: rt.ByteVec): void { export function sizes(data: Uint8Array, out: rt.ByteVec): void { let value!: rt.u64; - let iter!: rt.Range; + let iter!: { start: rt.u8; end: rt.u8 }; let _9!: rt.u8; let _13!: rt.Result; - let _9Some!: boolean; value = takeU64(data)[0]; - iter = new rt.Range(0, 3); + iter = { start: 0, end: 3 }; while (true) { - _9Some = iter.start < iter.end; - if (_9Some) { - _9 = iter.start++; - } - if (!_9Some) { + if (!((_9 = iter.start++) < iter.end)) { return; } else { _13 = size(value, form(_9)); @@ -547,7 +536,6 @@ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { let buf!: rt.ByteVec; let _14!: rt.Result; let _17!: Encoder.Encoder; - let err!: EncodeError.EncodeError; let err2!: DecodeError.DecodeError; _5 = rt.sliceSplitFirst(data); if (_5 !== undefined) { @@ -562,8 +550,7 @@ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { if (_14.ok) { rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - err = _14.error; - encodeFailed(out, err); + encodeFailed(out, _14.error); } } else { err2 = _8.error; @@ -582,7 +569,6 @@ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { let _14!: rt.Result; let _17!: Encoder.Encoder; let _19!: Form.Form; - let err!: EncodeError.EncodeError; let err2!: DecodeError.DecodeError; _5 = rt.sliceSplitFirst(data); if (_5 !== undefined) { @@ -598,8 +584,7 @@ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { if (_14.ok) { rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - err = _14.error; - encodeFailed(out, err); + encodeFailed(out, _14.error); } } else { err2 = _8.error; @@ -618,7 +603,6 @@ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { let _14!: rt.Result; let _17!: Encoder.Encoder; let _19!: Form.Form; - let err!: EncodeError.EncodeError; let err2!: DecodeError.DecodeError; _5 = rt.sliceSplitFirst(data); if (_5 !== undefined) { @@ -634,8 +618,7 @@ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { if (_14.ok) { rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - err = _14.error; - encodeFailed(out, err); + encodeFailed(out, _14.error); } } else { err2 = _8.error; @@ -657,14 +640,11 @@ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { let bitrate!: rt.u64; let _19!: [rt.u64, Uint8Array]; let rtt!: rt.u64; - let group!: Group.Group; - let probe!: Probe.Probe; let versions!: Versions.Versions; let buf!: rt.ByteVec; let _40!: rt.Result; let _43!: Encoder.Encoder; let _45!: Form.Form; - let err!: EncodeError.EncodeError; _5 = rt.sliceSplitFirst(data); if (_5 !== undefined) { version = liteVersion(_5[0]); @@ -677,10 +657,8 @@ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { _19 = takeU64(_16[1]); bitrate = _19[0]; rtt = takeU64(_19[1])[0]; - group = { subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }; - encodeMessage$Group(group, version, out); - probe = { bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }; - encodeMessage$Probe(probe, version, out); + encodeMessage$Group({ subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }, version, out); + encodeMessage$Probe({ bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }, version, out); versions = Versions.from$From_Versions([{ _0: subscribe }, { _0: sequence }]); buf = new rt.ByteVec(); _45 = Form.from$From_Version(version); @@ -689,8 +667,7 @@ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { if (_40.ok) { rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - err = _40.error; - encodeFailed(out, err); + encodeFailed(out, _40.error); } } } @@ -700,7 +677,6 @@ export function encodeMessage$Group(msg: Group.Group, version: Version.Version, let w!: Encoder.Encoder; let _7!: Form.Form; let _8!: rt.Result; - let err!: EncodeError.EncodeError; buf = new rt.ByteVec(); _7 = Form.from$From_Version(version); w = Encoder.new(buf, _7); @@ -710,8 +686,7 @@ export function encodeMessage$Group(msg: Group.Group, version: Version.Version, putUsize(out, buf.length); rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - err = _8.error; - encodeFailed(out, err); + encodeFailed(out, _8.error); } } @@ -720,7 +695,6 @@ export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, let w!: Encoder.Encoder; let _7!: Form.Form; let _8!: rt.Result; - let err!: EncodeError.EncodeError; buf = new rt.ByteVec(); _7 = Form.from$From_Version(version); w = Encoder.new(buf, _7); @@ -730,8 +704,7 @@ export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, putUsize(out, buf.length); rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - err = _8.error; - encodeFailed(out, err); + encodeFailed(out, _8.error); } } @@ -745,8 +718,11 @@ export function errors(data: Uint8Array, out: rt.ByteVec): void { let _20!: rt.Result; let _26!: string; let _28!: string; + let args2!: rt.Fmt[]; let _38!: string; + let args4!: rt.Fmt[]; let _47!: string; + let args6!: rt.Fmt[]; _5 = rt.sliceSplitFirst(data); b0: { if (_5 !== undefined) { @@ -774,16 +750,19 @@ export function errors(data: Uint8Array, out: rt.ByteVec): void { const arg = {}; _26 = rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$Display(arg, f)); const arg2 = ([{}] as [BoundsExceeded.BoundsExceeded])[0]; - _28 = rt.fmtFormat([(f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f))]); + args2 = [(f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f)]; + _28 = rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0])]); putText(out, _26, _28); break b0; } else { err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; } const arg3 = ([err] as [DecodeError.DecodeError])[0]; - _38 = rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Display(arg3, f), " ", rt.fmtSpec({ align: ">", width: 30 }, (f: rt.Formatter) => DecodeError.fmt$Display(arg3, f)), "|"]); + args4 = [(f: rt.Formatter) => DecodeError.fmt$Display(arg3, f)]; + _38 = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); const arg4 = ([err] as [DecodeError.DecodeError])[0]; - _47 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => DecodeError.fmt$Debug(arg4, f))]); + args6 = [(f: rt.Formatter) => DecodeError.fmt$Debug(arg4, f)]; + _47 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args6[0])]); putText(out, _38, _47); decodeFailed(out, err); } diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index 81af00650..be9bbe845 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -3,28 +3,24 @@ import * as rt from "./rt.ts"; export function fmt$Display(self: SessionError, __formatter: rt.Formatter): rt.Result { - let _02!: rt.u16; - let __display0!: rt.u16; + let args2!: rt.Fmt[]; if (self.tag === "ProtocolViolation") { return rt.fmtWriteStr(__formatter, "protocol violation"); } else { - _02 = self._0; - __display0 = ([_02] as [rt.u16])[0]; - const arg = ([__display0] as [rt.u16])[0]; - return rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(arg, f)]); + const arg = ([([self._0] as [rt.u16])[0]] as [rt.u16])[0]; + args2 = [(f: rt.Formatter) => rt.u16Display(arg, f)]; + return rt.fmtWriteFmt(__formatter, ["app code=", args2[0]]); } } export function fmt$Debug(self: SessionError, f: rt.Formatter): rt.Result { - let __self0!: rt.u16; let _6!: string; let _7!: rt.Fmt; if (self.tag === "ProtocolViolation") { return rt.fmtWriteStr(f, "ProtocolViolation"); } else { - __self0 = self._0; _6 = "App"; - _7 = (f: rt.Formatter) => rt.u16Display(__self0, f); + _7 = (f: rt.Formatter) => rt.u16Display(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } } diff --git a/ts/fixtures/codec/expected/lite/message.ts b/ts/fixtures/codec/expected/lite/message.ts index fa7d08b6f..3dd51d249 100644 --- a/ts/fixtures/codec/expected/lite/message.ts +++ b/ts/fixtures/codec/expected/lite/message.ts @@ -41,15 +41,13 @@ export function decodeWith$Group_decode_closure0(r: Decoder.Decoder, decode: (a0 _9 = Decoder.sub(r, _3.value); if (_9.ok) { body = _9.value; - result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg2: Group.Group): rt.Result => { + result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Group.Group): rt.Result => { if (!Decoder.isEmpty(body)) { return rt.Err({ tag: "Long" } as DecodeError.DecodeError); } else { - return rt.Ok(msg2); + return rt.Ok(msg); } }); - if (result.ok) { - } if (result.ok) { r.control = undefined; } @@ -76,15 +74,13 @@ export function decodeWith$Probe_decode_closure0(r: Decoder.Decoder, decode: (a0 _9 = Decoder.sub(r, _3.value); if (_9.ok) { body = _9.value; - result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg2: Probe.Probe): rt.Result => { + result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Probe.Probe): rt.Result => { if (!Decoder.isEmpty(body)) { return rt.Err({ tag: "Long" } as DecodeError.DecodeError); } else { - return rt.Ok(msg2); + return rt.Ok(msg); } }); - if (result.ok) { - } if (result.ok) { r.control = "Probe" as Control.Control; } diff --git a/ts/fixtures/lang/expected/fmt.Fails.ts b/ts/fixtures/lang/expected/fmt.Fails.ts index d45b8674d..3df147af5 100644 --- a/ts/fixtures/lang/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/expected/fmt.Fails.ts @@ -9,9 +9,11 @@ export interface Fails { export function fmt$Display(self: Fails, f: rt.Formatter): rt.Result { let _8!: rt.Result; + let args2!: rt.Fmt[]; if (!(rt.u8Rem(self._0, 2) === 0)) { const arg = ([self._0] as [rt.u8])[0]; - _8 = rt.fmtWriteFmt(f, ["half ", (f: rt.Formatter) => rt.u8Display(arg, f)]); + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + _8 = rt.fmtWriteFmt(f, ["half ", args2[0]]); if (_8.ok) { return rt.Err(new rt.FmtError()); } else { diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index 5288dc7b4..873a1147f 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -4,37 +4,31 @@ import * as rt from "./rt.ts"; import * as Pair from "./fmt.Pair.ts"; export function fmt$Debug(self: Fault, f: rt.Formatter): rt.Result { - let __self0!: rt.u16; let _6!: string; let _7!: rt.Fmt; - let __self1!: rt.usize; let _11!: string; let _12!: string; let _13!: rt.Fmt; let _14!: string; let _15!: rt.Fmt; - let __self02!: Pair.Pair; let _18!: string; let _19!: rt.Fmt; if (self.tag === "Short") { return rt.fmtWriteStr(f, "Short"); } else if (self.tag === "Code") { - __self0 = self._0; _6 = "Code"; - _7 = (f: rt.Formatter) => rt.u16Display(__self0, f); + _7 = (f: rt.Formatter) => rt.u16Display(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } else if (self.tag === "TooLarge") { - __self1 = self.max; _11 = "TooLarge"; _12 = "size"; _13 = (f: rt.Formatter) => rt.usizeDisplay(self.size, f); _14 = "max"; - _15 = (f: rt.Formatter) => rt.usizeDisplay(__self1, f); + _15 = (f: rt.Formatter) => rt.usizeDisplay(self.max, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _11), _12, _13), _14, _15)); } else { - __self02 = self._0; _18 = "At"; - _19 = (f: rt.Formatter) => Pair.fmt$Debug(__self02, f); + _19 = (f: rt.Formatter) => Pair.fmt$Debug(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _18), _19)); } } @@ -50,24 +44,26 @@ export type Fault = | { tag: "At"; _0: Pair.Pair }; export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result { - let code!: rt.u16; - let size!: rt.usize; - let max!: rt.usize; - let pair!: Pair.Pair; + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; + let _20!: rt.Fmt; + let args6!: rt.Fmt[]; if (self.tag === "Short") { return rt.fmtPad(f, "short buffer"); } else if (self.tag === "Code") { - code = self._0; - const arg2 = ([code] as [rt.u16])[0]; - return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, (f: rt.Formatter) => rt.u16LowerHex(arg2, f))]); + const arg4 = ([self._0] as [rt.u16])[0]; + args2 = [(f: rt.Formatter) => rt.u16LowerHex(arg4, f)]; + return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, args2[0])]); } else if (self.tag === "TooLarge") { - size = self.size; - max = self.max; - return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); + const arg2 = self.size; + _20 = (f: rt.Formatter) => rt.usizeDisplay(arg2, f); + const arg3 = self.max; + args4 = [_20, (f: rt.Formatter) => rt.usizeDisplay(arg3, f)]; + return rt.fmtWriteFmt(f, [args4[0], " bytes exceeds the ", args4[1], " byte limit"]); } else { - pair = self._0; - const arg = ([pair] as [Pair.Pair])[0]; - return rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(arg, f)]); + const arg = ([self._0] as [Pair.Pair])[0]; + args6 = [(f: rt.Formatter) => Pair.fmt$Debug(arg, f)]; + return rt.fmtWriteFmt(f, ["at ", args6[0]]); } } diff --git a/ts/fixtures/lang/expected/fmt.Hex.ts b/ts/fixtures/lang/expected/fmt.Hex.ts index ddbf4dfc3..9f5d00737 100644 --- a/ts/fixtures/lang/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/expected/fmt.Hex.ts @@ -8,12 +8,16 @@ export interface Hex { } export function fmt$Display(self: Hex, f: rt.Formatter): rt.Result { + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; if (!rt.fmtAlternate(f)) { const arg2 = ([self._0] as [rt.u32])[0]; - return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]); + args4 = [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]; + return rt.fmtWriteFmt(f, [args4[0]]); } else { const arg = ([self._0] as [rt.u32])[0]; - return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(arg, f))]); + args2 = [(f: rt.Formatter) => rt.u32LowerHex(arg, f)]; + return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, args2[0])]); } } diff --git a/ts/fixtures/lang/expected/fmt.Kind.ts b/ts/fixtures/lang/expected/fmt.Kind.ts index 3946443d9..c278f5d46 100644 --- a/ts/fixtures/lang/expected/fmt.Kind.ts +++ b/ts/fixtures/lang/expected/fmt.Kind.ts @@ -3,10 +3,8 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result { - let __self0!: rt.u8; let _8!: string; let _9!: rt.Fmt; - let __self1!: rt.ByteVec; let _13!: string; let _14!: string; let _15!: rt.Fmt; @@ -19,17 +17,15 @@ export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result rt.u8Display(__self0, f); + _9 = (f: rt.Formatter) => rt.u8Display(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _8), _9)); } else { - __self1 = self.items; _13 = "Many"; _14 = "count"; _15 = (f: rt.Formatter) => rt.u32Display(self.count, f); _16 = "items"; - _17 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(__self1), f, rt.u8Display); + _17 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.items), f, rt.u8Display); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _13), _14, _15), _16, _17)); } } diff --git a/ts/fixtures/lang/expected/fmt.Nested.ts b/ts/fixtures/lang/expected/fmt.Nested.ts index 99b8e48e6..fcb48905b 100644 --- a/ts/fixtures/lang/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/expected/fmt.Nested.ts @@ -9,39 +9,9 @@ import * as Shape from "./shapes.Shape.ts"; export function fmt$Debug(self: Nested, f: rt.Formatter): rt.Result { let names!: string[]; let values!: rt.Fmt[]; - let _6!: rt.Fmt[]; - let _7!: rt.Fmt; - let _9!: rt.Fmt; - let _11!: rt.Fmt; - let _13!: rt.Fmt; - let _15!: rt.Fmt; - let _17!: rt.Fmt; - let _19!: rt.Fmt; - let _21!: rt.Fmt; - let _23!: rt.Fmt; - let _25!: rt.Fmt; - let _27!: rt.Fmt; - let _29!: rt.Fmt; - let _31!: rt.Fmt; - let _35!: Kind.Kind; let _36!: string; - _7 = (f: rt.Formatter) => rt.fmtStr(self.name, f); - _9 = (f: rt.Formatter) => Point.fmt$Debug(self.point, f); - _11 = (f: rt.Formatter) => Shape.fmt$Debug(self.shape, f); - _13 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Display); - _15 = (f: rt.Formatter) => rt.fmtList(self.pairs, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); - _17 = (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); - _19 = (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Display); - _21 = (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Display, rt.fmtStr); - _23 = (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Display); - _25 = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f); - _27 = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.single[0], f)], f); - _29 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Display); - _31 = (f: rt.Formatter) => rt.fmtUnit(self.unit, f); - _35 = self.boxed; - _6 = [_7, _9, _11, _13, _15, _17, _19, _21, _23, _25, _27, _29, _31, (f: rt.Formatter) => Kind.fmt$Debug(_35, f)]; names = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; - values = _6; + values = [(f: rt.Formatter) => rt.fmtStr(self.name, f), (f: rt.Formatter) => Point.fmt$Debug(self.point, f), (f: rt.Formatter) => Shape.fmt$Debug(self.shape, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(self.pairs, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Display), (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Display, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Display), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.single[0], f)], f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Display), (f: rt.Formatter) => rt.fmtUnit(self.unit, f), (f: rt.Formatter) => Kind.fmt$Debug(self.boxed, f)]; _36 = "Nested"; return rt.fmtDebugStructFields(f, _36, names, values); } diff --git a/ts/fixtures/lang/expected/fmt.Pair.ts b/ts/fixtures/lang/expected/fmt.Pair.ts index 2c20743a5..3aaea45a2 100644 --- a/ts/fixtures/lang/expected/fmt.Pair.ts +++ b/ts/fixtures/lang/expected/fmt.Pair.ts @@ -6,11 +6,9 @@ export function fmt$Debug(self: Pair, f: rt.Formatter): rt.Result rt.u8Display(self._0, f); - _8 = self._1; _3 = "Pair"; - _6 = (f: rt.Formatter) => rt.i64Display(_8, f); + _4 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _6 = (f: rt.Formatter) => rt.i64Display(self._1, f); return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); } diff --git a/ts/fixtures/lang/expected/fmt.Six.ts b/ts/fixtures/lang/expected/fmt.Six.ts index 6dfd2cf28..1e0176a98 100644 --- a/ts/fixtures/lang/expected/fmt.Six.ts +++ b/ts/fixtures/lang/expected/fmt.Six.ts @@ -4,22 +4,8 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Six, f: rt.Formatter): rt.Result { let values!: rt.Fmt[]; - let _5!: rt.Fmt[]; - let _6!: rt.Fmt; - let _8!: rt.Fmt; - let _10!: rt.Fmt; - let _12!: rt.Fmt; - let _14!: rt.Fmt; - let _18!: rt.u8; let _19!: string; - _6 = (f: rt.Formatter) => rt.u8Display(self._0, f); - _8 = (f: rt.Formatter) => rt.u8Display(self._1, f); - _10 = (f: rt.Formatter) => rt.u8Display(self._2, f); - _12 = (f: rt.Formatter) => rt.u8Display(self._3, f); - _14 = (f: rt.Formatter) => rt.u8Display(self._4, f); - _18 = self._5; - _5 = [_6, _8, _10, _12, _14, (f: rt.Formatter) => rt.u8Display(_18, f)]; - values = _5; + values = [(f: rt.Formatter) => rt.u8Display(self._0, f), (f: rt.Formatter) => rt.u8Display(self._1, f), (f: rt.Formatter) => rt.u8Display(self._2, f), (f: rt.Formatter) => rt.u8Display(self._3, f), (f: rt.Formatter) => rt.u8Display(self._4, f), (f: rt.Formatter) => rt.u8Display(self._5, f)]; _19 = "Six"; return rt.fmtDebugTupleFields(f, _19, values); } diff --git a/ts/fixtures/lang/expected/fmt.Wide.ts b/ts/fixtures/lang/expected/fmt.Wide.ts index 92b59e5a8..0ef6fcc30 100644 --- a/ts/fixtures/lang/expected/fmt.Wide.ts +++ b/ts/fixtures/lang/expected/fmt.Wide.ts @@ -5,23 +5,9 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Wide, f: rt.Formatter): rt.Result { let names!: string[]; let values!: rt.Fmt[]; - let _6!: rt.Fmt[]; - let _7!: rt.Fmt; - let _9!: rt.Fmt; - let _11!: rt.Fmt; - let _13!: rt.Fmt; - let _15!: rt.Fmt; - let _19!: boolean; let _20!: string; - _7 = (f: rt.Formatter) => rt.u8Display(self.a, f); - _9 = (f: rt.Formatter) => rt.u16Display(self.b, f); - _11 = (f: rt.Formatter) => rt.u32Display(self.c, f); - _13 = (f: rt.Formatter) => rt.u64Display(self.d, f); - _15 = (f: rt.Formatter) => rt.i8Display(self.e, f); - _19 = self.f; - _6 = [_7, _9, _11, _13, _15, (f: rt.Formatter) => rt.fmtBool(_19, f)]; names = ["a", "b", "c", "d", "e", "f"]; - values = _6; + values = [(f: rt.Formatter) => rt.u8Display(self.a, f), (f: rt.Formatter) => rt.u16Display(self.b, f), (f: rt.Formatter) => rt.u32Display(self.c, f), (f: rt.Formatter) => rt.u64Display(self.d, f), (f: rt.Formatter) => rt.i8Display(self.e, f), (f: rt.Formatter) => rt.fmtBool(self.f, f)]; _20 = "Wide"; return rt.fmtDebugStructFields(f, _20, names, values); } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 67af81d22..c7a259f40 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -30,61 +30,73 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let buf!: Uint8Array; let n!: rt.usize; let _23!: string; + let args2!: rt.Fmt[]; let _38!: string; let v2!: rt.u16; let buf2!: Uint8Array; let n2!: rt.usize; let _57!: string; + let args4!: rt.Fmt[]; let _72!: string; let v3!: rt.u32; let buf3!: Uint8Array; let n3!: rt.usize; let _91!: string; + let args6!: rt.Fmt[]; let _106!: string; let v4!: rt.u64; let buf4!: Uint8Array; let n4!: rt.usize; let _125!: string; + let args8!: rt.Fmt[]; let _140!: string; let v5!: rt.u128; let buf5!: Uint8Array; let n5!: rt.usize; let _159!: string; + let args10!: rt.Fmt[]; let _174!: string; let v6!: rt.usize; let buf6!: Uint8Array; let n6!: rt.usize; let _193!: string; + let args12!: rt.Fmt[]; let _208!: string; let v7!: rt.i8; let buf7!: Uint8Array; let n7!: rt.usize; let _227!: string; + let args14!: rt.Fmt[]; let _242!: string; let v8!: rt.i16; let buf8!: Uint8Array; let n8!: rt.usize; let _261!: string; + let args16!: rt.Fmt[]; let _276!: string; let v9!: rt.i32; let buf9!: Uint8Array; let n9!: rt.usize; let _295!: string; + let args18!: rt.Fmt[]; let _310!: string; let v10!: rt.i64; let buf10!: Uint8Array; let n10!: rt.usize; let _329!: string; + let args20!: rt.Fmt[]; let _344!: string; let v11!: rt.i128; let buf11!: Uint8Array; let n11!: rt.usize; let _363!: string; + let args22!: rt.Fmt[]; let _378!: string; let v12!: rt.isize; let buf12!: Uint8Array; let n12!: rt.usize; let _397!: string; + let args24!: rt.Fmt[]; let _412!: string; _4 = rt.u8Rem(kind, 12); if (_4 === 0) { @@ -92,7 +104,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); v = rt.u8FromBeBytes(buf); - _23 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(v, f), " ", (f: rt.Formatter) => rt.u8Display(v, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", (f: rt.Formatter) => rt.u8LowerHex(v, f), " ", (f: rt.Formatter) => rt.u8UpperHex(v, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8Display(v, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u8Display(v, f))]); + args2 = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8UpperHex(v, f)]; + _23 = rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[1]), " ", rt.fmtSpec({ width: 3 }, args2[1])]); put(out, _23); _38 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f)); put(out, _38); @@ -101,7 +114,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n2 = rt.min(data.length, buf2.length); rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); v2 = rt.u16FromBeBytes(buf2); - _57 = rt.fmtFormat([(f: rt.Formatter) => rt.u16Display(v2, f), " ", (f: rt.Formatter) => rt.u16Display(v2, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", (f: rt.Formatter) => rt.u16LowerHex(v2, f), " ", (f: rt.Formatter) => rt.u16UpperHex(v2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16Display(v2, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u16Display(v2, f))]); + args4 = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16UpperHex(v2, f)]; + _57 = rt.fmtFormat([args4[0], " ", args4[1], " ", rt.fmtSpec({ width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args4[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args4[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args4[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args4[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args4[0]), "|", args4[2], " ", args4[3], " ", rt.fmtSpec({ alternate: true }, args4[2]), " ", rt.fmtSpec({ alternate: true }, args4[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args4[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args4[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args4[3]), "|", rt.fmtSpec({ alternate: true }, args4[1]), " ", rt.fmtSpec({ width: 3 }, args4[1])]); put(out, _57); _72 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f)); put(out, _72); @@ -110,7 +124,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n3 = rt.min(data.length, buf3.length); rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); v3 = rt.u32FromBeBytes(buf3); - _91 = rt.fmtFormat([(f: rt.Formatter) => rt.u32Display(v3, f), " ", (f: rt.Formatter) => rt.u32Display(v3, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", (f: rt.Formatter) => rt.u32LowerHex(v3, f), " ", (f: rt.Formatter) => rt.u32UpperHex(v3, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32Display(v3, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u32Display(v3, f))]); + args6 = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32UpperHex(v3, f)]; + _91 = rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args6[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args6[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args6[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args6[0]), "|", args6[2], " ", args6[3], " ", rt.fmtSpec({ alternate: true }, args6[2]), " ", rt.fmtSpec({ alternate: true }, args6[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args6[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args6[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args6[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args6[3]), "|", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ width: 3 }, args6[1])]); put(out, _91); _106 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f)); put(out, _106); @@ -119,7 +134,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n4 = rt.min(data.length, buf4.length); rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); v4 = rt.u64FromBeBytes(buf4); - _125 = rt.fmtFormat([(f: rt.Formatter) => rt.u64Display(v4, f), " ", (f: rt.Formatter) => rt.u64Display(v4, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", (f: rt.Formatter) => rt.u64LowerHex(v4, f), " ", (f: rt.Formatter) => rt.u64UpperHex(v4, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64Display(v4, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u64Display(v4, f))]); + args8 = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64UpperHex(v4, f)]; + _125 = rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rt.fmtSpec({ alternate: true }, args8[2]), " ", rt.fmtSpec({ alternate: true }, args8[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rt.fmtSpec({ alternate: true }, args8[1]), " ", rt.fmtSpec({ width: 3 }, args8[1])]); put(out, _125); _140 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f)); put(out, _140); @@ -128,7 +144,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n5 = rt.min(data.length, buf5.length); rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); v5 = rt.u128FromBeBytes(buf5); - _159 = rt.fmtFormat([(f: rt.Formatter) => rt.u128Display(v5, f), " ", (f: rt.Formatter) => rt.u128Display(v5, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", (f: rt.Formatter) => rt.u128LowerHex(v5, f), " ", (f: rt.Formatter) => rt.u128UpperHex(v5, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128Display(v5, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u128Display(v5, f))]); + args10 = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128UpperHex(v5, f)]; + _159 = rt.fmtFormat([args10[0], " ", args10[1], " ", rt.fmtSpec({ width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args10[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args10[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args10[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args10[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args10[0]), "|", args10[2], " ", args10[3], " ", rt.fmtSpec({ alternate: true }, args10[2]), " ", rt.fmtSpec({ alternate: true }, args10[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args10[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args10[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args10[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args10[3]), "|", rt.fmtSpec({ alternate: true }, args10[1]), " ", rt.fmtSpec({ width: 3 }, args10[1])]); put(out, _159); _174 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f)); put(out, _174); @@ -137,7 +154,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n6 = rt.min(data.length, buf6.length); rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); v6 = rt.usizeFromBeBytes(buf6); - _193 = rt.fmtFormat([(f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", (f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", (f: rt.Formatter) => rt.usizeLowerHex(v6, f), " ", (f: rt.Formatter) => rt.usizeUpperHex(v6, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f))]); + args12 = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeUpperHex(v6, f)]; + _193 = rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args12[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args12[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args12[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args12[0]), "|", args12[2], " ", args12[3], " ", rt.fmtSpec({ alternate: true }, args12[2]), " ", rt.fmtSpec({ alternate: true }, args12[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args12[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args12[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args12[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args12[3]), "|", rt.fmtSpec({ alternate: true }, args12[1]), " ", rt.fmtSpec({ width: 3 }, args12[1])]); put(out, _193); _208 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f)); put(out, _208); @@ -146,7 +164,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n7 = rt.min(data.length, buf7.length); rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); v7 = rt.i8FromBeBytes(buf7); - _227 = rt.fmtFormat([(f: rt.Formatter) => rt.i8Display(v7, f), " ", (f: rt.Formatter) => rt.i8Display(v7, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", (f: rt.Formatter) => rt.i8LowerHex(v7, f), " ", (f: rt.Formatter) => rt.i8UpperHex(v7, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8Display(v7, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i8Display(v7, f))]); + args14 = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8UpperHex(v7, f)]; + _227 = rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rt.fmtSpec({ alternate: true }, args14[2]), " ", rt.fmtSpec({ alternate: true }, args14[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rt.fmtSpec({ alternate: true }, args14[1]), " ", rt.fmtSpec({ width: 3 }, args14[1])]); put(out, _227); _242 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f)); put(out, _242); @@ -155,7 +174,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n8 = rt.min(data.length, buf8.length); rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); v8 = rt.i16FromBeBytes(buf8); - _261 = rt.fmtFormat([(f: rt.Formatter) => rt.i16Display(v8, f), " ", (f: rt.Formatter) => rt.i16Display(v8, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", (f: rt.Formatter) => rt.i16LowerHex(v8, f), " ", (f: rt.Formatter) => rt.i16UpperHex(v8, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16Display(v8, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i16Display(v8, f))]); + args16 = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16UpperHex(v8, f)]; + _261 = rt.fmtFormat([args16[0], " ", args16[1], " ", rt.fmtSpec({ width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args16[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args16[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args16[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args16[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args16[0]), "|", args16[2], " ", args16[3], " ", rt.fmtSpec({ alternate: true }, args16[2]), " ", rt.fmtSpec({ alternate: true }, args16[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args16[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args16[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args16[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args16[3]), "|", rt.fmtSpec({ alternate: true }, args16[1]), " ", rt.fmtSpec({ width: 3 }, args16[1])]); put(out, _261); _276 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f)); put(out, _276); @@ -164,7 +184,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n9 = rt.min(data.length, buf9.length); rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); v9 = rt.i32FromBeBytes(buf9); - _295 = rt.fmtFormat([(f: rt.Formatter) => rt.i32Display(v9, f), " ", (f: rt.Formatter) => rt.i32Display(v9, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", (f: rt.Formatter) => rt.i32LowerHex(v9, f), " ", (f: rt.Formatter) => rt.i32UpperHex(v9, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32Display(v9, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i32Display(v9, f))]); + args18 = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32UpperHex(v9, f)]; + _295 = rt.fmtFormat([args18[0], " ", args18[1], " ", rt.fmtSpec({ width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args18[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args18[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args18[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args18[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args18[0]), "|", args18[2], " ", args18[3], " ", rt.fmtSpec({ alternate: true }, args18[2]), " ", rt.fmtSpec({ alternate: true }, args18[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args18[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args18[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args18[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args18[3]), "|", rt.fmtSpec({ alternate: true }, args18[1]), " ", rt.fmtSpec({ width: 3 }, args18[1])]); put(out, _295); _310 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f)); put(out, _310); @@ -173,7 +194,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n10 = rt.min(data.length, buf10.length); rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); v10 = rt.i64FromBeBytes(buf10); - _329 = rt.fmtFormat([(f: rt.Formatter) => rt.i64Display(v10, f), " ", (f: rt.Formatter) => rt.i64Display(v10, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", (f: rt.Formatter) => rt.i64LowerHex(v10, f), " ", (f: rt.Formatter) => rt.i64UpperHex(v10, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64Display(v10, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i64Display(v10, f))]); + args20 = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64UpperHex(v10, f)]; + _329 = rt.fmtFormat([args20[0], " ", args20[1], " ", rt.fmtSpec({ width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rt.fmtSpec({ alternate: true }, args20[2]), " ", rt.fmtSpec({ alternate: true }, args20[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rt.fmtSpec({ alternate: true }, args20[1]), " ", rt.fmtSpec({ width: 3 }, args20[1])]); put(out, _329); _344 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f)); put(out, _344); @@ -182,7 +204,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n11 = rt.min(data.length, buf11.length); rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); v11 = rt.i128FromBeBytes(buf11); - _363 = rt.fmtFormat([(f: rt.Formatter) => rt.i128Display(v11, f), " ", (f: rt.Formatter) => rt.i128Display(v11, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", (f: rt.Formatter) => rt.i128LowerHex(v11, f), " ", (f: rt.Formatter) => rt.i128UpperHex(v11, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128Display(v11, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i128Display(v11, f))]); + args22 = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128UpperHex(v11, f)]; + _363 = rt.fmtFormat([args22[0], " ", args22[1], " ", rt.fmtSpec({ width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args22[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args22[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args22[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args22[0]), "|", args22[2], " ", args22[3], " ", rt.fmtSpec({ alternate: true }, args22[2]), " ", rt.fmtSpec({ alternate: true }, args22[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args22[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args22[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args22[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args22[3]), "|", rt.fmtSpec({ alternate: true }, args22[1]), " ", rt.fmtSpec({ width: 3 }, args22[1])]); put(out, _363); _378 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f)); put(out, _378); @@ -191,7 +214,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { n12 = rt.min(data.length, buf12.length); rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); v12 = rt.isizeFromBeBytes(buf12); - _397 = rt.fmtFormat([(f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", (f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", (f: rt.Formatter) => rt.isizeLowerHex(v12, f), " ", (f: rt.Formatter) => rt.isizeUpperHex(v12, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f))]); + args24 = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeUpperHex(v12, f)]; + _397 = rt.fmtFormat([args24[0], " ", args24[1], " ", rt.fmtSpec({ width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args24[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args24[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args24[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args24[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args24[0]), "|", args24[2], " ", args24[3], " ", rt.fmtSpec({ alternate: true }, args24[2]), " ", rt.fmtSpec({ alternate: true }, args24[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args24[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args24[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args24[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args24[3]), "|", rt.fmtSpec({ alternate: true }, args24[1]), " ", rt.fmtSpec({ width: 3 }, args24[1])]); put(out, _397); _412 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f)); put(out, _412); @@ -202,38 +226,45 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { export function strings(data: Uint8Array, out: rt.ByteVec): void { let iter!: { s: Uint8Array; i: number }; let _9!: rt.u8 | rt.Done; - let s!: string; let _15!: rt.usize; let _16!: rt.usize; let _17!: rt.usize; let _25!: string; + let args2!: rt.Fmt[]; + let _31!: rt.Fmt; let _36!: rt.Result; - let s2!: string; + let s!: string; let _42!: string; + let args4!: rt.Fmt[]; let e!: rt.FromUtf8Error; let _55!: string; + let args6!: rt.Fmt[]; let flag!: boolean; let _66!: rt.u8 | undefined; let _76!: string; + let args8!: rt.Fmt[]; let _93!: string; let _94!: boolean; let _95!: rt.Result; - let v!: rt.u8; let _104!: string; - let e2!: rt.TryFromIntError; + let args10!: rt.Fmt[]; let _116!: string; + let args12!: rt.Fmt[]; + let _122!: rt.Fmt; iter = { s: rt.sliceRange(data, 0, rt.min(data.length, 3)), i: 0 }; while (true) { _9 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_9 === rt.DONE) { _36 = rt.stringFromUtf8(rt.sliceToByteVec(data)); if (_36.ok) { - s2 = _36.value; - _42 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtStr(s2, f), " ", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.fmtPad(f, s2))]); + s = _36.value; + args4 = [(f: rt.Formatter) => rt.fmtStr(s, f), (f: rt.Formatter) => rt.fmtPad(f, s)]; + _42 = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 4 }, args4[1])]); put(out, _42); } else { e = _36.error; - _55 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), " ", (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)), " ", rt.fmtSpec({ align: ">", width: 80 }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f))]); + args6 = [(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)]; + _55 = rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ align: ">", width: 80 }, args6[0])]); put(out, _55); } _66 = rt.sliceFirst(data); @@ -246,20 +277,24 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { } flag = false; } - _76 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtBool(flag, f), " ", (f: rt.Formatter) => rt.fmtBool(flag, f), " ", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => rt.fmtBool(flag, f)), " ", (f: rt.Formatter) => rt.fmtUnit(undefined, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtUnit(undefined, f))]); + args8 = [(f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f)]; + _76 = rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ align: ">", width: 6 }, args8[0]), " ", args8[2], " ", rt.fmtSpec({ alternate: true }, args8[3])]); put(out, _76); _94 = flag; _93 = rt.fmtToString((f: rt.Formatter) => rt.fmtBool(_94, f)); put(out, _93); _95 = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); if (_95.ok) { - v = _95.value; - const arg = ([v] as [rt.u8])[0]; - _104 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); + const arg5 = ([_95.value] as [rt.u8])[0]; + args10 = [(f: rt.Formatter) => rt.u8Display(arg5, f)]; + _104 = rt.fmtFormat([args10[0]]); put(out, _104); } else { - e2 = _95.error; - _116 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f), " ", (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(e2, f), " ", rt.fmtSpec({ align: ">", width: 40 }, (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f)), "|"]); + const arg3 = _95.error; + _122 = (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(arg3, f); + const arg4 = _95.error; + args12 = [_122, (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(arg4, f)]; + _116 = rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ align: ">", width: 40 }, args12[0]), "|"]); put(out, _116); } return; @@ -270,8 +305,12 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { if (!(_15 < 14)) { rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); } - s = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]; - _25 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtPad(f, s), "|", rt.fmtSpec({ width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: "^", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", (f: rt.Formatter) => rt.fmtStr(s, f), "|", rt.fmtSpec({ width: 12 }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|{", (f: rt.Formatter) => rt.fmtPad(f, s), "}"]); + [["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]] as [string]; + const arg = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]; + _31 = (f: rt.Formatter) => rt.fmtPad(f, arg); + const arg2 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]; + args2 = [_31, (f: rt.Formatter) => rt.fmtStr(arg2, f)]; + _25 = rt.fmtFormat([args2[0], "|", rt.fmtSpec({ width: 8 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ width: 12 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"]); put(out, _25); } } @@ -288,7 +327,6 @@ export function nested(data: Uint8Array): Nested.Nested { let _23!: rt.u8; let _35!: rt.ByteVec; let _40!: Pair.Pair[]; - let _43!: Pair.Pair[]; let _49!: Pair.Pair | undefined; let _60!: rt.u8 | undefined; let _61!: rt.Result; @@ -298,7 +336,6 @@ export function nested(data: Uint8Array): Nested.Nested { let _88!: rt.ByteVec; let _90!: Kind.Kind; let _91!: rt.u8; - let _102!: Uint8Array; at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; @@ -319,8 +356,7 @@ export function nested(data: Uint8Array): Nested.Nested { _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; } _35 = rt.sliceToByteVec(rt.sliceRange(data, 0, rt.min(data.length, 4))); - _43 = [{ _0: at(4), _1: -1 }, { _0: 2, _1: rt.i64Of(-9223372036854775808n) }]; - _40 = rt.sliceToVec(_43); + _40 = rt.sliceToVec([{ _0: at(4), _1: -1 }, { _0: 2, _1: rt.i64Of(-9223372036854775808n) }]); if (!(rt.u8Rem(at(5), 2) === 0)) { _49 = undefined; } else { @@ -342,8 +378,7 @@ export function nested(data: Uint8Array): Nested.Nested { } else if (_91 === 1) { _90 = { tag: "One", _0: at(11) } as Kind.Kind; } else { - _102 = Uint8Array.of(at(11), at(12)); - _90 = { tag: "Many", count: 2, items: rt.sliceToByteVec(_102) } as Kind.Kind; + _90 = { tag: "Many", count: 2, items: rt.sliceToByteVec(Uint8Array.of(at(11), at(12))) } as Kind.Kind; } return { name: _3, point: _15, shape: _22, tags: _35, pairs: _40, maybe: _49, none: _60, result: _61, list: _73, tuple: _80, single: _84, empty: _88, unit: undefined, boxed: _90 }; } @@ -353,48 +388,56 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { let at!: (a0: rt.usize) => rt.u8; let value!: Nested.Nested; let _8!: string; + let args2!: rt.Fmt[]; let _20!: string; + let args4!: rt.Fmt[]; let wide!: Wide.Wide; let _30!: rt.u8; let _33!: boolean; let six!: Six.Six; let _47!: string; + let args6!: rt.Fmt[]; let _56!: rt.Fmt; let _57!: rt.Fmt; let _58!: rt.Fmt; let _65!: string; + let args8!: rt.Fmt[]; let point!: Point.Point; let _84!: string; let _89!: Pair.Pair; + let args10!: rt.Fmt[]; let kinds!: Kind.Kind[]; let _100!: Kind.Kind; let _101!: Kind.Kind; let _105!: Kind.Kind; let _106!: Kind.Kind; let _112!: string; - let _117!: Kind.Kind; let _118!: Kind.Kind; let _119!: rt.usize; + let args12!: rt.Fmt[]; let _130!: string; - let bytes!: Uint8Array; + let args14!: rt.Fmt[]; let words!: rt.u16[]; let _148!: string; let _153!: rt.u8 | undefined; let _155!: rt.u8 | undefined; + let args16!: rt.Fmt[]; let _168!: string; + let args18!: rt.Fmt[]; let _177!: rt.Fmt; let _178!: rt.Fmt; let _179!: rt.Fmt; - let _186!: Uint8Array; at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; value = nested(data); const arg = ([value] as [Nested.Nested])[0]; - _8 = rt.fmtFormat([(f: rt.Formatter) => Nested.fmt$Debug(arg, f)]); + args2 = [(f: rt.Formatter) => Nested.fmt$Debug(arg, f)]; + _8 = rt.fmtFormat([args2[0]]); put(out, _8); const arg2 = ([value] as [Nested.Nested])[0]; - _20 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Nested.fmt$Debug(arg2, f))]); + args4 = [(f: rt.Formatter) => Nested.fmt$Debug(arg2, f)]; + _20 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])]); put(out, _20); _30 = at(0); _33 = at(1) > 10; @@ -405,13 +448,16 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { const arg3 = {}; _58 = (f: rt.Formatter) => Unit.fmt$Debug(arg3, f); const arg4 = {}; - _47 = rt.fmtFormat([_56, " ", _57, " ", _58, " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Unit.fmt$Debug(arg4, f))]); + args6 = [_56, _57, _58, (f: rt.Formatter) => Unit.fmt$Debug(arg4, f)]; + _47 = rt.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", rt.fmtSpec({ alternate: true }, args6[3])]); put(out, _47); - _65 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wide.fmt$Debug(wide, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Six.fmt$Debug(six, f))]); + args8 = [(f: rt.Formatter) => Wide.fmt$Debug(wide, f), (f: rt.Formatter) => Six.fmt$Debug(six, f)]; + _65 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args8[0]), " ", rt.fmtSpec({ alternate: true }, args8[1])]); put(out, _65); point = { x: at(2) as rt.i32, y: -1 }; _89 = { _0: at(3), _1: -9 }; - _84 = rt.fmtFormat([rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: "<", width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ alternate: true, width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: ">", width: 3 }, (f: rt.Formatter) => Pair.fmt$Debug(_89, f))]); + args10 = [(f: rt.Formatter) => Point.fmt$Debug(point, f), (f: rt.Formatter) => Pair.fmt$Debug(_89, f)]; + _84 = rt.fmtFormat([rt.fmtSpec({ width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", width: 4 }, args10[0]), "|", rt.fmtSpec({ alternate: true, width: 4 }, args10[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args10[1])]); put(out, _84); _100 = { tag: "Empty" } as Kind.Kind; _101 = { tag: "One", _0: at(4) } as Kind.Kind; @@ -423,17 +469,18 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _119); } _118 = kinds[_119]; - _117 = _118; - _112 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), " ", (f: rt.Formatter) => Kind.fmt$Debug(_117, f)]); + args12 = [(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), (f: rt.Formatter) => Kind.fmt$Debug(_118, f)]; + _112 = rt.fmtFormat([args12[0], " ", args12[1]]); put(out, _112); const arg5 = ([kinds] as [Kind.Kind[]])[0]; - _130 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtList(arg5, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)))]); + args14 = [(f: rt.Formatter) => rt.fmtList(arg5, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f))]; + _130 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args14[0])]); put(out, _130); - bytes = data; words = [at(5) as rt.u16, 65535]; _153 = rt.sliceFirst(data); _155 = rt.sliceGet(data, 100); - _148 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(bytes, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), " ", (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(_155, f, rt.u8Display)]); + args16 = [(f: rt.Formatter) => rt.fmtList(data, f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), (f: rt.Formatter) => rt.fmtOption(_155, f, rt.u8Display)]; + _148 = rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); put(out, _148); const arg6 = {}; _177 = (f: rt.Formatter) => Braced.fmt$Debug(arg6, f); @@ -442,10 +489,10 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { const arg8 = {}; _179 = (f: rt.Formatter) => Bare.fmt$Debug(arg8, f); const arg9 = {}; - _168 = rt.fmtFormat([_177, " ", rt.fmtSpec({ alternate: true }, _178), " ", _179, " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Bare.fmt$Debug(arg9, f))]); + args18 = [_177, _178, _179, (f: rt.Formatter) => Bare.fmt$Debug(arg9, f)]; + _168 = rt.fmtFormat([args18[0], " ", rt.fmtSpec({ alternate: true }, args18[1]), " ", args18[2], " ", rt.fmtSpec({ alternate: true }, args18[3])]); put(out, _168); - _186 = Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0); - rt.byteVecExtendFromSlice(out, _186); + rt.byteVecExtendFromSlice(out, Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0)); } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ @@ -453,49 +500,50 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { let at!: (a0: rt.usize) => rt.u8; let hex!: Hex.Hex; let _14!: string; + let args2!: rt.Fmt[]; let _27!: string; - let padded!: Padded.Padded; let _33!: string; + let args4!: rt.Fmt[]; let manual!: Manual.Manual; - let _43!: rt.u8; - let _49!: rt.u16[]; let empty!: Manual.Manual; let _59!: string; + let args6!: rt.Fmt[]; let seq!: Seq.Seq; - let _74!: Pair.Pair[]; let none!: Seq.Seq; let _85!: string; - let tup!: Tup.Tup; + let args8!: rt.Fmt[]; let _97!: rt.u8; let _100!: rt.u8 | undefined; let _113!: string; - let fine!: Fails.Fails; + let args10!: rt.Fmt[]; let _131!: string; + let args12!: rt.Fmt[]; let _143!: string; - let _148!: rt.u8; - let _152!: rt.u8; + let args14!: rt.Fmt[]; + let _157!: rt.Fmt; + let _158!: rt.Fmt; at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; - _14 = rt.fmtFormat([(f: rt.Formatter) => Hex.fmt$Display(hex, f), "|", rt.fmtSpec({ align: ">", width: 12 }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", (f: rt.Formatter) => Hex.fmt$Debug(hex, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f))]); + args2 = [(f: rt.Formatter) => Hex.fmt$Display(hex, f), (f: rt.Formatter) => Hex.fmt$Debug(hex, f)]; + _14 = rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1])]); put(out, _14); _27 = rt.fmtToString((f: rt.Formatter) => Hex.fmt$Display(hex, f)); put(out, _27); - padded = { _0: "pad" }; - const arg = ([padded] as [Padded.Padded])[0]; - _33 = rt.fmtFormat([(f: rt.Formatter) => Padded.fmt$Display(arg, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|", rt.fmtSpec({ width: 30 }, (f: rt.Formatter) => Padded.fmt$Display(arg, f)), "|"]); + const arg = ([{ _0: "pad" }] as [Padded.Padded])[0]; + args4 = [(f: rt.Formatter) => Padded.fmt$Display(arg, f)]; + _33 = rt.fmtFormat([args4[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, args4[0]), "|", rt.fmtSpec({ width: 30 }, args4[0]), "|"]); put(out, _33); - _43 = at(1); - _49 = [1, at(2) as rt.u16]; - manual = { id: _43, list: rt.sliceToVec(_49) }; + manual = { id: at(1), list: rt.sliceToVec([1, at(2) as rt.u16]) }; empty = { id: 0, list: [] }; - _59 = rt.fmtFormat([(f: rt.Formatter) => Manual.fmt$Debug(manual, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Manual.fmt$Debug(manual, f)), " ", (f: rt.Formatter) => Manual.fmt$Debug(empty, f)]); + args6 = [(f: rt.Formatter) => Manual.fmt$Debug(manual, f), (f: rt.Formatter) => Manual.fmt$Debug(empty, f)]; + _59 = rt.fmtFormat([args6[0], " ", rt.fmtSpec({ alternate: true }, args6[0]), " ", args6[1]]); put(out, _59); - _74 = [{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }]; - seq = { _0: rt.sliceToVec(_74) }; + seq = { _0: rt.sliceToVec([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }]) }; none = { _0: [] }; - _85 = rt.fmtFormat([(f: rt.Formatter) => Seq.fmt$Debug(seq, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(seq, f)), " ", (f: rt.Formatter) => Seq.fmt$Debug(none, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(none, f))]); + args8 = [(f: rt.Formatter) => Seq.fmt$Debug(seq, f), (f: rt.Formatter) => Seq.fmt$Debug(none, f)]; + _85 = rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0]), " ", args8[1], " ", rt.fmtSpec({ alternate: true }, args8[1])]); put(out, _85); _97 = at(4); if (!(rt.u8Rem(at(5), 2) === 0)) { @@ -503,17 +551,22 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { } else { _100 = at(5); } - tup = { _0: _97, _1: _100 }; - const arg2 = ([tup] as [Tup.Tup])[0]; - _113 = rt.fmtFormat([(f: rt.Formatter) => Tup.fmt$Debug(arg2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Tup.fmt$Debug(arg2, f))]); + const arg2 = ([{ _0: _97, _1: _100 }] as [Tup.Tup])[0]; + args10 = [(f: rt.Formatter) => Tup.fmt$Debug(arg2, f)]; + _113 = rt.fmtFormat([args10[0], " ", rt.fmtSpec({ alternate: true }, args10[0])]); put(out, _113); - fine = { _0: at(6) & (~1 & 0xff) }; - const arg3 = ([fine] as [Fails.Fails])[0]; - _131 = rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg3, f), " ", rt.fmtSpec({ align: ">", width: 9 }, (f: rt.Formatter) => Fails.fmt$Display(arg3, f))]); + const arg3 = ([{ _0: at(6) & (~1 & 0xff) }] as [Fails.Fails])[0]; + args12 = [(f: rt.Formatter) => Fails.fmt$Display(arg3, f)]; + _131 = rt.fmtFormat([args12[0], " ", rt.fmtSpec({ align: ">", width: 9 }, args12[0])]); put(out, _131); - _148 = at(7); - _152 = at(8); - _143 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(_152, f), " ", (f: rt.Formatter) => rt.u8Display(_148, f), " ", (f: rt.Formatter) => rt.u8Display(_148, f), " named ", rt.fmtSpec({ align: ">", width: 5 }, (f: rt.Formatter) => rt.fmtPad(f, "named"))]); + [at(7), at(8), "named"] as [rt.u8, rt.u8, string]; + const arg4 = at(8); + _157 = (f: rt.Formatter) => rt.u8Display(arg4, f); + const arg5 = at(7); + _158 = (f: rt.Formatter) => rt.u8Display(arg5, f); + const arg6 = at(7); + args14 = [_157, _158, (f: rt.Formatter) => rt.u8Display(arg6, f), (f: rt.Formatter) => rt.fmtPad(f, "named")]; + _143 = rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " named ", rt.fmtSpec({ align: ">", width: 5 }, args14[3])]); put(out, _143); } @@ -521,14 +574,15 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let n!: rt.u8; let _7!: rt.u8; - let _23!: Hex.Hex; - let _37!: Pair.Pair; - let _58!: Pair.Pair; - let _60!: Pair.Pair; + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; + let _27!: rt.Fmt; + let args6!: rt.Fmt[]; + let _39!: rt.Fmt; let kind3!: string; let _66!: rt.Arguments | undefined; + let args8!: rt.Fmt[]; let r!: rt.Result; - let _94!: Uint8Array; let _98!: string; let _100!: rt.u8; let r2!: rt.Result; @@ -540,21 +594,24 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let _127!: string; let _129!: rt.u8; let _132!: string; + let args10!: rt.Fmt[]; let _143!: string; - let _148!: Fails.Fails; + let args12!: rt.Fmt[]; let _155!: string; let _157!: Fails.Fails; - let _162!: Hex.Hex; - let _165!: Fails.Fails; + let args14!: rt.Fmt[]; + let _167!: rt.Fmt; let start!: rt.usize; let end!: rt.usize; let _173!: [rt.usize, rt.usize]; let _183!: string; - let _188!: Uint8Array; - let _192!: Uint8Array; + let _189!: Uint8Array; + let args16!: rt.Fmt[]; + let _196!: rt.Fmt; let buf!: Uint8Array; let _202!: Uint8Array; let _211!: string; + let args18!: rt.Fmt[]; let r4!: rt.Result; let _221!: rt.Result; let s!: string; @@ -566,20 +623,26 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let dest!: rt.usize; let _244!: Uint8Array; let _258!: string; + let args20!: rt.Fmt[]; let r5!: rt.Result; let _274!: string; - let _279!: rt.u8; + let args22!: rt.Fmt[]; n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); _7 = rt.u8Rem(kind, 19); if (_7 === 0) { - rt.panicFmt(["bad ", (f: rt.Formatter) => rt.u8Display(n, f), ": ", (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]); + args2 = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]; + rt.panicFmt(["bad ", args2[0], ": ", args2[1]]); } else if (_7 === 1) { - _23 = { _0: n as rt.u32 }; - rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(n, f)), " ", (f: rt.Formatter) => Hex.fmt$Display(_23, f)]); + _27 = (f: rt.Formatter) => rt.u8LowerHex(n, f); + const arg13 = { _0: n as rt.u32 }; + args4 = [_27, (f: rt.Formatter) => Hex.fmt$Display(arg13, f)]; + rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, args4[0]), " ", args4[1]]); } else if (_7 === 2) { if (!(n > 200)) { - _37 = { _0: n, _1: 0 }; - rt.panicFmt(["small ", (f: rt.Formatter) => rt.u8Display(n, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(_37, f)]); + _39 = (f: rt.Formatter) => rt.u8Display(n, f); + const arg12 = { _0: n, _1: 0 }; + args6 = [_39, (f: rt.Formatter) => Pair.fmt$Debug(arg12, f)]; + rt.panicFmt(["small ", args6[0], " ", args6[1]]); } } else if (_7 === 3) { if (!(n > 200)) { @@ -590,13 +653,14 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(7, f), undefined); } } else if (_7 === 5) { - _58 = { _0: n, _1: 1 }; - _60 = { _0: n, _1: 1 }; - if (Pair.eq$PartialEq(_58, _60)) { - const arg6 = ([n] as [rt.u8])[0]; + if (Pair.eq$PartialEq({ _0: n, _1: 1 }, { _0: n, _1: 1 })) { + const arg9 = ([n] as [rt.u8])[0]; kind3 = "!="; - _66 = ["same ", (f: rt.Formatter) => rt.u8Display(arg6, f)]; - rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(_58, f), (f: rt.Formatter) => Pair.fmt$Debug(_60, f), _66); + args8 = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; + _66 = ["same ", args8[0]]; + const arg10 = { _0: n, _1: 1 }; + const arg11 = { _0: n, _1: 1 }; + rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(arg10, f), (f: rt.Formatter) => Pair.fmt$Debug(arg11, f), _66); } } else if (_7 === 6) { if (!(n === 9)) { @@ -606,8 +670,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { if (rt.u8Rem(n, 2) === 0) { r = rt.Err({ tag: "One", _0: n } as Kind.Kind); } else { - _94 = Uint8Array.of(n); - r = rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(_94) } as Kind.Kind); + r = rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(Uint8Array.of(n)) } as Kind.Kind); } _100 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)); _98 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_100, f)); @@ -627,31 +690,37 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { put(out, _119); } else if (_7 === 10) { missing = rt.sliceGet(rest, 200); - const arg5 = ([n] as [rt.u8])[0]; - _132 = rt.fmtFormat(["missing ", (f: rt.Formatter) => rt.u8Display(arg5, f)]); + const arg8 = ([n] as [rt.u8])[0]; + args10 = [(f: rt.Formatter) => rt.u8Display(arg8, f)]; + _132 = rt.fmtFormat(["missing ", args10[0]]); _129 = rt.optionExpect(missing, _132); _127 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_129, f)); put(out, _127); } else if (_7 === 11) { - _148 = { _0: n }; - const arg4 = ([_148] as [Fails.Fails])[0]; - _143 = rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg4, f)]); + const arg7 = ([{ _0: n }] as [Fails.Fails])[0]; + args12 = [(f: rt.Formatter) => Fails.fmt$Display(arg7, f)]; + _143 = rt.fmtFormat([args12[0]]); put(out, _143); } else if (_7 === 12) { _157 = { _0: n }; _155 = rt.fmtToString((f: rt.Formatter) => Fails.fmt$Display(_157, f)); put(out, _155); } else if (_7 === 13) { - _162 = { _0: n as rt.u32 }; - _165 = { _0: n }; - rt.panicFmt([(f: rt.Formatter) => Hex.fmt$Display(_162, f), " then ", (f: rt.Formatter) => Fails.fmt$Display(_165, f)]); + const arg5 = { _0: n as rt.u32 }; + _167 = (f: rt.Formatter) => Hex.fmt$Display(arg5, f); + const arg6 = { _0: n }; + args14 = [_167, (f: rt.Formatter) => Fails.fmt$Display(arg6, f)]; + rt.panicFmt([args14[0], " then ", args14[1]]); } else if (_7 === 14) { _173 = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize] as [rt.usize, rt.usize]; start = _173[0]; end = _173[1]; - _188 = rt.sliceRange(rest, start); - _192 = rt.sliceRange(rest, start, end); - _183 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(_188, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(_192, f, rt.u8Display)]); + _189 = rt.sliceRange(rest, start); + [_189, rt.sliceRange(rest, start, end)] as [Uint8Array, Uint8Array]; + _196 = (f: rt.Formatter) => rt.fmtList(_189, f, rt.u8Display); + const arg4 = rt.sliceRange(rest, start, end); + args16 = [_196, (f: rt.Formatter) => rt.fmtList(arg4, f, rt.u8Display)]; + _183 = rt.fmtFormat([args16[0], " ", args16[1]]); put(out, _183); } else if (_7 === 15) { buf = rt.bytes(3); @@ -659,7 +728,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { const part3 = rt.min(rest.length, 4); rt.sliceCopyFromSlice(_202, rt.sliceRange(rest, 0, part3)); const arg3 = ([buf] as [Uint8Array])[0]; - _211 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]); + args18 = [(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]; + _211 = rt.fmtFormat([args18[0]]); put(out, _211); } else if (_7 === 16) { _221 = rt.stringFromUtf8(rt.sliceToByteVec(rest)); @@ -682,7 +752,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _244 = buf2; rt.sliceCopyWithin(_244, part, part2, dest); const arg2 = ([buf2] as [Uint8Array])[0]; - _258 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Display)]); + args20 = [(f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Display)]; + _258 = rt.fmtFormat([args20[0]]); put(out, _258); } else { if (!(rt.u8Rem(n, 2) === 0)) { @@ -690,9 +761,9 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { } else { r5 = rt.Err(n); } - _279 = rt.resultUnwrapErr(r5, rt.u8Display); - const arg = ([_279] as [rt.u8])[0]; - _274 = rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg, f)]); + const arg = ([rt.resultUnwrapErr(r5, rt.u8Display)] as [rt.u8])[0]; + args22 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + _274 = rt.fmtFormat([args22[0]]); put(out, _274); } } diff --git a/ts/fixtures/lang/expected/generics.Either.ts b/ts/fixtures/lang/expected/generics.Either.ts index 7e6c49881..d2315f509 100644 --- a/ts/fixtures/lang/expected/generics.Either.ts +++ b/ts/fixtures/lang/expected/generics.Either.ts @@ -4,23 +4,19 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug_Point_u8(self: Either, f: rt.Formatter): rt.Result { - let __self0!: Point.Point; let _5!: string; let _6!: rt.Fmt; - let __self02!: rt.u8; let _9!: string; let _10!: string; let _11!: rt.Fmt; if (self.tag === "Left") { - __self0 = self._0; _5 = "Left"; - _6 = (f: rt.Formatter) => Point.fmt$Debug(__self0, f); + _6 = (f: rt.Formatter) => Point.fmt$Debug(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - __self02 = self.value; _9 = "Right"; _10 = "value"; - _11 = (f: rt.Formatter) => rt.u8Display(__self02, f); + _11 = (f: rt.Formatter) => rt.u8Display(self.value, f); return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { return rt.fmtWriteStr(f, "Neither"); @@ -28,23 +24,19 @@ export function fmt$Debug_Point_u8(self: Either, f: rt.Forma } export function fmt$Debug_u8_Point(self: Either, f: rt.Formatter): rt.Result { - let __self0!: rt.u8; let _5!: string; let _6!: rt.Fmt; - let __self02!: Point.Point; let _9!: string; let _10!: string; let _11!: rt.Fmt; if (self.tag === "Left") { - __self0 = self._0; _5 = "Left"; - _6 = (f: rt.Formatter) => rt.u8Display(__self0, f); + _6 = (f: rt.Formatter) => rt.u8Display(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - __self02 = self.value; _9 = "Right"; _10 = "value"; - _11 = (f: rt.Formatter) => Point.fmt$Debug(__self02, f); + _11 = (f: rt.Formatter) => Point.fmt$Debug(self.value, f); return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { return rt.fmtWriteStr(f, "Neither"); @@ -52,23 +44,19 @@ export function fmt$Debug_u8_Point(self: Either, f: rt.Forma } export function fmt$Debug_u8_u16(self: Either, f: rt.Formatter): rt.Result { - let __self0!: rt.u8; let _5!: string; let _6!: rt.Fmt; - let __self02!: rt.u16; let _9!: string; let _10!: string; let _11!: rt.Fmt; if (self.tag === "Left") { - __self0 = self._0; _5 = "Left"; - _6 = (f: rt.Formatter) => rt.u8Display(__self0, f); + _6 = (f: rt.Formatter) => rt.u8Display(self._0, f); return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - __self02 = self.value; _9 = "Right"; _10 = "value"; - _11 = (f: rt.Formatter) => rt.u16Display(__self02, f); + _11 = (f: rt.Formatter) => rt.u16Display(self.value, f); return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { return rt.fmtWriteStr(f, "Neither"); diff --git a/ts/fixtures/lang/expected/generics.Tagged.ts b/ts/fixtures/lang/expected/generics.Tagged.ts index f709cbd22..eb3cf6c88 100644 --- a/ts/fixtures/lang/expected/generics.Tagged.ts +++ b/ts/fixtures/lang/expected/generics.Tagged.ts @@ -12,15 +12,13 @@ export function fmt$Debug_Either_u8_u16_i16(self: Tagged[]; - _5 = (f: rt.Formatter) => Either.fmt$Debug_u8_u16(self.key, f); - _8 = (f: rt.Formatter) => Wrap.fmt$Debug_i16(self.inner, f); - _13 = self.all; _3 = "Tagged"; _4 = "key"; + _5 = (f: rt.Formatter) => Either.fmt$Debug_u8_u16(self.key, f); _7 = "inner"; + _8 = (f: rt.Formatter) => Wrap.fmt$Debug_i16(self.inner, f); _10 = "all"; - _11 = (f: rt.Formatter) => rt.fmtList(_13, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f)); + _11 = (f: rt.Formatter) => rt.fmtList(self.all, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f)); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } diff --git a/ts/fixtures/lang/expected/generics.Wrap.ts b/ts/fixtures/lang/expected/generics.Wrap.ts index 23499457a..bcaf4ed0d 100644 --- a/ts/fixtures/lang/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/expected/generics.Wrap.ts @@ -12,13 +12,11 @@ export function fmt$Debug_Option_u8(self: Wrap, f: rt.Formatt let _5!: rt.Fmt; let _7!: string; let _8!: rt.Fmt; - let _10!: rt.u8; - _5 = (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Display); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Display); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -28,13 +26,11 @@ export function fmt$Debug_Pair(self: Wrap, f: rt.Formatter): rt.Resul let _5!: rt.Fmt; let _7!: string; let _8!: rt.Fmt; - let _10!: rt.u8; - _5 = (f: rt.Formatter) => Pair.fmt$Debug(self.value, f); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => Pair.fmt$Debug(self.value, f); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -44,13 +40,11 @@ export function fmt$Debug_Point(self: Wrap, f: rt.Formatter): rt.Re let _5!: rt.Fmt; let _7!: string; let _8!: rt.Fmt; - let _10!: rt.u8; - _5 = (f: rt.Formatter) => Point.fmt$Debug(self.value, f); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => Point.fmt$Debug(self.value, f); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -60,13 +54,11 @@ export function fmt$Debug_Result_u8_Shape(self: Wrap rt.fmtResult(self.value, f, rt.u8Display, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$Debug(value, f)); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => rt.fmtResult(self.value, f, rt.u8Display, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$Debug(value, f)); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -76,13 +68,11 @@ export function fmt$Debug_Shape(self: Wrap, f: rt.Formatter): rt.Re let _5!: rt.Fmt; let _7!: string; let _8!: rt.Fmt; - let _10!: rt.u8; - _5 = (f: rt.Formatter) => Shape.fmt$Debug(self.value, f); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => Shape.fmt$Debug(self.value, f); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -92,13 +82,11 @@ export function fmt$Debug_Vec_u16(self: Wrap, f: rt.Formatter): rt.Res let _5!: rt.Fmt; let _7!: string; let _8!: rt.Fmt; - let _10!: rt.u8; - _5 = (f: rt.Formatter) => rt.fmtList(self.value, f, rt.u16Display); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => rt.fmtList(self.value, f, rt.u16Display); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -108,13 +96,11 @@ export function fmt$Debug_Wrap_Pair(self: Wrap>, f: rt.Formatter let _5!: rt.Fmt; let _7!: string; let _8!: rt.Fmt; - let _10!: rt.u8; - _5 = (f: rt.Formatter) => fmt$Debug_Pair(self.value, f); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => fmt$Debug_Pair(self.value, f); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -124,13 +110,11 @@ export function fmt$Debug_i16(self: Wrap, f: rt.Formatter): rt.Result rt.i16Display(self.value, f); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => rt.i16Display(self.value, f); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -140,13 +124,11 @@ export function fmt$Debug_u8(self: Wrap, f: rt.Formatter): rt.Result rt.u8Display(self.value, f); - _10 = self.count; _3 = "Wrap"; _4 = "value"; + _5 = (f: rt.Formatter) => rt.u8Display(self.value, f); _7 = "count"; - _8 = (f: rt.Formatter) => rt.u8Display(_10, f); + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } @@ -259,18 +241,14 @@ export function area$Area_Shape(self: Wrap): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area_Meters(self: Wrap, out: rt.ByteVec): void { - let _7!: Uint8Array; rt.byteVecPush(out, 0); - _7 = rt.u64ToBeBytes(area$Area_Meters(self)); - rt.byteVecExtendFromSlice(out, _7); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area_Meters(self))); } /** A default method, monomorphized for each type. */ export function describe$Area_Shape(self: Wrap, out: rt.ByteVec): void { - let _7!: Uint8Array; rt.byteVecPush(out, 4); - _7 = rt.u64ToBeBytes(area$Area_Shape(self)); - rt.byteVecExtendFromSlice(out, _7); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area_Shape(self))); } //# sourceMappingURL=generics.Wrap.ts.map diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 66b4a5508..05ae75ddb 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -19,21 +19,23 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { let meters!: Wrap.Wrap; let shape!: Wrap.Wrap; let _46!: string; + let args2!: rt.Fmt[]; let _64!: string; - let _76!: Uint8Array; - let _91!: Uint8Array; - let _97!: Uint8Array; + let args4!: rt.Fmt[]; let mapped!: Wrap.Wrap; let _111!: string; - let _116!: boolean; let _119!: Wrap.Wrap; + let args6!: rt.Fmt[]; + let _126!: rt.Fmt; let iter!: rt.Iter>; let _140!: Either.Either | rt.Done; let either!: Either.Either; let flipped!: Either.Either; let _148!: string; - let _153!: rt.u8 | undefined; - let _156!: Point.Point | undefined; + let args8!: rt.Fmt[]; + let _161!: rt.Fmt; + let _162!: rt.Fmt; + let _163!: rt.Fmt; let list!: Wrap.Wrap; let _171!: rt.u16; let none!: Wrap.Wrap; @@ -41,12 +43,11 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { let err!: Wrap.Wrap>; let _188!: string; let _193!: rt.u8; + let args10!: rt.Fmt[]; let tagged!: Tagged.Tagged, rt.i16>; - let _212!: Wrap.Wrap; - let _222!: Wrap.Wrap[]; let _232!: string; - let _237!: Wrap.Wrap | undefined; - let _248!: Uint8Array; + let args12!: rt.Fmt[]; + let _241!: rt.Fmt; at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; @@ -58,27 +59,29 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { nested = Wrap.new$Wrap_Pair(Wrap.new$Pair({ _0: at(2), _1: -3 })); meters = new Wrap.Wrap({ value: { _0: at(3) as rt.u64 }, count: at(4) }); shape = Wrap.new$Shape({ tag: "Rect", corner: Wrap.intoInner$Point(point), width: at(5) as rt.u16, height: 3 } as Shape.Shape); - _46 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)]); + args2 = [(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)]; + _46 = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); put(out, _46); const arg = ([nested] as [Wrap.Wrap>])[0]; - _64 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(arg, f))]); + args4 = [(f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(arg, f)]; + _64 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])]); put(out, _64); - _76 = rt.u16ToBeBytes(Wrap.double$u8(byte)); - rt.byteVecExtendFromSlice(out, _76); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(Wrap.double$u8(byte))); rt.byteVecPush(out, Wrap.get$u8(byte)); rt.byteVecPush(out, Wrap.get$Pair(Wrap.get$Wrap_Pair(nested))._0); - _91 = rt.u64ToBeBytes(Wrap.scaled$Meters(meters)); - rt.byteVecExtendFromSlice(out, _91); - _97 = rt.u64ToBeBytes(Wrap.scaled$Shape(shape)); - rt.byteVecExtendFromSlice(out, _97); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Meters(meters))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Shape(shape))); Wrap.describe$Area_Meters(meters, out); Wrap.describe$Area_Shape(shape, out); mapped = Wrap.map$u8_Pair_methods_closure1(byte, (b: rt.u8): Pair.Pair => { return { _0: b, _1: at(6) as rt.i64 }; }); _119 = Wrap.new$Pair({ _0: at(1), _1: 0 }); - _116 = Wrap.eq$PartialEq_Pair(mapped, _119); - _111 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Pair(mapped, f), " ", (f: rt.Formatter) => rt.fmtBool(_116, f)]); + [Wrap.eq$PartialEq_Pair(mapped, _119), mapped] as [boolean, Wrap.Wrap]; + _126 = (f: rt.Formatter) => Wrap.fmt$Debug_Pair(mapped, f); + const arg2 = Wrap.eq$PartialEq_Pair(mapped, _119); + args6 = [_126, (f: rt.Formatter) => rt.fmtBool(arg2, f)]; + _111 = rt.fmtFormat([args6[0], " ", args6[1]]); put(out, _111); iter = rt.iterSlice([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either]); while (true) { @@ -92,24 +95,30 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { some = Wrap.new$Option_u8(rt.sliceGet(data, 11)); err = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); _193 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); - _188 = rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), " ", (f: rt.Formatter) => rt.u8Display(_193, f)]); + args10 = [(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), (f: rt.Formatter) => rt.u8Display(_193, f)]; + _188 = rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]]); put(out, _188); - _212 = Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)); - _222 = [Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]; - tagged = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: _212, all: rt.sliceToVec(_222) }); - _237 = Tagged.first$Either_u8_u16_i16(tagged); - _232 = rt.fmtFormat([(f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f), " ", (f: rt.Formatter) => rt.fmtOption(_237, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]); + tagged = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), all: rt.sliceToVec([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]) }); + [Tagged.first$Either_u8_u16_i16(tagged), tagged] as [Wrap.Wrap | undefined, Tagged.Tagged, rt.i16>]; + _241 = (f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f); + const arg5 = Tagged.first$Either_u8_u16_i16(tagged); + args12 = [_241, (f: rt.Formatter) => rt.fmtOption(arg5, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]; + _232 = rt.fmtFormat([args12[0], " ", args12[1]]); put(out, _232); - _248 = rt.i16ToBeBytes(tagged.inner.value); - rt.byteVecExtendFromSlice(out, _248); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); return; } else { either = _140; flipped = Either.flip$u8_Point(either); - _153 = Either.left$u8_Point(either); - _156 = Either.left$Point_u8(flipped); - _148 = rt.fmtFormat([(f: rt.Formatter) => Either.fmt$Debug_u8_Point(either, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Either.fmt$Debug_Point_u8(flipped, f)), " ", (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(_156, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))]); + [Either.left$u8_Point(either), Either.left$Point_u8(flipped), either, flipped] as [rt.u8 | undefined, Point.Point | undefined, Either.Either, Either.Either]; + _161 = (f: rt.Formatter) => Either.fmt$Debug_u8_Point(either, f); + _162 = (f: rt.Formatter) => Either.fmt$Debug_Point_u8(flipped, f); + const arg3 = Either.left$u8_Point(either); + _163 = (f: rt.Formatter) => rt.fmtOption(arg3, f, rt.u8Display); + const arg4 = Either.left$Point_u8(flipped); + args8 = [_161, _162, _163, (f: rt.Formatter) => rt.fmtOption(arg4, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))]; + _148 = rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]]); put(out, _148); } } diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 85377cd64..9f58c2ff1 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -19,25 +19,19 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.u8) => void; let _51!: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void; let _52!: rt.u8; - let _117!: Uint8Array; - let _121!: Uint8Array; let x!: rt.u8; _50 = (out2: rt.ByteVec, v: rt.u8): void => { - let _7!: Uint8Array; - _7 = rt.u128ToBeBytes(v as rt.u128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { let v3!: rt.u8; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.u128ToBeBytes(v3 as rt.u128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); } }; buf = Uint8Array.of(0); @@ -109,11 +103,9 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u8WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _117 = rt.u32ToBeBytes(rt.u8LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _117); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingOnes(a))); } else if (_52 === 19) { - _121 = rt.u32ToBeBytes(rt.u8LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -156,25 +148,19 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.u16) => void; let _51!: (a0: rt.ByteVec, a1: rt.u16 | undefined) => void; let _52!: rt.u8; - let _117!: Uint8Array; - let _121!: Uint8Array; let x!: rt.u16; _50 = (out2: rt.ByteVec, v: rt.u16): void => { - let _7!: Uint8Array; - _7 = rt.u128ToBeBytes(v as rt.u128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { let v3!: rt.u16; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.u128ToBeBytes(v3 as rt.u128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); } }; buf = rt.bytes(2); @@ -246,11 +232,9 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u16WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _117 = rt.u32ToBeBytes(rt.u16LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _117); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingOnes(a))); } else if (_52 === 19) { - _121 = rt.u32ToBeBytes(rt.u16LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -293,25 +277,19 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.u32) => void; let _51!: (a0: rt.ByteVec, a1: rt.u32 | undefined) => void; let _52!: rt.u8; - let _117!: Uint8Array; - let _121!: Uint8Array; let x!: rt.u32; _50 = (out2: rt.ByteVec, v: rt.u32): void => { - let _7!: Uint8Array; - _7 = rt.u128ToBeBytes(v as rt.u128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { let v3!: rt.u32; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.u128ToBeBytes(v3 as rt.u128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); } }; buf = rt.bytes(4); @@ -383,11 +361,9 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u32WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _117 = rt.u32ToBeBytes(rt.u32LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _117); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingOnes(a))); } else if (_52 === 19) { - _121 = rt.u32ToBeBytes(rt.u32LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -430,25 +406,19 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.u64) => void; let _51!: (a0: rt.ByteVec, a1: rt.u64 | undefined) => void; let _52!: rt.u8; - let _117!: Uint8Array; - let _121!: Uint8Array; let x!: rt.u64; _50 = (out2: rt.ByteVec, v: rt.u64): void => { - let _7!: Uint8Array; - _7 = rt.u128ToBeBytes(rt.u128Cast(v)); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(rt.u128Cast(v))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { let v3!: rt.u64; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.u128ToBeBytes(rt.u128Cast(v3)); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(rt.u128Cast(v3))); } }; buf = rt.bytes(8); @@ -520,11 +490,9 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u64WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _117 = rt.u32ToBeBytes(rt.u64LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _117); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingOnes(a))); } else if (_52 === 19) { - _121 = rt.u32ToBeBytes(rt.u64LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.u64Max(a, b); _50(out, part2); @@ -567,25 +535,19 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.u128) => void; let _51!: (a0: rt.ByteVec, a1: rt.u128 | undefined) => void; let _52!: rt.u8; - let _117!: Uint8Array; - let _121!: Uint8Array; let x!: rt.u128; _50 = (out2: rt.ByteVec, v: rt.u128): void => { - let _7!: Uint8Array; - _7 = rt.u128ToBeBytes(v); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v)); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { let v3!: rt.u128; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.u128ToBeBytes(v3); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3)); } }; buf = rt.bytes(16); @@ -657,11 +619,9 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u128WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _117 = rt.u32ToBeBytes(rt.u128LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _117); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingOnes(a))); } else if (_52 === 19) { - _121 = rt.u32ToBeBytes(rt.u128LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.u128Max(a, b); _50(out, part2); @@ -704,25 +664,19 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.usize) => void; let _51!: (a0: rt.ByteVec, a1: rt.usize | undefined) => void; let _52!: rt.u8; - let _117!: Uint8Array; - let _121!: Uint8Array; let x!: rt.usize; _50 = (out2: rt.ByteVec, v: rt.usize): void => { - let _7!: Uint8Array; - _7 = rt.u128ToBeBytes(v as rt.u128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { let v3!: rt.usize; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.u128ToBeBytes(v3 as rt.u128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); } }; buf = rt.bytes(4); @@ -794,11 +748,9 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.usizeWrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _117 = rt.u32ToBeBytes(rt.usizeLeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _117); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingOnes(a))); } else if (_52 === 19) { - _121 = rt.u32ToBeBytes(rt.usizeLeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -841,25 +793,19 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.i8) => void; let _51!: (a0: rt.ByteVec, a1: rt.i8 | undefined) => void; let _52!: rt.u8; - let _123!: Uint8Array; - let _127!: Uint8Array; let x!: rt.i8; _50 = (out2: rt.ByteVec, v: rt.i8): void => { - let _7!: Uint8Array; - _7 = rt.i128ToBeBytes(v as rt.i128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { let v3!: rt.i8; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.i128ToBeBytes(v3 as rt.i128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); } }; buf = Uint8Array.of(0); @@ -935,11 +881,9 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i8WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _123 = rt.u32ToBeBytes(rt.i8LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _123); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingOnes(a))); } else if (_52 === 19) { - _127 = rt.u32ToBeBytes(rt.i8LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -982,25 +926,19 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.i16) => void; let _51!: (a0: rt.ByteVec, a1: rt.i16 | undefined) => void; let _52!: rt.u8; - let _123!: Uint8Array; - let _127!: Uint8Array; let x!: rt.i16; _50 = (out2: rt.ByteVec, v: rt.i16): void => { - let _7!: Uint8Array; - _7 = rt.i128ToBeBytes(v as rt.i128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { let v3!: rt.i16; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.i128ToBeBytes(v3 as rt.i128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); } }; buf = rt.bytes(2); @@ -1076,11 +1014,9 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i16WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _123 = rt.u32ToBeBytes(rt.i16LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _123); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingOnes(a))); } else if (_52 === 19) { - _127 = rt.u32ToBeBytes(rt.i16LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -1123,25 +1059,19 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.i32) => void; let _51!: (a0: rt.ByteVec, a1: rt.i32 | undefined) => void; let _52!: rt.u8; - let _123!: Uint8Array; - let _127!: Uint8Array; let x!: rt.i32; _50 = (out2: rt.ByteVec, v: rt.i32): void => { - let _7!: Uint8Array; - _7 = rt.i128ToBeBytes(v as rt.i128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { let v3!: rt.i32; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.i128ToBeBytes(v3 as rt.i128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); } }; buf = rt.bytes(4); @@ -1217,11 +1147,9 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i32WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _123 = rt.u32ToBeBytes(rt.i32LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _123); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingOnes(a))); } else if (_52 === 19) { - _127 = rt.u32ToBeBytes(rt.i32LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -1264,25 +1192,19 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.i64) => void; let _51!: (a0: rt.ByteVec, a1: rt.i64 | undefined) => void; let _52!: rt.u8; - let _123!: Uint8Array; - let _127!: Uint8Array; let x!: rt.i64; _50 = (out2: rt.ByteVec, v: rt.i64): void => { - let _7!: Uint8Array; - _7 = rt.i128ToBeBytes(rt.i128Cast(v)); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(rt.i128Cast(v))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { let v3!: rt.i64; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.i128ToBeBytes(rt.i128Cast(v3)); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(rt.i128Cast(v3))); } }; buf = rt.bytes(8); @@ -1358,11 +1280,9 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i64WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _123 = rt.u32ToBeBytes(rt.i64LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _123); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingOnes(a))); } else if (_52 === 19) { - _127 = rt.u32ToBeBytes(rt.i64LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.i64Max(a, b); _50(out, part2); @@ -1405,25 +1325,19 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.i128) => void; let _51!: (a0: rt.ByteVec, a1: rt.i128 | undefined) => void; let _52!: rt.u8; - let _123!: Uint8Array; - let _127!: Uint8Array; let x!: rt.i128; _50 = (out2: rt.ByteVec, v: rt.i128): void => { - let _7!: Uint8Array; - _7 = rt.i128ToBeBytes(v); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v)); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { let v3!: rt.i128; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.i128ToBeBytes(v3); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3)); } }; buf = rt.bytes(16); @@ -1499,11 +1413,9 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i128WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _123 = rt.u32ToBeBytes(rt.i128LeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _123); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingOnes(a))); } else if (_52 === 19) { - _127 = rt.u32ToBeBytes(rt.i128LeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.i128Max(a, b); _50(out, part2); @@ -1546,25 +1458,19 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _50!: (a0: rt.ByteVec, a1: rt.isize) => void; let _51!: (a0: rt.ByteVec, a1: rt.isize | undefined) => void; let _52!: rt.u8; - let _123!: Uint8Array; - let _127!: Uint8Array; let x!: rt.isize; _50 = (out2: rt.ByteVec, v: rt.isize): void => { - let _7!: Uint8Array; - _7 = rt.i128ToBeBytes(v as rt.i128); - rt.byteVecExtendFromSlice(out2, _7); + rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); }; _51 = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { let v3!: rt.isize; - let _106!: Uint8Array; if (v2 === undefined) { rt.byteVecPush(out3, 0); } else { v3 = v2; rt.byteVecPush(out3, 1); - _106 = rt.i128ToBeBytes(v3 as rt.i128); - rt.byteVecExtendFromSlice(out3, _106); + rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); } }; buf = rt.bytes(4); @@ -1640,11 +1546,9 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.isizeWrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - _123 = rt.u32ToBeBytes(rt.isizeLeadingOnes(a)); - rt.byteVecExtendFromSlice(out, _123); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingOnes(a))); } else if (_52 === 19) { - _127 = rt.u32ToBeBytes(rt.isizeLeadingZeros(a)); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingZeros(a))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -1675,13 +1579,11 @@ export function i8Neg(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.i8; let buf!: Uint8Array; let n!: rt.usize; - let _24!: Uint8Array; buf = Uint8Array.of(0); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); a = ([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]; - _24 = rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128); - rt.byteVecExtendFromSlice(out, _24); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128)); } /** Negate, which overflows at the minimum. */ @@ -1689,13 +1591,11 @@ export function i16Neg(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.i16; let buf!: Uint8Array; let n!: rt.usize; - let _24!: Uint8Array; buf = rt.bytes(2); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); a = ([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]; - _24 = rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128); - rt.byteVecExtendFromSlice(out, _24); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128)); } /** Negate, which overflows at the minimum. */ @@ -1703,13 +1603,11 @@ export function i32Neg(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.i32; let buf!: Uint8Array; let n!: rt.usize; - let _24!: Uint8Array; buf = rt.bytes(4); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); a = ([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]; - _24 = rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128); - rt.byteVecExtendFromSlice(out, _24); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128)); } /** Negate, which overflows at the minimum. */ @@ -1717,13 +1615,11 @@ export function i64Neg(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.i64; let buf!: Uint8Array; let n!: rt.usize; - let _24!: Uint8Array; buf = rt.bytes(8); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); a = ([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0]; - _24 = rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a))); - rt.byteVecExtendFromSlice(out, _24); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a)))); } /** Negate, which overflows at the minimum. */ @@ -1731,13 +1627,11 @@ export function i128Neg(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.i128; let buf!: Uint8Array; let n!: rt.usize; - let _24!: Uint8Array; buf = rt.bytes(16); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); a = ([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]; - _24 = rt.i128ToBeBytes(rt.i128Neg(a)); - rt.byteVecExtendFromSlice(out, _24); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(a))); } /** Negate, which overflows at the minimum. */ @@ -1745,13 +1639,11 @@ export function isizeNeg(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.isize; let buf!: Uint8Array; let n!: rt.usize; - let _24!: Uint8Array; buf = rt.bytes(4); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); a = ([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]; - _24 = rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128); - rt.byteVecExtendFromSlice(out, _24); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128)); } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ @@ -1762,480 +1654,336 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): let n!: rt.usize; let _25!: rt.u8; let v2!: rt.u8; - let _31!: Uint8Array; let _35!: string; let v3!: rt.u16; - let _41!: Uint8Array; let _45!: string; let v4!: rt.u32; - let _51!: Uint8Array; let _55!: string; let v5!: rt.u64; - let _61!: Uint8Array; let _65!: string; let v6!: rt.u128; - let _71!: Uint8Array; let _75!: string; let v7!: rt.usize; - let _81!: Uint8Array; let _85!: string; let v8!: rt.i8; - let _91!: Uint8Array; let _95!: string; let v9!: rt.i16; - let _101!: Uint8Array; let _105!: string; let v10!: rt.i32; - let _111!: Uint8Array; let _115!: string; let v11!: rt.i64; - let _121!: Uint8Array; let _125!: string; let v12!: rt.i128; - let _131!: Uint8Array; let _135!: string; let v13!: rt.isize; - let _141!: Uint8Array; let _145!: string; let v14!: rt.u16; let buf2!: Uint8Array; let n2!: rt.usize; let _165!: rt.u8; let v15!: rt.u8; - let _171!: Uint8Array; let _175!: string; let v16!: rt.u16; - let _181!: Uint8Array; let _185!: string; let v17!: rt.u32; - let _191!: Uint8Array; let _195!: string; let v18!: rt.u64; - let _201!: Uint8Array; let _205!: string; let v19!: rt.u128; - let _211!: Uint8Array; let _215!: string; let v20!: rt.usize; - let _221!: Uint8Array; let _225!: string; let v21!: rt.i8; - let _231!: Uint8Array; let _235!: string; let v22!: rt.i16; - let _241!: Uint8Array; let _245!: string; let v23!: rt.i32; - let _251!: Uint8Array; let _255!: string; let v24!: rt.i64; - let _261!: Uint8Array; let _265!: string; let v25!: rt.i128; - let _271!: Uint8Array; let _275!: string; let v26!: rt.isize; - let _281!: Uint8Array; let _285!: string; let v27!: rt.u32; let buf3!: Uint8Array; let n3!: rt.usize; let _305!: rt.u8; let v28!: rt.u8; - let _311!: Uint8Array; let _315!: string; let v29!: rt.u16; - let _321!: Uint8Array; let _325!: string; let v30!: rt.u32; - let _331!: Uint8Array; let _335!: string; let v31!: rt.u64; - let _341!: Uint8Array; let _345!: string; let v32!: rt.u128; - let _351!: Uint8Array; let _355!: string; let v33!: rt.usize; - let _361!: Uint8Array; let _365!: string; let v34!: rt.i8; - let _371!: Uint8Array; let _375!: string; let v35!: rt.i16; - let _381!: Uint8Array; let _385!: string; let v36!: rt.i32; - let _391!: Uint8Array; let _395!: string; let v37!: rt.i64; - let _401!: Uint8Array; let _405!: string; let v38!: rt.i128; - let _411!: Uint8Array; let _415!: string; let v39!: rt.isize; - let _421!: Uint8Array; let _425!: string; let v40!: rt.u64; let buf4!: Uint8Array; let n4!: rt.usize; let _445!: rt.u8; let v41!: rt.u8; - let _451!: Uint8Array; let _455!: string; let v42!: rt.u16; - let _461!: Uint8Array; let _465!: string; let v43!: rt.u32; - let _471!: Uint8Array; let _475!: string; let v44!: rt.u64; - let _481!: Uint8Array; let _485!: string; let v45!: rt.u128; - let _491!: Uint8Array; let _495!: string; let v46!: rt.usize; - let _501!: Uint8Array; let _505!: string; let v47!: rt.i8; - let _511!: Uint8Array; let _515!: string; let v48!: rt.i16; - let _521!: Uint8Array; let _525!: string; let v49!: rt.i32; - let _531!: Uint8Array; let _535!: string; let v50!: rt.i64; - let _541!: Uint8Array; let _545!: string; let v51!: rt.i128; - let _551!: Uint8Array; let _555!: string; let v52!: rt.isize; - let _561!: Uint8Array; let _565!: string; let v53!: rt.u128; let buf5!: Uint8Array; let n5!: rt.usize; let _585!: rt.u8; let v54!: rt.u8; - let _591!: Uint8Array; let _595!: string; let v55!: rt.u16; - let _601!: Uint8Array; let _605!: string; let v56!: rt.u32; - let _611!: Uint8Array; let _615!: string; let v57!: rt.u64; - let _621!: Uint8Array; let _625!: string; let v58!: rt.u128; - let _631!: Uint8Array; let _635!: string; let v59!: rt.usize; - let _641!: Uint8Array; let _645!: string; let v60!: rt.i8; - let _651!: Uint8Array; let _655!: string; let v61!: rt.i16; - let _661!: Uint8Array; let _665!: string; let v62!: rt.i32; - let _671!: Uint8Array; let _675!: string; let v63!: rt.i64; - let _681!: Uint8Array; let _685!: string; let v64!: rt.i128; - let _691!: Uint8Array; let _695!: string; let v65!: rt.isize; - let _701!: Uint8Array; let _705!: string; let v66!: rt.usize; let buf6!: Uint8Array; let n6!: rt.usize; let _725!: rt.u8; let v67!: rt.u8; - let _731!: Uint8Array; let _735!: string; let v68!: rt.u16; - let _741!: Uint8Array; let _745!: string; let v69!: rt.u32; - let _751!: Uint8Array; let _755!: string; let v70!: rt.u64; - let _761!: Uint8Array; let _765!: string; let v71!: rt.u128; - let _771!: Uint8Array; let _775!: string; let v72!: rt.usize; - let _781!: Uint8Array; let _785!: string; let v73!: rt.i8; - let _791!: Uint8Array; let _795!: string; let v74!: rt.i16; - let _801!: Uint8Array; let _805!: string; let v75!: rt.i32; - let _811!: Uint8Array; let _815!: string; let v76!: rt.i64; - let _821!: Uint8Array; let _825!: string; let v77!: rt.i128; - let _831!: Uint8Array; let _835!: string; let v78!: rt.isize; - let _841!: Uint8Array; let _845!: string; let v79!: rt.i8; let buf7!: Uint8Array; let n7!: rt.usize; let _865!: rt.u8; let v80!: rt.u8; - let _871!: Uint8Array; let _875!: string; let v81!: rt.u16; - let _881!: Uint8Array; let _885!: string; let v82!: rt.u32; - let _891!: Uint8Array; let _895!: string; let v83!: rt.u64; - let _901!: Uint8Array; let _905!: string; let v84!: rt.u128; - let _911!: Uint8Array; let _915!: string; let v85!: rt.usize; - let _921!: Uint8Array; let _925!: string; let v86!: rt.i8; - let _931!: Uint8Array; let _935!: string; let v87!: rt.i16; - let _941!: Uint8Array; let _945!: string; let v88!: rt.i32; - let _951!: Uint8Array; let _955!: string; let v89!: rt.i64; - let _961!: Uint8Array; let _965!: string; let v90!: rt.i128; - let _971!: Uint8Array; let _975!: string; let v91!: rt.isize; - let _981!: Uint8Array; let _985!: string; let v92!: rt.i16; let buf8!: Uint8Array; let n8!: rt.usize; let _1005!: rt.u8; let v93!: rt.u8; - let _1011!: Uint8Array; let _1015!: string; let v94!: rt.u16; - let _1021!: Uint8Array; let _1025!: string; let v95!: rt.u32; - let _1031!: Uint8Array; let _1035!: string; let v96!: rt.u64; - let _1041!: Uint8Array; let _1045!: string; let v97!: rt.u128; - let _1051!: Uint8Array; let _1055!: string; let v98!: rt.usize; - let _1061!: Uint8Array; let _1065!: string; let v99!: rt.i8; - let _1071!: Uint8Array; let _1075!: string; let v100!: rt.i16; - let _1081!: Uint8Array; let _1085!: string; let v101!: rt.i32; - let _1091!: Uint8Array; let _1095!: string; let v102!: rt.i64; - let _1101!: Uint8Array; let _1105!: string; let v103!: rt.i128; - let _1111!: Uint8Array; let _1115!: string; let v104!: rt.isize; - let _1121!: Uint8Array; let _1125!: string; let v105!: rt.i32; let buf9!: Uint8Array; let n9!: rt.usize; let _1145!: rt.u8; let v106!: rt.u8; - let _1151!: Uint8Array; let _1155!: string; let v107!: rt.u16; - let _1161!: Uint8Array; let _1165!: string; let v108!: rt.u32; - let _1171!: Uint8Array; let _1175!: string; let v109!: rt.u64; - let _1181!: Uint8Array; let _1185!: string; let v110!: rt.u128; - let _1191!: Uint8Array; let _1195!: string; let v111!: rt.usize; - let _1201!: Uint8Array; let _1205!: string; let v112!: rt.i8; - let _1211!: Uint8Array; let _1215!: string; let v113!: rt.i16; - let _1221!: Uint8Array; let _1225!: string; let v114!: rt.i32; - let _1231!: Uint8Array; let _1235!: string; let v115!: rt.i64; - let _1241!: Uint8Array; let _1245!: string; let v116!: rt.i128; - let _1251!: Uint8Array; let _1255!: string; let v117!: rt.isize; - let _1261!: Uint8Array; let _1265!: string; let v118!: rt.i64; let buf10!: Uint8Array; let n10!: rt.usize; let _1285!: rt.u8; let v119!: rt.u8; - let _1291!: Uint8Array; let _1295!: string; let v120!: rt.u16; - let _1301!: Uint8Array; let _1305!: string; let v121!: rt.u32; - let _1311!: Uint8Array; let _1315!: string; let v122!: rt.u64; - let _1321!: Uint8Array; let _1325!: string; let v123!: rt.u128; - let _1331!: Uint8Array; let _1335!: string; let v124!: rt.usize; - let _1341!: Uint8Array; let _1345!: string; let v125!: rt.i8; - let _1351!: Uint8Array; let _1355!: string; let v126!: rt.i16; - let _1361!: Uint8Array; let _1365!: string; let v127!: rt.i32; - let _1371!: Uint8Array; let _1375!: string; let v128!: rt.i64; - let _1381!: Uint8Array; let _1385!: string; let v129!: rt.i128; - let _1391!: Uint8Array; let _1395!: string; let v130!: rt.isize; - let _1401!: Uint8Array; let _1405!: string; let v131!: rt.i128; let buf11!: Uint8Array; let n11!: rt.usize; let _1425!: rt.u8; let v132!: rt.u8; - let _1431!: Uint8Array; let _1435!: string; let v133!: rt.u16; - let _1441!: Uint8Array; let _1445!: string; let v134!: rt.u32; - let _1451!: Uint8Array; let _1455!: string; let v135!: rt.u64; - let _1461!: Uint8Array; let _1465!: string; let v136!: rt.u128; - let _1471!: Uint8Array; let _1475!: string; let v137!: rt.usize; - let _1481!: Uint8Array; let _1485!: string; let v138!: rt.i8; - let _1491!: Uint8Array; let _1495!: string; let v139!: rt.i16; - let _1501!: Uint8Array; let _1505!: string; let v140!: rt.i32; - let _1511!: Uint8Array; let _1515!: string; let v141!: rt.i64; - let _1521!: Uint8Array; let _1525!: string; let v142!: rt.i128; - let _1531!: Uint8Array; let _1535!: string; let v143!: rt.isize; - let _1541!: Uint8Array; let _1545!: string; let v144!: rt.isize; let buf12!: Uint8Array; let n12!: rt.usize; let _1565!: rt.u8; let v145!: rt.u8; - let _1571!: Uint8Array; let _1575!: string; let v146!: rt.u16; - let _1581!: Uint8Array; let _1585!: string; let v147!: rt.u32; - let _1591!: Uint8Array; let _1595!: string; let v148!: rt.u64; - let _1601!: Uint8Array; let _1605!: string; let v149!: rt.u128; - let _1611!: Uint8Array; let _1615!: string; let v150!: rt.usize; - let _1621!: Uint8Array; let _1625!: string; let v151!: rt.i8; - let _1631!: Uint8Array; let _1635!: string; let v152!: rt.i16; - let _1641!: Uint8Array; let _1645!: string; let v153!: rt.i32; - let _1651!: Uint8Array; let _1655!: string; let v154!: rt.i64; - let _1661!: Uint8Array; let _1665!: string; let v155!: rt.i128; - let _1671!: Uint8Array; let _1675!: string; let v156!: rt.isize; - let _1681!: Uint8Array; let _1685!: string; _5 = rt.u8Rem(from, 12); if (_5 === 0) { @@ -2246,74 +1994,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _25 = rt.u8Rem(to, 12); if (_25 === 0) { v2 = v; - _31 = rt.u8ToBeBytes(v2); - rt.byteVecExtendFromSlice(out, _31); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v2)); _35 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_35)); } else if (_25 === 1) { v3 = v as rt.u16; - _41 = rt.u16ToBeBytes(v3); - rt.byteVecExtendFromSlice(out, _41); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v3)); _45 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_45)); } else if (_25 === 2) { v4 = v as rt.u32; - _51 = rt.u32ToBeBytes(v4); - rt.byteVecExtendFromSlice(out, _51); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v4)); _55 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_55)); } else if (_25 === 3) { v5 = v as rt.u64; - _61 = rt.u64ToBeBytes(v5); - rt.byteVecExtendFromSlice(out, _61); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v5)); _65 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_65)); } else if (_25 === 4) { v6 = v as rt.u128; - _71 = rt.u128ToBeBytes(v6); - rt.byteVecExtendFromSlice(out, _71); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v6)); _75 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_75)); } else if (_25 === 5) { v7 = v as rt.usize; - _81 = rt.usizeToBeBytes(v7); - rt.byteVecExtendFromSlice(out, _81); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v7)); _85 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_85)); } else if (_25 === 6) { v8 = (v << 24) >> 24; - _91 = rt.i8ToBeBytes(v8); - rt.byteVecExtendFromSlice(out, _91); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v8)); _95 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_95)); } else if (_25 === 7) { v9 = v as rt.i16; - _101 = rt.i16ToBeBytes(v9); - rt.byteVecExtendFromSlice(out, _101); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v9)); _105 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_105)); } else if (_25 === 8) { v10 = v as rt.i32; - _111 = rt.i32ToBeBytes(v10); - rt.byteVecExtendFromSlice(out, _111); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v10)); _115 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_115)); } else if (_25 === 9) { v11 = v as rt.i64; - _121 = rt.i64ToBeBytes(v11); - rt.byteVecExtendFromSlice(out, _121); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v11)); _125 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_125)); } else if (_25 === 10) { v12 = v as rt.i128; - _131 = rt.i128ToBeBytes(v12); - rt.byteVecExtendFromSlice(out, _131); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v12)); _135 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_135)); } else { v13 = v as rt.isize; - _141 = rt.isizeToBeBytes(v13); - rt.byteVecExtendFromSlice(out, _141); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v13)); _145 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_145)); } @@ -2325,74 +2061,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _165 = rt.u8Rem(to, 12); if (_165 === 0) { v15 = v14 & 0xff; - _171 = rt.u8ToBeBytes(v15); - rt.byteVecExtendFromSlice(out, _171); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v15)); _175 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_175)); } else if (_165 === 1) { v16 = v14; - _181 = rt.u16ToBeBytes(v16); - rt.byteVecExtendFromSlice(out, _181); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v16)); _185 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_185)); } else if (_165 === 2) { v17 = v14 as rt.u32; - _191 = rt.u32ToBeBytes(v17); - rt.byteVecExtendFromSlice(out, _191); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v17)); _195 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_195)); } else if (_165 === 3) { v18 = v14 as rt.u64; - _201 = rt.u64ToBeBytes(v18); - rt.byteVecExtendFromSlice(out, _201); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v18)); _205 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_205)); } else if (_165 === 4) { v19 = v14 as rt.u128; - _211 = rt.u128ToBeBytes(v19); - rt.byteVecExtendFromSlice(out, _211); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v19)); _215 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_215)); } else if (_165 === 5) { v20 = v14 as rt.usize; - _221 = rt.usizeToBeBytes(v20); - rt.byteVecExtendFromSlice(out, _221); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v20)); _225 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_225)); } else if (_165 === 6) { v21 = (v14 << 24) >> 24; - _231 = rt.i8ToBeBytes(v21); - rt.byteVecExtendFromSlice(out, _231); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v21)); _235 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_235)); } else if (_165 === 7) { v22 = (v14 << 16) >> 16; - _241 = rt.i16ToBeBytes(v22); - rt.byteVecExtendFromSlice(out, _241); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v22)); _245 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_245)); } else if (_165 === 8) { v23 = v14 as rt.i32; - _251 = rt.i32ToBeBytes(v23); - rt.byteVecExtendFromSlice(out, _251); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v23)); _255 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_255)); } else if (_165 === 9) { v24 = v14 as rt.i64; - _261 = rt.i64ToBeBytes(v24); - rt.byteVecExtendFromSlice(out, _261); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v24)); _265 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_265)); } else if (_165 === 10) { v25 = v14 as rt.i128; - _271 = rt.i128ToBeBytes(v25); - rt.byteVecExtendFromSlice(out, _271); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v25)); _275 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_275)); } else { v26 = v14 as rt.isize; - _281 = rt.isizeToBeBytes(v26); - rt.byteVecExtendFromSlice(out, _281); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v26)); _285 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_285)); } @@ -2404,74 +2128,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _305 = rt.u8Rem(to, 12); if (_305 === 0) { v28 = v27 & 0xff; - _311 = rt.u8ToBeBytes(v28); - rt.byteVecExtendFromSlice(out, _311); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v28)); _315 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_315)); } else if (_305 === 1) { v29 = v27 & 0xffff; - _321 = rt.u16ToBeBytes(v29); - rt.byteVecExtendFromSlice(out, _321); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v29)); _325 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_325)); } else if (_305 === 2) { v30 = v27; - _331 = rt.u32ToBeBytes(v30); - rt.byteVecExtendFromSlice(out, _331); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v30)); _335 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_335)); } else if (_305 === 3) { v31 = v27 as rt.u64; - _341 = rt.u64ToBeBytes(v31); - rt.byteVecExtendFromSlice(out, _341); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v31)); _345 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_345)); } else if (_305 === 4) { v32 = v27 as rt.u128; - _351 = rt.u128ToBeBytes(v32); - rt.byteVecExtendFromSlice(out, _351); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v32)); _355 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_355)); } else if (_305 === 5) { v33 = v27 as rt.usize; - _361 = rt.usizeToBeBytes(v33); - rt.byteVecExtendFromSlice(out, _361); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v33)); _365 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_365)); } else if (_305 === 6) { v34 = (v27 << 24) >> 24; - _371 = rt.i8ToBeBytes(v34); - rt.byteVecExtendFromSlice(out, _371); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v34)); _375 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_375)); } else if (_305 === 7) { v35 = (v27 << 16) >> 16; - _381 = rt.i16ToBeBytes(v35); - rt.byteVecExtendFromSlice(out, _381); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v35)); _385 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_385)); } else if (_305 === 8) { v36 = v27 | 0; - _391 = rt.i32ToBeBytes(v36); - rt.byteVecExtendFromSlice(out, _391); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v36)); _395 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_395)); } else if (_305 === 9) { v37 = v27 as rt.i64; - _401 = rt.i64ToBeBytes(v37); - rt.byteVecExtendFromSlice(out, _401); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v37)); _405 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_405)); } else if (_305 === 10) { v38 = v27 as rt.i128; - _411 = rt.i128ToBeBytes(v38); - rt.byteVecExtendFromSlice(out, _411); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v38)); _415 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_415)); } else { v39 = v27 | 0; - _421 = rt.isizeToBeBytes(v39); - rt.byteVecExtendFromSlice(out, _421); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v39)); _425 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_425)); } @@ -2483,74 +2195,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _445 = rt.u8Rem(to, 12); if (_445 === 0) { v41 = rt.u64Low(v40) & 0xff; - _451 = rt.u8ToBeBytes(v41); - rt.byteVecExtendFromSlice(out, _451); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v41)); _455 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_455)); } else if (_445 === 1) { v42 = rt.u64Low(v40) & 0xffff; - _461 = rt.u16ToBeBytes(v42); - rt.byteVecExtendFromSlice(out, _461); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v42)); _465 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_465)); } else if (_445 === 2) { v43 = rt.u64Low(v40); - _471 = rt.u32ToBeBytes(v43); - rt.byteVecExtendFromSlice(out, _471); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v43)); _475 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_475)); } else if (_445 === 3) { v44 = v40; - _481 = rt.u64ToBeBytes(v44); - rt.byteVecExtendFromSlice(out, _481); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v44)); _485 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_485)); } else if (_445 === 4) { v45 = rt.u128Cast(v40); - _491 = rt.u128ToBeBytes(v45); - rt.byteVecExtendFromSlice(out, _491); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v45)); _495 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_495)); } else if (_445 === 5) { v46 = rt.u64Low(v40); - _501 = rt.usizeToBeBytes(v46); - rt.byteVecExtendFromSlice(out, _501); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v46)); _505 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_505)); } else if (_445 === 6) { v47 = (rt.u64Low(v40) << 24) >> 24; - _511 = rt.i8ToBeBytes(v47); - rt.byteVecExtendFromSlice(out, _511); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v47)); _515 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_515)); } else if (_445 === 7) { v48 = (rt.u64Low(v40) << 16) >> 16; - _521 = rt.i16ToBeBytes(v48); - rt.byteVecExtendFromSlice(out, _521); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v48)); _525 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_525)); } else if (_445 === 8) { v49 = rt.u64Low(v40) | 0; - _531 = rt.i32ToBeBytes(v49); - rt.byteVecExtendFromSlice(out, _531); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v49)); _535 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_535)); } else if (_445 === 9) { v50 = rt.i64Cast(v40); - _541 = rt.i64ToBeBytes(v50); - rt.byteVecExtendFromSlice(out, _541); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v50)); _545 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_545)); } else if (_445 === 10) { v51 = rt.i128Cast(v40); - _551 = rt.i128ToBeBytes(v51); - rt.byteVecExtendFromSlice(out, _551); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v51)); _555 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_555)); } else { v52 = rt.u64Low(v40) | 0; - _561 = rt.isizeToBeBytes(v52); - rt.byteVecExtendFromSlice(out, _561); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v52)); _565 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_565)); } @@ -2562,74 +2262,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _585 = rt.u8Rem(to, 12); if (_585 === 0) { v54 = rt.u128Low(v53) & 0xff; - _591 = rt.u8ToBeBytes(v54); - rt.byteVecExtendFromSlice(out, _591); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v54)); _595 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_595)); } else if (_585 === 1) { v55 = rt.u128Low(v53) & 0xffff; - _601 = rt.u16ToBeBytes(v55); - rt.byteVecExtendFromSlice(out, _601); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v55)); _605 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_605)); } else if (_585 === 2) { v56 = rt.u128Low(v53); - _611 = rt.u32ToBeBytes(v56); - rt.byteVecExtendFromSlice(out, _611); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v56)); _615 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_615)); } else if (_585 === 3) { v57 = rt.u64Cast(v53); - _621 = rt.u64ToBeBytes(v57); - rt.byteVecExtendFromSlice(out, _621); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v57)); _625 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_625)); } else if (_585 === 4) { v58 = v53; - _631 = rt.u128ToBeBytes(v58); - rt.byteVecExtendFromSlice(out, _631); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v58)); _635 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_635)); } else if (_585 === 5) { v59 = rt.u128Low(v53); - _641 = rt.usizeToBeBytes(v59); - rt.byteVecExtendFromSlice(out, _641); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v59)); _645 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_645)); } else if (_585 === 6) { v60 = (rt.u128Low(v53) << 24) >> 24; - _651 = rt.i8ToBeBytes(v60); - rt.byteVecExtendFromSlice(out, _651); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v60)); _655 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_655)); } else if (_585 === 7) { v61 = (rt.u128Low(v53) << 16) >> 16; - _661 = rt.i16ToBeBytes(v61); - rt.byteVecExtendFromSlice(out, _661); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v61)); _665 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_665)); } else if (_585 === 8) { v62 = rt.u128Low(v53) | 0; - _671 = rt.i32ToBeBytes(v62); - rt.byteVecExtendFromSlice(out, _671); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v62)); _675 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_675)); } else if (_585 === 9) { v63 = rt.i64Cast(v53); - _681 = rt.i64ToBeBytes(v63); - rt.byteVecExtendFromSlice(out, _681); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v63)); _685 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_685)); } else if (_585 === 10) { v64 = rt.i128Cast(v53); - _691 = rt.i128ToBeBytes(v64); - rt.byteVecExtendFromSlice(out, _691); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v64)); _695 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_695)); } else { v65 = rt.u128Low(v53) | 0; - _701 = rt.isizeToBeBytes(v65); - rt.byteVecExtendFromSlice(out, _701); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v65)); _705 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_705)); } @@ -2641,74 +2329,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _725 = rt.u8Rem(to, 12); if (_725 === 0) { v67 = v66 & 0xff; - _731 = rt.u8ToBeBytes(v67); - rt.byteVecExtendFromSlice(out, _731); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v67)); _735 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_735)); } else if (_725 === 1) { v68 = v66 & 0xffff; - _741 = rt.u16ToBeBytes(v68); - rt.byteVecExtendFromSlice(out, _741); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v68)); _745 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_745)); } else if (_725 === 2) { v69 = v66 as rt.u32; - _751 = rt.u32ToBeBytes(v69); - rt.byteVecExtendFromSlice(out, _751); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v69)); _755 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_755)); } else if (_725 === 3) { v70 = v66 as rt.u64; - _761 = rt.u64ToBeBytes(v70); - rt.byteVecExtendFromSlice(out, _761); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v70)); _765 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_765)); } else if (_725 === 4) { v71 = v66 as rt.u128; - _771 = rt.u128ToBeBytes(v71); - rt.byteVecExtendFromSlice(out, _771); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v71)); _775 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_775)); } else if (_725 === 5) { v72 = v66; - _781 = rt.usizeToBeBytes(v72); - rt.byteVecExtendFromSlice(out, _781); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v72)); _785 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_785)); } else if (_725 === 6) { v73 = (v66 << 24) >> 24; - _791 = rt.i8ToBeBytes(v73); - rt.byteVecExtendFromSlice(out, _791); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v73)); _795 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_795)); } else if (_725 === 7) { v74 = (v66 << 16) >> 16; - _801 = rt.i16ToBeBytes(v74); - rt.byteVecExtendFromSlice(out, _801); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v74)); _805 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_805)); } else if (_725 === 8) { v75 = v66 | 0; - _811 = rt.i32ToBeBytes(v75); - rt.byteVecExtendFromSlice(out, _811); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v75)); _815 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_815)); } else if (_725 === 9) { v76 = v66 as rt.i64; - _821 = rt.i64ToBeBytes(v76); - rt.byteVecExtendFromSlice(out, _821); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v76)); _825 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_825)); } else if (_725 === 10) { v77 = v66 as rt.i128; - _831 = rt.i128ToBeBytes(v77); - rt.byteVecExtendFromSlice(out, _831); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v77)); _835 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_835)); } else { v78 = v66 | 0; - _841 = rt.isizeToBeBytes(v78); - rt.byteVecExtendFromSlice(out, _841); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v78)); _845 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_845)); } @@ -2720,74 +2396,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _865 = rt.u8Rem(to, 12); if (_865 === 0) { v80 = v79 & 0xff; - _871 = rt.u8ToBeBytes(v80); - rt.byteVecExtendFromSlice(out, _871); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v80)); _875 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_875)); } else if (_865 === 1) { v81 = v79 & 0xffff; - _881 = rt.u16ToBeBytes(v81); - rt.byteVecExtendFromSlice(out, _881); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v81)); _885 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_885)); } else if (_865 === 2) { v82 = v79 >>> 0; - _891 = rt.u32ToBeBytes(v82); - rt.byteVecExtendFromSlice(out, _891); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v82)); _895 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_895)); } else if (_865 === 3) { v83 = rt.u64Cast(v79); - _901 = rt.u64ToBeBytes(v83); - rt.byteVecExtendFromSlice(out, _901); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v83)); _905 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_905)); } else if (_865 === 4) { v84 = rt.u128Cast(v79); - _911 = rt.u128ToBeBytes(v84); - rt.byteVecExtendFromSlice(out, _911); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v84)); _915 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_915)); } else if (_865 === 5) { v85 = v79 >>> 0; - _921 = rt.usizeToBeBytes(v85); - rt.byteVecExtendFromSlice(out, _921); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v85)); _925 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_925)); } else if (_865 === 6) { v86 = v79; - _931 = rt.i8ToBeBytes(v86); - rt.byteVecExtendFromSlice(out, _931); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v86)); _935 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_935)); } else if (_865 === 7) { v87 = v79 as rt.i16; - _941 = rt.i16ToBeBytes(v87); - rt.byteVecExtendFromSlice(out, _941); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v87)); _945 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_945)); } else if (_865 === 8) { v88 = v79 as rt.i32; - _951 = rt.i32ToBeBytes(v88); - rt.byteVecExtendFromSlice(out, _951); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v88)); _955 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_955)); } else if (_865 === 9) { v89 = v79 as rt.i64; - _961 = rt.i64ToBeBytes(v89); - rt.byteVecExtendFromSlice(out, _961); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v89)); _965 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_965)); } else if (_865 === 10) { v90 = v79 as rt.i128; - _971 = rt.i128ToBeBytes(v90); - rt.byteVecExtendFromSlice(out, _971); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v90)); _975 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_975)); } else { v91 = v79 as rt.isize; - _981 = rt.isizeToBeBytes(v91); - rt.byteVecExtendFromSlice(out, _981); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v91)); _985 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_985)); } @@ -2799,74 +2463,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _1005 = rt.u8Rem(to, 12); if (_1005 === 0) { v93 = v92 & 0xff; - _1011 = rt.u8ToBeBytes(v93); - rt.byteVecExtendFromSlice(out, _1011); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v93)); _1015 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1015)); } else if (_1005 === 1) { v94 = v92 & 0xffff; - _1021 = rt.u16ToBeBytes(v94); - rt.byteVecExtendFromSlice(out, _1021); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v94)); _1025 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1025)); } else if (_1005 === 2) { v95 = v92 >>> 0; - _1031 = rt.u32ToBeBytes(v95); - rt.byteVecExtendFromSlice(out, _1031); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v95)); _1035 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1035)); } else if (_1005 === 3) { v96 = rt.u64Cast(v92); - _1041 = rt.u64ToBeBytes(v96); - rt.byteVecExtendFromSlice(out, _1041); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v96)); _1045 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1045)); } else if (_1005 === 4) { v97 = rt.u128Cast(v92); - _1051 = rt.u128ToBeBytes(v97); - rt.byteVecExtendFromSlice(out, _1051); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v97)); _1055 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1055)); } else if (_1005 === 5) { v98 = v92 >>> 0; - _1061 = rt.usizeToBeBytes(v98); - rt.byteVecExtendFromSlice(out, _1061); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v98)); _1065 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1065)); } else if (_1005 === 6) { v99 = (v92 << 24) >> 24; - _1071 = rt.i8ToBeBytes(v99); - rt.byteVecExtendFromSlice(out, _1071); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v99)); _1075 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1075)); } else if (_1005 === 7) { v100 = v92; - _1081 = rt.i16ToBeBytes(v100); - rt.byteVecExtendFromSlice(out, _1081); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v100)); _1085 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1085)); } else if (_1005 === 8) { v101 = v92 as rt.i32; - _1091 = rt.i32ToBeBytes(v101); - rt.byteVecExtendFromSlice(out, _1091); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v101)); _1095 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1095)); } else if (_1005 === 9) { v102 = v92 as rt.i64; - _1101 = rt.i64ToBeBytes(v102); - rt.byteVecExtendFromSlice(out, _1101); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v102)); _1105 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1105)); } else if (_1005 === 10) { v103 = v92 as rt.i128; - _1111 = rt.i128ToBeBytes(v103); - rt.byteVecExtendFromSlice(out, _1111); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v103)); _1115 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1115)); } else { v104 = v92 as rt.isize; - _1121 = rt.isizeToBeBytes(v104); - rt.byteVecExtendFromSlice(out, _1121); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v104)); _1125 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1125)); } @@ -2878,74 +2530,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _1145 = rt.u8Rem(to, 12); if (_1145 === 0) { v106 = v105 & 0xff; - _1151 = rt.u8ToBeBytes(v106); - rt.byteVecExtendFromSlice(out, _1151); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v106)); _1155 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1155)); } else if (_1145 === 1) { v107 = v105 & 0xffff; - _1161 = rt.u16ToBeBytes(v107); - rt.byteVecExtendFromSlice(out, _1161); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v107)); _1165 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1165)); } else if (_1145 === 2) { v108 = v105 >>> 0; - _1171 = rt.u32ToBeBytes(v108); - rt.byteVecExtendFromSlice(out, _1171); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v108)); _1175 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1175)); } else if (_1145 === 3) { v109 = rt.u64Cast(v105); - _1181 = rt.u64ToBeBytes(v109); - rt.byteVecExtendFromSlice(out, _1181); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v109)); _1185 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1185)); } else if (_1145 === 4) { v110 = rt.u128Cast(v105); - _1191 = rt.u128ToBeBytes(v110); - rt.byteVecExtendFromSlice(out, _1191); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v110)); _1195 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1195)); } else if (_1145 === 5) { v111 = v105 >>> 0; - _1201 = rt.usizeToBeBytes(v111); - rt.byteVecExtendFromSlice(out, _1201); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v111)); _1205 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1205)); } else if (_1145 === 6) { v112 = (v105 << 24) >> 24; - _1211 = rt.i8ToBeBytes(v112); - rt.byteVecExtendFromSlice(out, _1211); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v112)); _1215 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1215)); } else if (_1145 === 7) { v113 = (v105 << 16) >> 16; - _1221 = rt.i16ToBeBytes(v113); - rt.byteVecExtendFromSlice(out, _1221); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v113)); _1225 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1225)); } else if (_1145 === 8) { v114 = v105; - _1231 = rt.i32ToBeBytes(v114); - rt.byteVecExtendFromSlice(out, _1231); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v114)); _1235 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1235)); } else if (_1145 === 9) { v115 = v105 as rt.i64; - _1241 = rt.i64ToBeBytes(v115); - rt.byteVecExtendFromSlice(out, _1241); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v115)); _1245 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1245)); } else if (_1145 === 10) { v116 = v105 as rt.i128; - _1251 = rt.i128ToBeBytes(v116); - rt.byteVecExtendFromSlice(out, _1251); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v116)); _1255 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1255)); } else { v117 = v105 as rt.isize; - _1261 = rt.isizeToBeBytes(v117); - rt.byteVecExtendFromSlice(out, _1261); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v117)); _1265 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1265)); } @@ -2957,74 +2597,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _1285 = rt.u8Rem(to, 12); if (_1285 === 0) { v119 = rt.i64Low(v118) & 0xff; - _1291 = rt.u8ToBeBytes(v119); - rt.byteVecExtendFromSlice(out, _1291); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v119)); _1295 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1295)); } else if (_1285 === 1) { v120 = rt.i64Low(v118) & 0xffff; - _1301 = rt.u16ToBeBytes(v120); - rt.byteVecExtendFromSlice(out, _1301); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v120)); _1305 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1305)); } else if (_1285 === 2) { v121 = rt.i64Low(v118); - _1311 = rt.u32ToBeBytes(v121); - rt.byteVecExtendFromSlice(out, _1311); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v121)); _1315 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1315)); } else if (_1285 === 3) { v122 = rt.u64Cast(v118); - _1321 = rt.u64ToBeBytes(v122); - rt.byteVecExtendFromSlice(out, _1321); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v122)); _1325 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1325)); } else if (_1285 === 4) { v123 = rt.u128Cast(v118); - _1331 = rt.u128ToBeBytes(v123); - rt.byteVecExtendFromSlice(out, _1331); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v123)); _1335 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1335)); } else if (_1285 === 5) { v124 = rt.i64Low(v118); - _1341 = rt.usizeToBeBytes(v124); - rt.byteVecExtendFromSlice(out, _1341); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v124)); _1345 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1345)); } else if (_1285 === 6) { v125 = (rt.i64Low(v118) << 24) >> 24; - _1351 = rt.i8ToBeBytes(v125); - rt.byteVecExtendFromSlice(out, _1351); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v125)); _1355 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1355)); } else if (_1285 === 7) { v126 = (rt.i64Low(v118) << 16) >> 16; - _1361 = rt.i16ToBeBytes(v126); - rt.byteVecExtendFromSlice(out, _1361); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v126)); _1365 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1365)); } else if (_1285 === 8) { v127 = rt.i64Low(v118) | 0; - _1371 = rt.i32ToBeBytes(v127); - rt.byteVecExtendFromSlice(out, _1371); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v127)); _1375 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1375)); } else if (_1285 === 9) { v128 = v118; - _1381 = rt.i64ToBeBytes(v128); - rt.byteVecExtendFromSlice(out, _1381); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v128)); _1385 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1385)); } else if (_1285 === 10) { v129 = rt.i128Cast(v118); - _1391 = rt.i128ToBeBytes(v129); - rt.byteVecExtendFromSlice(out, _1391); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v129)); _1395 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1395)); } else { v130 = rt.i64Low(v118) | 0; - _1401 = rt.isizeToBeBytes(v130); - rt.byteVecExtendFromSlice(out, _1401); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v130)); _1405 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1405)); } @@ -3036,74 +2664,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _1425 = rt.u8Rem(to, 12); if (_1425 === 0) { v132 = rt.i128Low(v131) & 0xff; - _1431 = rt.u8ToBeBytes(v132); - rt.byteVecExtendFromSlice(out, _1431); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v132)); _1435 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1435)); } else if (_1425 === 1) { v133 = rt.i128Low(v131) & 0xffff; - _1441 = rt.u16ToBeBytes(v133); - rt.byteVecExtendFromSlice(out, _1441); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v133)); _1445 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1445)); } else if (_1425 === 2) { v134 = rt.i128Low(v131); - _1451 = rt.u32ToBeBytes(v134); - rt.byteVecExtendFromSlice(out, _1451); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v134)); _1455 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1455)); } else if (_1425 === 3) { v135 = rt.u64Cast(v131); - _1461 = rt.u64ToBeBytes(v135); - rt.byteVecExtendFromSlice(out, _1461); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v135)); _1465 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1465)); } else if (_1425 === 4) { v136 = rt.u128Cast(v131); - _1471 = rt.u128ToBeBytes(v136); - rt.byteVecExtendFromSlice(out, _1471); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v136)); _1475 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1475)); } else if (_1425 === 5) { v137 = rt.i128Low(v131); - _1481 = rt.usizeToBeBytes(v137); - rt.byteVecExtendFromSlice(out, _1481); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v137)); _1485 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1485)); } else if (_1425 === 6) { v138 = (rt.i128Low(v131) << 24) >> 24; - _1491 = rt.i8ToBeBytes(v138); - rt.byteVecExtendFromSlice(out, _1491); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v138)); _1495 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1495)); } else if (_1425 === 7) { v139 = (rt.i128Low(v131) << 16) >> 16; - _1501 = rt.i16ToBeBytes(v139); - rt.byteVecExtendFromSlice(out, _1501); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v139)); _1505 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1505)); } else if (_1425 === 8) { v140 = rt.i128Low(v131) | 0; - _1511 = rt.i32ToBeBytes(v140); - rt.byteVecExtendFromSlice(out, _1511); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v140)); _1515 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1515)); } else if (_1425 === 9) { v141 = rt.i64Cast(v131); - _1521 = rt.i64ToBeBytes(v141); - rt.byteVecExtendFromSlice(out, _1521); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v141)); _1525 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1525)); } else if (_1425 === 10) { v142 = v131; - _1531 = rt.i128ToBeBytes(v142); - rt.byteVecExtendFromSlice(out, _1531); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v142)); _1535 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1535)); } else { v143 = rt.i128Low(v131) | 0; - _1541 = rt.isizeToBeBytes(v143); - rt.byteVecExtendFromSlice(out, _1541); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v143)); _1545 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1545)); } @@ -3115,74 +2731,62 @@ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): _1565 = rt.u8Rem(to, 12); if (_1565 === 0) { v145 = v144 & 0xff; - _1571 = rt.u8ToBeBytes(v145); - rt.byteVecExtendFromSlice(out, _1571); + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v145)); _1575 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1575)); } else if (_1565 === 1) { v146 = v144 & 0xffff; - _1581 = rt.u16ToBeBytes(v146); - rt.byteVecExtendFromSlice(out, _1581); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v146)); _1585 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1585)); } else if (_1565 === 2) { v147 = v144 >>> 0; - _1591 = rt.u32ToBeBytes(v147); - rt.byteVecExtendFromSlice(out, _1591); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v147)); _1595 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1595)); } else if (_1565 === 3) { v148 = rt.u64Cast(v144); - _1601 = rt.u64ToBeBytes(v148); - rt.byteVecExtendFromSlice(out, _1601); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v148)); _1605 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1605)); } else if (_1565 === 4) { v149 = rt.u128Cast(v144); - _1611 = rt.u128ToBeBytes(v149); - rt.byteVecExtendFromSlice(out, _1611); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v149)); _1615 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1615)); } else if (_1565 === 5) { v150 = v144 >>> 0; - _1621 = rt.usizeToBeBytes(v150); - rt.byteVecExtendFromSlice(out, _1621); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v150)); _1625 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1625)); } else if (_1565 === 6) { v151 = (v144 << 24) >> 24; - _1631 = rt.i8ToBeBytes(v151); - rt.byteVecExtendFromSlice(out, _1631); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v151)); _1635 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1635)); } else if (_1565 === 7) { v152 = (v144 << 16) >> 16; - _1641 = rt.i16ToBeBytes(v152); - rt.byteVecExtendFromSlice(out, _1641); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v152)); _1645 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1645)); } else if (_1565 === 8) { v153 = v144 as rt.i32; - _1651 = rt.i32ToBeBytes(v153); - rt.byteVecExtendFromSlice(out, _1651); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v153)); _1655 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1655)); } else if (_1565 === 9) { v154 = v144 as rt.i64; - _1661 = rt.i64ToBeBytes(v154); - rt.byteVecExtendFromSlice(out, _1661); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v154)); _1665 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1665)); } else if (_1565 === 10) { v155 = v144 as rt.i128; - _1671 = rt.i128ToBeBytes(v155); - rt.byteVecExtendFromSlice(out, _1671); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v155)); _1675 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1675)); } else { v156 = v144; - _1681 = rt.isizeToBeBytes(v156); - rt.byteVecExtendFromSlice(out, _1681); + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v156)); _1685 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1685)); } @@ -3200,32 +2804,16 @@ export function convert(data: Uint8Array, out: rt.ByteVec): void { let n2!: rt.usize; let _31!: Uint8Array; let _36!: rt.i32; - let _44!: rt.Result; let _46!: rt.Result; - let _51!: Uint8Array; let _53!: rt.Result; - let _58!: Uint8Array; let _60!: rt.Result; - let _65!: Uint8Array; let widened!: rt.u64; let into!: rt.i64; - let _72!: Uint8Array; - let _76!: Uint8Array; let a!: rt.u8; let b!: rt.u8; let c!: rt.u8; let d!: rt.u8; let _86!: Uint8Array; - let _91!: Uint8Array; - let _97!: Uint8Array; - let _103!: Uint8Array; - let _109!: Uint8Array; - let _115!: Uint8Array; - let _122!: Uint8Array; - let _128!: Uint8Array; - let _134!: Uint8Array; - let _138!: Uint8Array; - let _142!: Uint8Array; buf = rt.bytes(8); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); @@ -3239,60 +2827,44 @@ export function convert(data: Uint8Array, out: rt.ByteVec): void { _36 = rt.i32FromBeBytes(buf2); const slice2 = rt.sliceRange(data, n); signed = ([_36, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array])[0]; - _44 = rt.u8TryFrom(wide); - rt.byteVecPush(out, _44.ok ? 1 : 0); + rt.byteVecPush(out, rt.u8TryFrom(wide).ok ? 1 : 0); _46 = rt.u32TryFrom(wide); if (_46.ok) { - _51 = rt.u32ToBeBytes(_46.value); - rt.byteVecExtendFromSlice(out, _51); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_46.value)); } else { rt.byteVecPush(out, 255); } _53 = rt.usizeTryFrom(signed); if (_53.ok) { - _58 = rt.usizeToBeBytes(_53.value); - rt.byteVecExtendFromSlice(out, _58); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(_53.value)); } else { rt.byteVecPush(out, 254); } _60 = rt.i8TryFrom(signed); if (_60.ok) { - _65 = rt.i8ToBeBytes(_60.value); - rt.byteVecExtendFromSlice(out, _65); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(_60.value)); } else { rt.byteVecPush(out, 253); } widened = (rt.u64Low(wide) & 0xffff) as rt.u64; into = signed as rt.i64; - _72 = rt.u64ToBeBytes(widened); - rt.byteVecExtendFromSlice(out, _72); - _76 = rt.i64ToBeBytes(into); - rt.byteVecExtendFromSlice(out, _76); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(widened)); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(into)); rt.byteVecPush(out, rt.u8Add(true ? 1 : 0, false ? 1 : 0)); _86 = rt.u32ToBeBytes(signed >>> 0); a = _86[0]; b = _86[1]; c = _86[2]; d = _86[3]; - _91 = rt.i8ToBeBytes((a << 24) >> 24); - rt.byteVecExtendFromSlice(out, _91); - _97 = rt.u16ToBeBytes((a << 8) | b); - rt.byteVecExtendFromSlice(out, _97); - _103 = rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16); - rt.byteVecExtendFromSlice(out, _103); - _109 = rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0); - rt.byteVecExtendFromSlice(out, _109); - _115 = rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d); - rt.byteVecExtendFromSlice(out, _115); - _122 = rt.i32ToBeBytes((a << 24) | (c << 8) | d); - rt.byteVecExtendFromSlice(out, _122); - _128 = rt.u32ToBeBytes(0); - rt.byteVecExtendFromSlice(out, _128); - _134 = rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d))); - rt.byteVecExtendFromSlice(out, _134); - _138 = Uint8Array.of(d, c, b, a); - _142 = rt.i32ToBeBytes(rt.i32FromBeBytes(_138)); - rt.byteVecExtendFromSlice(out, _142); + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes((a << 24) >> 24)); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes((a << 8) | b)); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d)); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes((a << 24) | (c << 8) | d)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(0)); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d)))); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(rt.i32FromBeBytes(Uint8Array.of(d, c, b, a)))); } //# sourceMappingURL=ints.ts.map diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 4411189fc..97f98afdd 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -17,7 +17,6 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let doubled!: rt.ByteVec; let iter!: { s: rt.u16[]; i: number }; let _18!: rt.u16 | rt.Done; - let _25!: Uint8Array; let iter2!: rt.Iter<[rt.usize, rt.u8]>; let _32!: [rt.usize, rt.u8] | rt.Done; let i!: rt.usize; @@ -36,7 +35,6 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _118!: rt.u8 | rt.Done; let b2!: rt.u8; let run!: rt.u8; - let _125!: rt.u8 | undefined; let _133!: rt.u8 | undefined; let it2!: rt.Iter; let firsts!: rt.ByteVec; @@ -68,8 +66,7 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_18 === rt.DONE) { break b0; } else { - _25 = rt.u16ToBeBytes(_18); - rt.byteVecExtendFromSlice(out, _25); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_18)); } } } else if (_4 === 1) { @@ -133,10 +130,9 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { b2 = _118; run = 1; while (true) { - _125 = rt.peekableNextIf(it, (_210: rt.u8): boolean => { + if (!((rt.peekableNextIf(it, (_210: rt.u8): boolean => { return _210 === b2; - }); - if (!((_125 !== undefined))) { + }) !== undefined))) { rt.byteVecPush(out, b2); rt.byteVecPush(out, run); _133 = rt.peekablePeek(it); @@ -256,9 +252,6 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void let it!: rt.Iter; let _147!: rt.Iter; let _162!: rt.Iter; - let _178!: Uint8Array; - let _184!: Uint8Array; - let _198!: Uint8Array; let parsed!: rt.Result; let v!: rt.ByteVec; log = new rt.ByteVec(); @@ -366,27 +359,24 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_162, 2), 187)); rt.byteVecPush(out, it.len() & 0xff); } else if (_5 === 3) { - _178 = rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { return rt.u64Mul(_214 as rt.u64, 1103823438081); - }), rt.u64Add, 0)); - rt.byteVecExtendFromSlice(out, _178); - _184 = rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { + }), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { let b8!: rt.u8; let _510!: rt.u32; b8 = _34; _510 = (acc << 3) >>> 0; return rt.u32WrappingAdd(_510, (b8 as rt.u32 ^ acc) >>> 0); - })); - rt.byteVecExtendFromSlice(out, _184); + }))); rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); }); } else if (_5 === 4) { rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); - _198 = rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); - }), rt.u16Mul, 1)); - rt.byteVecExtendFromSlice(out, _198); + }), rt.u16Mul, 1))); } else { parsed = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { let b3!: rt.u8; @@ -447,22 +437,15 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { let _146!: rt.usize; let stepped!: rt.RangeInclusive; let wide!: rt.Range; - let _196!: Uint8Array; let edge!: rt.u64; let past!: rt.Range; - let _213!: Uint8Array; let _217!: rt.usize; - let _223!: Uint8Array; - let _230!: Uint8Array; let _234!: rt.RangeInclusive; let _237!: rt.usize; let _244!: rt.u64; - let _251!: Uint8Array; - let _261!: Uint8Array; let _265!: rt.i64; let _267!: rt.i64; let _274!: rt.i64; - let _282!: Uint8Array; let iter3!: { s: rt.u32[]; i: number }; let _289!: rt.u32 | rt.Done; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); @@ -531,33 +514,26 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { return _23 === 0; })) & 0xff); rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); - _196 = rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0)); - rt.byteVecExtendFromSlice(out, _196); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0))); edge = rt.u64Add(rt.u64Sub(rt.u64Of(9007199254740992n), 2), rt.u64Rem(a as rt.u64, 4)); past = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); _217 = rt.usizeRem(b as rt.usize, 3); - _213 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _217), 0)); - rt.byteVecExtendFromSlice(out, _213); - _223 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0)); - rt.byteVecExtendFromSlice(out, _223); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _217), 0))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); _234 = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); _237 = rt.usizeRem(b as rt.usize, 5); - _230 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_234, _237), 0)); - rt.byteVecExtendFromSlice(out, _230); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_234, _237), 0))); _244 = rt.u64Rem(a as rt.u64, 3); - _251 = rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _244), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _244), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { return rt.u64Rem(n4, 7); - }), rt.u64Add, 0)); - rt.byteVecExtendFromSlice(out, _251); - _261 = rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { + }), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { return _24; - }), 0)); - rt.byteVecExtendFromSlice(out, _261); + }), 0))); _267 = rt.i64Of(9007199254740992n); _265 = rt.i64Sub(rt.i64Neg(_267), 1); _274 = rt.i64Of(9007199254740992n); - _282 = rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(_265, rt.i64Add(rt.i64Neg(_274), 1), rt.i64Step)), 0)); - rt.byteVecExtendFromSlice(out, _282); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(_265, rt.i64Add(rt.i64Neg(_274), 1), rt.i64Step)), 0))); iter3 = { s: rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))), i: 0 }; while (true) { _289 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; @@ -588,8 +564,7 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): let _7!: rt.u8; let whole!: rt.Range; let _14!: rt.Range; - let _19!: Uint8Array; - let iter!: rt.Range; + let iter!: { start: rt.u8; end: rt.u8 }; let _29!: rt.u8; let i!: rt.u8; let _33!: rt.u8; @@ -600,7 +575,6 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): let all!: rt.Range; let copied!: rt.ByteVec; let _76!: Uint8Array; - let _29Some!: boolean; base = new rt.Range(a, b); rt.byteVecPush(out, 208); _7 = rt.u8Div(b, 2); @@ -608,15 +582,10 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): made = new rt.Range(rt.rangeClone(base).start, _7); _14 = rt.rangeClone(base); whole = new rt.Range(_14.start, _14.end); - _19 = Uint8Array.of(made.start, _7, whole.start, whole.end); - rt.byteVecExtendFromSlice(out, _19); - iter = new rt.Range(rt.u8Div(a, 2), base.end); + rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, _7, whole.start, whole.end)); + iter = { start: rt.u8Div(a, 2), end: base.end }; while (true) { - _29Some = iter.start < iter.end; - if (_29Some) { - _29 = iter.start++; - } - if (!_29Some) { + if (!((_29 = iter.start++) < iter.end)) { rt.byteVecPush(out, base.end); len = data.length; _41 = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)] as [rt.usize, rt.usize]; @@ -767,24 +736,21 @@ export function own(data: Uint8Array, out: rt.ByteVec): void { let step!: rt.u8; let iter!: Countdown.Countdown; let _13!: rt.u8 | rt.Done; - let _24!: Uint8Array; let down!: Countdown.Countdown; let _26!: rt.u8 | rt.Done; let evens!: rt.ByteVec; let byRef!: Evens.Evens; let firsts!: rt.ByteVec; let halves!: rt.ByteVec; - let _73!: Uint8Array; left = rt.optionUnwrapOr(rt.sliceFirst(data), 0); step = rt.max(rt.optionUnwrapOr(rt.sliceGet(data, 1), 1), 1); iter = { left, step }; while (true) { _13 = Countdown.next$Iterator(iter); if (_13 === rt.DONE) { - _24 = rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); - }), rt.u64Add, 0)); - rt.byteVecExtendFromSlice(out, _24); + }), rt.u64Add, 0))); down = { left, step }; l1: while (true) { _26 = Countdown.next$Iterator(down); @@ -802,8 +768,7 @@ export function own(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); halves = rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))); rt.byteVecExtendFromSlice(out, rt.byteVecView(halves)); - _73 = rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0)); - rt.byteVecExtendFromSlice(out, _73); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0))); return; } } else { @@ -835,8 +800,8 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { let iter2!: rt.Iter; let _21!: rt.u8 | rt.Done; let printed!: string; - let _31!: Doubled.Doubled; - let _33!: Doubled.Doubled; + let args2!: rt.Fmt[]; + let _39!: rt.Fmt; let tags!: Tag.Tag[]; let cloned!: Tag.Tag[]; let iter3!: rt.Iter; @@ -855,16 +820,17 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { while (true) { _21 = iter2.next(); if (_21 === rt.DONE) { - _31 = { _0: data }; - _33 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; - printed = rt.fmtFormat([(f: rt.Formatter) => Doubled.fmt$Debug(_31, f), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Doubled.fmt$Debug(_33, f))]); + [{ _0: data }, { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }] as [Doubled.Doubled, Doubled.Doubled]; + const arg = { _0: data }; + _39 = (f: rt.Formatter) => Doubled.fmt$Debug(arg, f); + const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; + args2 = [_39, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f)]; + printed = rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1])]); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(printed)); tags = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tag.Tag => { let b3!: rt.u8; - let _7!: Uint8Array; b3 = _2; - _7 = Uint8Array.of(b3, ~b3 & 0xff); - return { bytes: rt.sliceToByteVec(_7) }; + return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; })); cloned = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); iter3 = rt.iterSlice(cloned); diff --git a/ts/fixtures/lang/expected/shapes.Meters.ts b/ts/fixtures/lang/expected/shapes.Meters.ts index d9f462d03..343a34b72 100644 --- a/ts/fixtures/lang/expected/shapes.Meters.ts +++ b/ts/fixtures/lang/expected/shapes.Meters.ts @@ -13,10 +13,8 @@ export function area$Area(self: Meters): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area(self: Meters, out: rt.ByteVec): void { - let _7!: Uint8Array; rt.byteVecPush(out, 170); - _7 = rt.u64ToBeBytes(self._0); - rt.byteVecExtendFromSlice(out, _7); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(self._0)); } //# sourceMappingURL=shapes.Meters.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Moved.ts b/ts/fixtures/lang/expected/shapes.Moved.ts index 9c8b36d11..4f4c7216d 100644 --- a/ts/fixtures/lang/expected/shapes.Moved.ts +++ b/ts/fixtures/lang/expected/shapes.Moved.ts @@ -6,11 +6,9 @@ export function fmt$Debug(self: Moved, f: rt.Formatter): rt.Result rt.u8Display(self._0, f); - _8 = self._1; _3 = "Moved"; - _6 = (f: rt.Formatter) => rt.u16Display(_8, f); + _4 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _6 = (f: rt.Formatter) => rt.u16Display(self._1, f); return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); } diff --git a/ts/fixtures/lang/expected/shapes.Point.ts b/ts/fixtures/lang/expected/shapes.Point.ts index 009abeddc..795b24283 100644 --- a/ts/fixtures/lang/expected/shapes.Point.ts +++ b/ts/fixtures/lang/expected/shapes.Point.ts @@ -8,13 +8,11 @@ export function fmt$Debug(self: Point, f: rt.Formatter): rt.Result rt.i32Display(self.x, f); - _10 = self.y; _3 = "Point"; _4 = "x"; + _5 = (f: rt.Formatter) => rt.i32Display(self.x, f); _7 = "y"; - _8 = (f: rt.Formatter) => rt.i32Display(_10, f); + _8 = (f: rt.Formatter) => rt.i32Display(self.y, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } diff --git a/ts/fixtures/lang/expected/shapes.Shape.ts b/ts/fixtures/lang/expected/shapes.Shape.ts index cba94386b..eb4cafb82 100644 --- a/ts/fixtures/lang/expected/shapes.Shape.ts +++ b/ts/fixtures/lang/expected/shapes.Shape.ts @@ -4,11 +4,9 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug(self: Shape, f: rt.Formatter): rt.Result { - let __self1!: Point.Point; let _7!: string; let _8!: rt.Fmt; let _9!: rt.Fmt; - let __self2!: rt.u16; let _14!: string; let _15!: string; let _16!: rt.Fmt; @@ -19,20 +17,18 @@ export function fmt$Debug(self: Shape, f: rt.Formatter): rt.Result Point.fmt$Debug(self._0, f); - _9 = (f: rt.Formatter) => Point.fmt$Debug(__self1, f); + _9 = (f: rt.Formatter) => Point.fmt$Debug(self._1, f); return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8), _9)); } else { - __self2 = self.height; _14 = "Rect"; _15 = "corner"; _16 = (f: rt.Formatter) => Point.fmt$Debug(self.corner, f); _17 = "width"; _18 = (f: rt.Formatter) => rt.u16Display(self.width, f); _19 = "height"; - _20 = (f: rt.Formatter) => rt.u16Display(__self2, f); + _20 = (f: rt.Formatter) => rt.u16Display(self.height, f); return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); } } @@ -45,10 +41,8 @@ export type Shape = /** A default method, monomorphized for each type. */ export function describe$Area(self: Shape, out: rt.ByteVec): void { - let _7!: Uint8Array; rt.byteVecPush(out, 4); - _7 = rt.u64ToBeBytes(area$Area(self)); - rt.byteVecExtendFromSlice(out, _7); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area(self))); } export function area$Area(self: Shape): rt.u64 { diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 7c4dc005c..dcc873c62 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -116,39 +116,32 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { let _39!: rt.usize; let iter!: rt.Iter; let _42!: rt.i32 | rt.Done; - let _49!: Uint8Array; let a!: Point.Point; let b!: Point.Point; let old!: Point.Point; let _66!: Point.Point; - let _70!: Uint8Array; let _71!: rt.u8; let _73!: rt.u8; let n!: rt.u32; let both!: [rt.u32, rt.u32]; - let _85!: Uint8Array; let word!: Uint8Array; let converted!: rt.u32; let _98!: rt.usize; - let _103!: Uint8Array; let _107!: rt.usize; let cell!: Uint8Array; let source!: Uint8Array; let returned!: Uint8Array; let _122!: rt.usize; - let _127!: Uint8Array; let _128!: rt.u8; let _129!: rt.usize; let _132!: rt.usize; let marked!: boolean; let opt!: Meters.Meters | undefined; let taken!: Meters.Meters | undefined; - let _155!: Uint8Array; let res!: rt.Result; let first!: Point.Point; let fail!: rt.Result; let err!: Point.Point; - let _165!: Uint8Array; p = Point.new(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.i32, 7); q = rt.copy(p); _9 = rt.i32Add(q.x, 100); @@ -215,13 +208,11 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { old = old2; _71 = a.x & 0xff; _73 = b.x & 0xff; - _70 = Uint8Array.of(_71, _73, old.x & 0xff); - rt.byteVecExtendFromSlice(out, _70); + rt.byteVecExtendFromSlice(out, Uint8Array.of(_71, _73, old.x & 0xff)); n = data.length as rt.u32; both = [n, n] as [rt.u32, rt.u32]; n = 9; - _85 = rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n)); - rt.byteVecExtendFromSlice(out, _85); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); word = Uint8Array.of(0, 0, 0, data.length & 0xff); converted = rt.u32FromBeBytes(word); _98 = 0; @@ -233,8 +224,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { if (!(_107 < 4)) { rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _107); } - _103 = rt.u32ToBeBytes(rt.u32Add(converted, word[_107] as rt.u32)); - rt.byteVecExtendFromSlice(out, _103); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[_107] as rt.u32))); cell = Uint8Array.of(data.length & 0xff); rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); source = Uint8Array.of(data.length & 0xff); @@ -253,8 +243,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { if (!(_132 < 1)) { rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _132); } - _127 = Uint8Array.of(_128, source[_132]); - rt.byteVecExtendFromSlice(out, _127); + rt.byteVecExtendFromSlice(out, Uint8Array.of(_128, source[_132])); rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); marked = mark(out, 1) === 0; mark(out, 2); @@ -264,22 +253,19 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { opt = undefined; taken = taken2; rt.byteVecPush(out, opt === undefined ? 1 : 0); - _155 = rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { return m._0; - })); - rt.byteVecExtendFromSlice(out, _155); + }))); res = rt.Ok(p); first = rt.copy(rt.resultUnwrap(res, rt.u8Display)); first.x = 2; fail = rt.Err(rt.copy(q)); err = rt.copy(rt.resultUnwrapErr(fail, rt.u8Display)); err.y = 3; - _165 = Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff); - rt.byteVecExtendFromSlice(out, _165); + rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff)); return; } else { - _49 = rt.i32ToBeBytes(_42); - rt.byteVecExtendFromSlice(out, _49); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(_42)); } } } @@ -353,15 +339,17 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { let sum!: rt.usize; let _70!: rt.usize; let _71!: rt.usize; - let iter!: rt.Range; + let iter!: { start: rt.usize; end: rt.usize }; let _75!: rt.usize; let len!: rt.usize; - let slice!: Uint8Array; + let _82!: Uint8Array; let _83!: Uint8Array; let _85!: rt.usize; let _87!: rt.usize; let text!: string; - let _75Some!: boolean; + let _102!: Shape.Shape; + let _103!: rt.usize; + let args2!: rt.Fmt[]; at = (i2: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i2), 0); }; @@ -400,19 +388,18 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { sum = 0; _70 = mark(out, 12); _71 = rt.usizeSub(mark(out, 13), 4); - iter = new rt.Range(_71, _70); + iter = { start: _71, end: _70 }; while (true) { - _75Some = iter.start < iter.end; - if (_75Some) { - _75 = iter.start++; - } - if (!_75Some) { + if (!((_75 = iter.start++) < iter.end)) { len = data.length; _83 = logged(data, out); _85 = rt.min(mark(out, 14), len); _87 = rt.usizeDiv(rt.min(mark(out, 15), len), 2); - slice = rt.sliceRange(_83, _87, _85); - text = rt.fmtFormat([(f: rt.Formatter) => Shape.fmt$Debug(rect, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(line, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(pair, f), " ", (f: rt.Formatter) => Point.fmt$Debug(read, f), " ", (f: rt.Formatter) => Moved.fmt$Debug(updated, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(taken, f), " ", (f: rt.Formatter) => rt.usizeDisplay(_64, f), " ", (f: rt.Formatter) => rt.usizeDisplay(_63, f), " ", (f: rt.Formatter) => rt.usizeDisplay(sum, f), " ", (f: rt.Formatter) => rt.fmtList(slice, f, rt.u8Display)]); + _82 = rt.sliceRange(_83, _87, _85); + _102 = taken; + _103 = sum; + args2 = [(f: rt.Formatter) => Shape.fmt$Debug(rect, f), (f: rt.Formatter) => Shape.fmt$Debug(line, f), (f: rt.Formatter) => Pair.fmt$Debug(pair, f), (f: rt.Formatter) => Point.fmt$Debug(read, f), (f: rt.Formatter) => Moved.fmt$Debug(updated, f), (f: rt.Formatter) => Shape.fmt$Debug(_102, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(_82, f, rt.u8Display)]; + text = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); indexed(data, out); return; @@ -446,7 +433,6 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { let slots!: Uint8Array; let _58!: rt.u8; let _59!: rt.usize; - let _67!: Uint8Array; let _68!: rt.u8; let _71!: rt.usize; at = (i: rt.usize): rt.u8 => { @@ -493,17 +479,14 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { if (!(_71 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _71); } - _67 = Uint8Array.of(first, second, called, _68, slots[_71], n); - rt.byteVecExtendFromSlice(out, _67); + rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, _68, slots[_71], n)); rt.byteVecExtendFromSlice(out, bytes); } /** A vector of `b`, logging that it was made. */ export function listed(out: rt.ByteVec, b: rt.u8): rt.ByteVec { - let _6!: Uint8Array; rt.byteVecPush(out, 224); - _6 = Uint8Array.of(b, b ^ 1); - return rt.sliceToByteVec(_6); + return rt.sliceToByteVec(Uint8Array.of(b, b ^ 1)); } /** `s`, logging that it was read. */ @@ -564,12 +547,6 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { let _10!: rt.u8; let signed!: Signed.Signed; let _13!: rt.u8; - let _27!: Uint8Array; - let _34!: Uint8Array; - let _45!: Uint8Array; - let _52!: Uint8Array; - let _59!: Uint8Array; - let _66!: Uint8Array; iter = { s: data, i: 0 }; while (true) { _5 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; @@ -595,19 +572,13 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, { Low: 1, High: 300, Top: 65535 }[wide] & 0xff); rt.byteVecPush(out, (({ Low: 1, High: 300, Top: 65535 }[wide] << 24) >> 24) & 0xff); - _27 = rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16); - rt.byteVecExtendFromSlice(out, _27); - _34 = rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64); - rt.byteVecExtendFromSlice(out, _34); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16)); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64)); rt.byteVecPush(out, { Neg: -1, Min: -128, Pos: 100 }[signed] & 0xff); - _45 = rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff); - rt.byteVecExtendFromSlice(out, _45); - _52 = rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0); - rt.byteVecExtendFromSlice(out, _52); - _59 = rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64); - rt.byteVecExtendFromSlice(out, _59); - _66 = rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, _66); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0)); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64)); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed]))); } } } @@ -621,12 +592,11 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let popped!: rt.u32; let _5!: rt.u8 | undefined; let top!: rt.u8; - let _17!: Uint8Array; let found!: [rt.usize, rt.usize] | undefined; - let iter!: rt.Range; + let iter!: { start: rt.usize; end: rt.usize }; let _24!: rt.usize; let i!: rt.usize; - let iter2!: rt.Range; + let iter2!: { start: rt.usize; end: rt.usize }; let _34!: rt.usize; let j!: rt.usize; let _39!: rt.u8; @@ -635,7 +605,6 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let _49!: rt.usize; let i2!: rt.usize; let j2!: rt.usize; - let _57!: Uint8Array; let n!: rt.u64; let steps!: rt.u8; let _65!: rt.u64; @@ -648,19 +617,11 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let r!: rt.Range; let first!: rt.i32 | undefined; let second!: rt.i32 | undefined; - let _114!: Uint8Array; - let _120!: Uint8Array; - let iter4!: rt.Range; + let iter4!: { start: rt.i32; end: rt.i32 }; let _124!: rt.i32; - let iter5!: rt.Range; + let iter5!: { start: rt.i8; end: rt.i8 }; let _136!: rt.i8; - let _147!: Uint8Array; - let _154!: Uint8Array; let _158!: (a0: rt.u8) => rt.u8; - let _124Some!: boolean; - let _136Some!: boolean; - let _24Some!: boolean; - let _34Some!: boolean; _158 = (x3: rt.u8): rt.u8 => { while (true) { if (!(x3 < 10)) { @@ -685,25 +646,16 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { continue l0; } } - _17 = rt.u32ToBeBytes(popped); - rt.byteVecExtendFromSlice(out, _17); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); found = undefined; - iter = new rt.Range(0, data.length); + iter = { start: 0, end: data.length }; l2: while (true) { - _24Some = iter.start < iter.end; - if (_24Some) { - _24 = iter.start++; - } b3: { - if (_24Some) { + if ((_24 = iter.start++) < iter.end) { i = _24; - iter2 = new rt.Range(rt.usizeAdd(i, 1), data.length); + iter2 = { start: rt.usizeAdd(i, 1), end: data.length }; while (true) { - _34Some = iter2.start < iter2.end; - if (_34Some) { - _34 = iter2.start++; - } - if (!_34Some) { + if (!((_34 = iter2.start++) < iter2.end)) { continue l2; } else { j = _34; @@ -737,8 +689,7 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { } else { i2 = found[0]; j2 = found[1]; - _57 = Uint8Array.of(i2 & 0xff, j2 & 0xff); - rt.byteVecExtendFromSlice(out, _57); + rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); } n = data.length as rt.u64; l6: while (true) { @@ -774,35 +725,22 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { r.end = r.start; second = r.start < r.end ? r.start++ : undefined; if (first !== undefined) { - _114 = rt.i32ToBeBytes(first); - rt.byteVecExtendFromSlice(out, _114); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(first)); } if (second !== undefined) { - _120 = rt.i32ToBeBytes(second); - rt.byteVecExtendFromSlice(out, _120); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(second)); } - iter4 = new rt.Range(lo, 2); + iter4 = { start: lo, end: 2 }; while (true) { - _124Some = iter4.start < iter4.end; - if (_124Some) { - _124 = iter4.start++; - } - if (!_124Some) { - iter5 = new rt.Range(rt.i8Sub(124, (lo << 24) >> 24), 127); + if (!((_124 = iter4.start++) < iter4.end)) { + iter5 = { start: rt.i8Sub(124, (lo << 24) >> 24), end: 127 }; while (true) { - _136Some = iter5.start < iter5.end; - if (_136Some) { - _136 = iter5.start++; - } - if (!_136Some) { + if (!((_136 = iter5.start++) < iter5.end)) { rt.byteVecPush(out, firstRepeat(data)); - _147 = rt.u16ToBeBytes(tailBreak(data)); - rt.byteVecExtendFromSlice(out, _147); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); rt.byteVecPush(out, armLoop(data)); - _154 = rt.u32ToBeBytes(position$u8(data, 0) as rt.u32); - rt.byteVecExtendFromSlice(out, _154); - const part = rt.u8Mul(data.length & 0xff, 7); - rt.byteVecPush(out, _158(part)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); + rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); drain(data, out); rt.byteVecPush(out, returnedLoop(data)); branchLoops(data, out); @@ -839,11 +777,13 @@ export function diverging(data: Uint8Array, out: rt.ByteVec): void { let b!: rt.u8; let _15!: (a0: rt.u8) => rt.u8; _15 = (b2: rt.u8): rt.u8 => { + let args2!: rt.Fmt[]; if (!(b2 === 253)) { return rt.u8Div(b2, 3); } else { const arg = ([b2] as [rt.u8])[0]; - rt.panicFmt(["closure ", (f: rt.Formatter) => rt.u8Display(arg, f)]); + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["closure ", args2[0]]); } }; head = rt.sliceRange(data, 0, rt.min(data.length, 2)); @@ -867,8 +807,10 @@ export function closureNever(b: rt.u8): rt.u8 { let ptr!: (a0: rt.u8) => never; let _4!: (a0: rt.u8) => never; _2 = (b2: rt.u8): never => { + let args2!: rt.Fmt[]; const arg = ([b2] as [rt.u8])[0]; - rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(arg, f))]); + args2 = [(f: rt.Formatter) => rt.u8LowerHex(arg, f)]; + rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, args2[0])]); }; _4 = madeNever(); ptr = bail; @@ -893,8 +835,10 @@ export function closureNever(b: rt.u8): rt.u8 { /** A closure that never returns, made by a function. */ export function madeNever(): (a0: rt.u8) => never { return (b: rt.u8): never => { + let args2!: rt.Fmt[]; const arg = ([b] as [rt.u8])[0]; - rt.panicFmt(["made ", (f: rt.Formatter) => rt.u8Display(arg, f)]); + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["made ", args2[0]]); }; } @@ -903,19 +847,23 @@ export function madeNever(): (a0: rt.u8) => never { * never exists: given one, and given an `Option` of none, which then calls one. */ export function genericNever(b: rt.u8, len: rt.usize): void { + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; if (!(b === 241)) { if (!(b === 246)) { if (b === 249) { if (!(len > 1)) { const arg2 = ([b] as [rt.u8])[0]; - rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); + args4 = [(f: rt.Formatter) => rt.u8Display(arg2, f)]; + rt.panicFmt(["some ", args4[0]]); } else { unwrapOrBail$never(undefined, b); } } } else { const arg = ([b] as [rt.u8])[0]; - rt.panicFmt(["passed ", (f: rt.Formatter) => rt.u8Display(arg, f)]); + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["passed ", args2[0]]); } } else { bail(b); @@ -937,21 +885,27 @@ export function unwrapOrBail$never(o: never | undefined, b: rt.u8): never { /** A function that never returns. */ export function bail(b: rt.u8): never { + let args2!: rt.Fmt[]; const arg = ([b] as [rt.u8])[0]; - rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(arg, f))]); + args2 = [(f: rt.Formatter) => rt.u8LowerHex(arg, f)]; + rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, args2[0])]); } /** `return`, and `break` out of the function's labeled block, with values that never exist. */ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; if (b === 247) { const arg2 = ([b] as [rt.u8])[0]; - rt.panicFmt(["returned ", (f: rt.Formatter) => rt.u8Display(arg2, f)]); + args2 = [(f: rt.Formatter) => rt.u8Display(arg2, f)]; + rt.panicFmt(["returned ", args2[0]]); } else if (b === 248) { if (!(rt.usizeRem(len, 2) === 0)) { bail(b); } else { const arg = ([b] as [rt.u8])[0]; - rt.panicFmt(["then ", (f: rt.Formatter) => rt.u8Display(arg, f)]); + args4 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["then ", args4[0]]); } } else if (!(b === 254)) { return b ^ 17; @@ -964,20 +918,16 @@ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { export function guardedReturn(data: Uint8Array): rt.u8 { let a!: rt.u8; let b!: rt.u8; - let _13!: rt.u8; - let a2!: rt.u8; if (!((data.length === 0))) { if (data.length === 2) { a = data[0]; b = data[1]; - _13 = b; - if (a > _13) { + if (a > b) { return rt.u8Sub(a, b); } } if (data.length >= 1) { - a2 = data[0]; - if (a2 > 128) { + if (data[0] > 128) { return 1; } } @@ -993,6 +943,7 @@ export function brokenNever(data: Uint8Array): rt.u8 { let i!: rt.usize; let _6!: rt.usize; let _7!: rt.usize; + let args2!: rt.Fmt[]; let _19!: rt.usize; let _20!: rt.usize; i = 0; @@ -1006,7 +957,8 @@ export function brokenNever(data: Uint8Array): rt.u8 { const value = data[_6]; if (value === 251) { const arg = ([i] as [rt.usize])[0]; - rt.panicFmt(["broken at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); + args2 = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + rt.panicFmt(["broken at ", args2[0]]); return _0; } else if (value === 252) { _19 = i; @@ -1037,6 +989,7 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { let i!: rt.usize; let _8!: rt.usize; let _9!: rt.usize; + let args2!: rt.Fmt[]; let _22!: rt.usize; let _23!: rt.usize; let _32!: rt.usize; @@ -1052,7 +1005,8 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { const value = data[_8]; if (value === 239) { const arg = ([i] as [rt.usize])[0]; - rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)]); + args2 = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + rt.panicFmt(["bound at ", args2[0]]); return _0; } else if (value === 240) { _22 = i; @@ -1095,7 +1049,6 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { let w!: Uint8Array; let a!: rt.u8; let b!: rt.u8; - let _27!: rt.u8; let n!: rt.u8; let n2!: rt.u8; i = 0; @@ -1109,8 +1062,7 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { if (w.length === 2) { a = w[0]; b = w[1]; - _27 = b; - if (a > _27) { + if (a > b) { n = a; while (true) { if (!(n <= b)) { @@ -1380,8 +1332,6 @@ export function drain(data: Uint8Array, out: rt.ByteVec): void { /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ export function patterns(data: Uint8Array, out: rt.ByteVec): void { - let first!: rt.u8; - let last!: rt.u8; let iter!: { s: Uint8Array; i: number }; let _33!: rt.u8 | rt.Done; let b!: rt.u8; @@ -1397,29 +1347,22 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { let _79!: rt.i64; let a!: Point.Point; let b2!: Point.Point; - let _100!: Uint8Array; let bytes!: Uint8Array; let _107!: rt.usize; - let _116!: Shape.Shape[]; - let _125!: Uint8Array; let parsed!: rt.Result; let a2!: rt.u8; let b3!: rt.u8; - let _138!: Uint8Array; let _143!: string; + let args2!: rt.Fmt[]; if (!(data.length === 0)) { if (!(data.length === 1)) { if (!(data.length >= 2)) { rt.unreachable(undefined); + } else if (!((data[0] === data[data.length - 1]))) { + rt.byteVecPush(out, data[0] ^ data[1]); + rt.byteVecPush(out, data.subarray(2, data.length - 0).length & 0xff); } else { - first = data[0]; - last = data[data.length - 1]; - if (!((first === last))) { - rt.byteVecPush(out, data[0] ^ data[1]); - rt.byteVecPush(out, data.subarray(2, data.length - 0).length & 0xff); - } else { - rt.byteVecPush(out, 2); - } + rt.byteVecPush(out, 2); } } else { rt.byteVecPush(out, data[0]); @@ -1469,8 +1412,7 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } area = 0; } - _100 = rt.i64ToBeBytes(area); - rt.byteVecExtendFromSlice(out, _100); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); bytes = Uint8Array.of(data.length & 0xff, 1, 2); _107 = 0; if (!(_107 < 2)) { @@ -1478,16 +1420,14 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } bytes.subarray(1, 3)[_107] = 9; rt.byteVecExtendFromSlice(out, bytes); - _116 = [shape_, { tag: "Dot" } as Shape.Shape]; - _125 = rt.u64ToBeBytes(rt.u64Add(total$Shape(_116, out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out))); - rt.byteVecExtendFromSlice(out, _125); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)))); parsed = rt.Ok(data.length & 0xff); a2 = (parsed as { ok: true; value: rt.u8 }).value; b3 = (parsed as { ok: true; value: rt.u8 }).value; - _138 = Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2)); - rt.byteVecExtendFromSlice(out, _138); + rt.byteVecExtendFromSlice(out, Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2))); const arg = ([parsed] as [rt.Result])[0]; - _143 = rt.fmtFormat([(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]); + args2 = [(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; + _143 = rt.fmtFormat([args2[0]]); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_143)); return; } else { @@ -1537,8 +1477,6 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { let add!: (a0: rt.u8) => void; let iter!: { s: Uint8Array; i: number }; let _8!: rt.u8 | rt.Done; - let _18!: Uint8Array; - let _26!: Uint8Array; let whole!: Uint8Array; let _36!: rt.usize; let parsed!: Array; @@ -1557,13 +1495,11 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { while (true) { _8 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_8 === rt.DONE) { - _18 = rt.u32ToBeBytes(sum); - rt.byteVecExtendFromSlice(out, _18); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); const captured = data.length as rt.u32; - _26 = rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { return rt.u32Add(rt.u32Mul(v2, 3), captured); - }, sum)); - rt.byteVecExtendFromSlice(out, _26); + }, sum))); whole = Uint8Array.of(data.length & 0xff); overwrite(whole); _36 = 0; @@ -1618,11 +1554,8 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { let a!: rt.u8; let parsed!: rt.Result; let mapped!: rt.Result; - let _25!: Uint8Array; - let _29!: Uint8Array; let _30!: rt.Result; let s!: string; - let _38!: Uint8Array; _3 = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { let _4!: rt.u8 | undefined; let _82!: rt.u8 | undefined; @@ -1639,8 +1572,7 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { } }; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const part = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); - rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, part), 255)); + rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, rt.optionUnwrapOr(rt.sliceGet(data, 1), 0)), 255)); if (a === 0) { parsed = rt.Err("zero"); } else { @@ -1652,18 +1584,15 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { return rt.stringLen(e) & 0xff; }); if (mapped.ok) { - _25 = Uint8Array.of(0, mapped.value); - rt.byteVecExtendFromSlice(out, _25); + rt.byteVecExtendFromSlice(out, Uint8Array.of(0, mapped.value)); } else { - _29 = Uint8Array.of(1, mapped.error); - rt.byteVecExtendFromSlice(out, _29); + rt.byteVecExtendFromSlice(out, Uint8Array.of(1, mapped.error)); } _30 = rt.stringFromUtf8(rt.sliceToByteVec(data)); if (_30.ok) { s = _30.value; rt.byteVecPush(out, 1); - _38 = rt.u32ToBeBytes(rt.stringLen(s) as rt.u32); - rt.byteVecExtendFromSlice(out, _38); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.stringLen(s) as rt.u32)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); } else { rt.byteVecPush(out, 0); diff --git a/ts/fixtures/reject/census.md b/ts/fixtures/reject/census.md index 95d7cec41..70adf869e 100644 --- a/ts/fixtures/reject/census.md +++ b/ts/fixtures/reject/census.md @@ -1,6 +1,6 @@ # Census of `reject-fixture` -- Refusals: 61 +- Refusals: 60 - Function instances: 69 - Generic functions no instance reached, lowered over their type parameters: 3 @@ -10,9 +10,9 @@ | ---: | --- | --- | | 6 | an assignment through a reference to `_` | fixtures/reject/src/lib.rs:20:2 | | 5 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:19:1 | -| 4 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:1 | | 4 | unsupported call to `_` | fixtures/reject/src/lib.rs:36:4 | | 4 | unsupported type `_` | fixtures/reject/src/lib.rs:6:1 | +| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:1 | | 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:69:2 | | 3 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:161:2 | | 2 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:222:1 | @@ -49,8 +49,8 @@ The type or module each refused type or path belongs to. | Count | API | First | | ---: | --- | --- | -| 5 | `Option` | fixtures/reject/src/lib.rs:31:1 | | 5 | `f64` | fixtures/reject/src/lib.rs:6:1 | +| 4 | `Option` | fixtures/reject/src/lib.rs:31:1 | | 4 | `u32` | fixtures/reject/src/lib.rs:19:1 | | 3 | `u8` | fixtures/reject/src/lib.rs:105:10 | | 2 | `Iterator` | fixtures/reject/src/lib.rs:282:2 | @@ -86,7 +86,7 @@ The type or module each refused type or path belongs to. | Count | Construct | Type or path | First | | ---: | --- | --- | --- | -| 4 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:1 | +| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:1 | | 2 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:222:1 | | 2 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:1 | | 2 | an assignment through a reference to `_` | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | @@ -151,15 +151,6 @@ The type or module each refused type or path belongs to.
-
`_` is not supported: its `None` and `Some` would both be `undefined` (4) - -- fixtures/reject/src/lib.rs:31:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:39:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:40:42: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:227:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` - -
-
unsupported call to `_` (4) - fixtures/reject/src/lib.rs:36:4: unsupported call to `std::slice::::sort` @@ -178,6 +169,14 @@ The type or module each refused type or path belongs to.
+
`_` is not supported: its `None` and `Some` would both be `undefined` (3) + +- fixtures/reject/src/lib.rs:31:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:40:42: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:227:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` + +
+
an iterator that owns `_`, which drops, which is not supported yet (3) - fixtures/reject/src/lib.rs:69:2: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 2953b1888..ec2661799 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -13,7 +13,6 @@ an assignment through a reference to `u32` at fixtures/reject/src/lib.rs:20:2 `Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:1 unsupported call to `std::slice::::sort` at fixtures/reject/src/lib.rs:36:4 `Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:40:42 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:39:1 an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:69:11 `&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:88:1 `Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:10 diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index 92046c3a2..3204e1ab4 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -26,7 +26,10 @@ function new_(id: rt.u32, log: Log.Log): Guard { /** Log `event` as this guard's. */ export function note(self: Guard, event: string): void { let _5!: string; - _5 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " ", (f: rt.Formatter) => rt.fmtPad(f, event)]); + let args2!: rt.Fmt[]; + const arg = self.id; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.fmtPad(f, event)]; + _5 = rt.fmtFormat(["g", args2[0], " ", args2[1]]); Log.note(self.log, _5); } @@ -52,8 +55,10 @@ export function finish(self: Guard, event: string): rt.u32 { export function drop$Drop(self: Guard): void { let _4!: string; + let args2!: rt.Fmt[]; const arg = ([self.id] as [rt.u32])[0]; - _4 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " drop"]); + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f)]; + _4 = rt.fmtFormat(["g", args2[0], " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index fdeaec889..a5e28227a 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -78,7 +78,9 @@ export class sumFuture { let _11!: rt.Poll; let result!: rt.u64 | undefined; let value!: rt.u64; + let args2!: rt.Fmt[]; let _32!: string; + let args4!: rt.Fmt[]; let _47!: rt.u64; let unwind: number = 0; try { @@ -117,10 +119,13 @@ export class sumFuture { if (result !== undefined) { value = result; if (!(value !== 99)) { - const arg = ([this.guard_.id] as [rt.u32])[0]; - rt.panicFmt(["g", (f: rt.Formatter) => rt.u32Display(arg, f), " poisoned"]); + const arg2 = ([this.guard_.id] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32Display(arg2, f)]; + rt.panicFmt(["g", args2[0], " poisoned"]); } else { - _32 = rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(this.guard_.id, f), " got ", (f: rt.Formatter) => rt.u64Display(value, f)]); + const arg = this.guard_.id; + args4 = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.u64Display(value, f)]; + _32 = rt.fmtFormat(["g", args4[0], " got ", args4[1]]); Log.note(this.inner_.log, _32); this.total_ = rt.u64Add(this.total_, value); bb0 = 4; @@ -330,9 +335,12 @@ export class blocksFuture { let _27!: string; let _32!: rt.u32; let _35!: rt.Poll; + let args2!: rt.Fmt[]; let _51!: rt.Poll; let _61!: string; let _63!: string; + let args4!: rt.Fmt[]; + let _70!: rt.Fmt; let _75!: Inner.Inner | undefined; let _76!: Guard.Guard; let _83!: Outer.Outer; @@ -391,7 +399,9 @@ export class blocksFuture { unwind = 81; _32 = _35; rt.drop(this.__awaitee_); - _27 = rt.fmtFormat(["tally ", (f: rt.Formatter) => rt.u32Display(this._saved, f), " then ", (f: rt.Formatter) => rt.u32Display(_32, f)]); + const arg = this._saved; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.u32Display(_32, f)]; + _27 = rt.fmtFormat(["tally ", args2[0], " then ", args2[1]]); unwind = 72; _25 = _27; Guard.note(this.saved, _25); @@ -409,7 +419,11 @@ export class blocksFuture { unwind = 81; this.replaced_ = _51; rt.drop(this.___awaitee_); - _63 = rt.fmtFormat(["mark ", (f: rt.Formatter) => rt.u32Display(this.replaced_, f), " ", (f: rt.Formatter) => rt.u32Display(this.mark_.n, f)]); + const arg2 = this.replaced_; + _70 = (f: rt.Formatter) => rt.u32Display(arg2, f); + const arg3 = this.mark_.n; + args4 = [_70, (f: rt.Formatter) => rt.u32Display(arg3, f)]; + _63 = rt.fmtFormat(["mark ", args4[0], " ", args4[1]]); unwind = 70; _61 = _63; Guard.note(this.guard_, _61); @@ -835,8 +849,10 @@ export function read(t: Tally.Tally): rt.u32 { /** `i`, noted as picked. */ export function pick(log: Log.Log, i: rt.usize): rt.usize { + let args2!: rt.Fmt[]; const arg = ([i] as [rt.usize])[0]; - Log.note(log, rt.fmtFormat(["pick ", (f: rt.Formatter) => rt.usizeDisplay(arg, f)])); + args2 = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + Log.note(log, rt.fmtFormat(["pick ", args2[0]])); return i; } @@ -859,9 +875,11 @@ export function turns(log: Log.Log, count: rt.u32): void { let _34!: Guard.Guard; let scoped!: rt.u32; let _42!: Guard.Guard; + let args2!: rt.Fmt[]; let boxed!: Guard.Guard; - let once!: rt.u32; - let finished!: rt.u32; + let args4!: rt.Fmt[]; + let _70!: rt.Fmt; + let args6!: rt.Fmt[]; let spares!: Guard.Guard[]; let _91!: Guard.Guard; let _95!: Guard.Guard; @@ -891,14 +909,18 @@ export function turns(log: Log.Log, count: rt.u32): void { scoped = _42.id; rt.drop(_42); const arg = ([scoped] as [rt.u32])[0]; - Log.note(log, rt.fmtFormat(["after ", (f: rt.Formatter) => rt.u32Display(arg, f)])); + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f)]; + Log.note(log, rt.fmtFormat(["after ", args2[0]])); boxed = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); unwind = 89; - once = boxed.id; - Log.note(log, rt.fmtFormat(["boxed ", (f: rt.Formatter) => rt.u32Display(once, f), " ", (f: rt.Formatter) => rt.u32Display(boxed.id, f)])); - finished = Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); - const arg2 = ([finished] as [rt.u32])[0]; - Log.note(log, rt.fmtFormat(["finished ", (f: rt.Formatter) => rt.u32Display(arg2, f)])); + const arg2 = boxed.id; + _70 = (f: rt.Formatter) => rt.u32Display(arg2, f); + const arg3 = boxed.id; + args4 = [_70, (f: rt.Formatter) => rt.u32Display(arg3, f)]; + Log.note(log, rt.fmtFormat(["boxed ", args4[0], " ", args4[1]])); + const arg4 = ([Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing")] as [rt.u32])[0]; + args6 = [(f: rt.Formatter) => rt.u32Display(arg4, f)]; + Log.note(log, rt.fmtFormat(["finished ", args6[0]])); _91 = Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)); unwind = 88; _95 = Guard.new(rt.u32Add(count, 80), Log.clone$Clone(log)); diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index cd9a8b1dd..46f25f38c 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -39,15 +39,25 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let name = name.to_string(); self.assigned[dest.local] = true; - self.range_next(name, recv, &mut pre); + let stepped = match &args[0].node { + Operand::Copy(p) | Operand::Move(p) => { + p.as_local().is_some_and(|b| self.stepped_borrows.contains_key(&b)) + } + Operand::Constant(_) | Operand::RuntimeChecks(_) => false, + }; + let read = self.uses[dest.local] > 1; + let held = self.range_next(name, recv, stepped, read, &mut pre); self.emit(pre, None, false, out); + if let Some((flag, more)) = held { + self.hold_flag(flag, more); + } return; } if let Some(name) = self.var(dest.local) { let name = name.to_string(); self.next_names.insert(name); } - if self.stepped_recv(&args[0].node).is_some() { + if self.stepped_array(&args[0].node) { let it = self.path(recv, "iter", &mut pre); (self.stepped_next(it), true) } else { @@ -288,7 +298,17 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let ty = targ(0)?; let value = self.operand(&args[0].node, span, out); - let value = self.path(value, "arg", out); + // The function reads it later, in a closure, where TypeScript no longer + // narrows a member of a union: a member is read now, into a name. + let value = match value { + Expr::Member(..) | Expr::Index(..) => { + let name = self.b.fresh("arg"); + let stmt = StmtKind::decl(false, name.clone(), None, Some(value)).at(None); + self.emit(vec![stmt], None, false, out); + Expr::ident(name) + } + value => self.path(value, "arg", out), + }; done(self.b.fmt_value(tr, ty, value, span, out), false) } ("Arguments", "from_str" | "from_str_nonconst") => { @@ -432,11 +452,29 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// `name = recv.next()` of a range of numbers, stepped in place rather than through /// `rt.Range`'s generic steps, into the item alone and a flag for whether there was /// one: a number that is sometimes `rt.DONE` is slower in V8. Past the end, `name` is - /// left as it was, since only `Some` reads it. - fn range_next(&mut self, name: String, recv: Expr, out: &mut Vec) { + /// left as it was, since only `Some` reads it. A range only `next` reads (`stepped`) + /// steps past its end too, so the flag is one comparison, to hold back for the switch + /// that reads it; it assigns `name` only if something reads it (`read`). + fn range_next( + &mut self, + name: String, + recv: Expr, + stepped: bool, + read: bool, + out: &mut Vec, + ) -> Option<(String, Expr)> { let range = self.path(recv, "range", out); let start = range.clone().member("start"); let flag = self.b.fresh(&format!("{name}Some")); + self.range_flags.insert(name.clone(), flag.clone()); + if stepped { + let step = Expr::Postfix(Box::new(start), "++"); + let item = match read { + true => Expr::ident(&name).assign(step), + false => step, + }; + return Some((flag, item.binary("<", range.member("end")))); + } let more = start.clone().binary("<", range.member("end")); out.push(StmtKind::Expr(Expr::ident(&flag).assign(more)).at(None)); let step = Expr::ident(&name).assign(Expr::Postfix(Box::new(start), "++")); @@ -448,7 +486,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } .at(None), ); - self.range_flags.insert(name, flag); + None } /// The value at `place`, after setting `place` to `value`. diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 8e133208e..17ac5c074 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -340,6 +340,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } self.find_next_results(); self.find_stepped(); + self.unborrow_passed(); for local in mir.local_decls.indices() { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { @@ -385,6 +386,30 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } + /// A local nothing changes whose one read is a shared borrow, itself read once, is + /// read once where the borrow is: it folds like a local nothing borrows, as an array + /// made to pass as a slice does. + fn unborrow_passed(&mut self) { + let mir = self.mir; + for data in mir.basic_blocks.iter() { + for stmt in &data.statements { + if let StatementKind::Assign(assign) = &stmt.kind + && let (to, Rvalue::Ref(_, mir::BorrowKind::Shared, from)) = &**assign + && let Some(to) = to.as_local() + && let Some(from) = from.as_local() + && self.borrowed[from] + && !self.mutated[from] + && self.uses[from] == 1 + && self.defs[to] == 1 + && self.uses[to] == 1 + && !self.borrowed[to] + { + self.borrowed[from] = false; + } + } + } + } + /// Find the swaps `t = move x; x = move t;` through a `t` nothing else names. fn find_noops(&mut self) { use rustc_middle::mir::visit::{PlaceContext, Visitor}; @@ -1220,6 +1245,25 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }); } + /// Hold back `value`, the assignment of the flag `flag`, to fold into the switch that + /// reads it. + fn hold_flag(&mut self, flag: String, value: Expr) { + self.order += 1; + let mut reads = Vec::new(); + reads_of(&value, &mut reads); + self.pending.push(Pending { + name: flag, + value, + order: self.order, + effect: true, + memory: true, + parts: None, + reads, + copy: false, + decl: false, + }); + } + /// The parts of the pending aggregate `local`, each held back in its place, so the /// expression that reads them keeps what they do and read in order. fn take_parts(&mut self, op: &Operand<'tcx>) -> Option> { @@ -1457,6 +1501,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.force_share = true; } let value = self.rvalue(rvalue, place, span, &mut pre); + let value = match (value, place.as_local()) { + (Some(value), Some(local)) if self.stepped.contains(&local) => Some(self.stepped_make(value, span)), + (value, _) => value, + }; self.into_frozen = false; self.force_share = false; self.copy_on_flush = shares; @@ -1636,10 +1684,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => None, }; let tests: Vec<(Expr, BasicBlock)> = match discr_local.map(|l| self.slots[l].clone()) { - Some(Slot::Discr(Some((scrut, ty)))) => arms - .iter() - .map(|&(value, target)| (self.variant_test(&scrut, ty, value, span), target)) - .collect(), + Some(Slot::Discr(Some((scrut, ty)))) => { + let tests: Vec = arms + .iter() + .map(|&(value, _)| self.variant_test(&scrut, ty, value, span)) + .collect(); + // What one test reads that is held back folds into it; of several, all but + // the first may not run. + let conds = match tests.len() { + 1 => self.fold_exprs(Vec::new(), tests, false, out), + _ => tests, + }; + conds.into_iter().zip(arms.iter().map(|&(_, t)| t)).collect() + } _ => { let ty = discr.ty(&self.mir.local_decls, self.tcx); let mut pre = Vec::new(); diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 993b8e789..f13e9c452 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -1,6 +1,7 @@ -//! Iterators over an array stepped in place: a slice's or a `Vec`'s iterator that only -//! `next` reads, as a `for` loop's is, is the array and an index, `{ s, i }`, rather than -//! an `rt.Iter`, which a bundler can't shake its adaptors from. +//! Iterators stepped in place: a slice's or a `Vec`'s iterator, or a range of numbers, +//! that only `next` reads, as a `for` loop's is, is an object of the array and an index, +//! `{ s, i }`, or of the bounds, `{ start, end }`, rather than an `rt.Iter`, which a +//! bundler can't shake its adaptors from. use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_middle::mir::{self, Local, Operand, Rvalue, StatementKind, TerminatorKind}; @@ -43,7 +44,10 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { .local_decls .indices() .filter(|&l| !self.is_arg(l) && l != mir::RETURN_PLACE && self.defs[l] == 1) - .filter(|&l| array_iter(tcx, mir.local_decls[l].ty).is_some()) + .filter(|&l| { + let ty = mir.local_decls[l].ty; + array_iter(tcx, ty).is_some() || super::small_range(tcx, ty) + }) .collect(); if iters.is_empty() { return; @@ -75,6 +79,9 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { moves.push((from, to)); } } + Rvalue::Aggregate(..) if let Some(to) = place.as_local() => { + made.insert(to); + } _ => {} } } @@ -100,9 +107,21 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { if maker && let Some(to) = destination.as_local() && let [arg] = &**args - && array(tcx, arg.node.ty(&mir.local_decls, tcx)) { - made.insert(to); + match &arg.node { + // A range is its own iterator. + Operand::Move(from) + if let Some(from) = from.as_local() + && super::small_range(tcx, mir.local_decls[from].ty) => + { + *reads.entry(from).or_default() += 1; + moves.push((from, to)); + } + op if array(tcx, op.ty(&mir.local_decls, tcx)) => { + made.insert(to); + } + _ => {} + } } if crate::lower::iter::is_next(tcx, def_id) && destination.as_local().is_some_and(|l| self.next_results.contains(&l)) @@ -147,29 +166,37 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.stepped = ok; } - /// The iterator a `next` receiver `op` borrows, if it steps in place. - pub(super) fn stepped_recv(&self, op: &Operand<'tcx>) -> Option { + /// The array iterator a `next` receiver `op` borrows, if it steps in place. A range's + /// `next` steps one in place anyway. + pub(super) fn stepped_array(&self, op: &Operand<'tcx>) -> bool { let (Operand::Copy(p) | Operand::Move(p)) = op else { - return None; + return false; }; - self.stepped_borrows.get(&p.as_local()?).copied() + p.as_local() + .and_then(|b| self.stepped_borrows.get(&b)) + .is_some_and(|&l| array_iter(self.tcx, self.mir.local_decls[l].ty).is_some()) } - /// `{ s, i: 0 }`, from what `into_iter` or `iter` made: `rt.iterSlice(s)`. + /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` + /// from `rt.iterSlice(s)`, and `{ start, end }` from `new rt.Range(start, end)`. A + /// moved one is already made. pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { + let rt = |f: &Expr, name: &str| matches!(f, Expr::Rt(n) if n == name); + let object = |fields: [(&str, Expr); 2]| { + Expr::Object(fields.into_iter().map(|(k, v)| (Key::Name(k.into()), v)).collect()) + }; match value { - Expr::Call(f, mut args) if matches!(&*f, Expr::Rt(name) if name == "iterSlice") && args.len() == 1 => { - Expr::Object(vec![ - (Key::Name("s".into()), args.pop().unwrap()), - (Key::Name("i".into()), Expr::lit("0")), - ]) + Expr::Call(f, mut args) if rt(&f, "iterSlice") && args.len() == 1 => { + object([("s", args.pop().unwrap()), ("i", Expr::lit("0"))]) + } + Expr::New(f, args) if rt(&f, "Range") && args.len() == 2 => { + let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); + object([("start", start), ("end", end)]) } + Expr::Ident(_) => value, // Refused already. Expr::Lit(lit) if lit == "undefined" => Expr::undefined(), - _ => self.err( - span, - "an iterator stepped in place that its mapping didn't make from an array", - ), + _ => self.err(span, "an iterator stepped in place that its mapping didn't make"), } } @@ -184,16 +211,25 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) } - /// The type of a local stepped in place: its array and index. + /// The type of a local stepped in place: its array and index, or its bounds. pub(super) fn stepped_ty(&mut self, local: Local) -> Option { if !self.stepped.contains(&local) { return None; } - let item = array_iter(self.tcx, self.mir.local_decls[local].ty)?; - let array = self.b.t.ty(Ty::new_slice(self.tcx, item), self.span); - Some(Type::Object(vec![ - ("s".into(), array), - ("i".into(), Type::Builtin("number")), - ])) + let ty = self.mir.local_decls[local].ty; + let fields = match array_iter(self.tcx, ty) { + Some(item) => [ + ("s", self.b.t.ty(Ty::new_slice(self.tcx, item), self.span)), + ("i", Type::Builtin("number")), + ], + None => { + let ty::Adt(_, args) = ty.kind() else { + unreachable!("a range is a struct") + }; + let bound = self.b.t.ty(args.type_at(0), self.span); + [("start", bound.clone()), ("end", bound)] + } + }; + Some(Type::Object(fields.into_iter().map(|(k, t)| (k.into(), t)).collect())) } } From fbe76c11ce14d38da4d798ff81f8c99c3d8fcb0b Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 18:45:20 -0700 Subject: [PATCH 06/17] perf(ts): fold reads of unchanging locals' fields and skip empty switch arms Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/codec/expected/bench.ts | 28 ++---- .../codec/expected/coding/varint.Form.ts | 5 +- ts/fixtures/codec/expected/harness.ts | 12 +-- .../codec/expected/lite/probe.Probe.ts | 10 +- .../codec/expected/lite/version.Version.ts | 16 ++- ts/fixtures/lang/expected/shapes.ts | 20 ++-- ts/fixtures/task/expected/kio.ts | 6 +- ts/fixtures/task/expected/model.ts | 91 ++++++----------- ts/src/lower/mir/mod.rs | 98 ++++++++++++++++--- 9 files changed, 152 insertions(+), 134 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 0dde4f96f..13d49a0b7 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -18,13 +18,6 @@ export function run(input: Uint8Array): rt.ByteVec { let _5!: [rt.u8, Uint8Array] | undefined; let selector!: rt.u8; let _9!: [rt.u8, Uint8Array] | undefined; - let _13!: Form.Form; - let _17!: Form.Form; - let _21!: Version.Version; - let _25!: Version.Version; - let _29!: Version.Version; - let _34!: Version.Version; - let _38!: Version.Version; out = new rt.ByteVec(); _5 = rt.sliceSplitFirst(input); if (_5 !== undefined) { @@ -33,28 +26,21 @@ export function run(input: Uint8Array): rt.ByteVec { if (_9 !== undefined) { selector = _9[0]; if (op === 0) { - _13 = form(selector); - encoded(encodeVarints(_9[1], _13, out), out); + encoded(encodeVarints(_9[1], form(selector), out), out); } else if (op === 1) { - _17 = form(selector); - decoded(decodeVarints(_9[1], _17, out), out); + decoded(decodeVarints(_9[1], form(selector), out), out); } else if (op === 2) { - _21 = liteVersion(selector); - encoded(encodeFrames(_9[1], _21, out), out); + encoded(encodeFrames(_9[1], liteVersion(selector), out), out); } else if (op === 3) { - _25 = liteVersion(selector); - decoded(decodeFrames(_9[1], _25, out), out); + decoded(decodeFrames(_9[1], liteVersion(selector), out), out); } else if (op === 4) { - _29 = liteVersion(selector); - encoded(encodeGroup(_9[1], _29, out), out); + encoded(encodeGroup(_9[1], liteVersion(selector), out), out); } else if (op === 6) { iterate(selector, _9[1], out); } else if (op === 7) { - _34 = liteVersion(selector); - decoded(decodeSplit(_9[1], _34, out), out); + decoded(decodeSplit(_9[1], liteVersion(selector), out), out); } else { - _38 = liteVersion(selector); - decoded(decodeGroup(_9[1], _38, out), out); + decoded(decodeGroup(_9[1], liteVersion(selector), out), out); } return out; } else { diff --git a/ts/fixtures/codec/expected/coding/varint.Form.ts b/ts/fixtures/codec/expected/coding/varint.Form.ts index bc43ba703..a674376a7 100644 --- a/ts/fixtures/codec/expected/coding/varint.Form.ts +++ b/ts/fixtures/codec/expected/coding/varint.Form.ts @@ -6,10 +6,11 @@ import type * as Version from "../lite/version.Version.ts"; export type Form = { tag: "Quic" } | { tag: "LeadingOnes"; seven: boolean }; export function from$From_Version(version: Version.Version): Form { - if (!(version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06")) { + if (version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06") { + return { tag: "Quic" } as Form; + } else { return { tag: "LeadingOnes", seven: true } as Form; } - return { tag: "Quic" } as Form; } //# sourceMappingURL=varint.Form.ts.map diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 981acf058..7a761e62a 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -210,10 +210,8 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { let len!: rt.u8; let _9!: [rt.u8, Uint8Array] | undefined; let _13!: [Uint8Array, Uint8Array]; - let _14!: rt.usize; let _15!: rt.usize; let r!: Decoder.Decoder; - let _18!: Form.Form; let iter!: { s: Uint8Array; i: number }; let _21!: rt.u8 | rt.Done; let _26!: rt.Result; @@ -226,10 +224,8 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { if (_9 !== undefined) { len = _9[0]; _15 = _9[1].length; - _14 = rt.min(_15, len as rt.usize); - _13 = rt.sliceSplitAt(_9[1], _14); - _18 = form(selector); - r = Decoder.new(_13[1], _18); + _13 = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + r = Decoder.new(_13[1], form(selector)); iter = { s: _13[0], i: 0 }; l1: while (true) { _21 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; @@ -363,7 +359,6 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { let _9!: [rt.u8, Uint8Array] | undefined; let values!: Uint8Array; let _13!: [Uint8Array, Uint8Array]; - let _14!: rt.usize; let _15!: rt.usize; let buf!: rt.ByteVec; let w!: Encoder.Encoder; @@ -397,8 +392,7 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { if (_9 !== undefined) { len = _9[0]; _15 = _9[1].length; - _14 = rt.min(_15, len as rt.usize); - _13 = rt.sliceSplitAt(_9[1], _14); + _13 = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); values = _13[1]; buf = new rt.ByteVec(); _20 = form(selector); diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index 7d3583ca3..304a8da52 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -83,7 +83,9 @@ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): let rtt!: rt.u64 | undefined; let _13!: rt.Result; let val2!: rt.u64; - if (!(version === "Lite01" || version === "Lite02")) { + if (version === "Lite01" || version === "Lite02") { + return rt.Err({ tag: "Version" } as DecodeError.DecodeError); + } else { _6 = Decoder.varint(r); if (_6.ok) { val = _6.value; @@ -112,14 +114,15 @@ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): return _6; } } - return rt.Err({ tag: "Version" } as DecodeError.DecodeError); } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { let _9!: rt.Result; let _17!: rt.Result; - if (!(version === "Lite01" || version === "Lite02")) { + if (version === "Lite01" || version === "Lite02") { + return rt.Err("Version" as EncodeError.EncodeError); + } else { _9 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { return rt.u64Max(v, 1); }), 0)); @@ -137,7 +140,6 @@ export function encodeMsg$Message(self: Probe, w: Encoder.Encoder, version: Vers return _9; } } - return rt.Err("Version" as EncodeError.EncodeError); } //# sourceMappingURL=probe.Probe.ts.map diff --git a/ts/fixtures/codec/expected/lite/version.Version.ts b/ts/fixtures/codec/expected/lite/version.Version.ts index e259d7165..ca2caf859 100644 --- a/ts/fixtures/codec/expected/lite/version.Version.ts +++ b/ts/fixtures/codec/expected/lite/version.Version.ts @@ -10,12 +10,10 @@ export type Version = "Lite01" | "Lite02" | "Lite03" | "Lite04" | "Lite05" | "Li */ export function hasProbeRtt(self: Version): boolean { let _2!: boolean; - b0: { - if (!(self === "Lite01" || self === "Lite02" || self === "Lite03")) { - _2 = false; - break b0; - } + if (self === "Lite01" || self === "Lite02" || self === "Lite03") { _2 = true; + } else { + _2 = false; } return !_2; } @@ -30,12 +28,10 @@ export function hasProbeRtt(self: Version): boolean { */ export function hasFrameBounds(self: Version): boolean { let _2!: boolean; - b0: { - if (!(self === "Lite01" || self === "Lite02" || self === "Lite03" || self === "Lite04" || self === "Lite05")) { - _2 = false; - break b0; - } + if (self === "Lite01" || self === "Lite02" || self === "Lite03" || self === "Lite04" || self === "Lite05") { _2 = true; + } else { + _2 = false; } return !_2; } diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index dcc873c62..b3ff3601d 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -1374,39 +1374,39 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { while (true) { _33 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_33 === rt.DONE) { - b6: { + b5: { if (data.length >= 2) { _56 = dir(data[0]); if (_56 !== undefined) { d = _56; if (data[1] > 10) { rt.byteVecPush(out, from$From_Dir_u8(d)); - break b6; + break b5; } } } rt.byteVecPush(out, 238); } shape_ = shape(data); - b8: { + b7: { if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { a = shape_._0; b2 = shape_._1; area = rt.i64Mul(rt.i32Sub(a.x, b2.x) as rt.i64, rt.i32Sub(a.y, b2.y) as rt.i64); - break b8; + break b7; } else if (shape_.width !== 0) { if (!(shape_.corner.x > 0)) { width2 = shape_.width; height = shape_.height; _79 = rt.i64Mul(width2 as rt.i64, height as rt.i64); area = rt.i64Neg(_79); - break b8; + break b7; } else { x = shape_.corner.x; _74 = shape_.width as rt.i64; area = rt.i64Mul(_74, x as rt.i64); - break b8; + break b7; } } } @@ -1435,8 +1435,9 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { b = _33; if (b === 0) { class_ = 0; - break b2; - } else if (!(b === 10 || b === 20 || b === 30)) { + } else if (b === 10 || b === 20 || b === 30) { + class_ = 2; + } else { if (1 <= b) { if (b <= 9) { class_ = 1; @@ -1453,13 +1454,10 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } if (!(b >= 250)) { class_ = 5; - break b2; } else { class_ = 4; - break b2; } } - class_ = 2; } rt.byteVecPush(out, class_); } diff --git a/ts/fixtures/task/expected/kio.ts b/ts/fixtures/task/expected/kio.ts index 33ab146f7..57e6cbe09 100644 --- a/ts/fixtures/task/expected/kio.ts +++ b/ts/fixtures/task/expected/kio.ts @@ -23,10 +23,8 @@ export class recvFuture { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index a5e28227a..84752d6e9 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -1047,6 +1047,7 @@ export class drainFuture { let unwind: number = 0; try { if (this.state === 0) { + unwind = 0; rt.drop(this.rx); return; } else if (this.state === 3) { @@ -1211,10 +1212,8 @@ export class level1Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1268,10 +1267,8 @@ export class level10Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1325,10 +1322,8 @@ export class level11Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1382,10 +1377,8 @@ export class level12Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1439,10 +1432,8 @@ export class level13Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1496,10 +1487,8 @@ export class level14Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1553,10 +1542,8 @@ export class level15Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1610,10 +1597,8 @@ export class level2Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1667,10 +1652,8 @@ export class level3Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1724,10 +1707,8 @@ export class level4Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1781,10 +1762,8 @@ export class level5Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1838,10 +1817,8 @@ export class level6Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1895,10 +1872,8 @@ export class level7Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -1952,10 +1927,8 @@ export class level8Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } @@ -2009,10 +1982,8 @@ export class level9Future { } [Symbol.dispose](): void { - if (this.state !== 0) { - if (this.state === 3) { - rt.drop(this.__awaitee_); - } + if (this.state === 3) { + rt.drop(this.__awaitee_); } } diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 17ac5c074..ae89a760b 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -137,6 +137,10 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { mutated: IndexVec, /// The names of borrowed locals. shared: FxHashSet, + /// The names of locals whose own value nothing changes: a tuple, array, or enum or + /// struct of their own, never changed in place nor borrowed, so a call can't change + /// what their fields hold. + frozen_names: FxHashSet, /// `(value, overflowed)` pairs of checked arithmetic, whose `.1` is false once the value /// is made, which panics where the assert would. checked: FxHashSet, @@ -213,6 +217,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { borrowed: IndexVec::from_elem_n(false, n), mutated: IndexVec::from_elem_n(false, n), shared: FxHashSet::default(), + frozen_names: FxHashSet::default(), checked: FxHashSet::default(), pending: Vec::new(), order: 0, @@ -381,6 +386,20 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.borrowed[local] { self.shared.insert(name.clone()); } + let owned = match mir.local_decls[local].ty.kind() { + ty::Tuple(_) | ty::Array(..) => true, + ty::Adt(adt, _) => { + adt.did().is_local() + || matches!( + crate::lower::library::Std::of(self.tcx, adt.did()), + Some(crate::lower::library::Std::Option | crate::lower::library::Std::Result) + ) + } + _ => false, + }; + if owned && !self.is_arg(local) && !self.borrowed[local] && !self.mutated[local] { + self.frozen_names.insert(name.clone()); + } self.slots[local] = Slot::Var(name); } } @@ -1014,9 +1033,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { TerminatorKind::Goto { target, .. } => vec![*target], // An unreachable default is no edge: the last value takes its place. TerminatorKind::SwitchInt { targets, .. } => { - let mut all = targets.all_targets().to_vec(); - if self.unreachable.contains(&targets.otherwise()) && all.len() > 1 { - all.pop(); + let (arms, default) = self.switch_targets(targets); + let mut all: Vec = Vec::new(); + for bb in arms.into_iter().map(|(_, bb)| bb).chain([default]) { + if !all.contains(&bb) { + all.push(bb); + } } all } @@ -1034,6 +1056,51 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // Locals + /// A switch's arms and default, each past blocks that do nothing but go on, without + /// the arms that go where the default does. An unreachable default leaves the last + /// arm as the default. + fn switch_targets(&self, targets: &mir::SwitchTargets) -> (Vec<(u128, BasicBlock)>, BasicBlock) { + let mut arms: Vec<(u128, BasicBlock)> = targets.iter().collect(); + let mut default = targets.otherwise(); + if self.unreachable.contains(&default) + && let Some((_, last)) = arms.pop() + { + default = last; + } + let default = self.forward(default); + let returns = |bb: BasicBlock| matches!(self.mir.basic_blocks[bb].terminator().kind, TerminatorKind::Return); + arms.retain_mut(|(_, target)| { + *target = self.forward(*target); + *target != default && !(returns(*target) && returns(default) && self.empty(*target) && self.empty(default)) + }); + (arms, default) + } + + /// Whether `bb` has no statement that does anything. + fn empty(&self, bb: BasicBlock) -> bool { + self.mir.basic_blocks[bb].statements.iter().enumerate().all(|(i, s)| { + matches!( + s.kind, + StatementKind::StorageDead(_) | StatementKind::StorageLive(_) | StatementKind::Nop + ) || self.noops.contains(&(bb, i)) + }) + } + + /// Where `bb` goes, past blocks that do nothing but go on. + fn forward(&self, mut bb: BasicBlock) -> BasicBlock { + for _ in 0..self.mir.basic_blocks.len() { + let data = &self.mir.basic_blocks[bb]; + let TerminatorKind::Goto { target, .. } = data.terminator().kind else { + return bb; + }; + if !self.empty(bb) || data.is_cleanup || self.redirect.contains_key(&bb) { + return bb; + } + bb = target; + } + bb + } + /// The JS name of a local held in a variable. fn var(&self, local: Local) -> Option<&str> { match &self.slots[local] { @@ -1108,6 +1175,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { None => seen_memory |= self.shared.contains(name.as_str()), }, Read::Memory => seen_memory = true, + Read::Field(name) => seen_memory |= !self.frozen_names.contains(name.as_str()), Read::Effect => seen_effect = true, } } @@ -1293,6 +1361,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let effect = events.iter().any(|r| matches!(r, Read::Effect)); let memory = events.iter().any(|r| match r { Read::Memory => true, + Read::Field(name) => !self.frozen_names.contains(name.as_str()), Read::Ident(name, _) => self.shared.contains(name.as_str()), Read::Effect => false, }); @@ -1671,14 +1740,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } fn switch(&mut self, discr: &Operand<'tcx>, targets: &mir::SwitchTargets, span: Span, out: &mut Vec) -> Exit { - let mut arms: Vec<(u128, BasicBlock)> = targets.iter().collect(); - let mut default = targets.otherwise(); - // An unreachable default leaves the last value as the default. - if self.unreachable.contains(&default) - && let Some((_, last)) = arms.pop() - { - default = last; - } + let (arms, default) = self.switch_targets(targets); let discr_local = match discr { Operand::Copy(p) | Operand::Move(p) => p.as_local(), _ => None, @@ -1932,6 +1994,8 @@ enum Read { Ident(String, bool), /// Memory: a member or an element. Memory, + /// A member or an element of a local's own value, by its name. + Field(String), /// A call, which may do anything. Effect, } @@ -1953,6 +2017,14 @@ fn scan_stmt(stmt: &Stmt, reads: &mut Vec, lazy: bool) { } } +/// A read of a member or element of `base`. +fn field(base: &Expr) -> Read { + match base { + Expr::Ident(name) => Read::Field(name.clone()), + _ => Read::Memory, + } +} + fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { match e { Expr::Ident(name) => reads.push(Read::Ident(name.clone(), lazy)), @@ -1963,12 +2035,12 @@ fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { Expr::Member(base, _) if matches!(&**base, Expr::Rt(_) | Expr::Sym(_)) => {} Expr::Member(base, _) => { scan(base, reads, lazy); - reads.push(Read::Memory); + reads.push(field(base)); } Expr::Index(base, index) => { scan(base, reads, lazy); scan(index, reads, lazy); - reads.push(Read::Memory); + reads.push(field(base)); } Expr::Call(f, args) | Expr::New(f, args) => { // A method's lookup reads no data the arguments could change: only its receiver. From a19e2d2bb0a7c18e75c7d8e7c5162ad4efb8af1f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 18:50:21 -0700 Subject: [PATCH 07/17] perf(ts): convert a residual made in place without a variable Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- .../codec/expected/coding/encode.Encoder.ts | 6 ++--- ts/src/lower/mir/call.rs | 24 +++++++++++++------ 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index 9d32d3aba..e6acf2c51 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -52,8 +52,7 @@ export function varint(self: Encoder, v: rt.u64): rt.Result { diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 46f25f38c..d76b1f550 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -388,13 +388,23 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if from == to { return done(value, false); } - let value = self.path(value, "residual", out); - // The residual is an `Err`. - let err = crate::ts::Type::Object(vec![ - ("ok".into(), crate::ts::Type::Builtin("false")), - ("error".into(), self.b.t.ty(from, span)), - ]); - let error = Expr::As(Box::new(value), err).member("error"); + let error = match value { + // Made in place: its error. + Expr::Call(f, mut items) + if matches!(&*f, Expr::Rt(n) if n == "Err") && items.len() == 1 => + { + items.pop().expect("checked above") + } + value => { + let value = self.path(value, "residual", out); + // The residual is an `Err`. + let err = crate::ts::Type::Object(vec![ + ("ok".into(), crate::ts::Type::Builtin("false")), + ("error".into(), self.b.t.ty(from, span)), + ]); + Expr::As(Box::new(value), err).member("error") + } + }; let converted = self.b.convert(error, from, to, span, out); done(Expr::rt("Err", vec![converted]), true) } From a8b3d8ea52d869ff8f90e49e48ca939d84efe64b Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 18:56:50 -0700 Subject: [PATCH 08/17] perf(ts): bounds-check slices with rt.idx and inline constant locals Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- .../codec/expected/coding/decode.Decoder.ts | 30 +- ts/fixtures/codec/expected/coding/varint.ts | 6 +- ts/fixtures/lang/expected/fmt.Fault.ts | 7 +- ts/fixtures/lang/expected/fmt.ts | 79 +++--- ts/fixtures/lang/expected/ints.ts | 120 ++------ ts/fixtures/lang/expected/iters.ts | 15 +- ts/fixtures/lang/expected/shapes.ts | 260 +++--------------- ts/fixtures/lang/src/fmt.rs | 3 +- ts/fixtures/task/expected/kio.WaiterList.ts | 6 +- ts/src/lower/mir/mod.rs | 103 ++++++- ts/tests/fixtures.rs | 1 + 11 files changed, 208 insertions(+), 422 deletions(-) diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index b4923bedf..a317ff116 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -95,16 +95,10 @@ export function sub(self: Decoder, len: rt.usize): rt.Result { let _3!: rt.Result; - let _8!: rt.usize; - let _9!: rt.usize; _3 = slice(self, 1); if (_3.ok) { - _8 = 0; - _9 = _3.value.length; - if (!(_8 < _9)) { - rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); - } - return rt.Ok(_3.value[_8]); + rt.idx(_3.value, 0); + return rt.Ok(_3.value[0]); } else { return _3; } @@ -114,24 +108,12 @@ export function u8(self: Decoder): rt.Result { export function u16(self: Decoder): rt.Result { let _2!: rt.Result; let _9!: rt.u8; - let _10!: rt.usize; - let _11!: rt.usize; - let _14!: rt.usize; - let _15!: rt.usize; _2 = slice(self, 2); if (_2.ok) { - _10 = 0; - _11 = _2.value.length; - if (!(_10 < _11)) { - rt.panic("index out of bounds: the len is " + _11 + " but the index is " + _10); - } - _9 = _2.value[_10]; - _14 = 1; - _15 = _2.value.length; - if (!(_14 < _15)) { - rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); - } - return rt.Ok((_9 << 8) | _2.value[_14]); + rt.idx(_2.value, 0); + _9 = _2.value[0]; + rt.idx(_2.value, 1); + return rt.Ok((_9 << 8) | _2.value[1]); } else { return _2; } diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 781cfc069..f89d9ff64 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -391,11 +391,7 @@ export function zigzag(signed: rt.i64): rt.u64 { /** The inverse of [`zigzag`]. */ export function unzigzag(value: rt.u64): rt.i64 { - let _2!: rt.i64; - let _7!: rt.i64; - _2 = rt.i64Cast(rt.u64Shr(value, 1)); - _7 = rt.i64Cast(rt.u64And(value, 1)); - return rt.i64Xor(_2, rt.i64Neg(_7)); + return rt.i64Xor(rt.i64Cast(rt.u64Shr(value, 1)), rt.i64Neg(rt.i64Cast(rt.u64And(value, 1)))); } //# sourceMappingURL=varint.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index 873a1147f..4baf20303 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -69,7 +69,6 @@ export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result rt.u8; let _3!: rt.u8; at = (i: rt.usize): rt.u8 => { @@ -81,11 +80,9 @@ function new_(data: Uint8Array): Fault { } else if (_3 === 1) { return { tag: "Code", _0: (at(1) << 8) | at(2) } as Fault; } else if (_3 === 2) { - _0 = { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize } as Fault; - return _0; + return { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize } as Fault; } else { - _0 = { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } } as Fault; - return _0; + return { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } } as Fault; } } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index c7a259f40..c0f0f2c8c 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -227,8 +227,6 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { let iter!: { s: Uint8Array; i: number }; let _9!: rt.u8 | rt.Done; let _15!: rt.usize; - let _16!: rt.usize; - let _17!: rt.usize; let _25!: string; let args2!: rt.Fmt[]; let _31!: rt.Fmt; @@ -299,9 +297,7 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { } return; } else { - _16 = _9 as rt.usize; - _17 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length; - _15 = rt.usizeRem(_16, _17); + _15 = rt.usizeRem(_9 as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); if (!(_15 < 14)) { rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); } @@ -320,8 +316,6 @@ export function nested(data: Uint8Array): Nested.Nested { let at!: (a0: rt.usize) => rt.u8; let _3!: string; let _5!: rt.usize; - let _6!: rt.usize; - let _10!: rt.usize; let _15!: Point.Point; let _22!: Shape.Shape; let _23!: rt.u8; @@ -339,9 +333,7 @@ export function nested(data: Uint8Array): Nested.Nested { at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - _6 = at(0) as rt.usize; - _10 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length; - _5 = rt.usizeRem(_6, _10); + _5 = rt.usizeRem(at(0) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); if (!(_5 < 14)) { rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); } @@ -413,7 +405,6 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { let _106!: Kind.Kind; let _112!: string; let _118!: Kind.Kind; - let _119!: rt.usize; let args12!: rt.Fmt[]; let _130!: string; let args14!: rt.Fmt[]; @@ -464,11 +455,7 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { _105 = { tag: "Braced" } as Kind.Kind; _106 = { tag: "Bare" } as Kind.Kind; kinds = [_100, _101, _105, _106, { tag: "Many", count: 0, items: new rt.ByteVec() } as Kind.Kind]; - _119 = 1; - if (!(_119 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _119); - } - _118 = kinds[_119]; + _118 = kinds[1]; args12 = [(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), (f: rt.Formatter) => Kind.fmt$Debug(_118, f)]; _112 = rt.fmtFormat([args12[0], " ", args12[1]]); put(out, _112); @@ -624,24 +611,26 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { let _244!: Uint8Array; let _258!: string; let args20!: rt.Fmt[]; + let _269!: string; + let _271!: rt.usize; let r5!: rt.Result; - let _274!: string; + let _283!: string; let args22!: rt.Fmt[]; n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); - _7 = rt.u8Rem(kind, 19); + _7 = rt.u8Rem(kind, 20); if (_7 === 0) { args2 = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]; rt.panicFmt(["bad ", args2[0], ": ", args2[1]]); } else if (_7 === 1) { _27 = (f: rt.Formatter) => rt.u8LowerHex(n, f); - const arg13 = { _0: n as rt.u32 }; - args4 = [_27, (f: rt.Formatter) => Hex.fmt$Display(arg13, f)]; + const arg14 = { _0: n as rt.u32 }; + args4 = [_27, (f: rt.Formatter) => Hex.fmt$Display(arg14, f)]; rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, args4[0]), " ", args4[1]]); } else if (_7 === 2) { if (!(n > 200)) { _39 = (f: rt.Formatter) => rt.u8Display(n, f); - const arg12 = { _0: n, _1: 0 }; - args6 = [_39, (f: rt.Formatter) => Pair.fmt$Debug(arg12, f)]; + const arg13 = { _0: n, _1: 0 }; + args6 = [_39, (f: rt.Formatter) => Pair.fmt$Debug(arg13, f)]; rt.panicFmt(["small ", args6[0], " ", args6[1]]); } } else if (_7 === 3) { @@ -654,13 +643,13 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { } } else if (_7 === 5) { if (Pair.eq$PartialEq({ _0: n, _1: 1 }, { _0: n, _1: 1 })) { - const arg9 = ([n] as [rt.u8])[0]; + const arg10 = ([n] as [rt.u8])[0]; kind3 = "!="; - args8 = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; + args8 = [(f: rt.Formatter) => rt.u8Display(arg10, f)]; _66 = ["same ", args8[0]]; - const arg10 = { _0: n, _1: 1 }; const arg11 = { _0: n, _1: 1 }; - rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(arg10, f), (f: rt.Formatter) => Pair.fmt$Debug(arg11, f), _66); + const arg12 = { _0: n, _1: 1 }; + rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(arg11, f), (f: rt.Formatter) => Pair.fmt$Debug(arg12, f), _66); } } else if (_7 === 6) { if (!(n === 9)) { @@ -690,15 +679,15 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { put(out, _119); } else if (_7 === 10) { missing = rt.sliceGet(rest, 200); - const arg8 = ([n] as [rt.u8])[0]; - args10 = [(f: rt.Formatter) => rt.u8Display(arg8, f)]; + const arg9 = ([n] as [rt.u8])[0]; + args10 = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; _132 = rt.fmtFormat(["missing ", args10[0]]); _129 = rt.optionExpect(missing, _132); _127 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_129, f)); put(out, _127); } else if (_7 === 11) { - const arg7 = ([{ _0: n }] as [Fails.Fails])[0]; - args12 = [(f: rt.Formatter) => Fails.fmt$Display(arg7, f)]; + const arg8 = ([{ _0: n }] as [Fails.Fails])[0]; + args12 = [(f: rt.Formatter) => Fails.fmt$Display(arg8, f)]; _143 = rt.fmtFormat([args12[0]]); put(out, _143); } else if (_7 === 12) { @@ -706,10 +695,10 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _155 = rt.fmtToString((f: rt.Formatter) => Fails.fmt$Display(_157, f)); put(out, _155); } else if (_7 === 13) { - const arg5 = { _0: n as rt.u32 }; - _167 = (f: rt.Formatter) => Hex.fmt$Display(arg5, f); - const arg6 = { _0: n }; - args14 = [_167, (f: rt.Formatter) => Fails.fmt$Display(arg6, f)]; + const arg6 = { _0: n as rt.u32 }; + _167 = (f: rt.Formatter) => Hex.fmt$Display(arg6, f); + const arg7 = { _0: n }; + args14 = [_167, (f: rt.Formatter) => Fails.fmt$Display(arg7, f)]; rt.panicFmt([args14[0], " then ", args14[1]]); } else if (_7 === 14) { _173 = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize] as [rt.usize, rt.usize]; @@ -718,8 +707,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _189 = rt.sliceRange(rest, start); [_189, rt.sliceRange(rest, start, end)] as [Uint8Array, Uint8Array]; _196 = (f: rt.Formatter) => rt.fmtList(_189, f, rt.u8Display); - const arg4 = rt.sliceRange(rest, start, end); - args16 = [_196, (f: rt.Formatter) => rt.fmtList(arg4, f, rt.u8Display)]; + const arg5 = rt.sliceRange(rest, start, end); + args16 = [_196, (f: rt.Formatter) => rt.fmtList(arg5, f, rt.u8Display)]; _183 = rt.fmtFormat([args16[0], " ", args16[1]]); put(out, _183); } else if (_7 === 15) { @@ -727,8 +716,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { _202 = buf; const part3 = rt.min(rest.length, 4); rt.sliceCopyFromSlice(_202, rt.sliceRange(rest, 0, part3)); - const arg3 = ([buf] as [Uint8Array])[0]; - args18 = [(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]; + const arg4 = ([buf] as [Uint8Array])[0]; + args18 = [(f: rt.Formatter) => rt.fmtList(arg4, f, rt.u8Display)]; _211 = rt.fmtFormat([args18[0]]); put(out, _211); } else if (_7 === 16) { @@ -751,10 +740,16 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { dest = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); _244 = buf2; rt.sliceCopyWithin(_244, part, part2, dest); - const arg2 = ([buf2] as [Uint8Array])[0]; - args20 = [(f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Display)]; + const arg3 = ([buf2] as [Uint8Array])[0]; + args20 = [(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]; _258 = rt.fmtFormat([args20[0]]); put(out, _258); + } else if (_7 === 18) { + _271 = rt.u8Rem(n, 8) as rt.usize; + rt.idx(rest, _271); + const arg2 = rest[_271]; + _269 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg2, f)); + put(out, _269); } else { if (!(rt.u8Rem(n, 2) === 0)) { r5 = rt.Ok(n); @@ -763,8 +758,8 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { } const arg = ([rt.resultUnwrapErr(r5, rt.u8Display)] as [rt.u8])[0]; args22 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - _274 = rt.fmtFormat([args22[0]]); - put(out, _274); + _283 = rt.fmtFormat([args22[0]]); + put(out, _283); } } diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 9f58c2ff1..bae867873 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -14,8 +14,6 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.u8; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.u8) => void; let _51!: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void; let _52!: rt.u8; @@ -48,9 +46,7 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.u8, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 8); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 8)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.u8Add(a, b); @@ -143,8 +139,6 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.u16; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.u16) => void; let _51!: (a0: rt.ByteVec, a1: rt.u16 | undefined) => void; let _52!: rt.u8; @@ -177,9 +171,7 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.u16, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 16); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 16)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.u16Add(a, b); @@ -272,8 +264,6 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.u32; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.u32) => void; let _51!: (a0: rt.ByteVec, a1: rt.u32 | undefined) => void; let _52!: rt.u8; @@ -306,9 +296,7 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.u32, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 32); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.u32Add(a, b); @@ -401,8 +389,6 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.u64; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.u64) => void; let _51!: (a0: rt.ByteVec, a1: rt.u64 | undefined) => void; let _52!: rt.u8; @@ -435,9 +421,7 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.u64, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 64); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 64)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.u64Add(a, b); @@ -530,8 +514,6 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.u128; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.u128) => void; let _51!: (a0: rt.ByteVec, a1: rt.u128 | undefined) => void; let _52!: rt.u8; @@ -564,9 +546,7 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.u128, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 128); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 128)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.u128Add(a, b); @@ -659,8 +639,6 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.usize; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.usize) => void; let _51!: (a0: rt.ByteVec, a1: rt.usize | undefined) => void; let _52!: rt.u8; @@ -693,9 +671,7 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.usize, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 32); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.usizeAdd(a, b); @@ -788,8 +764,6 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.i8; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.i8) => void; let _51!: (a0: rt.ByteVec, a1: rt.i8 | undefined) => void; let _52!: rt.u8; @@ -822,9 +796,7 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.i8, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 8); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 8)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.i8Add(a, b); @@ -836,13 +808,9 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part14 = rt.i8Mul(a, b); _50(out, part14); } else if (_52 === 3) { - b === -1; - a === -128; const part13 = rt.i8Div(a, b); _50(out, part13); } else if (_52 === 4) { - b === -1; - a === -128; const part12 = rt.i8Rem(a, b); _50(out, part12); } else if (_52 === 5) { @@ -921,8 +889,6 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.i16; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.i16) => void; let _51!: (a0: rt.ByteVec, a1: rt.i16 | undefined) => void; let _52!: rt.u8; @@ -955,9 +921,7 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.i16, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 16); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 16)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.i16Add(a, b); @@ -969,13 +933,9 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part14 = rt.i16Mul(a, b); _50(out, part14); } else if (_52 === 3) { - b === -1; - a === -32768; const part13 = rt.i16Div(a, b); _50(out, part13); } else if (_52 === 4) { - b === -1; - a === -32768; const part12 = rt.i16Rem(a, b); _50(out, part12); } else if (_52 === 5) { @@ -1054,8 +1014,6 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.i32; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.i32) => void; let _51!: (a0: rt.ByteVec, a1: rt.i32 | undefined) => void; let _52!: rt.u8; @@ -1088,9 +1046,7 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 32); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.i32Add(a, b); @@ -1102,13 +1058,9 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part14 = rt.i32Mul(a, b); _50(out, part14); } else if (_52 === 3) { - b === -1; - a === -2147483648; const part13 = rt.i32Div(a, b); _50(out, part13); } else if (_52 === 4) { - b === -1; - a === -2147483648; const part12 = rt.i32Rem(a, b); _50(out, part12); } else if (_52 === 5) { @@ -1187,8 +1139,6 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.i64; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.i64) => void; let _51!: (a0: rt.ByteVec, a1: rt.i64 | undefined) => void; let _52!: rt.u8; @@ -1221,9 +1171,7 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.i64, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 64); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 64)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.i64Add(a, b); @@ -1235,13 +1183,9 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part14 = rt.i64Mul(a, b); _50(out, part14); } else if (_52 === 3) { - b === -1; - rt.i64Eq(a, rt.i64Of(-9223372036854775808n)); const part13 = rt.i64Div(a, b); _50(out, part13); } else if (_52 === 4) { - b === -1; - rt.i64Eq(a, rt.i64Of(-9223372036854775808n)); const part12 = rt.i64Rem(a, b); _50(out, part12); } else if (_52 === 5) { @@ -1320,8 +1264,6 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.i128; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.i128) => void; let _51!: (a0: rt.ByteVec, a1: rt.i128 | undefined) => void; let _52!: rt.u8; @@ -1354,9 +1296,7 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.i128, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 128); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 128)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.i128Add(a, b); @@ -1368,13 +1308,9 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part14 = rt.i128Mul(a, b); _50(out, part14); } else if (_52 === 3) { - b === -1; - rt.i128Eq(a, rt.i128Of(-170141183460469231731687303715884105728n)); const part13 = rt.i128Div(a, b); _50(out, part13); } else if (_52 === 4) { - b === -1; - rt.i128Eq(a, rt.i128Of(-170141183460469231731687303715884105728n)); const part12 = rt.i128Rem(a, b); _50(out, part12); } else if (_52 === 5) { @@ -1453,8 +1389,6 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _33!: Uint8Array; let _38!: rt.isize; let shift!: rt.u32; - let _43!: rt.u32; - let _47!: rt.u32; let _50!: (a0: rt.ByteVec, a1: rt.isize) => void; let _51!: (a0: rt.ByteVec, a1: rt.isize | undefined) => void; let _52!: rt.u8; @@ -1487,9 +1421,7 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const slice2 = rt.sliceRange(data, n); [_38, rt.sliceRange(slice2, n2)] as [rt.isize, Uint8Array]; b = _38; - _43 = rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32; - _47 = rt.u32Mul(2, 32); - shift = rt.u32Rem(_43, _47); + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); _52 = rt.u8Rem(op, 24); if (_52 === 0) { const part16 = rt.isizeAdd(a, b); @@ -1501,13 +1433,9 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part14 = rt.isizeMul(a, b); _50(out, part14); } else if (_52 === 3) { - b === -1; - a === -2147483648; const part13 = rt.isizeDiv(a, b); _50(out, part13); } else if (_52 === 4) { - b === -1; - a === -2147483648; const part12 = rt.isizeRem(a, b); _50(out, part12); } else if (_52 === 5) { @@ -1576,74 +1504,62 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { /** Negate, which overflows at the minimum. */ export function i8Neg(data: Uint8Array, out: rt.ByteVec): void { - let a!: rt.i8; let buf!: Uint8Array; let n!: rt.usize; buf = Uint8Array.of(0); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - a = ([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]) as rt.i128)); } /** Negate, which overflows at the minimum. */ export function i16Neg(data: Uint8Array, out: rt.ByteVec): void { - let a!: rt.i16; let buf!: Uint8Array; let n!: rt.usize; buf = rt.bytes(2); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - a = ([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]) as rt.i128)); } /** Negate, which overflows at the minimum. */ export function i32Neg(data: Uint8Array, out: rt.ByteVec): void { - let a!: rt.i32; let buf!: Uint8Array; let n!: rt.usize; buf = rt.bytes(4); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - a = ([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]) as rt.i128)); } /** Negate, which overflows at the minimum. */ export function i64Neg(data: Uint8Array, out: rt.ByteVec): void { - let a!: rt.i64; let buf!: Uint8Array; let n!: rt.usize; buf = rt.bytes(8); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - a = ([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a)))); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0])))); } /** Negate, which overflows at the minimum. */ export function i128Neg(data: Uint8Array, out: rt.ByteVec): void { - let a!: rt.i128; let buf!: Uint8Array; let n!: rt.usize; buf = rt.bytes(16); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - a = ([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(a))); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]))); } /** Negate, which overflows at the minimum. */ export function isizeNeg(data: Uint8Array, out: rt.ByteVec): void { - let a!: rt.isize; let buf!: Uint8Array; let n!: rt.usize; buf = rt.bytes(4); n = rt.min(data.length, buf.length); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - a = ([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]) as rt.i128)); } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 97f98afdd..a97ecace4 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -42,7 +42,6 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let rest!: rt.ByteVec; let pairs!: Uint8Array[]; let copies!: Uint8Array[]; - let _176!: rt.usize; let iter4!: rt.Iter; let _187!: Uint8Array | rt.Done; let v2!: rt.u16[]; @@ -172,11 +171,7 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { copies = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); if (!((copies.length === 0))) { const at = rt.idx(copies, 0); - _176 = 0; - if (!(_176 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _176); - } - copies[at][_176] = 85; + copies[at][0] = 85; } iter4 = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); while (true) { @@ -443,9 +438,6 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { let _234!: rt.RangeInclusive; let _237!: rt.usize; let _244!: rt.u64; - let _265!: rt.i64; - let _267!: rt.i64; - let _274!: rt.i64; let iter3!: { s: rt.u32[]; i: number }; let _289!: rt.u32 | rt.Done; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); @@ -530,10 +522,7 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { return _24; }), 0))); - _267 = rt.i64Of(9007199254740992n); - _265 = rt.i64Sub(rt.i64Neg(_267), 1); - _274 = rt.i64Of(9007199254740992n); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(_265, rt.i64Add(rt.i64Neg(_274), 1), rt.i64Step)), 0))); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0))); iter3 = { s: rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))), i: 0 }; while (true) { _289 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index b3ff3601d..9b33b30ed 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -98,10 +98,8 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { let pair!: [Point.Point, rt.u8]; let saved!: [Point.Point, rt.u8]; let grid!: Point.Point[]; - let _17!: rt.usize; let row!: Point.Point[]; let _20!: Point.Point; - let _21!: rt.usize; let _25!: rt.i32; let _26!: rt.i32; let _27!: rt.i32; @@ -110,10 +108,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { let _30!: rt.i32; let _31!: rt.i32; let _32!: rt.i32; - let _33!: rt.usize; let _35!: rt.i32; - let _36!: rt.usize; - let _39!: rt.usize; let iter!: rt.Iter; let _42!: rt.i32 | rt.Done; let a!: Point.Point; @@ -126,15 +121,10 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { let both!: [rt.u32, rt.u32]; let word!: Uint8Array; let converted!: rt.u32; - let _98!: rt.usize; - let _107!: rt.usize; let cell!: Uint8Array; let source!: Uint8Array; let returned!: Uint8Array; - let _122!: rt.usize; let _128!: rt.u8; - let _129!: rt.usize; - let _132!: rt.usize; let marked!: boolean; let opt!: Meters.Meters | undefined; let taken!: Meters.Meters | undefined; @@ -156,18 +146,10 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { grid = Array.from({ length: 3 }, (): Point.Point => { return rt.copy(item); }); - _17 = 1; - if (!(_17 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _17); - } - grid[_17].x = 9; + grid[1].x = 9; row = rt.copy(grid); _20 = rt.copy(q); - _21 = 2; - if (!(_21 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _21); - } - grid[_21] = rt.copy(_20); + grid[2] = rt.copy(_20); _25 = p.x; _26 = p.y; _27 = q.x; @@ -175,21 +157,9 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { _29 = r.x; _30 = saved[0].y; _31 = pair[0].y; - _33 = 1; - if (!(_33 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _33); - } - _32 = row[_33].x; - _36 = 2; - if (!(_36 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _36); - } - _35 = row[_36].x; - _39 = 2; - if (!(_39 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _39); - } - iter = rt.iterSlice([_25, _26, _27, _28, _29, _30, _31, _32, _35, grid[_39].x]); + _32 = row[1].x; + _35 = row[2].x; + iter = rt.iterSlice([_25, _26, _27, _28, _29, _30, _31, _32, _35, grid[2].x]); while (true) { _42 = iter.next(); if (_42 === rt.DONE) { @@ -215,35 +185,15 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); word = Uint8Array.of(0, 0, 0, data.length & 0xff); converted = rt.u32FromBeBytes(word); - _98 = 0; - if (!(_98 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _98); - } - word[_98] = 9; - _107 = 0; - if (!(_107 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _107); - } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[_107] as rt.u32))); + word[0] = 9; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); cell = Uint8Array.of(data.length & 0xff); rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); source = Uint8Array.of(data.length & 0xff); returned = same(rt.copy(source)); - _122 = 0; - if (!(_122 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _122); - } - source[_122] = 9; - _129 = 0; - if (!(_129 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _129); - } - _128 = returned[_129]; - _132 = 0; - if (!(_132 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _132); - } - rt.byteVecExtendFromSlice(out, Uint8Array.of(_128, source[_132])); + source[0] = 9; + _128 = returned[0]; + rt.byteVecExtendFromSlice(out, Uint8Array.of(_128, source[0])); rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); marked = mark(out, 1) === 0; mark(out, 2); @@ -272,18 +222,8 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { /** `a`'s byte, after writing `b`'s. */ export function writeThenRead(a: Uint8Array, b: Uint8Array): rt.u8 { - let _3!: rt.usize; - let _5!: rt.usize; - _3 = 0; - if (!(_3 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _3); - } - b[_3] = 9; - _5 = 0; - if (!(_5 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _5); - } - return a[_5]; + b[0] = 9; + return a[0]; } /** A copy of `a` read after `a` changes in place, which it doesn't see. */ @@ -326,7 +266,6 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { let n!: Uint8Array; let read!: Point.Point; let _37!: rt.i32; - let _39!: rt.usize; let _41!: rt.i32; let base!: Moved.Moved; let updated!: Moved.Moved; @@ -365,11 +304,7 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { _30 = mark(out, 7) & 0xff; pair = { _0: _30, _1: _28 }; n = Uint8Array.of(at(2)); - _39 = 0; - if (!(_39 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _39); - } - _37 = n[_39] as rt.i32; + _37 = n[0] as rt.i32; _41 = increment(n) as rt.i32; read = { x: _41, y: _37 }; base = { _0: at(4), _1: 0 }; @@ -424,17 +359,13 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { let _36!: Uint8Array; let second!: rt.u8; let _41!: Uint8Array; - let _44!: rt.usize; - let _46!: rt.usize; let f!: (a0: rt.u8) => rt.u8; let called!: rt.u8; let _50!: (a0: rt.u8) => rt.u8; let n!: rt.u8; let slots!: Uint8Array; let _58!: rt.u8; - let _59!: rt.usize; let _68!: rt.u8; - let _71!: rt.usize; at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; @@ -455,12 +386,8 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { rt.sliceCopyWithin(_36, 3, _36.length, 0); _41 = logged(bytes, out); rt.byteVecPush(out, 230); - _44 = 1; - _46 = _41.length; - if (!(_44 < _46)) { - rt.panic("index out of bounds: the len is " + _46 + " but the index is " + _44); - } - second = _41[_44]; + rt.idx(_41, 1); + second = _41[1]; f = halve; _50 = f; f = twice; @@ -469,17 +396,9 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { slots = rt.bytes(2); _58 = n; n = rt.u8WrappingAdd(n, 1); - _59 = 0; - if (!(_59 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _59); - } - slots[_59] = rt.u8Add(slots[_59], _58); + slots[0] = rt.u8Add(slots[0], _58); _68 = f(1); - _71 = 0; - if (!(_71 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _71); - } - rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, _68, slots[_71], n)); + rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, _68, slots[0], n)); rt.byteVecExtendFromSlice(out, bytes); } @@ -512,24 +431,9 @@ export function logged(data: Uint8Array, out: rt.ByteVec): Uint8Array { /** `n`'s byte, incremented. */ export function increment(n: Uint8Array): rt.u8 { let _2!: rt.u8; - let _4!: rt.usize; - let _6!: rt.usize; - let _8!: rt.usize; - _4 = 0; - if (!(_4 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _4); - } - _2 = rt.u8WrappingAdd(n[_4], 1); - _6 = 0; - if (!(_6 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _6); - } - n[_6] = _2; - _8 = 0; - if (!(_8 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _8); - } - return n[_8]; + _2 = rt.u8WrappingAdd(n[0], 1); + n[0] = _2; + return n[0]; } /** Changes `m`'s first field. */ @@ -600,9 +504,6 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let _34!: rt.usize; let j!: rt.usize; let _39!: rt.u8; - let _40!: rt.usize; - let _43!: rt.usize; - let _49!: rt.usize; let i2!: rt.usize; let j2!: rt.usize; let n!: rt.u64; @@ -613,7 +514,6 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let _84!: rt.u8 | rt.Done; let i3!: rt.i8; let lo!: rt.i32; - let _96!: rt.i32; let r!: rt.Range; let first!: rt.i32 | undefined; let second!: rt.i32 | undefined; @@ -659,20 +559,11 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { continue l2; } else { j = _34; - _40 = data.length; - if (!(i < _40)) { - rt.panic("index out of bounds: the len is " + _40 + " but the index is " + i); - } + rt.idx(data, i); _39 = data[i]; - _43 = data.length; - if (!(j < _43)) { - rt.panic("index out of bounds: the len is " + _43 + " but the index is " + j); - } + rt.idx(data, j); if (!(_39 === data[j])) { - _49 = data.length; - if (!(j < _49)) { - rt.panic("index out of bounds: the len is " + _49 + " but the index is " + j); - } + rt.idx(data, j); if (data[j] === 0) { continue l2; } @@ -718,8 +609,7 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { while (true) { if (!(i3 > -3)) { rt.byteVecPush(out, count); - _96 = rt.usizeRem(data.length, 4) | 0; - lo = rt.i32Neg(_96); + lo = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); r = new rt.Range(lo, rt.i32Add(lo, 3)); first = r.start < r.end ? r.start++ : undefined; r.end = r.start; @@ -942,18 +832,13 @@ export function brokenNever(data: Uint8Array): rt.u8 { let _0!: rt.u8; let i!: rt.usize; let _6!: rt.usize; - let _7!: rt.usize; let args2!: rt.Fmt[]; let _19!: rt.usize; - let _20!: rt.usize; i = 0; l0: while (true) { if (!(i >= data.length)) { _6 = i; - _7 = data.length; - if (!(_6 < _7)) { - rt.panic("index out of bounds: the len is " + _7 + " but the index is " + _6); - } + rt.idx(data, _6); const value = data[_6]; if (value === 251) { const arg = ([i] as [rt.usize])[0]; @@ -962,10 +847,7 @@ export function brokenNever(data: Uint8Array): rt.u8 { return _0; } else if (value === 252) { _19 = i; - _20 = data.length; - if (!(_19 < _20)) { - rt.panic("index out of bounds: the len is " + _20 + " but the index is " + _19); - } + rt.idx(data, _19); bail(data[_19]); return _0; } else if (value === 0) { @@ -988,20 +870,14 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { let _0!: rt.u8; let i!: rt.usize; let _8!: rt.usize; - let _9!: rt.usize; let args2!: rt.Fmt[]; let _22!: rt.usize; - let _23!: rt.usize; let _32!: rt.usize; - let _33!: rt.usize; i = 0; l0: while (true) { if (!(i >= data.length)) { _8 = i; - _9 = data.length; - if (!(_8 < _9)) { - rt.panic("index out of bounds: the len is " + _9 + " but the index is " + _8); - } + rt.idx(data, _8); const value = data[_8]; if (value === 239) { const arg = ([i] as [rt.usize])[0]; @@ -1010,10 +886,7 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { return _0; } else if (value === 240) { _22 = i; - _23 = data.length; - if (!(_22 < _23)) { - rt.panic("index out of bounds: the len is " + _23 + " but the index is " + _22); - } + rt.idx(data, _22); bail(data[_22]); return _0; } else if (value === 0) { @@ -1023,10 +896,7 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { i = rt.usizeAdd(i, 1); if (!(i >= data.length)) { _32 = i; - _33 = data.length; - if (!(_32 < _33)) { - rt.panic("index out of bounds: the len is " + _33 + " but the index is " + _32); - } + rt.idx(data, _32); if (!(data[_32] < 128)) { continue l2; } @@ -1131,14 +1001,10 @@ export function firstRepeat(data: Uint8Array): rt.u8 { let i!: rt.usize; let j!: rt.usize; let _14!: rt.usize; - let _15!: rt.usize; let _20!: rt.u8; let _21!: rt.usize; - let _22!: rt.usize; let _25!: rt.usize; - let _26!: rt.usize; let _29!: rt.usize; - let _30!: rt.usize; i = 0; l0: while (true) { if (!(i >= data.length)) { @@ -1149,30 +1015,18 @@ export function firstRepeat(data: Uint8Array): rt.u8 { continue l0; } else { _14 = j; - _15 = data.length; - if (!(_14 < _15)) { - rt.panic("index out of bounds: the len is " + _15 + " but the index is " + _14); - } + rt.idx(data, _14); if (!(data[_14] === 0)) { _21 = i; - _22 = data.length; - if (!(_21 < _22)) { - rt.panic("index out of bounds: the len is " + _22 + " but the index is " + _21); - } + rt.idx(data, _21); _20 = data[_21]; _25 = j; - _26 = data.length; - if (!(_25 < _26)) { - rt.panic("index out of bounds: the len is " + _26 + " but the index is " + _25); - } + rt.idx(data, _25); if (!(_20 === data[_25])) { j = rt.usizeAdd(j, 1); } else { _29 = j; - _30 = data.length; - if (!(_29 < _30)) { - rt.panic("index out of bounds: the len is " + _30 + " but the index is " + _29); - } + rt.idx(data, _29); return data[_29] ^ (i & 0xff); } } else { @@ -1192,7 +1046,6 @@ export function tailBreak(data: Uint8Array): rt.u16 { let i!: rt.usize; let b!: rt.u8; let _7!: rt.usize; - let _8!: rt.usize; let _11!: rt.u8; let iter!: { s: Uint8Array; i: number }; let _18!: rt.u8 | rt.Done; @@ -1202,10 +1055,7 @@ export function tailBreak(data: Uint8Array): rt.u16 { l0: while (true) { if (!(i >= data.length)) { _7 = i; - _8 = data.length; - if (!(_7 < _8)) { - rt.panic("index out of bounds: the len is " + _8 + " but the index is " + _7); - } + rt.idx(data, _7); b = data[_7]; i = rt.usizeAdd(i, 1); _11 = rt.u8Rem(b, 4); @@ -1251,9 +1101,7 @@ export function armLoop(data: Uint8Array): rt.u8 { let k!: rt.usize; let _3!: rt.u8 | undefined; let _13!: rt.usize; - let _14!: rt.usize; let _17!: rt.usize; - let _18!: rt.usize; k = 0; _3 = rt.sliceFirst(data); if (_3 !== undefined) { @@ -1264,18 +1112,12 @@ export function armLoop(data: Uint8Array): rt.u8 { while (true) { if (!(k >= data.length)) { _13 = k; - _14 = data.length; - if (!(_13 < _14)) { - rt.panic("index out of bounds: the len is " + _14 + " but the index is " + _13); - } + rt.idx(data, _13); if (!(data[_13] >= 128)) { k = rt.usizeAdd(k, 1); } else { _17 = k; - _18 = data.length; - if (!(_17 < _18)) { - rt.panic("index out of bounds: the len is " + _18 + " but the index is " + _17); - } + rt.idx(data, _17); return rt.u8Sub(data[_17], 128); } } else { @@ -1288,15 +1130,11 @@ export function armLoop(data: Uint8Array): rt.u8 { export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { let i!: rt.usize; let _9!: rt.usize; - let _10!: rt.usize; i = 0; l0: while (true) { if (!(i === items.length)) { _9 = i; - _10 = items.length; - if (!(_9 < _10)) { - rt.panic("index out of bounds: the len is " + _10 + " but the index is " + _9); - } + rt.idx(items, _9); if (!((items[_9] === want))) { i = rt.usizeAdd(i, 1); continue l0; @@ -1313,15 +1151,11 @@ export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { export function drain(data: Uint8Array, out: rt.ByteVec): void { let i!: rt.usize; let _10!: rt.usize; - let _11!: rt.usize; i = 0; while (true) { if (!(i >= data.length)) { _10 = i; - _11 = data.length; - if (!(_10 < _11)) { - rt.panic("index out of bounds: the len is " + _11 + " but the index is " + _10); - } + rt.idx(data, _10); rt.byteVecPush(out, data[_10] ^ 90); i = rt.usizeAdd(i, 2); } else { @@ -1344,11 +1178,9 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { let _74!: rt.i64; let width2!: rt.u16; let height!: rt.u16; - let _79!: rt.i64; let a!: Point.Point; let b2!: Point.Point; let bytes!: Uint8Array; - let _107!: rt.usize; let parsed!: rt.Result; let a2!: rt.u8; let b3!: rt.u8; @@ -1399,8 +1231,7 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { if (!(shape_.corner.x > 0)) { width2 = shape_.width; height = shape_.height; - _79 = rt.i64Mul(width2 as rt.i64, height as rt.i64); - area = rt.i64Neg(_79); + area = rt.i64Neg(rt.i64Mul(width2 as rt.i64, height as rt.i64)); break b7; } else { x = shape_.corner.x; @@ -1414,11 +1245,7 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); bytes = Uint8Array.of(data.length & 0xff, 1, 2); - _107 = 0; - if (!(_107 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _107); - } - bytes.subarray(1, 3)[_107] = 9; + bytes.subarray(1, 3)[0] = 9; rt.byteVecExtendFromSlice(out, bytes); rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)))); parsed = rt.Ok(data.length & 0xff); @@ -1476,7 +1303,6 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { let iter!: { s: Uint8Array; i: number }; let _8!: rt.u8 | rt.Done; let whole!: Uint8Array; - let _36!: rt.usize; let parsed!: Array; let iter2!: { s: Uint8Array; i: number }; let _41!: rt.u8 | rt.Done; @@ -1500,11 +1326,7 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { }, sum))); whole = Uint8Array.of(data.length & 0xff); overwrite(whole); - _36 = 0; - if (!(_36 < 1)) { - rt.panic("index out of bounds: the len is " + 1 + " but the index is " + _36); - } - rt.byteVecPush(out, whole[_36]); + rt.byteVecPush(out, whole[0]); parsed = []; iter2 = { s: data, i: 0 }; while (true) { diff --git a/ts/fixtures/lang/src/fmt.rs b/ts/fixtures/lang/src/fmt.rs index 67ee6347a..90860d2be 100644 --- a/ts/fixtures/lang/src/fmt.rs +++ b/ts/fixtures/lang/src/fmt.rs @@ -350,7 +350,7 @@ pub fn written(data: &[u8], out: &mut Vec) { /// Panics, each with the message native Rust formats. pub fn panics(kind: u8, rest: &[u8], out: &mut Vec) { let n = rest.first().copied().unwrap_or(0); - match kind % 19 { + match kind % 20 { 0 => panic!("bad {n}: {:?}", rest), 1 => unreachable!("never {n:#x} {}", Hex(n.into())), 2 => assert!(n > 200, "small {} {:?}", n, Pair(n, 0)), @@ -405,6 +405,7 @@ pub fn panics(kind: u8, rest: &[u8], out: &mut Vec) { buf.copy_within((n % 6) as usize..(n / 6 % 6) as usize, dest); put(out, &format!("{buf:?}")); } + 18 => put(out, &rest[(n % 8) as usize].to_string()), _ => { let r: Result = if n % 2 == 0 { Err(n) } else { Ok(n) }; put(out, &format!("{}", r.unwrap_err())); diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index e1cd13178..eb5a38ccc 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -22,8 +22,6 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { let _23!: rt.usize; let _24!: rt.Weak; let _27!: rt.usize; - let _28!: rt.usize; - let _31!: rt.usize; let live!: rt.Weak[]; let iter2!: { s: rt.Weak[]; i: number }; let _43!: rt.Weak | rt.Done; @@ -67,9 +65,7 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { _23 = self.cursor; const at = rt.idx(self.entries, _23); if (!(self.entries[at].arc.strong === 0)) { - _28 = rt.usizeAdd(self.cursor, 1); - _31 = self.entries.length; - self.cursor = rt.usizeRem(_28, _31); + self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.length); probes = rt.usizeSub(probes, 1); } else { _24 = weak; diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index ae89a760b..e85ed3fb1 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -195,6 +195,8 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { /// Statements that change nothing: a swap through a temporary nothing else names, as /// an async body moves its context at each `await`. noops: FxHashSet<(BasicBlock, usize)>, + /// The lengths a bounds check compares with, of the slices whose `rt.idx` it is. + idx_of: FxHashMap>, /// Each block's one predecessor, if it has one. sole_pred: FxHashMap, /// What the cleanup variable holds as each block lowered so far leaves. @@ -246,6 +248,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { stepped_borrows: FxHashMap::default(), noops: FxHashSet::default(), sole_pred: FxHashMap::default(), + idx_of: FxHashMap::default(), unwind_out: FxHashMap::default(), }; fx.analyze(); @@ -261,6 +264,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn analyze(&mut self) { let mir = self.mir; self.find_noops(); + let mut bounds = Vec::new(); for (bb, data) in mir.basic_blocks.iter_enumerated() { if data.statements.iter().all(|s| { matches!( @@ -331,18 +335,35 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // The assert after checked arithmetic reads `.1`, which lowering folds away. let folded = matches!(cond, Operand::Move(p) | Operand::Copy(p) if p.projection.len() == 1 && self.checked.contains(&p.local)); - if !folded && !redundant(msg) { + if let mir::AssertKind::BoundsCheck { len, index } = &**msg { + // Counted once every length's definition is known. + bounds.push((cond, len, index)); + } else if !folded && !redundant(msg) { self.operand_use(cond); - // Only a bounds check's message shows its operands. - if let mir::AssertKind::BoundsCheck { len, index } = &**msg { - self.operand_use(len); - self.operand_use(index); - } } } _ => {} } } + // A bounds check of a slice's length is `rt.idx` of the slice; others test their + // condition, and show their operands. + for (cond, len, index) in bounds { + if let Operand::Copy(l) | Operand::Move(l) = len + && let Some(l) = l.as_local() + && let Some(Rvalue::UnaryOp(mir::UnOp::PtrMetadata, Operand::Copy(slice) | Operand::Move(slice))) = + self.def_rvalue(l) + && self.stable(*slice) + { + self.idx_of.insert(l, *slice); + self.place_use(*slice); + self.operand_use(index); + continue; + } + self.operand_use(cond); + self.operand_use(len); + self.operand_use(index); + } + self.drop_unread(); self.find_next_results(); self.find_stepped(); self.unborrow_passed(); @@ -405,6 +426,57 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } + /// Uncount the reads of what computes a local nothing reads without doing anything + /// else, as the test of an assert a runtime function checks for itself is. + fn drop_unread(&mut self) { + let mir = self.mir; + let mut computed: IndexVec>> = + IndexVec::from_elem_n(Vec::new(), mir.local_decls.len()); + let mut pure = IndexVec::from_elem_n(true, mir.local_decls.len()); + for (bb, data) in mir.basic_blocks.iter_enumerated() { + for (i, stmt) in data.statements.iter().enumerate() { + if self.noops.contains(&(bb, i)) { + continue; + } + if let StatementKind::Assign(assign) = &stmt.kind + && let Some(local) = assign.0.as_local() + { + match &assign.1 { + r @ (Rvalue::BinaryOp(..) | Rvalue::UnaryOp(..) | Rvalue::Use(..)) => computed[local].push(r), + _ => pure[local] = false, + } + } + } + if let TerminatorKind::Call { destination, .. } = &data.terminator().kind { + pure[destination.local] = false; + } + } + let mut work: Vec = mir.local_decls.indices().collect(); + while let Some(local) = work.pop() { + if self.uses[local] != 0 || !pure[local] || self.is_arg(local) || local == mir::RETURN_PLACE { + continue; + } + for rvalue in std::mem::take(&mut computed[local]) { + let ops: Vec<&Operand<'tcx>> = match rvalue { + Rvalue::BinaryOp(_, ops) => vec![&ops.0, &ops.1], + Rvalue::UnaryOp(_, op) | Rvalue::Use(op, _) => vec![op], + _ => unreachable!("collected above"), + }; + for op in ops { + if let Operand::Copy(p) | Operand::Move(p) = op { + self.uses[p.local] -= 1; + for elem in p.projection { + if let mir::ProjectionElem::Index(index) = elem { + self.uses[index] -= 1; + } + } + work.push(p.local); + } + } + } + } + } + /// A local nothing changes whose one read is a shared borrow, itself read once, is /// read once where the borrow is: it folds like a local nothing borrows, as an array /// made to pass as a slice does. @@ -584,6 +656,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.context_of_arg(local) { return true; } + // A number or a flag assigned once from a constant: the constant. + if let Rvalue::Use(Operand::Constant(_), _) = rvalue + && !self.mutated[local] + { + let ty = mir.local_decls[local].ty; + return ty.is_bool() || crate::lower::num::Int::of(ty).is_some_and(|i| !i.big()); + } match (mir.local_decls[local].ty.kind(), rvalue) { // A borrow: borrow checking keeps the place as it is but through the borrow, // unless the path to it goes through a reference held in a field or element, @@ -1522,6 +1601,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Rvalue::CopyForDeref(p) => self.place_expr(*p, span, out), Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) => self.place_expr(*p, span, out), Rvalue::Cast(_, Operand::Copy(p) | Operand::Move(p), _) => self.place_expr(*p, span, out), + Rvalue::Use(op @ Operand::Constant(_), _) => self.operand(op, span, out), // The task's context, wrapped. Rvalue::Aggregate(_, ops) => match &ops[rustc_abi::FieldIdx::ZERO] { Operand::Copy(p) | Operand::Move(p) => self.place_expr(*p, span, out), @@ -1831,6 +1911,17 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if redundant(msg) { return; } + if let mir::AssertKind::BoundsCheck { len, index } = msg + && let Operand::Copy(l) | Operand::Move(l) = len + && let Some(&slice) = l.as_local().and_then(|l| self.idx_of.get(&l)) + { + let mut pre = Vec::new(); + let slice = self.place_expr(slice, span, &mut pre); + let index = self.operand(index, span, &mut pre); + pre.push(StmtKind::Expr(Expr::rt("idx", vec![slice, index])).at(self.b.t.loc(span))); + self.emit(pre, None, false, out); + return; + } let mut pre = Vec::new(); let value = self.operand(cond, span, &mut pre); let mut exprs = vec![value]; diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index ce462f802..3f9dda273 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -254,6 +254,7 @@ fn shake(out: &Path) { "Panic", "checked", "clamp", + "idx", "max", "panic", "sliceRange", From 65ffb1f32307d70ebd9d405982d78fe4315ab399 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 18:59:22 -0700 Subject: [PATCH 09/17] test(ts): signed division and remainder by a constant Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/lang/expected/ints.ts | 24 ++++++++++++++++++++++++ ts/fixtures/lang/src/ints.rs | 3 +++ 2 files changed, 27 insertions(+) diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index bae867873..95025aa1b 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -123,6 +123,8 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x | (1 << 3); x = x ^ b; x = x & (~(1 << 2) & 0xff); + x = rt.u8Rem(x, 7); + x = rt.u8Div(x, 3); _50(out, x); } } @@ -248,6 +250,8 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x | (1 << 3); x = x ^ b; x = x & (~(1 << 2) & 0xffff); + x = rt.u16Rem(x, 7); + x = rt.u16Div(x, 3); _50(out, x); } } @@ -373,6 +377,8 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = (x | (1 << 3)) >>> 0; x = (x ^ b) >>> 0; x = (x & (~(1 << 2) >>> 0)) >>> 0; + x = rt.u32Rem(x, 7); + x = rt.u32Div(x, 3); _50(out, x); } } @@ -498,6 +504,8 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.u64Or(x, 8); x = rt.u64Xor(x, b); x = rt.u64And(x, rt.u64Not(4)); + x = rt.u64Rem(x, 7); + x = rt.u64Div(x, 3); _50(out, x); } } @@ -623,6 +631,8 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.u128Or(x, rt.u128Shl(1, 3)); x = rt.u128Xor(x, b); x = rt.u128And(x, rt.u128Not(rt.u128Shl(1, 2))); + x = rt.u128Rem(x, 7); + x = rt.u128Div(x, 3); _50(out, x); } } @@ -748,6 +758,8 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = (x | (1 << 3)) >>> 0; x = (x ^ b) >>> 0; x = (x & (~(1 << 2) >>> 0)) >>> 0; + x = rt.usizeRem(x, 7); + x = rt.usizeDiv(x, 3); _50(out, x); } } @@ -873,6 +885,8 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x | (1 << 3); x = x ^ b; x = x & ~(1 << 2); + x = rt.i8Rem(x, 7); + x = rt.i8Div(x, 3); _50(out, x); } } @@ -998,6 +1012,8 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x | (1 << 3); x = x ^ b; x = x & ~(1 << 2); + x = rt.i16Rem(x, 7); + x = rt.i16Div(x, 3); _50(out, x); } } @@ -1123,6 +1139,8 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x | (1 << 3); x = x ^ b; x = x & ~(1 << 2); + x = rt.i32Rem(x, 7); + x = rt.i32Div(x, 3); _50(out, x); } } @@ -1248,6 +1266,8 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.i64Or(x, 8); x = rt.i64Xor(x, b); x = rt.i64And(x, rt.i64Not(4)); + x = rt.i64Rem(x, 7); + x = rt.i64Div(x, 3); _50(out, x); } } @@ -1373,6 +1393,8 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = rt.i128Or(x, rt.i128Shl(1, 3)); x = rt.i128Xor(x, b); x = rt.i128And(x, rt.i128Not(rt.i128Shl(1, 2))); + x = rt.i128Rem(x, 7); + x = rt.i128Div(x, 3); _50(out, x); } } @@ -1498,6 +1520,8 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { x = x | (1 << 3); x = x ^ b; x = x & ~(1 << 2); + x = rt.isizeRem(x, 7); + x = rt.isizeDiv(x, 3); _50(out, x); } } diff --git a/ts/fixtures/lang/src/ints.rs b/ts/fixtures/lang/src/ints.rs index 307fc9541..52a3d12be 100644 --- a/ts/fixtures/lang/src/ints.rs +++ b/ts/fixtures/lang/src/ints.rs @@ -71,6 +71,9 @@ macro_rules! ops { x |= 1 << 3; x ^= b; x &= !(1 << 2); + // By a constant, whose overflow check a signed type folds. + x %= 7; + x /= 3; put(out, x); } } From 40a62cd33b72b7961edab265ec5ffff67856d76b Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 19:04:03 -0700 Subject: [PATCH 10/17] feat(ts): `?` on a Result in a function returning Poll Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/lang/expected/shapes.ts | 55 ++++++++++++++++++++++++----- ts/fixtures/lang/src/shapes.rs | 15 ++++++++ ts/src/lower/mir/call.rs | 16 +++++++-- 3 files changed, 75 insertions(+), 11 deletions(-) diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 9b33b30ed..56e8e0ec5 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -1372,9 +1372,12 @@ export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): r export function library(data: Uint8Array, out: rt.ByteVec): void { let _3!: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined; let a!: rt.u8; + let b!: rt.u8; let parsed!: rt.Result; let mapped!: rt.Result; - let _30!: rt.Result; + let _30!: (a0: rt.u8) => rt.Poll>; + let _32!: rt.Poll>; + let _45!: rt.Result; let s!: string; _3 = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { let _4!: rt.u8 | undefined; @@ -1391,26 +1394,60 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { return undefined; } }; + _30 = (a3: rt.u8): rt.Poll> => { + let half!: rt.Result; + let _43!: Dir.Dir | undefined; + let _132!: rt.Result; + let residual!: rt.Result; + _43 = dir(a3); + b0: { + if (_43 !== undefined) { + if (rt.u8Rem(a3, 2) === 1) { + half = rt.Err(_43); + break b0; + } + } + half = rt.Ok(rt.u8Div(a3, 2)); + } + _132 = half; + if (_132.ok) { + return rt.Ok(_132.value); + } else { + residual = _132; + return rt.Err(from$From_Dir_u8((residual as { ok: false; error: Dir.Dir }).error)); + } + }; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, rt.optionUnwrapOr(rt.sliceGet(data, 1), 0)), 255)); + b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); + rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, b), 255)); if (a === 0) { parsed = rt.Err("zero"); } else { parsed = rt.Ok(a); } - mapped = rt.resultMapErr(rt.resultMap(parsed, (n3: rt.u8): rt.u8 => { - return rt.u8Div(n3, 2); - }), (e: string): rt.u8 => { - return rt.stringLen(e) & 0xff; + mapped = rt.resultMapErr(rt.resultMap(parsed, (n5: rt.u8): rt.u8 => { + return rt.u8Div(n5, 2); + }), (e2: string): rt.u8 => { + return rt.stringLen(e2) & 0xff; }); if (mapped.ok) { rt.byteVecExtendFromSlice(out, Uint8Array.of(0, mapped.value)); } else { rt.byteVecExtendFromSlice(out, Uint8Array.of(1, mapped.error)); } - _30 = rt.stringFromUtf8(rt.sliceToByteVec(data)); - if (_30.ok) { - s = _30.value; + _32 = _30(b); + if (_32 !== rt.Pending) { + if (_32.ok) { + rt.byteVecExtendFromSlice(out, Uint8Array.of(2, _32.value)); + } else { + rt.byteVecExtendFromSlice(out, Uint8Array.of(3, _32.error)); + } + } else { + rt.byteVecPush(out, 4); + } + _45 = rt.stringFromUtf8(rt.sliceToByteVec(data)); + if (_45.ok) { + s = _45.value; rt.byteVecPush(out, 1); rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.stringLen(s) as rt.u32)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); diff --git a/ts/fixtures/lang/src/shapes.rs b/ts/fixtures/lang/src/shapes.rs index 236e5f1d6..38d2bacc5 100644 --- a/ts/fixtures/lang/src/shapes.rs +++ b/ts/fixtures/lang/src/shapes.rs @@ -979,6 +979,21 @@ pub fn library(data: &[u8], out: &mut Vec) { Err(n) => out.extend_from_slice(&[1, n]), } + // `?` in a function that returns a `Poll`, converting the error. + let ready = |a: u8| -> std::task::Poll> { + let half: Result = match dir(a) { + Some(d) if a % 2 == 1 => Err(d), + _ => Ok(a / 2), + }; + let n = half?; + std::task::Poll::Ready(Ok(n)) + }; + match ready(b) { + std::task::Poll::Ready(Ok(n)) => out.extend_from_slice(&[2, n]), + std::task::Poll::Ready(Err(e)) => out.extend_from_slice(&[3, e]), + std::task::Poll::Pending => out.push(4), + } + match String::from_utf8(data.to_vec()) { Ok(s) => { out.push(1); diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index d76b1f550..d52ee0c9f 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -381,9 +381,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let to = targ(0)?; let residual = targ(1)?; let value = self.operand(&args[0].node, span, out); - match (self.b.t.std_of(to), to.kind(), residual.kind()) { + // What a `Result` residual goes into: a `Result`, or one that is ready, which + // is the same value. + let result = match (self.b.t.std_of(to), to.kind()) { + (Some(Std::Result), _) => Some(to), + (Some(Std::Poll), ty::Adt(_, poll_args)) => { + let inner = poll_args.type_at(0); + (self.b.t.std_of(inner) == Some(Std::Result)).then_some(inner) + } + _ => None, + }; + match (self.b.t.std_of(to), result.map(|r| r.kind()), residual.kind()) { (Some(Std::Option), ..) => done(Expr::undefined(), false), - (Some(Std::Result), ty::Adt(_, to_args), ty::Adt(_, from_args)) => { + (_, Some(ty::Adt(_, to_args)), ty::Adt(_, from_args)) + if self.b.t.std_of(residual) == Some(Std::Result) => + { let (from, to) = (from_args.type_at(1), to_args.type_at(1)); if from == to { return done(value, false); From 22721ccf80c4211374b7e623ba30519e738176e8 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 19:06:20 -0700 Subject: [PATCH 11/17] feat(ts): constant inclusive ranges Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/lang/expected/iters.ts | 61 +++++++++++++++--------------- ts/fixtures/lang/src/iters.rs | 4 ++ ts/src/lower/consts.rs | 11 ++++++ 3 files changed, 46 insertions(+), 30 deletions(-) diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index a97ecace4..2399de827 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -421,25 +421,25 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { let inclusive!: rt.RangeInclusive; let near!: rt.RangeInclusive; let low!: rt.RangeInclusive; - let _107!: rt.usize; - let _119!: rt.u8; + let _113!: rt.usize; + let _125!: rt.u8; let reversed!: rt.RangeInclusive; - let _126!: rt.Iter; + let _132!: rt.Iter; let counted!: rt.Iter<[rt.usize, rt.u8]>; let i3!: rt.usize; let n!: rt.u8; - let _143!: [rt.usize, rt.u8]; - let _146!: rt.usize; + let _149!: [rt.usize, rt.u8]; + let _152!: rt.usize; let stepped!: rt.RangeInclusive; let wide!: rt.Range; let edge!: rt.u64; let past!: rt.Range; - let _217!: rt.usize; - let _234!: rt.RangeInclusive; - let _237!: rt.usize; - let _244!: rt.u64; + let _223!: rt.usize; + let _240!: rt.RangeInclusive; + let _243!: rt.usize; + let _250!: rt.u64; let iter3!: { s: rt.u32[]; i: number }; - let _289!: rt.u32 | rt.Done; + let _295!: rt.u32 | rt.Done; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); range = new rt.Range(a, b); @@ -466,6 +466,7 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(new rt.RangeInclusive(32, 127, rt.u64Step), a as rt.u64) ? 1 : 0); near = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 238)); rt.byteVecPush(out, rt.rangeInclusiveStart(near)); @@ -473,21 +474,21 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); low = new rt.RangeInclusive(0, b, rt.u8Step); - _107 = rt.usizeRem(a as rt.usize, 16); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(_107)), 238)); + _113 = rt.usizeRem(a as rt.usize, 16); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(_113)), 238)); rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); - _119 = rt.u8Div(b, 2); - rt.byteVecPush(out, rt.rangeInclusiveContains(low, _119) ? 1 : 0); + _125 = rt.u8Div(b, 2); + rt.byteVecPush(out, rt.rangeInclusiveContains(low, _125) ? 1 : 0); reversed = new rt.RangeInclusive(a, b, rt.u8Step); - _126 = rt.iterRev(reversed); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_126, a as rt.usize), 238)); + _132 = rt.iterRev(reversed); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_132, a as rt.usize), 238)); rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); counted = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); - _146 = rt.usizeDiv(b as rt.usize, 4); - _143 = rt.optionUnwrapOr(rt.iterNth(counted, _146), [221, 221] as [rt.usize, rt.u8]); - i3 = _143[0]; - n = _143[1]; + _152 = rt.usizeDiv(b as rt.usize, 4); + _149 = rt.optionUnwrapOr(rt.iterNth(counted, _152), [221, 221] as [rt.usize, rt.u8]); + i3 = _149[0]; + n = _149[1]; rt.byteVecPush(out, i3 & 0xff); rt.byteVecPush(out, n); rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 204, (_2: [rt.usize, rt.u8]): rt.u8 => { @@ -509,14 +510,14 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0))); edge = rt.u64Add(rt.u64Sub(rt.u64Of(9007199254740992n), 2), rt.u64Rem(a as rt.u64, 4)); past = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); - _217 = rt.usizeRem(b as rt.usize, 3); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _217), 0))); + _223 = rt.usizeRem(b as rt.usize, 3); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _223), 0))); rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); - _234 = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); - _237 = rt.usizeRem(b as rt.usize, 5); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_234, _237), 0))); - _244 = rt.u64Rem(a as rt.u64, 3); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _244), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { + _240 = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); + _243 = rt.usizeRem(b as rt.usize, 5); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_240, _243), 0))); + _250 = rt.u64Rem(a as rt.u64, 3); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _250), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { return rt.u64Rem(n4, 7); }), rt.u64Add, 0))); rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { @@ -525,12 +526,12 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0))); iter3 = { s: rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))), i: 0 }; while (true) { - _289 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; - if (_289 === rt.DONE) { + _295 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; + if (_295 === rt.DONE) { updates(a, b, data, out); return; } else { - rt.byteVecPush(out, _289 & 0xff); + rt.byteVecPush(out, _295 & 0xff); } } } else { diff --git a/ts/fixtures/lang/src/iters.rs b/ts/fixtures/lang/src/iters.rs index 75ddd7bd2..be5240292 100644 --- a/ts/fixtures/lang/src/iters.rs +++ b/ts/fixtures/lang/src/iters.rs @@ -247,6 +247,10 @@ pub fn ranges(data: &[u8], out: &mut Vec) { out.push(*inclusive.start()); out.push(*inclusive.end()); out.push(inclusive.contains(&b) as u8); + // Of constants, which is itself a constant. + const LOW: u64 = 0x20; + const HIGH: u64 = 0x7f; + out.push((LOW..=HIGH).contains(&u64::from(a)) as u8); // `nth` past the end, or past the type's last value, leaves the range as std's does. let mut near = a.max(200)..=255; out.push(near.nth(b as usize).unwrap_or(0xee)); diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index d0d51c628..70ab25cfe 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -100,6 +100,17 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { (Std::Option, _) => values.pop().unwrap(), (Std::Result, 0) => Expr::rt("Ok", values), (Std::Result, _) => Expr::rt("Err", values), + // `start..=end`, not yet stepped past its end. + (Std::RangeInclusive, _) + if values.len() == 3 && matches!(&values[2], Expr::Lit(l) if l == "false") => + { + values.pop(); + let ty::Adt(_, args) = ty.kind() else { + unreachable!("matched above") + }; + values.extend(crate::lower::num::Int::of(args.type_at(0)).map(|int| int.func("step"))); + Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) + } _ => self.err(span, format!("a constant of type `{ty}`")), }; } From f4955b010603c32fd187e04503a4f1ed17fc0987 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 19:18:25 -0700 Subject: [PATCH 12/17] test(ts): move the drops MIR lowers out of the reject fixture The reject fixture held constructs THIR refused that MIR lowers: temporaries, scrutinees, skipped pattern parts, empty repeats, closures consumed by their call, iterators that drop after their loop, and values held across an await. They move into the task fixture, whose guards log each drop against native Rust, and the lang fixture, which gains or-bindings, a move closure's copy, and an empty repeat. Two bugs they found: an empty array MIR never assigns read as an undeclared name, and a dropped closure that owns a value that drops failed inside std's drop glue span. It now refuses at its drop. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/lang/expected/shapes.ts | 55 +- ts/fixtures/lang/src/shapes.rs | 17 + ts/fixtures/reject/census.md | 280 +++--- ts/fixtures/reject/expected.txt | 98 +- ts/fixtures/reject/src/lib.rs | 123 +-- ts/fixtures/reject/ts.toml | 14 - ts/fixtures/task/expected/model.Countdown.ts | 31 + ts/fixtures/task/expected/model.ts | 920 ++++++++++++++----- ts/fixtures/task/src/model.rs | 86 +- ts/src/lower/drop.rs | 8 + ts/src/lower/mir/glue.rs | 2 +- ts/src/lower/mir/mod.rs | 16 +- 12 files changed, 1069 insertions(+), 581 deletions(-) create mode 100644 ts/fixtures/task/expected/model.Countdown.ts diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 56e8e0ec5..9c78825d6 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -1180,11 +1180,13 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { let height!: rt.u16; let a!: Point.Point; let b2!: Point.Point; + let either!: rt.Result; + let v!: rt.u8; let bytes!: Uint8Array; let parsed!: rt.Result; let a2!: rt.u8; let b3!: rt.u8; - let _143!: string; + let _166!: string; let args2!: rt.Fmt[]; if (!(data.length === 0)) { if (!(data.length === 1)) { @@ -1244,6 +1246,18 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { area = 0; } rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); + if (!(rt.usizeRem(data.length, 2) === 0)) { + either = rt.Err(160); + } else { + either = rt.Ok(data.length & 0xff); + } + if (either.ok) { + v = either.value; + } else { + v = either.error; + } + rt.byteVecPush(out, v); + rt.byteVecPush(out, rt.u8Add(Uint8Array.of().length & 0xff, rt.iterSum(rt.iterSlice(Uint8Array.of()), rt.u8Add, 0))); bytes = Uint8Array.of(data.length & 0xff, 1, 2); bytes.subarray(1, 3)[0] = 9; rt.byteVecExtendFromSlice(out, bytes); @@ -1254,8 +1268,8 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2))); const arg = ([parsed] as [rt.Result])[0]; args2 = [(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; - _143 = rt.fmtFormat([args2[0]]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_143)); + _166 = rt.fmtFormat([args2[0]]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_166)); return; } else { b2: { @@ -1302,15 +1316,17 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { let add!: (a0: rt.u8) => void; let iter!: { s: Uint8Array; i: number }; let _8!: rt.u8 | rt.Done; + let base!: rt.u32; + let n!: rt.u32; let whole!: Uint8Array; let parsed!: Array; let iter2!: { s: Uint8Array; i: number }; - let _41!: rt.u8 | rt.Done; - let _47!: Dir.Dir | undefined; + let _53!: rt.u8 | rt.Done; + let _59!: Dir.Dir | undefined; let tags!: rt.ByteVec; let iter3!: { s: Array; i: number }; - let _52!: Dir.Dir | undefined | rt.Done; - let _58!: rt.u8; + let _64!: Dir.Dir | undefined | rt.Done; + let _70!: rt.u8; sum = 0; add = (v: rt.u8): void => { sum = rt.u32Add(sum, v as rt.u32); @@ -1320,33 +1336,40 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { _8 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; if (_8 === rt.DONE) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); - const captured = data.length as rt.u32; + base = data.length as rt.u32; + const captured = base; rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { return rt.u32Add(rt.u32Mul(v2, 3), captured); }, sum))); + n = base; + const captured2 = n; + n = rt.u32Add(n, 10); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { + return rt.u32Add(captured2, 1); + })(), n))); whole = Uint8Array.of(data.length & 0xff); overwrite(whole); rt.byteVecPush(out, whole[0]); parsed = []; iter2 = { s: data, i: 0 }; while (true) { - _41 = iter2.i < iter2.s.length ? iter2.s[iter2.i++] : rt.DONE; - if (_41 === rt.DONE) { + _53 = iter2.i < iter2.s.length ? iter2.s[iter2.i++] : rt.DONE; + if (_53 === rt.DONE) { tags = new rt.ByteVec(); iter3 = { s: parsed, i: 0 }; while (true) { - _52 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; - if (_52 === rt.DONE) { + _64 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; + if (_64 === rt.DONE) { rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); return; } else { - _58 = rt.optionUnwrapOr(rt.optionMap(_52, from$From_Dir_u8), 0); - rt.byteVecPush(tags, _58); + _70 = rt.optionUnwrapOr(rt.optionMap(_64, from$From_Dir_u8), 0); + rt.byteVecPush(tags, _70); } } } else { - _47 = dir(_41); - parsed.push(_47); + _59 = dir(_53); + parsed.push(_59); } } } else { diff --git a/ts/fixtures/lang/src/shapes.rs b/ts/fixtures/lang/src/shapes.rs index 38d2bacc5..aac088ae8 100644 --- a/ts/fixtures/lang/src/shapes.rs +++ b/ts/fixtures/lang/src/shapes.rs @@ -879,6 +879,18 @@ pub fn patterns(data: &[u8], out: &mut Vec) { Shape::Line(a, b) => (a.x - b.x) as i64 * (a.y - b.y) as i64, }; out.extend_from_slice(&area.to_be_bytes()); + // One binding from either side of an or-pattern. + let either: Result = if data.len() % 2 == 0 { + Ok(data.len() as u8) + } else { + Err(0xa0) + }; + match either { + Ok(v) | Err(v) => out.push(v), + } + // An empty repeat, which MIR never assigns since it holds nothing. + let none = [data.len() as u8; 0]; + out.push(none.len() as u8 + none.iter().sum::()); // A rest pattern borrowing bytes changes them where they are. let mut bytes = [data.len() as u8, 1, 2]; let [_, tail @ ..] = &mut bytes; @@ -931,6 +943,11 @@ pub fn closures(data: &[u8], out: &mut Vec) { let base = data.len() as u32; let scale = move |v: u32| v * 3 + base; out.extend_from_slice(&apply(scale, sum).to_be_bytes()); + // A `move` closure copies what it captured, which a later change to the original misses. + let mut n = base; + let copied = move || n + 1; + n += 10; + out.extend_from_slice(&(copied() + n).to_be_bytes()); // A closure writing a whole array through a reference it captured changes the caller's. let mut whole = [data.len() as u8]; diff --git a/ts/fixtures/reject/census.md b/ts/fixtures/reject/census.md index 70adf869e..4f83a7acf 100644 --- a/ts/fixtures/reject/census.md +++ b/ts/fixtures/reject/census.md @@ -1,7 +1,7 @@ # Census of `reject-fixture` -- Refusals: 60 -- Function instances: 69 +- Refusals: 62 +- Function instances: 51 - Generic functions no instance reached, lowered over their type parameters: 3 ## By construct @@ -10,38 +10,39 @@ | ---: | --- | --- | | 6 | an assignment through a reference to `_` | fixtures/reject/src/lib.rs:20:2 | | 5 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:19:1 | -| 4 | unsupported call to `_` | fixtures/reject/src/lib.rs:36:4 | +| 5 | unsupported call to `_` | fixtures/reject/src/lib.rs:36:4 | | 4 | unsupported type `_` | fixtures/reject/src/lib.rs:6:1 | | 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:1 | -| 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:69:2 | -| 3 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:161:2 | -| 2 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:222:1 | -| 2 | a field of `_` | fixtures/reject/src/lib.rs:441:7 | -| 2 | an iterator of the crate implementing `_`, which is not supported yet | fixtures/reject/src/lib.rs:302:1 | -| 2 | constructing `_` from another crate | fixtures/reject/src/lib.rs:288:23 | -| 2 | overriding `_`, which std's adaptors call in place of `next` or beside it | fixtures/reject/src/lib.rs:282:2 | -| 1 | `Binary` formatting, as in `{:b}`, is not supported | fixtures/reject/src/lib.rs:125:3 | -| 1 | `LowerExp` formatting, as in `{:e}`, is not supported | fixtures/reject/src/lib.rs:127:3 | -| 1 | `Octal` formatting, as in `{:o}`, is not supported | fixtures/reject/src/lib.rs:126:3 | -| 1 | `Pointer` formatting, as in `{:p}`, is not supported | fixtures/reject/src/lib.rs:130:3 | -| 1 | `_` is generic and implements `Drop`, which is not supported yet | fixtures/reject/src/lib.rs:90:1 | -| 1 | a `_` cast from `_` to `_` | fixtures/reject/src/lib.rs:172:2 | -| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | fixtures/reject/src/lib.rs:315:51 | +| 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:59:2 | +| 3 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:133:2 | +| 2 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:159:1 | +| 2 | a field of `_` | fixtures/reject/src/lib.rs:326:7 | +| 2 | an iterator of the crate implementing `_`, which is not supported yet | fixtures/reject/src/lib.rs:218:1 | +| 2 | constructing `_` from another crate | fixtures/reject/src/lib.rs:204:23 | +| 2 | overriding `_`, which std's adaptors call in place of `next` or beside it | fixtures/reject/src/lib.rs:198:2 | +| 1 | `Binary` formatting, as in `{:b}`, is not supported | fixtures/reject/src/lib.rs:110:3 | +| 1 | `LowerExp` formatting, as in `{:e}`, is not supported | fixtures/reject/src/lib.rs:112:3 | +| 1 | `Octal` formatting, as in `{:o}`, is not supported | fixtures/reject/src/lib.rs:111:3 | +| 1 | `Pointer` formatting, as in `{:p}`, is not supported | fixtures/reject/src/lib.rs:115:3 | +| 1 | `_` is generic and implements `Drop`, which is not supported yet | fixtures/reject/src/lib.rs:75:1 | +| 1 | a `_` cast from `_` to `_` | fixtures/reject/src/lib.rs:144:2 | +| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | fixtures/reject/src/lib.rs:231:51 | | 1 | a cast from `_` | fixtures/reject/src/lib.rs:11:2 | -| 1 | a constant of type `_` | fixtures/reject/src/lib.rs:156:2 | -| 1 | a copy of a closure that changes what it captured | fixtures/reject/src/lib.rs:435:14 | -| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | fixtures/reject/src/lib.rs:404:13 | -| 1 | a precision, as in `{:.2}`, is not supported | fixtures/reject/src/lib.rs:122:3 | -| 1 | a printable type must implement `Display` or `Debug` | fixtures/reject/src/lib.rs:168:1 | +| 1 | a constant of type `_` | fixtures/reject/src/lib.rs:128:2 | +| 1 | a copy of a closure that changes what it captured | fixtures/reject/src/lib.rs:320:14 | +| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | fixtures/reject/src/lib.rs:295:13 | +| 1 | a precision, as in `{:.2}`, is not supported | fixtures/reject/src/lib.rs:107:3 | +| 1 | a printable type must implement `Display` or `Debug` | fixtures/reject/src/lib.rs:140:1 | | 1 | a scalar constant of type `_` | fixtures/reject/src/lib.rs:7:2 | -| 1 | a width or precision from an argument, as in `{:1$}`, is not supported | fixtures/reject/src/lib.rs:129:3 | -| 1 | a zero-sized constant of type `_` | fixtures/reject/src/lib.rs:115:2 | +| 1 | a width or precision from an argument, as in `{:1$}`, is not supported | fixtures/reject/src/lib.rs:114:3 | +| 1 | a zero-sized constant of type `_` | fixtures/reject/src/lib.rs:100:2 | | 1 | arithmetic on `_` | fixtures/reject/src/lib.rs:7:2 | -| 1 | dropping `_`, which is not supported yet | fixtures/reject/src/lib.rs:179:1 | -| 1 | hex `Debug`, as in `{:x?}`, is not supported | fixtures/reject/src/lib.rs:128:3 | -| 1 | passing `_`, which drops, to `_`, which is not supported yet | fixtures/reject/src/lib.rs:393:4 | -| 1 | the `+` flag of a format spec is not supported | fixtures/reject/src/lib.rs:123:3 | -| 1 | the `-` flag of a format spec is not supported | fixtures/reject/src/lib.rs:124:3 | +| 1 | dropping `_`, which is not supported yet | fixtures/reject/src/lib.rs:151:1 | +| 1 | dropping a closure that owns a value that drops, which is not supported yet | fixtures/reject/src/lib.rs:54:1 | +| 1 | hex `Debug`, as in `{:x?}`, is not supported | fixtures/reject/src/lib.rs:113:3 | +| 1 | passing `_`, which drops, to `_`, which is not supported yet | fixtures/reject/src/lib.rs:290:4 | +| 1 | the `+` flag of a format spec is not supported | fixtures/reject/src/lib.rs:108:3 | +| 1 | the `-` flag of a format spec is not supported | fixtures/reject/src/lib.rs:109:3 | ## By API @@ -52,78 +53,80 @@ The type or module each refused type or path belongs to. | 5 | `f64` | fixtures/reject/src/lib.rs:6:1 | | 4 | `Option` | fixtures/reject/src/lib.rs:31:1 | | 4 | `u32` | fixtures/reject/src/lib.rs:19:1 | -| 3 | `u8` | fixtures/reject/src/lib.rs:105:10 | -| 2 | `Iterator` | fixtures/reject/src/lib.rs:282:2 | -| 2 | `Meters` | fixtures/reject/src/lib.rs:161:2 | -| 2 | `Poll` | fixtures/reject/src/lib.rs:222:1 | +| 3 | `u8` | fixtures/reject/src/lib.rs:90:10 | +| 2 | `Iterator` | fixtures/reject/src/lib.rs:198:2 | +| 2 | `Meters` | fixtures/reject/src/lib.rs:133:2 | +| 2 | `Poll` | fixtures/reject/src/lib.rs:159:1 | | 2 | `char` | fixtures/reject/src/lib.rs:10:1 | -| 2 | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | -| 2 | `std::string::String` | fixtures/reject/src/lib.rs:135:1 | -| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:179:1 | -| 2 | `std::vec::Vec` | fixtures/reject/src/lib.rs:69:2 | -| 1 | `Boxed` | fixtures/reject/src/lib.rs:90:1 | -| 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:302:1 | -| 1 | `FusedIterator` | fixtures/reject/src/lib.rs:356:1 | -| 1 | `IntToFloat` | fixtures/reject/src/lib.rs:172:2 | -| 1 | `Noisy` | fixtures/reject/src/lib.rs:369:20 | -| 1 | `Slot` | fixtures/reject/src/lib.rs:88:1 | -| 1 | `[u8; 1]` | fixtures/reject/src/lib.rs:424:22 | +| 2 | `std::pin::Pin` | fixtures/reject/src/lib.rs:175:2 | +| 2 | `std::string::String` | fixtures/reject/src/lib.rs:120:1 | +| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:151:1 | +| 2 | `std::vec::Vec` | fixtures/reject/src/lib.rs:59:2 | +| 1 | `Boxed` | fixtures/reject/src/lib.rs:75:1 | +| 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:218:1 | +| 1 | `FusedIterator` | fixtures/reject/src/lib.rs:272:1 | +| 1 | `IntToFloat` | fixtures/reject/src/lib.rs:144:2 | +| 1 | `Noisy` | fixtures/reject/src/lib.rs:285:20 | +| 1 | `Slot` | fixtures/reject/src/lib.rs:73:1 | +| 1 | `[u8; 1]` | fixtures/reject/src/lib.rs:309:22 | | 1 | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:1 | -| 1 | `std::iter::Chain` | fixtures/reject/src/lib.rs:315:51 | -| 1 | `std::iter::Map` | fixtures/reject/src/lib.rs:288:23 | -| 1 | `std::iter::Rev` | fixtures/reject/src/lib.rs:309:14 | -| 1 | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:441:48 | -| 1 | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:441:7 | -| 1 | `std::ops::Range` | fixtures/reject/src/lib.rs:323:8 | -| 1 | `std::option::Option` | fixtures/reject/src/lib.rs:393:4 | -| 1 | `std::slice::Iter` | fixtures/reject/src/lib.rs:269:11 | +| 1 | `std::iter::Chain` | fixtures/reject/src/lib.rs:231:51 | +| 1 | `std::iter::Map` | fixtures/reject/src/lib.rs:204:23 | +| 1 | `std::iter::Rev` | fixtures/reject/src/lib.rs:225:14 | +| 1 | `std::mem` | fixtures/reject/src/lib.rs:52:18 | +| 1 | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:326:48 | +| 1 | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:326:7 | +| 1 | `std::ops::Range` | fixtures/reject/src/lib.rs:239:8 | +| 1 | `std::option::Option` | fixtures/reject/src/lib.rs:290:4 | +| 1 | `std::slice::Iter` | fixtures/reject/src/lib.rs:185:11 | | 1 | `std::slice` | fixtures/reject/src/lib.rs:36:4 | -| 1 | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | -| 1 | `u64` | fixtures/reject/src/lib.rs:172:2 | -| 1 | `{async closure}` | fixtures/reject/src/lib.rs:115:2 | +| 1 | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:180:2 | +| 1 | `u64` | fixtures/reject/src/lib.rs:144:2 | +| 1 | `{async closure}` | fixtures/reject/src/lib.rs:100:2 | ## By type or path | Count | Construct | Type or path | First | | ---: | --- | --- | --- | | 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:1 | -| 2 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:222:1 | +| 2 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:159:1 | | 2 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:1 | -| 2 | an assignment through a reference to `_` | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | -| 2 | an iterator that owns `_`, which drops, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:69:2 | -| 2 | replacing the value behind a reference to `_` | `Meters` | fixtures/reject/src/lib.rs:161:2 | +| 2 | an assignment through a reference to `_` | `std::pin::Pin` | fixtures/reject/src/lib.rs:175:2 | +| 2 | an iterator that owns `_`, which drops, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:59:2 | +| 2 | replacing the value behind a reference to `_` | `Meters` | fixtures/reject/src/lib.rs:133:2 | | 2 | unsupported type `_` | `f64` | fixtures/reject/src/lib.rs:6:1 | -| 1 | `_` is generic and implements `Drop`, which is not supported yet | `Boxed` | fixtures/reject/src/lib.rs:90:1 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut Slot`, `Slot` | fixtures/reject/src/lib.rs:88:1 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:135:1 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u8`, `u8` | fixtures/reject/src/lib.rs:105:10 | -| 1 | a `_` cast from `_` to `_` | `IntToFloat`, `u64`, `f64` | fixtures/reject/src/lib.rs:172:2 | -| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | `std::iter::Chain` | fixtures/reject/src/lib.rs:315:51 | +| 1 | `_` is generic and implements `Drop`, which is not supported yet | `Boxed` | fixtures/reject/src/lib.rs:75:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut Slot`, `Slot` | fixtures/reject/src/lib.rs:73:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:120:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u8`, `u8` | fixtures/reject/src/lib.rs:90:10 | +| 1 | a `_` cast from `_` to `_` | `IntToFloat`, `u64`, `f64` | fixtures/reject/src/lib.rs:144:2 | +| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | `std::iter::Chain` | fixtures/reject/src/lib.rs:231:51 | | 1 | a cast from `_` | `char` | fixtures/reject/src/lib.rs:11:2 | -| 1 | a constant of type `_` | `&u8` | fixtures/reject/src/lib.rs:156:2 | -| 1 | a field of `_` | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:441:48 | -| 1 | a field of `_` | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:441:7 | -| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | `u32` | fixtures/reject/src/lib.rs:404:13 | +| 1 | a constant of type `_` | `&u8` | fixtures/reject/src/lib.rs:128:2 | +| 1 | a field of `_` | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:326:48 | +| 1 | a field of `_` | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:326:7 | +| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | `u32` | fixtures/reject/src/lib.rs:295:13 | | 1 | a scalar constant of type `_` | `f64` | fixtures/reject/src/lib.rs:7:2 | -| 1 | a zero-sized constant of type `_` | `{async closure}` | fixtures/reject/src/lib.rs:115:2 | -| 1 | an assignment through a reference to `_` | `std::sync::Arc` | fixtures/reject/src/lib.rs:218:2 | -| 1 | an assignment through a reference to `_` | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | +| 1 | a zero-sized constant of type `_` | `{async closure}` | fixtures/reject/src/lib.rs:100:2 | +| 1 | an assignment through a reference to `_` | `std::sync::Arc` | fixtures/reject/src/lib.rs:155:2 | +| 1 | an assignment through a reference to `_` | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:180:2 | | 1 | an assignment through a reference to `_` | `u32` | fixtures/reject/src/lib.rs:20:2 | -| 1 | an assignment through a reference to `_` | `u8` | fixtures/reject/src/lib.rs:106:3 | -| 1 | an iterator of the crate implementing `_`, which is not supported yet | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:302:1 | -| 1 | an iterator of the crate implementing `_`, which is not supported yet | `FusedIterator` | fixtures/reject/src/lib.rs:356:1 | -| 1 | an iterator that owns `_`, which drops, which is not supported yet | `Noisy` | fixtures/reject/src/lib.rs:369:20 | +| 1 | an assignment through a reference to `_` | `u8` | fixtures/reject/src/lib.rs:91:3 | +| 1 | an iterator of the crate implementing `_`, which is not supported yet | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:218:1 | +| 1 | an iterator of the crate implementing `_`, which is not supported yet | `FusedIterator` | fixtures/reject/src/lib.rs:272:1 | +| 1 | an iterator that owns `_`, which drops, which is not supported yet | `Noisy` | fixtures/reject/src/lib.rs:285:20 | | 1 | arithmetic on `_` | `f64` | fixtures/reject/src/lib.rs:7:2 | -| 1 | constructing `_` from another crate | `std::iter::Map` | fixtures/reject/src/lib.rs:288:23 | -| 1 | constructing `_` from another crate | `std::iter::Rev` | fixtures/reject/src/lib.rs:309:14 | -| 1 | dropping `_`, which is not supported yet | `std::sync::Arc` | fixtures/reject/src/lib.rs:179:1 | -| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::fold` | fixtures/reject/src/lib.rs:282:2 | -| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::size_hint` | fixtures/reject/src/lib.rs:336:2 | -| 1 | passing `_`, which drops, to `_`, which is not supported yet | `std::option::Option`, `Option::unwrap_or` | fixtures/reject/src/lib.rs:393:4 | -| 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:424:22 | -| 1 | unsupported call to `_` | `::cycle` | fixtures/reject/src/lib.rs:269:11 | -| 1 | unsupported call to `_` | `::write_fmt` | fixtures/reject/src/lib.rs:137:10 | -| 1 | unsupported call to `_` | `std::ops::Range::contains` | fixtures/reject/src/lib.rs:323:8 | +| 1 | constructing `_` from another crate | `std::iter::Map` | fixtures/reject/src/lib.rs:204:23 | +| 1 | constructing `_` from another crate | `std::iter::Rev` | fixtures/reject/src/lib.rs:225:14 | +| 1 | dropping `_`, which is not supported yet | `std::sync::Arc` | fixtures/reject/src/lib.rs:151:1 | +| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::fold` | fixtures/reject/src/lib.rs:198:2 | +| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::size_hint` | fixtures/reject/src/lib.rs:252:2 | +| 1 | passing `_`, which drops, to `_`, which is not supported yet | `std::option::Option`, `Option::unwrap_or` | fixtures/reject/src/lib.rs:290:4 | +| 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:309:22 | +| 1 | unsupported call to `_` | `::cycle` | fixtures/reject/src/lib.rs:185:11 | +| 1 | unsupported call to `_` | `::write_fmt` | fixtures/reject/src/lib.rs:122:10 | +| 1 | unsupported call to `_` | `std::mem::size_of_val` | fixtures/reject/src/lib.rs:52:18 | +| 1 | unsupported call to `_` | `std::ops::Range::contains` | fixtures/reject/src/lib.rs:239:8 | | 1 | unsupported call to `_` | `std::slice::sort` | fixtures/reject/src/lib.rs:36:4 | | 1 | unsupported type `_` | `char` | fixtures/reject/src/lib.rs:10:1 | | 1 | unsupported type `_` | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:1 | @@ -133,11 +136,11 @@ The type or module each refused type or path belongs to.
an assignment through a reference to `_` (6) - fixtures/reject/src/lib.rs:20:2: an assignment through a reference to `u32` -- fixtures/reject/src/lib.rs:106:3: an assignment through a reference to `u8` -- fixtures/reject/src/lib.rs:218:2: an assignment through a reference to `std::sync::Arc` -- fixtures/reject/src/lib.rs:254:2: an assignment through a reference to `std::pin::Pin>` -- fixtures/reject/src/lib.rs:264:2: an assignment through a reference to `std::sync::MutexGuard<'_, u8>` -- fixtures/reject/src/lib.rs:412:2: an assignment through a reference to `std::pin::Pin<&mut Noisy>` +- fixtures/reject/src/lib.rs:91:3: an assignment through a reference to `u8` +- fixtures/reject/src/lib.rs:155:2: an assignment through a reference to `std::sync::Arc` +- fixtures/reject/src/lib.rs:175:2: an assignment through a reference to `std::pin::Pin>` +- fixtures/reject/src/lib.rs:180:2: an assignment through a reference to `std::sync::MutexGuard<'_, u8>` +- fixtures/reject/src/lib.rs:303:2: an assignment through a reference to `std::pin::Pin<&mut Noisy>`
@@ -145,18 +148,19 @@ The type or module each refused type or path belongs to. - fixtures/reject/src/lib.rs:19:1: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it - fixtures/reject/src/lib.rs:24:1: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it -- fixtures/reject/src/lib.rs:88:1: `&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it -- fixtures/reject/src/lib.rs:105:10: `&mut u8`: a JS value of `u8` is a copy, so a reference can't change it -- fixtures/reject/src/lib.rs:135:1: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:73:1: `&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:90:10: `&mut u8`: a JS value of `u8` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:120:1: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it
-
unsupported call to `_` (4) +
unsupported call to `_` (5) - fixtures/reject/src/lib.rs:36:4: unsupported call to `std::slice::::sort` -- fixtures/reject/src/lib.rs:137:10: unsupported call to `::write_fmt` -- fixtures/reject/src/lib.rs:269:11: unsupported call to ` as std::iter::Iterator>::cycle` -- fixtures/reject/src/lib.rs:323:8: unsupported call to `std::ops::Range::::contains::` +- fixtures/reject/src/lib.rs:52:18: unsupported call to `std::mem::size_of_val::` +- fixtures/reject/src/lib.rs:122:10: unsupported call to `::write_fmt` +- fixtures/reject/src/lib.rs:185:11: unsupported call to ` as std::iter::Iterator>::cycle` +- fixtures/reject/src/lib.rs:239:8: unsupported call to `std::ops::Range::::contains::`
@@ -165,7 +169,7 @@ The type or module each refused type or path belongs to. - fixtures/reject/src/lib.rs:6:1: unsupported type `f64` - fixtures/reject/src/lib.rs:10:1: unsupported type `char` - fixtures/reject/src/lib.rs:14:1: unsupported type `dyn std::ops::Fn(u8) -> u8` -- fixtures/reject/src/lib.rs:170:1: unsupported type `f64` +- fixtures/reject/src/lib.rs:142:1: unsupported type `f64`
@@ -173,100 +177,100 @@ The type or module each refused type or path belongs to. - fixtures/reject/src/lib.rs:31:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` - fixtures/reject/src/lib.rs:40:42: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:227:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:164:1: `Option>` is not supported: its `None` and `Some` would both be `undefined`
an iterator that owns `_`, which drops, which is not supported yet (3) -- fixtures/reject/src/lib.rs:69:2: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet -- fixtures/reject/src/lib.rs:364:4: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet -- fixtures/reject/src/lib.rs:369:20: an iterator that owns `Noisy`, which drops, which is not supported yet +- fixtures/reject/src/lib.rs:59:2: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet +- fixtures/reject/src/lib.rs:280:4: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet +- fixtures/reject/src/lib.rs:285:20: an iterator that owns `Noisy`, which drops, which is not supported yet
replacing the value behind a reference to `_` (3) -- fixtures/reject/src/lib.rs:161:2: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:165:2: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:424:22: replacing the value behind a reference to `[u8; 1]` +- fixtures/reject/src/lib.rs:133:2: replacing the value behind a reference to `Meters` +- fixtures/reject/src/lib.rs:137:2: replacing the value behind a reference to `Meters` +- fixtures/reject/src/lib.rs:309:22: replacing the value behind a reference to `[u8; 1]`
`_` is not supported: it would be pending two ways with one value (2) -- fixtures/reject/src/lib.rs:222:1: `Poll>>` is not supported: it would be pending two ways with one value -- fixtures/reject/src/lib.rs:238:54: `Poll>` is not supported: it would be pending two ways with one value +- fixtures/reject/src/lib.rs:159:1: `Poll>>` is not supported: it would be pending two ways with one value +- fixtures/reject/src/lib.rs:169:54: `Poll>` is not supported: it would be pending two ways with one value
a field of `_` (2) -- fixtures/reject/src/lib.rs:441:7: a field of `std::ops::RangeTo` -- fixtures/reject/src/lib.rs:441:48: a field of `std::ops::RangeFrom` +- fixtures/reject/src/lib.rs:326:7: a field of `std::ops::RangeTo` +- fixtures/reject/src/lib.rs:326:48: a field of `std::ops::RangeFrom`
an iterator of the crate implementing `_`, which is not supported yet (2) -- fixtures/reject/src/lib.rs:302:1: an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet -- fixtures/reject/src/lib.rs:356:1: an iterator of the crate implementing `FusedIterator`, which is not supported yet +- fixtures/reject/src/lib.rs:218:1: an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet +- fixtures/reject/src/lib.rs:272:1: an iterator of the crate implementing `FusedIterator`, which is not supported yet
constructing `_` from another crate (2) -- fixtures/reject/src/lib.rs:288:23: constructing `std::iter::Map` from another crate -- fixtures/reject/src/lib.rs:309:14: constructing `std::iter::Rev` from another crate +- fixtures/reject/src/lib.rs:204:23: constructing `std::iter::Map` from another crate +- fixtures/reject/src/lib.rs:225:14: constructing `std::iter::Rev` from another crate
overriding `_`, which std's adaptors call in place of `next` or beside it (2) -- fixtures/reject/src/lib.rs:282:2: overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it -- fixtures/reject/src/lib.rs:336:2: overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it +- fixtures/reject/src/lib.rs:198:2: overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it +- fixtures/reject/src/lib.rs:252:2: overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it
`Binary` formatting, as in `{:b}`, is not supported (1) -- fixtures/reject/src/lib.rs:125:3: `Binary` formatting, as in `{:b}`, is not supported +- fixtures/reject/src/lib.rs:110:3: `Binary` formatting, as in `{:b}`, is not supported
`LowerExp` formatting, as in `{:e}`, is not supported (1) -- fixtures/reject/src/lib.rs:127:3: `LowerExp` formatting, as in `{:e}`, is not supported +- fixtures/reject/src/lib.rs:112:3: `LowerExp` formatting, as in `{:e}`, is not supported
`Octal` formatting, as in `{:o}`, is not supported (1) -- fixtures/reject/src/lib.rs:126:3: `Octal` formatting, as in `{:o}`, is not supported +- fixtures/reject/src/lib.rs:111:3: `Octal` formatting, as in `{:o}`, is not supported
`Pointer` formatting, as in `{:p}`, is not supported (1) -- fixtures/reject/src/lib.rs:130:3: `Pointer` formatting, as in `{:p}`, is not supported +- fixtures/reject/src/lib.rs:115:3: `Pointer` formatting, as in `{:p}`, is not supported
`_` is generic and implements `Drop`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:90:1: `Boxed` is generic and implements `Drop`, which is not supported yet +- fixtures/reject/src/lib.rs:75:1: `Boxed` is generic and implements `Drop`, which is not supported yet
a `_` cast from `_` to `_` (1) -- fixtures/reject/src/lib.rs:172:2: a `IntToFloat` cast from `u64` to `f64` +- fixtures/reject/src/lib.rs:144:2: a `IntToFloat` cast from `u64` to `f64`
a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` (1) -- fixtures/reject/src/lib.rs:315:51: a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` +- fixtures/reject/src/lib.rs:231:51: a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:231:15: 231:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold`
@@ -278,31 +282,31 @@ The type or module each refused type or path belongs to.
a constant of type `_` (1) -- fixtures/reject/src/lib.rs:156:2: a constant of type `&u8` +- fixtures/reject/src/lib.rs:128:2: a constant of type `&u8`
a copy of a closure that changes what it captured (1) -- fixtures/reject/src/lib.rs:435:14: a copy of a closure that changes what it captured +- fixtures/reject/src/lib.rs:320:14: a copy of a closure that changes what it captured
a mutable borrow of a subslice of `_`, which JS would copy, having no views (1) -- fixtures/reject/src/lib.rs:404:13: a mutable borrow of a subslice of `u32`, which JS would copy, having no views +- fixtures/reject/src/lib.rs:295:13: a mutable borrow of a subslice of `u32`, which JS would copy, having no views
a precision, as in `{:.2}`, is not supported (1) -- fixtures/reject/src/lib.rs:122:3: a precision, as in `{:.2}`, is not supported +- fixtures/reject/src/lib.rs:107:3: a precision, as in `{:.2}`, is not supported
a printable type must implement `Display` or `Debug` (1) -- fixtures/reject/src/lib.rs:168:1: a printable type must implement `Display` or `Debug` +- fixtures/reject/src/lib.rs:140:1: a printable type must implement `Display` or `Debug`
@@ -314,13 +318,13 @@ The type or module each refused type or path belongs to.
a width or precision from an argument, as in `{:1$}`, is not supported (1) -- fixtures/reject/src/lib.rs:129:3: a width or precision from an argument, as in `{:1$}`, is not supported +- fixtures/reject/src/lib.rs:114:3: a width or precision from an argument, as in `{:1$}`, is not supported
a zero-sized constant of type `_` (1) -- fixtures/reject/src/lib.rs:115:2: a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` +- fixtures/reject/src/lib.rs:100:2: a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:99:10: 99:18}`
@@ -332,30 +336,36 @@ The type or module each refused type or path belongs to.
dropping `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:179:1: dropping `std::sync::Arc<&Noisy>`, which is not supported yet +- fixtures/reject/src/lib.rs:151:1: dropping `std::sync::Arc<&Noisy>`, which is not supported yet + +
+ +
dropping a closure that owns a value that drops, which is not supported yet (1) + +- fixtures/reject/src/lib.rs:54:1: dropping a closure that owns a value that drops, which is not supported yet
hex `Debug`, as in `{:x?}`, is not supported (1) -- fixtures/reject/src/lib.rs:128:3: hex `Debug`, as in `{:x?}`, is not supported +- fixtures/reject/src/lib.rs:113:3: hex `Debug`, as in `{:x?}`, is not supported
passing `_`, which drops, to `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:393:4: passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet +- fixtures/reject/src/lib.rs:290:4: passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet
the `+` flag of a format spec is not supported (1) -- fixtures/reject/src/lib.rs:123:3: the `+` flag of a format spec is not supported +- fixtures/reject/src/lib.rs:108:3: the `+` flag of a format spec is not supported
the `-` flag of a format spec is not supported (1) -- fixtures/reject/src/lib.rs:124:3: the `-` flag of a format spec is not supported +- fixtures/reject/src/lib.rs:109:3: the `-` flag of a format spec is not supported
diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index ec2661799..1b51cd4be 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -1,6 +1,6 @@ -a root must not be generic at fixtures/reject/src/lib.rs:170:1 +a root must not be generic at fixtures/reject/src/lib.rs:142:1 no item `missing` in the crate -a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:168:1 +a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:140:1 unsupported type `f64` at fixtures/reject/src/lib.rs:6:1 a scalar constant of type `f64` at fixtures/reject/src/lib.rs:7:2 arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 @@ -13,49 +13,51 @@ an assignment through a reference to `u32` at fixtures/reject/src/lib.rs:20:2 `Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:1 unsupported call to `std::slice::::sort` at fixtures/reject/src/lib.rs:36:4 `Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:40:42 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:69:11 -`&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:88:1 -`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:10 -`&mut u8`: a JS value of `u8` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:105:10 -an assignment through a reference to `u8` at fixtures/reject/src/lib.rs:106:3 -a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:115:2 -a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:122:3 -the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:123:3 -the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:124:3 -`Binary` formatting, as in `{:b}`, is not supported at fixtures/reject/src/lib.rs:125:12 -`Octal` formatting, as in `{:o}`, is not supported at fixtures/reject/src/lib.rs:126:12 -`LowerExp` formatting, as in `{:e}`, is not supported at fixtures/reject/src/lib.rs:127:12 -hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:128:3 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:15 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:3 -`Pointer` formatting, as in `{:p}`, is not supported at fixtures/reject/src/lib.rs:130:12 -`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:135:1 -unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:137:10 -a constant of type `&u8` at fixtures/reject/src/lib.rs:156:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:165:2 -dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:179:1 -an assignment through a reference to `std::sync::Arc` at fixtures/reject/src/lib.rs:218:2 -`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:222:1 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:227:1 -`Poll>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:238:54 -an assignment through a reference to `std::pin::Pin>` at fixtures/reject/src/lib.rs:254:2 -an assignment through a reference to `std::sync::MutexGuard<'_, u8>` at fixtures/reject/src/lib.rs:264:2 -unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:269:11 -constructing `std::iter::Map` from another crate at fixtures/reject/src/lib.rs:288:23 -constructing `std::iter::Rev` from another crate at fixtures/reject/src/lib.rs:309:14 -a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:315:51 -unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:323:8 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:4 -an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:369:20 -passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:393:4 -a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:404:13 -an assignment through a reference to `std::pin::Pin<&mut Noisy>` at fixtures/reject/src/lib.rs:412:2 -replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:424:22 -a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:435:14 -a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:441:7 -a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:441:48 -overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:282:2 -an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:302:1 -overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:336:2 -an iterator of the crate implementing `FusedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:356:1 +unsupported call to `std::mem::size_of_val::` at fixtures/reject/src/lib.rs:52:18 +dropping a closure that owns a value that drops, which is not supported yet at fixtures/reject/src/lib.rs:54:1 +an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:59:11 +`&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:73:1 +`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:83:10 +`&mut u8`: a JS value of `u8` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:90:10 +an assignment through a reference to `u8` at fixtures/reject/src/lib.rs:91:3 +a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:99:10: 99:18}` at fixtures/reject/src/lib.rs:100:2 +a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:107:3 +the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:108:3 +the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:109:3 +`Binary` formatting, as in `{:b}`, is not supported at fixtures/reject/src/lib.rs:110:12 +`Octal` formatting, as in `{:o}`, is not supported at fixtures/reject/src/lib.rs:111:12 +`LowerExp` formatting, as in `{:e}`, is not supported at fixtures/reject/src/lib.rs:112:12 +hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:113:3 +a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:114:15 +a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:114:3 +`Pointer` formatting, as in `{:p}`, is not supported at fixtures/reject/src/lib.rs:115:12 +`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:120:1 +unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:122:10 +a constant of type `&u8` at fixtures/reject/src/lib.rs:128:2 +replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:133:2 +replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:137:2 +dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:151:1 +an assignment through a reference to `std::sync::Arc` at fixtures/reject/src/lib.rs:155:2 +`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:159:1 +`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:164:1 +`Poll>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:169:54 +an assignment through a reference to `std::pin::Pin>` at fixtures/reject/src/lib.rs:175:2 +an assignment through a reference to `std::sync::MutexGuard<'_, u8>` at fixtures/reject/src/lib.rs:180:2 +unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:185:11 +constructing `std::iter::Map` from another crate at fixtures/reject/src/lib.rs:204:23 +constructing `std::iter::Rev` from another crate at fixtures/reject/src/lib.rs:225:14 +a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:231:15: 231:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:231:51 +unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:239:8 +an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:280:4 +an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:285:20 +passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:290:4 +a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:295:13 +an assignment through a reference to `std::pin::Pin<&mut Noisy>` at fixtures/reject/src/lib.rs:303:2 +replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:309:22 +a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:320:14 +a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:326:7 +a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:326:48 +overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:198:2 +an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:218:1 +overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:252:2 +an iterator of the crate implementing `FusedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:272:1 diff --git a/ts/fixtures/reject/src/lib.rs b/ts/fixtures/reject/src/lib.rs index 417451278..505d6650b 100644 --- a/ts/fixtures/reject/src/lib.rs +++ b/ts/fixtures/reject/src/lib.rs @@ -46,21 +46,11 @@ impl Drop for Noisy { fn drop(&mut self) {} } -pub fn make() -> Noisy { - Noisy(1) -} - -/// The temporary drops at the end of the statement, which nothing in JS marks. -pub fn temporary() -> u8 { - make().0 -} - -/// Dropping the closure would drop what it captured. +/// Dropping the closure would drop what it captured, which lives in an arrow function. pub fn owning_closure() -> u8 { - let n = make(); - let f = move || drop(n); - f(); - 0 + let n = Noisy(1); + let f = move || std::mem::size_of_val(&n) as u8; + f() } /// Each element drops at the end of its iteration, and the rest on a `break`. @@ -72,11 +62,6 @@ pub fn each(v: Vec) -> u8 { sum } -/// The part the pattern skips drops at the end of the function, which nothing marks. -pub fn destructured((a, _): (Noisy, Noisy)) -> u8 { - a.0 -} - pub enum Slot { Empty, Full(Noisy), @@ -137,19 +122,6 @@ pub fn written(s: &mut String, n: u8) { let _ = write!(s, "{n}"); } -pub fn captured() -> u8 { - let mut n = 1; - let f = move || n + 1; - n += 10; - f() + n -} - -pub fn or_bindings(x: Result) -> u8 { - match x { - Ok(v) | Err(v) => v, - } -} - static COUNT: u8 = 0; pub fn statics() -> u8 { @@ -178,41 +150,6 @@ pub fn shared_borrow(n: &Noisy) -> usize { std::sync::Arc::strong_count(&a) } -/// `n` would wait out the `.await` where no scope drops it if the future is cancelled. -pub async fn held_across(n: Noisy) -> u8 { - consume(n, async { 1u8 }.await) -} - -fn consume(n: Noisy, v: u8) -> u8 { - drop(n); - v -} - -/// The skipped element drops at the end of the statement, which nothing marks. -pub fn skipped() -> u8 { - let [kept, _] = [make(), make()]; - kept.0 -} - -/// `n` would wait out the `.await` in the index where no scope drops it on a cancel. -pub async fn assigned(n: Noisy) -> u8 { - let mut slots = [make(), make()]; - slots[index().await] = n; - slots[0].0 -} - -async fn index() -> usize { - 1 -} - -/// `Some(..)` leaves the payload in the temporary, which drops after the `match`. -pub fn unnamed() -> u8 { - match Some(make()) { - Some(..) => 1, - None => 0, - } -} - /// Every clone of an `Arc` is one JS object: replacing the payload would reach them all. pub fn replace_shared(dst: &mut std::sync::Arc, src: std::sync::Arc) { *dst = src; @@ -228,37 +165,16 @@ pub fn ready_unit(p: Option>) -> bool { matches!(p, None) } -/// The payload of the `Some` that fails the test drops after the `if let`. -#[allow(clippy::redundant_pattern_matching, reason = "the `if let` is under test")] -pub fn unmatched() -> u8 { - if let None = Some(make()) { 1 } else { 0 } -} - /// A future's `Ready(Pending)` would be `rt.Pending`, as its own pending is. pub async fn pending_output() -> std::task::Poll { std::task::Poll::Pending } -/// The temporary drops after the `match`, which nothing marks. -#[allow(clippy::match_like_matches_macro, reason = "the `match` is under test")] -pub fn tested() -> u8 { - let matched = match Some(make()) { - Some(_) => 1, - None => 0, - }; - matched + 1 -} - /// A `Pin` is its pointer in JS: replacing the `Arc` would reach every clone. pub fn replace_pinned(dst: &mut std::pin::Pin>, src: std::pin::Pin>) { *dst = src; } -/// The box drops its `Noisy` at the end of the statement, which nothing marks. -pub fn boxed_field() -> u8 { - Box::new(make()).0 -} - /// A guard is its mutex in JS: replacing it would copy the other mutex's value in. pub fn replace_guard<'a>(dst: &mut std::sync::MutexGuard<'a, u8>, src: std::sync::MutexGuard<'a, u8>) { *dst = src; @@ -369,36 +285,11 @@ pub fn counted() -> usize { (0..2).map(Noisy).count() } -/// An iterator that drops, after the loop. -pub struct Countdown(pub Noisy); - -impl Iterator for Countdown { - type Item = u8; - - fn next(&mut self) -> Option { - None - } -} - -pub fn looped(c: Countdown) -> u8 { - let mut n = 0; - for i in c { - n += i; - } - n -} - /// `unwrap_or` drops its fallback when the option holds a value. pub fn fallback(a: Option, b: Noisy) -> Noisy { a.unwrap_or(b) } -/// `rest` moves the tail out of `pair`, which would still drop it. -pub fn rest_moved(pair: [Noisy; 2]) -> u8 { - let [first, rest @ ..] = pair; - first.0 + rest[0].0 -} - /// `rest` borrows the tail of `items` mutably, but a JS array has no views. pub fn rest_mut(items: &mut [u32; 3]) -> u32 { if let [_, rest @ ..] = items { @@ -412,12 +303,6 @@ pub fn replace_pinned_ref<'a>(dst: &mut std::pin::Pin<&'a mut Noisy>, src: std:: *dst = src; } -/// `[n; 0]` drops `n` at once, which no element of the array would. -pub fn repeated(n: Noisy) -> usize { - let empty = [n; 0]; - empty.len() -} - /// A reference copied into a closure holds its referent's object: replacing through it /// would change the copy, not the referent. pub fn replace_captured(a: &mut [u8; 1]) -> [u8; 1] { diff --git a/ts/fixtures/reject/ts.toml b/ts/fixtures/reject/ts.toml index 4361887d5..1f9283dc8 100644 --- a/ts/fixtures/reject/ts.toml +++ b/ts/fixtures/reject/ts.toml @@ -9,35 +9,24 @@ roots = [ "sorted", "iterators", "Noisy", - "temporary", "owning_closure", "each", - "destructured", "slot", "boxed", "async_borrow", "async_closure", "specs", "written", - "captured", - "or_bindings", "statics", "swapped", "replaced", "generic", "shared_borrow", - "held_across", - "skipped", - "assigned", - "unnamed", "replace_shared", "nested_poll", "ready_unit", - "unmatched", "pending_output", - "tested", "replace_pinned", - "boxed_field", "replace_guard", "cycled", "folds", @@ -48,12 +37,9 @@ roots = [ "fused", "drained", "counted", - "looped", "fallback", - "rest_moved", "rest_mut", "replace_pinned_ref", - "repeated", "replace_captured", "copied_closure", "one_sided", diff --git a/ts/fixtures/task/expected/model.Countdown.ts b/ts/fixtures/task/expected/model.Countdown.ts new file mode 100644 index 000000000..c07d605f4 --- /dev/null +++ b/ts/fixtures/task/expected/model.Countdown.ts @@ -0,0 +1,31 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as Guard from "./model.Guard.ts"; + +/** Counts down, holding a guard the loop drops after its last turn. */ +export class Countdown { + left: rt.u32; + guard: Guard.Guard; + + constructor(fields: { left: rt.u32; guard: Guard.Guard }) { + this.left = fields.left; + this.guard = fields.guard; + } + + [Symbol.dispose](): void { + rt.drop(this.guard); + } +} + +export function next$Iterator(self: Countdown): rt.u32 | rt.Done { + if (!(self.left === 0)) { + self.left = rt.u32Sub(self.left, 1); + Guard.note(self.guard, "count"); + return self.left; + } else { + return rt.DONE; + } +} + +//# sourceMappingURL=model.Countdown.ts.map diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index 84752d6e9..38ce177be 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -3,6 +3,7 @@ import * as rt from "./rt.ts"; import * as Consumer from "./kio.Consumer.ts"; import * as Log from "./log.Log.ts"; +import * as Countdown from "./model.Countdown.ts"; import * as Guard from "./model.Guard.ts"; import * as Inner from "./model.Inner.ts"; import type * as Mark from "./model.Mark.ts"; @@ -183,7 +184,8 @@ export class sumFuture { * dropping the block must not drop; a copy, which a later change to the original must * not reach; a mutable borrow the block replaces whole, which the caller must see; a * move on one path only; and a move the block only borrows, which drops when the block - * returns or is cancelled. Between them, a value of two types that hold each other. + * returns or is cancelled. Between them, a value of two types that hold each other, and + * guards held across awaits that read values first. */ export function blocks(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): rt.Future { return new blocksFuture(rx, guard, moves); @@ -199,21 +201,29 @@ export class blocksFuture { moves_!: boolean; first_!: Guard.Guard; second_!: Guard.Guard; - tally_!: Tally.Tally; + waited_!: rt.u64; saved!: Guard.Guard; - _saved!: rt.u32; - __awaitee_!: rt.Future; + __awaitee_!: rt.Future; + slots_!: Guard.Guard[]; + _saved!: Guard.Guard; + ___awaitee_!: rt.Future; + tally_!: Tally.Tally; + _saved$2!: Guard.Guard; + _saved$3!: rt.u32; + ___awaitee_$2!: rt.Future; mark_!: Mark.Mark; replaced_!: rt.u32; - ___awaitee_!: rt.Future; + ___awaitee_$3!: rt.Future; _nested_!: Inner.Inner; chosen_!: Guard.Guard; - ___awaitee_$2!: rt.Future; - _saved$2!: boolean; - _saved$3!: boolean; + ___awaitee_$4!: rt.Future; _saved$4!: boolean; _saved$5!: boolean; _saved$6!: boolean; + _saved$7!: boolean; + _saved$8!: boolean; + _saved$9!: boolean; + _saved$10!: boolean; constructor(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean) { this.rx = rx; @@ -224,104 +234,151 @@ export class blocksFuture { [Symbol.dispose](): void { let unwind: number = 0; try { - if (this.state === 0) { - unwind = 62; - rt.drop(this.rx); - unwind = 0; - rt.drop(this.guard); - return; - } else if (this.state === 3) { - unwind = 36; - rt.drop(this.__awaitee_); - } else if (this.state === 4) { - unwind = 33; - rt.drop(this.___awaitee_); - } else if (this.state === 5) { - unwind = 26; - rt.drop(this.___awaitee_$2); - unwind = 29; - rt.drop(this.chosen_); - unwind = 31; - rt.drop(this._nested_); - } else { - return; + b0: { + b1: { + if (this.state === 0) { + unwind = 82; + rt.drop(this.rx); + unwind = 0; + rt.drop(this.guard); + return; + } else if (this.state === 3) { + unwind = 56; + rt.drop(this.__awaitee_); + unwind = 57; + rt.drop(this.saved); + this._saved$10 = false; + break b0; + } else if (this.state === 4) { + unwind = 51; + rt.drop(this.___awaitee_); + unwind = 52; + rt.drop(this._saved); + this._saved$9 = false; + break b1; + } else if (this.state === 5) { + unwind = 47; + rt.drop(this.___awaitee_$2); + } else if (this.state === 6) { + unwind = 44; + rt.drop(this.___awaitee_$3); + } else if (this.state === 7) { + unwind = 37; + rt.drop(this.___awaitee_$4); + unwind = 40; + rt.drop(this.chosen_); + unwind = 42; + rt.drop(this._nested_); + } else { + return; + } + this._saved$8 = false; + } + unwind = 55; + rt.dropAll(this.slots_); } - this._saved$6 = false; - if (this._saved$3) { - unwind = 40; + if (this._saved$5) { + unwind = 60; rt.drop(this.second_); } - this._saved$3 = false; - if (this._saved$4) { - unwind = 41; + this._saved$5 = false; + if (this._saved$6) { + unwind = 61; rt.drop(this.first_); } - this._saved$4 = false; - if (this._saved$2) { - unwind = 42; + this._saved$6 = false; + if (this._saved$4) { + unwind = 62; rt.drop(this.guard_); } - this._saved$2 = false; - if (this._saved$5) { + this._saved$4 = false; + if (this._saved$7) { unwind = 0; rt.drop(this.rx_); } - this._saved$5 = false; + this._saved$7 = false; } catch (e) { - b6: { - b7: { - b8: { - b9: { - b10: { - b11: { - b12: { - if (unwind === 0) { - throw e; - } - if (unwind === 26) { - rt.drop(this.chosen_); - } else if (unwind !== 29) { - if (unwind === 31) { - break b12; - } else if (unwind === 33) { - break b11; - } else if (unwind === 36) { - break b10; - } else if (unwind === 40) { - break b9; - } else if (unwind === 41) { - break b8; - } else if (unwind === 42) { - break b7; - } else { - rt.drop(this.guard); - break b6; + b8: { + b9: { + b10: { + b11: { + b12: { + b13: { + b14: { + b15: { + b16: { + b17: { + b18: { + b19: { + if (unwind === 0) { + throw e; + } + if (unwind === 37) { + rt.drop(this.chosen_); + break b18; + } else if (unwind === 40) { + break b18; + } else if (unwind === 42) { + break b17; + } else if (unwind === 44) { + break b16; + } else if (unwind === 47) { + break b15; + } else if (unwind === 51) { + rt.drop(this._saved); + break b19; + } else if (unwind === 52) { + break b19; + } else if (unwind === 55) { + break b13; + } else if (unwind === 56) { + rt.drop(this.saved); + } else if (unwind !== 57) { + if (unwind === 60) { + break b11; + } else if (unwind === 61) { + break b10; + } else if (unwind === 62) { + break b9; + } else { + rt.drop(this.guard); + break b8; + } + } + this._saved$10 = false; + break b12; + } + this._saved$9 = false; + break b14; + } + rt.drop(this._nested_); + } } } - rt.drop(this._nested_); + this._saved$8 = false; } + rt.dropAll(this.slots_); } } - this._saved$6 = false; - if (this._saved$3) { + if (this._saved$5) { rt.drop(this.second_); } } - this._saved$3 = false; - if (this._saved$4) { + this._saved$5 = false; + if (this._saved$6) { rt.drop(this.first_); } } - this._saved$4 = false; - if (this._saved$2) { + this._saved$6 = false; + if (this._saved$4) { rt.drop(this.guard_); } } - this._saved$2 = false; - if (this._saved$5) { + this._saved$4 = false; + if (this._saved$7) { rt.drop(this.rx_); } - this._saved$5 = false; + this._saved$7 = false; } throw e; } @@ -329,226 +386,353 @@ export class blocksFuture { poll(_2: rt.Context): rt.Poll { let _18!: rt.u32; - let seen!: rt.Future; - let _23!: rt.u32; - let _25!: string; - let _27!: string; - let _32!: rt.u32; - let _35!: rt.Poll; + let _32!: rt.Poll; + let result!: rt.u64 | undefined; + let _40!: Guard.Guard; + let _46!: Guard.Guard; + let _60!: rt.Poll; + let result2!: rt.usize; + let _73!: string; + let _75!: string; let args2!: rt.Fmt[]; - let _51!: rt.Poll; - let _61!: string; - let _63!: string; + let seen!: rt.Future; + let _86!: rt.u32; + let _88!: string; + let _90!: string; + let _95!: rt.u32; + let _98!: rt.Poll; let args4!: rt.Fmt[]; - let _70!: rt.Fmt; - let _75!: Inner.Inner | undefined; - let _76!: Guard.Guard; - let _83!: Outer.Outer; + let _114!: rt.Poll; + let _124!: string; + let _126!: string; + let args6!: rt.Fmt[]; + let _133!: rt.Fmt; + let _138!: Inner.Inner | undefined; + let _139!: Guard.Guard; + let _146!: Outer.Outer; let third!: Guard.Guard; - let _98!: rt.Poll; - let result3!: rt.u64; + let _161!: rt.Poll; + let result5!: rt.u64; let unwind: number = 0; try { b0: { b1: { - if (this.state === 0) { - unwind = 76; - this._saved$5 = false; - this._saved$2 = false; - this._saved$4 = false; - this._saved$3 = false; - this._saved$6 = false; - this._saved$5 = true; - this.rx_ = this.rx; - this._saved$2 = true; - this.guard_ = this.guard; - this.moves_ = this.moves; - this.first_ = Guard.new(rt.u32Add(this.guard_.id, 200), Log.clone$Clone(this.guard_.log)); - unwind = 75; - this._saved$4 = true; - this.second_ = Guard.new(rt.u32Add(this.guard_.id, 300), Log.clone$Clone(this.guard_.log)); - unwind = 83; - this._saved$3 = true; - rt.drop(new blocksFuture$2(this.first_)); - _18 = rt.u32Rem(this.guard_.id, 5); - turns(this.guard_.log, _18); - unwind = 81; - this.tally_ = { n: this.guard_.id }; - this._saved$6 = true; - seen = new blocksFuture$3(rt.copy(this.tally_)); - _23 = rt.u32Add(this.tally_.n, 1000); - this.tally_.n = _23; - this.saved = this.guard_; - this._saved = this.tally_.n; - this._saved$6 = false; - this.__awaitee_ = seen; - } else if (this.state === 1) { - rt.panic("`async fn` resumed after completion"); - } else if (this.state === 2) { - rt.panic("`async fn` resumed after panicking"); - } else if (this.state !== 3) { - if (this.state === 4) { - break b1; + b2: { + b3: { + if (this.state === 0) { + unwind = 132; + this._saved$7 = false; + this._saved$4 = false; + this._saved$6 = false; + this._saved$5 = false; + this._saved$10 = false; + this._saved$9 = false; + this._saved$8 = false; + this._saved$7 = true; + this.rx_ = this.rx; + this._saved$4 = true; + this.guard_ = this.guard; + this.moves_ = this.moves; + this.first_ = Guard.new(rt.u32Add(this.guard_.id, 200), Log.clone$Clone(this.guard_.log)); + unwind = 131; + this._saved$6 = true; + this.second_ = Guard.new(rt.u32Add(this.guard_.id, 300), Log.clone$Clone(this.guard_.log)); + unwind = 142; + this._saved$5 = true; + rt.drop(new blocksFuture$2(this.first_)); + _18 = rt.u32Rem(this.guard_.id, 5); + turns(this.guard_.log, _18); + temporaries(this.guard_.log, this.guard_.id); + unwind = 130; + this.saved = Guard.new(rt.u32Add(this.guard_.id, 900), Log.clone$Clone(this.guard_.log)); + unwind = 128; + this._saved$10 = true; + this.__awaitee_ = Consumer.recv(this.rx_); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } else if (this.state !== 3) { + if (this.state === 4) { + break b3; + } else if (this.state === 5) { + break b2; + } else if (this.state === 6) { + break b1; + } else { + break b0; + } + } + unwind = 125; + _32 = this.__awaitee_.poll(_2); + if (_32 !== rt.Pending) { + unwind = 126; + result = _32; + rt.drop(this.__awaitee_); + this._saved$10 = false; + this.waited_ = consume(this.saved, result); + unwind = 142; + this._saved$10 = false; + _40 = Guard.new(rt.u32Add(this.guard_.id, 910), Log.clone$Clone(this.guard_.log)); + unwind = 124; + _46 = Guard.new(rt.u32Add(this.guard_.id, 920), Log.clone$Clone(this.guard_.log)); + unwind = 122; + this.slots_ = [_40, _46]; + this._saved = Guard.new(rt.u32Add(this.guard_.id, 930), Log.clone$Clone(this.guard_.log)); + unwind = 120; + this._saved$9 = true; + this.___awaitee_ = slot(this.rx_); + } else { + this.state = 3; + return rt.Pending; + } + } + unwind = 118; + _60 = this.___awaitee_.poll(_2); + if (_60 !== rt.Pending) { + unwind = 139; + result2 = _60; + rt.drop(this.___awaitee_); + if (!(result2 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + result2); + } + unwind = 44; + rt.drop(this.slots_[result2]); + unwind = 123; + this._saved$9 = false; + this.slots_[result2] = this._saved; + this._saved$9 = false; + const arg = ([this.waited_] as [rt.u64])[0]; + args2 = [(f: rt.Formatter) => rt.u64Display(arg, f)]; + _75 = rt.fmtFormat(["slot after ", args2[0]]); + unwind = 117; + _73 = _75; + Guard.note(this.slots_[0], _73); + unwind = 137; + this.tally_ = { n: this.guard_.id }; + this._saved$8 = true; + seen = new blocksFuture$3(rt.copy(this.tally_)); + _86 = rt.u32Add(this.tally_.n, 1000); + this.tally_.n = _86; + this._saved$2 = this.guard_; + this._saved$3 = this.tally_.n; + this._saved$8 = false; + this.___awaitee_$2 = seen; } else { - break b0; + this.state = 4; + return rt.Pending; } } - unwind = 73; - _35 = this.__awaitee_.poll(_2); - if (_35 !== rt.Pending) { - unwind = 81; - _32 = _35; - rt.drop(this.__awaitee_); - const arg = this._saved; - args2 = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.u32Display(_32, f)]; - _27 = rt.fmtFormat(["tally ", args2[0], " then ", args2[1]]); - unwind = 72; - _25 = _27; - Guard.note(this.saved, _25); - unwind = 81; + unwind = 115; + _98 = this.___awaitee_$2.poll(_2); + if (_98 !== rt.Pending) { + unwind = 137; + _95 = _98; + rt.drop(this.___awaitee_$2); + const arg2 = this._saved$3; + args4 = [(f: rt.Formatter) => rt.u32Display(arg2, f), (f: rt.Formatter) => rt.u32Display(_95, f)]; + _90 = rt.fmtFormat(["tally ", args4[0], " then ", args4[1]]); + unwind = 114; + _88 = _90; + Guard.note(this._saved$2, _88); + unwind = 137; this.mark_ = { n: 1 }; - this.___awaitee_ = new blocksFuture$4(this.mark_); + this.___awaitee_$3 = new blocksFuture$4(this.mark_); } else { - this.state = 3; + this.state = 5; return rt.Pending; } } - unwind = 71; - _51 = this.___awaitee_.poll(_2); - if (_51 !== rt.Pending) { - unwind = 81; - this.replaced_ = _51; - rt.drop(this.___awaitee_); - const arg2 = this.replaced_; - _70 = (f: rt.Formatter) => rt.u32Display(arg2, f); - const arg3 = this.mark_.n; - args4 = [_70, (f: rt.Formatter) => rt.u32Display(arg3, f)]; - _63 = rt.fmtFormat(["mark ", args4[0], " ", args4[1]]); - unwind = 70; - _61 = _63; - Guard.note(this.guard_, _61); - unwind = 69; - _75 = undefined; - _76 = Guard.new(rt.u32Add(this.guard_.id, 800), Log.clone$Clone(this.guard_.log)); - unwind = 81; - _83 = new Outer.Outer({ inner: _75, guard: _76 }); - unwind = 68; - this._nested_ = new Inner.Inner({ outer: _83 }); + unwind = 113; + _114 = this.___awaitee_$3.poll(_2); + if (_114 !== rt.Pending) { + unwind = 137; + this.replaced_ = _114; + rt.drop(this.___awaitee_$3); + const arg3 = this.replaced_; + _133 = (f: rt.Formatter) => rt.u32Display(arg3, f); + const arg4 = this.mark_.n; + args6 = [_133, (f: rt.Formatter) => rt.u32Display(arg4, f)]; + _126 = rt.fmtFormat(["mark ", args6[0], " ", args6[1]]); + unwind = 112; + _124 = _126; + Guard.note(this.guard_, _124); + unwind = 111; + _138 = undefined; + _139 = Guard.new(rt.u32Add(this.guard_.id, 800), Log.clone$Clone(this.guard_.log)); + unwind = 137; + _146 = new Outer.Outer({ inner: _138, guard: _139 }); + unwind = 110; + this._nested_ = new Inner.Inner({ outer: _146 }); third = Guard.new(rt.u32Add(this.guard_.id, 400), Log.clone$Clone(this.guard_.log)); if (!this.moves_) { this.chosen_ = third; } else { this.chosen_ = third; } - unwind = 67; + unwind = 109; Guard.note(this.chosen_, "chosen"); if (this.moves_) { - this._saved$2 = false; + this._saved$4 = false; rt.drop(new blocksFuture$5(this.guard_)); } - unwind = 67; - this._saved$4 = false; - this._saved$3 = false; + unwind = 109; + this._saved$6 = false; this._saved$5 = false; - this.___awaitee_$2 = new blocksFuture$6(this.first_, this.second_, this.rx_); + this._saved$7 = false; + this.___awaitee_$4 = new blocksFuture$6(this.first_, this.second_, this.rx_); } else { - this.state = 4; + this.state = 6; return rt.Pending; } } - unwind = 66; - _98 = this.___awaitee_$2.poll(_2); - if (_98 !== rt.Pending) { - unwind = 67; - result3 = _98; - rt.drop(this.___awaitee_$2); - unwind = 68; + unwind = 108; + _161 = this.___awaitee_$4.poll(_2); + if (_161 !== rt.Pending) { + unwind = 109; + result5 = _161; + rt.drop(this.___awaitee_$4); + unwind = 110; rt.drop(this.chosen_); - unwind = 81; + unwind = 137; rt.drop(this._nested_); + unwind = 142; + this._saved$8 = false; + rt.dropAll(this.slots_); + this._saved$5 = false; this._saved$6 = false; - this._saved$3 = false; - this._saved$4 = false; - if (this._saved$2) { - unwind = 77; + if (this._saved$4) { + unwind = 133; rt.drop(this.guard_); } - this._saved$2 = false; - this._saved$5 = false; + this._saved$4 = false; + this._saved$7 = false; this.state = 1; - return result3; + return result5; } else { - this.state = 5; + this.state = 7; return rt.Pending; } } catch (e) { - b6: { - b7: { - b8: { - b9: { - b10: { - b11: { - if (unwind === 0) { - throw e; - } - if (unwind === 66) { - rt.drop(this.___awaitee_$2); - } else if (unwind !== 67) { - if (unwind === 68) { - break b11; - } else if (unwind === 69) { - rt.drop(_75); - break b10; - } else if (unwind === 70) { - break b10; - } else if (unwind === 71) { - rt.drop(this.___awaitee_); - break b10; - } else if (unwind === 72) { - break b10; - } else if (unwind === 73) { - rt.drop(this.__awaitee_); - break b10; - } else if (unwind === 75) { - break b8; - } else if (unwind === 76) { - break b7; - } else if (unwind === 77) { - break b6; - } else if (unwind === 81) { - break b10; - } else { - break b9; + b8: { + b9: { + b10: { + b11: { + b12: { + b13: { + b14: { + b15: { + b16: { + if (unwind === 0) { + throw e; + } + if (unwind === 44) { + this._saved$9 = false; + this.slots_[result2] = this._saved; + break b13; + } else if (unwind === 108) { + rt.drop(this.___awaitee_$4); + break b16; + } else if (unwind === 109) { + break b16; + } else if (unwind === 110) { + break b15; + } else if (unwind === 111) { + rt.drop(_138); + break b14; + } else if (unwind === 112) { + break b14; + } else if (unwind === 113) { + rt.drop(this.___awaitee_$3); + break b14; + } else if (unwind === 114) { + break b14; + } else if (unwind === 115) { + rt.drop(this.___awaitee_$2); + break b14; + } else if (unwind === 117) { + break b12; + } else if (unwind === 118) { + rt.drop(this.___awaitee_); + break b13; + } else if (unwind === 120) { + rt.drop(this._saved); + this._saved$9 = false; + break b12; + } else if (unwind === 122) { + this._saved$9 = false; + break b12; + } else if (unwind === 123) { + break b12; + } else if (unwind === 124) { + rt.drop(_40); + break b11; + } else if (unwind === 125) { + rt.drop(this.__awaitee_); + } else if (unwind !== 126) { + if (unwind === 128) { + rt.drop(this.saved); + this._saved$10 = false; + break b11; + } else if (unwind === 130) { + this._saved$10 = false; + break b11; + } else if (unwind === 131) { + break b10; + } else if (unwind === 132) { + break b9; + } else if (unwind === 133) { + break b8; + } else if (unwind === 137) { + break b14; + } else if (unwind === 139) { + break b13; + } else { + break b11; + } + } + if (this._saved$10) { + rt.drop(this.saved); + } + this._saved$10 = false; + break b11; + } + rt.drop(this.chosen_); } + rt.drop(this._nested_); } - rt.drop(this.chosen_); + if (this._saved$8) { + rt.drop(seen); + } + this._saved$8 = false; + break b12; } - rt.drop(this._nested_); - } - if (this._saved$6) { - rt.drop(seen); + if (this._saved$9) { + rt.drop(this._saved); + } + this._saved$9 = false; } - this._saved$6 = false; + rt.dropAll(this.slots_); } - if (this._saved$3) { + if (this._saved$5) { rt.drop(this.second_); } } - this._saved$3 = false; - if (this._saved$4) { + this._saved$5 = false; + if (this._saved$6) { rt.drop(this.first_); } } - this._saved$4 = false; - if (this._saved$2) { + this._saved$6 = false; + if (this._saved$4) { rt.drop(this.guard_); } } - this._saved$2 = false; - if (this._saved$5) { + this._saved$4 = false; + if (this._saved$7) { rt.drop(this.rx_); } - this._saved$5 = false; + this._saved$7 = false; this.state = 2; throw e; } @@ -843,6 +1027,256 @@ export class blocksFuture$6 { } } +/** `v`, or 0, plus the id of `guard`, which it drops. */ +export function consume(guard: Guard.Guard, v: rt.u64 | undefined): rt.u64 { + return rt.u64Add(Guard.finish(guard, "consumed") as rt.u64, rt.optionUnwrapOr(v, 0)); +} + +/** The slot the next value picks. */ +export function slot(rx: Consumer.Consumer): rt.Future { + return new slotFuture(rx); +} + +export class slotFuture { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _18!: rt.usize; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 16; + this.__awaitee_ = Consumer.recv(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 15; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 16; + result = _6; + rt.drop(this.__awaitee_); + if (result === undefined) { + _18 = 0; + } else { + _18 = rt.usizeRem(rt.u64Low(result), 2); + } + this.state = 1; + return _18; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 15) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; + } + } +} + +/** + * Guards no binding holds to the end of the scope, each dropping where Rust drops it: a + * temporary at the end of its statement, a scrutinee after its `match` or `if let`, a + * boxed temporary, the part a parameter's pattern skips at the end of the call, the rest + * a pattern moves out of an array, an empty repeat at once, a closure's captures in its + * call, and an iterator's after its loop. + */ +export function temporaries(log: Log.Log, id: rt.u32): void { + let guard!: (a0: rt.u32) => Guard.Guard; + let _7!: string; + let _11!: Guard.Guard; + let args2!: rt.Fmt[]; + let matched!: rt.i32; + let _19!: Guard.Guard | undefined; + let _24!: Guard.Guard | undefined; + let _35!: string; + let _39!: Guard.Guard; + let args4!: rt.Fmt[]; + let _57!: Guard.Guard; + let _60!: Guard.Guard; + let args6!: rt.Fmt[]; + let head!: Guard.Guard; + let rest!: Guard.Guard[]; + let _69!: Guard.Guard[]; + let _70!: Guard.Guard; + let _73!: Guard.Guard; + let _76!: Guard.Guard; + let args8!: rt.Fmt[]; + let args10!: rt.Fmt[]; + let sum_!: rt.u32; + let iter!: Countdown.Countdown; + let _126!: rt.u32 | rt.Done; + let args12!: rt.Fmt[]; + let unwind: number = 0; + try { + guard = (n2: rt.u32): Guard.Guard => { + return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); + }; + _11 = guard(1000); + unwind = 83; + const arg = ([_11.id] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f)]; + _7 = rt.fmtFormat(["temporary ", args2[0]]); + unwind = 0; + rt.drop(_11); + Log.note(log, _7); + _19 = guard(1010); + if (_19 === undefined) { + matched = 0; + } else { + matched = 1; + } + unwind = 0; + rt.drop(_19); + _24 = guard(1020); + if (_24 === undefined) { + unwind = 82; + Log.note(log, rt.fmtFormat(["unmatched"])); + unwind = 0; + rt.drop(_24); + } else { + rt.drop(_24); + } + unwind = 0; + _39 = guard(1030); + unwind = 81; + const arg2 = _39.id; + args4 = [(f: rt.Formatter) => rt.u32Display(arg2, f), (f: rt.Formatter) => rt.i32Display(matched, f)]; + _35 = rt.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); + unwind = 0; + rt.drop(_39); + Log.note(log, _35); + _57 = guard(1040); + unwind = 80; + _60 = guard(1050); + unwind = 0; + const arg3 = ([first([_57, _60] as [Guard.Guard, Guard.Guard])] as [rt.u32])[0]; + args6 = [(f: rt.Formatter) => rt.u32Display(arg3, f)]; + Log.note(log, rt.fmtFormat(["skipped ", args6[0]])); + _70 = guard(1060); + unwind = 79; + _73 = guard(1070); + unwind = 78; + _76 = guard(1080); + unwind = 76; + _69 = [_70, _73, _76]; + head = _69[0]; + rest = _69.slice(1, 3); + Guard.note(head, "head"); + Guard.note(rest[1], "rest"); + rt.drop(guard(1090)); + const arg4 = ([([] as Guard.Guard[]).length] as [rt.usize])[0]; + args8 = [(f: rt.Formatter) => rt.usizeDisplay(arg4, f)]; + Log.note(log, rt.fmtFormat(["empty ", args8[0]])); + const captured = guard(1100); + const arg5 = ([((): rt.u32 => { + return Guard.finish(captured, "closure"); + })()] as [rt.u32])[0]; + args10 = [(f: rt.Formatter) => rt.u32Display(arg5, f)]; + Log.note(log, rt.fmtFormat(["closed ", args10[0]])); + sum_ = 0; + iter = new Countdown.Countdown({ left: 2, guard: guard(1110) }); + while (true) { + unwind = 75; + _126 = Countdown.next$Iterator(iter); + if (_126 === rt.DONE) { + unwind = 76; + rt.drop(iter); + const arg6 = ([sum_] as [rt.u32])[0]; + args12 = [(f: rt.Formatter) => rt.u32Display(arg6, f)]; + Log.note(log, rt.fmtFormat(["counted ", args12[0]])); + unwind = 77; + rt.dropAll(rest); + unwind = 0; + rt.drop(head); + return; + } else { + sum_ = rt.u32Add(sum_, _126); + } + } + } catch (e) { + b3: { + b4: { + b5: { + if (unwind === 0) { + throw e; + } + if (unwind === 75) { + rt.drop(iter); + break b5; + } else if (unwind === 76) { + break b5; + } else if (unwind === 77) { + break b4; + } else if (unwind === 78) { + rt.drop(_73); + } else if (unwind !== 79) { + if (unwind === 80) { + rt.drop(_57); + break b3; + } else if (unwind === 81) { + rt.drop(_39); + break b3; + } else if (unwind === 82) { + rt.drop(_24); + break b3; + } else { + rt.drop(_11); + break b3; + } + } + rt.drop(_70); + break b3; + } + rt.dropAll(rest); + } + rt.drop(head); + } + throw e; + } +} + +/** The id of the first guard, which it drops; the second drops as the call returns. */ +export function first(_1: [Guard.Guard, Guard.Guard]): rt.u32 { + let _0!: rt.u32; + let unwind: number = 0; + try { + unwind = 5; + _0 = Guard.finish(_1[0], "first"); + unwind = 0; + rt.drop(_1[1]); + return _0; + } catch (e) { + if (unwind === 0) { + throw e; + } + rt.drop(_1[1]); + throw e; + } +} + export function read(t: Tally.Tally): rt.u32 { return t.n; } diff --git a/ts/fixtures/task/src/model.rs b/ts/fixtures/task/src/model.rs index edbd64016..2be0352b8 100644 --- a/ts/fixtures/task/src/model.rs +++ b/ts/fixtures/task/src/model.rs @@ -104,12 +104,23 @@ pub async fn sum(mut rx: Consumer, guard: Guard) -> u64 { /// dropping the block must not drop; a copy, which a later change to the original must /// not reach; a mutable borrow the block replaces whole, which the caller must see; a /// move on one path only; and a move the block only borrows, which drops when the block -/// returns or is cancelled. Between them, a value of two types that hold each other. +/// returns or is cancelled. Between them, a value of two types that hold each other, and +/// guards held across awaits that read values first. pub async fn blocks(mut rx: Consumer, guard: Guard, moves: bool) -> u64 { let first = Guard::new(guard.id + 200, guard.log.clone()); let second = Guard::new(guard.id + 300, guard.log.clone()); drop(async { first.note("borrowed") }); turns(&guard.log, guard.id % 5); + temporaries(&guard.log, guard.id); + // A guard passed beside an await waits it out, as does one assigned to the slot an + // await picks: a cancel drops both. + let waited = consume(Guard::new(guard.id + 900, guard.log.clone()), rx.recv().await); + let mut slots = [ + Guard::new(guard.id + 910, guard.log.clone()), + Guard::new(guard.id + 920, guard.log.clone()), + ]; + slots[slot(&mut rx).await] = Guard::new(guard.id + 930, guard.log.clone()); + slots[0].note(&format!("slot after {waited}")); let mut tally = Tally { n: guard.id }; let seen = async move { read(tally) }; tally.n += 1000; @@ -154,6 +165,79 @@ struct Mark { n: u32, } +/// `v`, or 0, plus the id of `guard`, which it drops. +fn consume(guard: Guard, v: Option) -> u64 { + u64::from(guard.finish("consumed")) + v.unwrap_or(0) +} + +/// The slot the next value picks. +async fn slot(rx: &mut Consumer) -> usize { + match rx.recv().await { + Some(v) => v as usize % 2, + None => 0, + } +} + +/// Guards no binding holds to the end of the scope, each dropping where Rust drops it: a +/// temporary at the end of its statement, a scrutinee after its `match` or `if let`, a +/// boxed temporary, the part a parameter's pattern skips at the end of the call, the rest +/// a pattern moves out of an array, an empty repeat at once, a closure's captures in its +/// call, and an iterator's after its loop. +#[expect(clippy::redundant_pattern_matching, reason = "the `if let` is under test")] +fn temporaries(log: &Log, id: u32) { + let guard = |n: u32| Guard::new(id + n, log.clone()); + log.note(format!("temporary {}", guard(1000).id)); + let matched = match Some(guard(1010)) { + Some(..) => 1, + None => 0, + }; + if let None = Some(guard(1020)) { + log.note(format!("unmatched")); + } + log.note(format!("boxed temporary {} {matched}", Box::new(guard(1030)).id)); + log.note(format!("skipped {}", first((guard(1040), guard(1050))))); + let [head, rest @ ..] = [guard(1060), guard(1070), guard(1080)]; + head.note("head"); + rest[1].note("rest"); + let empty = [guard(1090); 0]; + log.note(format!("empty {}", empty.len())); + let once = guard(1100); + let finish = move || once.finish("closure"); + log.note(format!("closed {}", finish())); + let mut sum = 0; + for n in (Countdown { + left: 2, + guard: guard(1110), + }) { + sum += n; + } + log.note(format!("counted {sum}")); +} + +/// The id of the first guard, which it drops; the second drops as the call returns. +fn first((a, _): (Guard, Guard)) -> u32 { + a.finish("first") +} + +/// Counts down, holding a guard the loop drops after its last turn. +struct Countdown { + left: u32, + guard: Guard, +} + +impl Iterator for Countdown { + type Item = u32; + + fn next(&mut self) -> Option { + if self.left == 0 { + return None; + } + self.left -= 1; + self.guard.note("count"); + Some(self.left) + } +} + /// Drops through `guard`, and `Inner` through it: deciding `Outer` first must not leave /// `Inner` decided as dropping nothing. struct Outer { diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index 8c30b3d17..bd89340b1 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -141,6 +141,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if !supported && let Some(sym) = super::mir::glue::shim(self, ty, span) { return Some(super::mir::glue::call(sym, value)); } + if !supported && let ty::Closure(..) = ty.kind() { + // Its captures live in an arrow function's scope, where nothing outside can drop them. + self.err( + span, + "dropping a closure that owns a value that drops, which is not supported yet", + ); + return None; + } if !supported { self.err(span, format!("dropping `{ty}`, which is not supported yet")); return None; diff --git a/ts/src/lower/mir/glue.rs b/ts/src/lower/mir/glue.rs index 931b6234f..68288bbca 100644 --- a/ts/src/lower/mir/glue.rs +++ b/ts/src/lower/mir/glue.rs @@ -21,7 +21,7 @@ pub fn shim<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Opt return None; } let structural = match ty.kind() { - ty::Tuple(_) | ty::Closure(..) => true, + ty::Tuple(_) => true, ty::Adt(adt, _) => adt.is_enum(), _ => false, }; diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index e85ed3fb1..cf06f47c7 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -371,7 +371,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { Slot::Unit - } else if let Some(value) = self.unit_struct(local, ty) { + } else if let Some(value) = self.unassigned(local, ty) { Slot::Alias(Some(value)) } else if self.alias(local) { Slot::Alias(None) @@ -614,12 +614,20 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } - /// A struct of no fields that nothing assigns, which MIR leaves unassigned since it - /// holds nothing: JS needs it made. - fn unit_struct(&mut self, local: Local, ty: Ty<'tcx>) -> Option { + /// A struct of no fields or an empty array that nothing assigns, which MIR leaves + /// unassigned since it holds nothing: JS needs it made. + fn unassigned(&mut self, local: Local, ty: Ty<'tcx>) -> Option { if self.defs[local] != 0 || self.is_arg(local) || local == mir::RETURN_PLACE { return None; } + if let ty::Array(elem, len) = ty.kind() + && len.try_to_target_usize(self.tcx) == Some(0) + { + return Some(match elem.kind() { + ty::Uint(ty::UintTy::U8) => Expr::ident("Uint8Array").member("of").call(Vec::new()), + _ => Expr::As(Box::new(Expr::Array(Vec::new())), self.b.t.ty(ty, self.span)), + }); + } let ty::Adt(adt, _) = ty.kind() else { return None; }; From df6e8114aa37a850ede34d9da74a726896b208fc Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 20:15:06 -0700 Subject: [PATCH 13/17] perf(ts): step iterators in place in two variables, not an object A range or an array iterator stepped in place was an object of its bounds or its array and index, whose fields V8 stepped up to 1.25x slower over the bench's BTreeMap, which THIR's counters had run as fast as. Each is now two variables, which an iterator moved into another and read nowhere else shares. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/codec/expected/bench.ts | 40 ++++-- .../codec/expected/coding/version.Versions.ts | 16 ++- ts/fixtures/codec/expected/harness.ts | 24 ++-- ts/fixtures/lang/expected/collections.ts | 120 ++++++++++------ ts/fixtures/lang/expected/fmt.ts | 8 +- ts/fixtures/lang/expected/iters.ts | 34 +++-- ts/fixtures/lang/expected/shapes.ts | 114 +++++++++------ ts/fixtures/task/expected/kio.WaiterList.ts | 24 ++-- ts/src/lower/mir/call.rs | 15 +- ts/src/lower/mir/mod.rs | 27 +++- ts/src/lower/mir/place.rs | 3 + ts/src/lower/mir/step.rs | 131 +++++++++++++++--- 12 files changed, 383 insertions(+), 173 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index c74bb11ae..cc6c4524f 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -73,15 +73,17 @@ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVe let _6!: [rt.u64, Uint8Array]; let value!: rt.u64; let w!: Encoder.Encoder; - let iter!: { start: rt.usize; end: rt.usize }; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; let _17!: rt.Result; _6 = takeU64(data); count = _6[0]; value = takeU64(_6[1])[0]; w = Encoder.new(out, form_); - iter = { start: 0, end: rt.u64Low(count) }; + iterStart = 0; + iterEnd = rt.u64Low(count); l0: while (true) { - if (!(iter.start++ < iter.end)) { + if (!(iterStart++ < iterEnd)) { return rt.Ok(undefined); } else { _17 = Encoder.varint(w, value); @@ -143,7 +145,8 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt let _23!: [rt.i64, rt.usize]; let _24!: rt.i64; let w!: Encoder.Encoder; - let iter!: { start: rt.usize; end: rt.usize }; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; let _32!: rt.usize; let n!: rt.usize; let delta3!: rt.i64; @@ -168,9 +171,10 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt delta2 = _24; keyEvery2 = _23[1]; w = Encoder.new(out, Form.from$From_Version(version)); - iter = { start: 0, end: rt.u64Low(count) }; + iterStart = 0; + iterEnd = rt.u64Low(count); l0: while (true) { - if (!((_32 = iter.start++) < iter.end)) { + if (!((_32 = iterStart++) < iterEnd)) { return rt.Ok(undefined); } else { b2: { @@ -350,12 +354,14 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { let count2!: rt.u32; let _10!: (a0: rt.u32) => rt.u32; let map!: rt.BTreeMap; - let iter!: { start: rt.u32; end: rt.u32 }; + let iterStart!: rt.u32; + let iterEnd!: rt.u32; let _15!: rt.u32; let i!: rt.u32; let _21!: rt.u32; let sum!: rt.u64; - let iter2!: { start: rt.u32; end: rt.u32 }; + let iterStart2!: rt.u32; + let iterEnd2!: rt.u32; let _28!: rt.u32; let i2!: rt.u32; let _38!: rt.u32; @@ -363,7 +369,8 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { let _49!: rt.Range; let iter3!: rt.Iter<[rt.u32, rt.u32]>; let _57!: [rt.u32, rt.u32] | rt.Done; - let iter4!: { start: rt.u32; end: rt.u32 }; + let iterStart3!: rt.u32; + let iterEnd3!: rt.u32; let _66!: rt.u32; let _73!: rt.u32; _10 = (i4: rt.u32): rt.u32 => { @@ -371,21 +378,24 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { }; count2 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); map = rt.btreeNew(rt.cmp) as rt.BTreeMap; - iter = { start: 0, end: count2 }; + iterStart = 0; + iterEnd = count2; while (true) { - if (!((_15 = iter.start++) < iter.end)) { + if (!((_15 = iterStart++) < iterEnd)) { sum = 0; - iter2 = { start: 0, end: count2 }; + iterStart2 = 0; + iterEnd2 = count2; while (true) { - if (!((_28 = iter2.start++) < iter2.end)) { + if (!((_28 = iterStart2++) < iterEnd2)) { _49 = new rt.Range(1 << 14, 2 << 14); iter3 = rt.btreeRange(map, _49); while (true) { _57 = iter3.next(); if (_57 === rt.DONE) { - iter4 = { start: 0, end: count2 }; + iterStart3 = 0; + iterEnd3 = count2; while (true) { - if (!((_66 = iter4.start++) < iter4.end)) { + if (!((_66 = iterStart3++) < iterEnd3)) { putU64(out, sum); return; } else { diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 3389a7f9a..5b129819d 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -69,14 +69,16 @@ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.R /** Encode the version list. */ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: Form.Form): rt.Result { let _4!: rt.Result; - let iter!: { s: Version.Version[]; i: number }; + let iterS!: Version.Version[]; + let iterI!: number; let _14!: Version.Version | rt.Done; let _18!: rt.Result; _4 = Encoder.varint(w, self._0.length as rt.u64); if (_4.ok) { - iter = { s: self._0, i: 0 }; + iterS = self._0; + iterI = 0; while (true) { - _14 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _14 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_14 === rt.DONE) { return rt.Ok(undefined); } else { @@ -94,14 +96,16 @@ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: /** Encode the version list. */ export function encode$Encode_Version(self: Versions, w: Encoder.Encoder, version: version_Version.Version): rt.Result { let _4!: rt.Result; - let iter!: { s: Version.Version[]; i: number }; + let iterS!: Version.Version[]; + let iterI!: number; let _14!: Version.Version | rt.Done; let _18!: rt.Result; _4 = Encoder.varint(w, self._0.length as rt.u64); if (_4.ok) { - iter = { s: self._0, i: 0 }; + iterS = self._0; + iterI = 0; while (true) { - _14 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _14 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_14 === rt.DONE) { return rt.Ok(undefined); } else { diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 7a761e62a..ef3e0a9d2 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -212,7 +212,8 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { let _13!: [Uint8Array, Uint8Array]; let _15!: rt.usize; let r!: Decoder.Decoder; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _21!: rt.u8 | rt.Done; let _26!: rt.Result; let err!: DecodeError.DecodeError; @@ -226,9 +227,10 @@ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { _15 = _9[1].length; _13 = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); r = Decoder.new(_13[1], form(selector)); - iter = { s: _13[0], i: 0 }; + iterS = _13[0]; + iterI = 0; l1: while (true) { - _21 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _21 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_21 !== rt.DONE) { _26 = decodeStep(r, _21, out); if (_26.ok) { @@ -364,7 +366,8 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { let w!: Encoder.Encoder; let _20!: Form.Form; let prefixes!: Prefix.Prefix[]; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _24!: rt.u8 | rt.Done; let step!: rt.u8; let value!: rt.u64; @@ -398,9 +401,10 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { _20 = form(selector); w = Encoder.new(buf, _20); prefixes = []; - iter = { s: _13[0], i: 0 }; + iterS = _13[0]; + iterI = 0; while (true) { - _24 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _24 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_24 === rt.DONE) { while (true) { _98 = prefixes.pop(); @@ -502,13 +506,15 @@ export function zigzag(data: Uint8Array, out: rt.ByteVec): void { export function sizes(data: Uint8Array, out: rt.ByteVec): void { let value!: rt.u64; - let iter!: { start: rt.u8; end: rt.u8 }; + let iterStart!: rt.u8; + let iterEnd!: rt.u8; let _9!: rt.u8; let _13!: rt.Result; value = takeU64(data)[0]; - iter = { start: 0, end: 3 }; + iterStart = 0; + iterEnd = 3; while (true) { - if (!((_9 = iter.start++) < iter.end)) { + if (!((_9 = iterStart++) < iterEnd)) { return; } else { _13 = size(value, form(_9)); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index a08a25f5d..d19e58acc 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -81,7 +81,8 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let pairs!: rt.HashMap; let ranks!: rt.HashMap; let tuples!: rt.HashMap<[rt.u8, string], rt.u8>; - let iter5!: { start: rt.usize; end: rt.usize }; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; let _161!: rt.usize; let i3!: rt.usize; let a!: rt.u8; @@ -110,7 +111,8 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _269!: [Pair.Pair, Tally.Tally] | rt.Done; let p!: Pair.Pair; let t3!: Tally.Tally; - let iter8!: { start: rt.usize; end: rt.usize }; + let iterStart2!: rt.usize; + let iterEnd2!: rt.usize; let _286!: rt.usize; let i4!: rt.usize; let a2!: rt.u8; @@ -129,10 +131,12 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let copy2!: rt.HashMap; let iter9!: rt.Iter; let _356!: Tally.Tally | rt.Done; - let iter10!: { start: rt.u8; end: rt.u8 }; + let iterStart3!: rt.u8; + let iterEnd3!: rt.u8; let _364!: rt.u8; let k4!: rt.u8; - let iter11!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _380!: rt.u8 | rt.Done; let b5!: rt.u8; let _387!: rt.u8; @@ -141,7 +145,8 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let extended!: rt.HashMap; let iter12!: rt.Iter; let _409!: Tally.Tally | rt.Done; - let iter13!: { start: rt.u8; end: rt.u8 }; + let iterStart4!: rt.u8; + let iterEnd4!: rt.u8; let _416!: rt.u8; let k5!: rt.u8; let _430!: (a0: Nibble.Nibble) => rt.u64; @@ -157,7 +162,8 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let iter14!: rt.Iter<[Rank.Rank, rt.u16]>; let _479!: [Rank.Rank, rt.u16] | rt.Done; let words!: rt.HashMap; - let iter15!: { s: Uint8Array; i: number }; + let iterS2!: Uint8Array; + let iterI2!: number; let _496!: rt.u8 | rt.Done; let b6!: rt.u8; let word!: string; @@ -281,9 +287,10 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { pairs = rt.hashNew(rt.hashing(Pair.hash$Hash_DefaultHasher, Pair.eq$PartialEq)) as rt.HashMap; ranks = rt.hashNew(rt.hashing(Rank.hash$Hash_DefaultHasher, Rank.eq$PartialEq)) as rt.HashMap; tuples = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashInt, rt.hashStr]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, string], rt.u8>; - iter5 = { start: 1, end: data.length }; + iterStart = 1; + iterEnd = data.length; while (true) { - if (!((_161 = iter5.start++) < iter5.end)) { + if (!((_161 = iterStart++) < iterEnd)) { _225 = rt.iterMap(rt.hashIter(map3), (_214: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { return [_214[0]._0, _214[1]] as [rt.u8, rt.u8]; }); @@ -308,9 +315,10 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { while (true) { _269 = iter7.next(); if (_269 === rt.DONE) { - iter8 = { start: 1, end: data.length }; + iterStart2 = 1; + iterEnd2 = data.length; while (true) { - if (!((_286 = iter8.start++) < iter8.end)) { + if (!((_286 = iterStart2++) < iterEnd2)) { copy = rt.hashClone(ranks, undefined, rt.copy); _327 = rt.hashGet(copy, { tag: "Low" } as Rank.Rank); if (_327 !== undefined) { @@ -340,12 +348,14 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { while (true) { _356 = iter9.next(); if (_356 === rt.DONE) { - iter10 = { start: 0, end: 8 }; + iterStart3 = 0; + iterEnd3 = 8; while (true) { - if (!((_364 = iter10.start++) < iter10.end)) { - iter11 = { s: data, i: 0 }; + if (!((_364 = iterStart3++) < iterEnd3)) { + iterS = data; + iterI = 0; while (true) { - _380 = iter11.i < iter11.s.length ? iter11.s[iter11.i++] : rt.DONE; + _380 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_380 === rt.DONE) { stamped = rt.hashNew() as rt.HashMap; stamp(stamped); @@ -357,9 +367,10 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { while (true) { _409 = iter12.next(); if (_409 === rt.DONE) { - iter13 = { start: 0, end: 8 }; + iterStart4 = 0; + iterEnd4 = 8; while (true) { - if (!((_416 = iter13.start++) < iter13.end)) { + if (!((_416 = iterStart4++) < iterEnd4)) { first = rt.optionUnwrapOr(rt.sliceFirst(data), 0); rt.byteVecPush(out, rt.u64Eq(_430({ _0: first }), _430({ _0: first ^ 240 })) ? 1 : 0); _448 = [rt.hasher(), { n: first as rt.u16 }] as [rt.Hasher, Tally.Tally]; @@ -502,9 +513,10 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } } else { words = rt.hashNew() as rt.HashMap; - iter15 = { s: data, i: 0 }; + iterS2 = data; + iterI2 = 0; while (true) { - _496 = iter15.i < iter15.s.length ? iter15.s[iter15.i++] : rt.DONE; + _496 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_496 === rt.DONE) { lens = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; iter16 = rt.hashIter(words); @@ -629,7 +641,8 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _4!: rt.u8; let hashed!: rt.HashSet; let sorted!: rt.BTreeSet; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _10!: rt.u8 | rt.Done; let b!: rt.u8; let v!: rt.u16; @@ -639,18 +652,21 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let firsts!: rt.u16[]; let nibbles!: rt.BTreeSet; let seen!: rt.HashSet; - let iter3!: { s: Uint8Array; i: number }; + let iterS2!: Uint8Array; + let iterI2!: number; let _106!: rt.u8 | rt.Done; let b2!: rt.u8; let iter4!: rt.Iter; let _123!: Nibble.Nibble | rt.Done; let _129!: Nibble.Nibble | undefined; let dirs!: rt.HashSet; - let iter5!: { s: Uint8Array; i: number }; + let iterS3!: Uint8Array; + let iterI3!: number; let _151!: rt.u8 | rt.Done; let _160!: rt.usize; let words!: rt.BTreeSet; - let iter6!: { s: Uint8Array; i: number }; + let iterS4!: Uint8Array; + let iterI4!: number; let _175!: rt.u8 | rt.Done; let _182!: rt.usize; let iter7!: rt.Iter; @@ -664,9 +680,10 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_4 === 0) { hashed = rt.hashNew() as rt.HashSet; sorted = rt.btreeNew(rt.cmp) as rt.BTreeSet; - iter = { s: data, i: 0 }; + iterS = data; + iterI = 0; while (true) { - _10 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _10 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_10 === rt.DONE) { rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.hashKeys(hashed), (v2: rt.u16): boolean => { @@ -714,9 +731,10 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else if (_4 === 1) { nibbles = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; seen = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; - iter3 = { s: data, i: 0 }; + iterS2 = data; + iterI2 = 0; while (true) { - _106 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; + _106 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_106 === rt.DONE) { iter4 = rt.btreeKeys(nibbles); while (true) { @@ -734,9 +752,10 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { rt.byteVecPush(out, rt.hashLen(seen) & 0xff); dirs = rt.hashNew(rt.hashing(Dir.hash$Hash_DefaultHasher, Dir.eq$PartialEq, true)) as rt.HashSet; - iter5 = { s: data, i: 0 }; + iterS3 = data; + iterI3 = 0; while (true) { - _151 = iter5.i < iter5.s.length ? iter5.s[iter5.i++] : rt.DONE; + _151 = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; if (_151 === rt.DONE) { rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); break b0; @@ -762,9 +781,10 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } } else { words = rt.btreeNew(rt.cmpStr) as rt.BTreeSet; - iter6 = { s: data, i: 0 }; + iterS4 = data; + iterI4 = 0; while (true) { - _175 = iter6.i < iter6.s.length ? iter6.s[iter6.i++] : rt.DONE; + _175 = iterI4 < iterS4.length ? iterS4[iterI4++] : rt.DONE; if (_175 === rt.DONE) { iter7 = rt.btreeKeys(words); while (true) { @@ -827,7 +847,8 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void let ranks!: rt.BTreeMap; let pairs!: rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; let wides!: rt.BTreeMap; - let iter5!: { start: rt.usize; end: rt.usize }; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; let _164!: rt.usize; let i2!: rt.usize; let a!: rt.u8; @@ -840,7 +861,8 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void let _188!: [rt.u8, rt.u8]; let _196!: rt.u64; let _197!: Tally.Tally | undefined; - let iter6!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _205!: rt.u8 | rt.Done; let b2!: rt.u8; let r!: Rank.Rank; @@ -862,14 +884,16 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void let _294!: [Fussy.Fussy, Fussy.Fussy] | rt.Done; let nibbles!: rt.BTreeMap; let words!: rt.BTreeMap; - let iter11!: { s: Uint8Array; i: number }; + let iterS2!: Uint8Array; + let iterI2!: number; let _307!: rt.u8 | rt.Done; let b3!: rt.u8; let t2!: Tally.Tally; let _320!: rt.usize; let iter12!: rt.Iter<[Nibble.Nibble, rt.u8]>; let _331!: [Nibble.Nibble, rt.u8] | rt.Done; - let iter13!: { start: rt.usize; end: rt.usize }; + let iterStart2!: rt.usize; + let iterEnd2!: rt.usize; let _344!: rt.usize; let i3!: rt.usize; let a2!: Nibble.Nibble; @@ -992,16 +1016,18 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void ranks = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; pairs = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; wides = rt.btreeNew(rt.cmp) as rt.BTreeMap; - iter5 = { start: 1, end: data.length }; + iterStart = 1; + iterEnd = data.length; while (true) { - if (!((_164 = iter5.start++) < iter5.end)) { + if (!((_164 = iterStart++) < iterEnd)) { _197 = rt.btreeGet(ranks, { tag: "Low" } as Rank.Rank); if (_197 !== undefined) { _197.n = _197.n ^ 23130; } - iter6 = { s: data, i: 0 }; + iterS = data; + iterI = 0; while (true) { - _205 = iter6.i < iter6.s.length ? iter6.s[iter6.i++] : rt.DONE; + _205 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_205 === rt.DONE) { iter7 = rt.btreeIter(ranks); while (true) { @@ -1087,17 +1113,19 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } else { nibbles = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap; words = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - iter11 = { s: data, i: 0 }; + iterS2 = data; + iterI2 = 0; while (true) { - _307 = iter11.i < iter11.s.length ? iter11.s[iter11.i++] : rt.DONE; + _307 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_307 === rt.DONE) { iter12 = rt.btreeIter(nibbles); while (true) { _331 = iter12.next(); if (_331 === rt.DONE) { - iter13 = { start: 1, end: data.length }; + iterStart2 = 1; + iterEnd2 = data.length; while (true) { - if (!((_344 = iter13.start++) < iter13.end)) { + if (!((_344 = iterStart2++) < iterEnd2)) { _409 = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { let b5!: rt.u8; b5 = _2; @@ -1200,7 +1228,8 @@ export function touch(q: rt.VecDeque): rt.VecDeque { export function deques(data: Uint8Array, out: rt.ByteVec): void { let q!: rt.VecDeque; let pairs!: rt.VecDeque<[rt.u8, rt.u8]>; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _7!: rt.u8 | rt.Done; let b!: rt.u8; let _12!: rt.u8; @@ -1227,9 +1256,10 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { let _181!: rt.RangeInclusive; q = rt.dequeNew() as rt.VecDeque; pairs = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; - iter = { s: data, i: 0 }; + iterS = data; + iterI = 0; while (true) { - _7 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _7 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_7 === rt.DONE) { touch(q); touch(q); diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index c0f0f2c8c..763c591df 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -224,7 +224,8 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { /** Strings padded and escaped, and bytes that may not be UTF-8. */ export function strings(data: Uint8Array, out: rt.ByteVec): void { - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _9!: rt.u8 | rt.Done; let _15!: rt.usize; let _25!: string; @@ -249,9 +250,10 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { let _116!: string; let args12!: rt.Fmt[]; let _122!: rt.Fmt; - iter = { s: rt.sliceRange(data, 0, rt.min(data.length, 3)), i: 0 }; + iterS = rt.sliceRange(data, 0, rt.min(data.length, 3)); + iterI = 0; while (true) { - _9 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _9 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_9 === rt.DONE) { _36 = rt.stringFromUtf8(rt.sliceToByteVec(data)); if (_36.ok) { diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 2399de827..8b17e10ec 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -15,7 +15,8 @@ import * as Wrapper from "./iters.Wrapper.ts"; export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _4!: rt.u8; let doubled!: rt.ByteVec; - let iter!: { s: rt.u16[]; i: number }; + let iterS!: rt.u16[]; + let iterI!: number; let _18!: rt.u16 | rt.Done; let iter2!: rt.Iter<[rt.usize, rt.u8]>; let _32!: [rt.usize, rt.u8] | rt.Done; @@ -55,13 +56,14 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { return rt.u8Rem(b11, 3) !== 0; })); rt.byteVecExtendFromSlice(out, rt.byteVecView(doubled)); - iter = { s: rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { + iterS = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { let b12!: rt.u8; b12 = _217; return rt.thenSome(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); - })), i: 0 }; + })); + iterI = 0; while (true) { - _18 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _18 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_18 === rt.DONE) { break b0; } else { @@ -199,15 +201,17 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { let words!: rt.ByteVec[]; let word!: rt.ByteVec; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _6!: rt.u8 | rt.Done; let b!: rt.u8; let _13!: rt.ByteVec; words = []; word = new rt.ByteVec(); - iter = { s: self, i: 0 }; + iterS = self; + iterI = 0; while (true) { - _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_6 === rt.DONE) { words.push(word); return words; @@ -438,7 +442,8 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { let _240!: rt.RangeInclusive; let _243!: rt.usize; let _250!: rt.u64; - let iter3!: { s: rt.u32[]; i: number }; + let iterS!: rt.u32[]; + let iterI!: number; let _295!: rt.u32 | rt.Done; a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); @@ -524,9 +529,10 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { return _24; }), 0))); rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0))); - iter3 = { s: rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))), i: 0 }; + iterS = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); + iterI = 0; while (true) { - _295 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; + _295 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_295 === rt.DONE) { updates(a, b, data, out); return; @@ -554,7 +560,8 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): let _7!: rt.u8; let whole!: rt.Range; let _14!: rt.Range; - let iter!: { start: rt.u8; end: rt.u8 }; + let iterStart!: rt.u8; + let iterEnd!: rt.u8; let _29!: rt.u8; let i!: rt.u8; let _33!: rt.u8; @@ -573,9 +580,10 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): _14 = rt.rangeClone(base); whole = new rt.Range(_14.start, _14.end); rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, _7, whole.start, whole.end)); - iter = { start: rt.u8Div(a, 2), end: base.end }; + iterStart = rt.u8Div(a, 2); + iterEnd = base.end; while (true) { - if (!((_29 = iter.start++) < iter.end)) { + if (!((_29 = iterStart++) < iterEnd)) { rt.byteVecPush(out, base.end); len = data.length; _41 = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)] as [rt.usize, rt.usize]; diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 9c78825d6..1ec7b3610 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -13,12 +13,14 @@ import type * as Wide from "./shapes.Wide.ts"; export function total$Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { let sum!: rt.u64; - let iter!: { s: Meters.Meters[]; i: number }; + let iterS!: Meters.Meters[]; + let iterI!: number; let _6!: Meters.Meters | rt.Done; sum = 0; - iter = { s: items, i: 0 }; + iterS = items; + iterI = 0; while (true) { - _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_6 === rt.DONE) { return sum; } else { @@ -30,12 +32,14 @@ export function total$Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { export function total$Shape(items: Shape.Shape[], out: rt.ByteVec): rt.u64 { let sum!: rt.u64; - let iter!: { s: Shape.Shape[]; i: number }; + let iterS!: Shape.Shape[]; + let iterI!: number; let _6!: Shape.Shape | rt.Done; sum = 0; - iter = { s: items, i: 0 }; + iterS = items; + iterI = 0; while (true) { - _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_6 === rt.DONE) { return sum; } else { @@ -277,8 +281,8 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { let _64!: rt.usize; let sum!: rt.usize; let _70!: rt.usize; - let _71!: rt.usize; - let iter!: { start: rt.usize; end: rt.usize }; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; let _75!: rt.usize; let len!: rt.usize; let _82!: Uint8Array; @@ -322,10 +326,10 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { new rt.Range(_64, _63); sum = 0; _70 = mark(out, 12); - _71 = rt.usizeSub(mark(out, 13), 4); - iter = { start: _71, end: _70 }; + iterStart = rt.usizeSub(mark(out, 13), 4); + iterEnd = _70; while (true) { - if (!((_75 = iter.start++) < iter.end)) { + if (!((_75 = iterStart++) < iterEnd)) { len = data.length; _83 = logged(data, out); _85 = rt.min(mark(out, 14), len); @@ -444,16 +448,18 @@ export function reset(m: Moved.Moved): rt.u16 { /** Fieldless enums cast to every width, past their discriminant's range and sign. */ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _5!: rt.u8 | rt.Done; let b!: rt.u8; let wide!: Wide.Wide; let _10!: rt.u8; let signed!: Signed.Signed; let _13!: rt.u8; - iter = { s: data, i: 0 }; + iterS = data; + iterI = 0; while (true) { - _5 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _5 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_5 === rt.DONE) { return; } else { @@ -497,10 +503,12 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let _5!: rt.u8 | undefined; let top!: rt.u8; let found!: [rt.usize, rt.usize] | undefined; - let iter!: { start: rt.usize; end: rt.usize }; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; let _24!: rt.usize; let i!: rt.usize; - let iter2!: { start: rt.usize; end: rt.usize }; + let iterStart2!: rt.usize; + let iterEnd2!: rt.usize; let _34!: rt.usize; let j!: rt.usize; let _39!: rt.u8; @@ -517,9 +525,11 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { let r!: rt.Range; let first!: rt.i32 | undefined; let second!: rt.i32 | undefined; - let iter4!: { start: rt.i32; end: rt.i32 }; + let iterStart3!: rt.i32; + let iterEnd3!: rt.i32; let _124!: rt.i32; - let iter5!: { start: rt.i8; end: rt.i8 }; + let iterStart4!: rt.i8; + let iterEnd4!: rt.i8; let _136!: rt.i8; let _158!: (a0: rt.u8) => rt.u8; _158 = (x3: rt.u8): rt.u8 => { @@ -548,14 +558,16 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); found = undefined; - iter = { start: 0, end: data.length }; + iterStart = 0; + iterEnd = data.length; l2: while (true) { b3: { - if ((_24 = iter.start++) < iter.end) { + if ((_24 = iterStart++) < iterEnd) { i = _24; - iter2 = { start: rt.usizeAdd(i, 1), end: data.length }; + iterStart2 = rt.usizeAdd(i, 1); + iterEnd2 = data.length; while (true) { - if (!((_34 = iter2.start++) < iter2.end)) { + if (!((_34 = iterStart2++) < iterEnd2)) { continue l2; } else { j = _34; @@ -620,12 +632,14 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { if (second !== undefined) { rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(second)); } - iter4 = { start: lo, end: 2 }; + iterStart3 = lo; + iterEnd3 = 2; while (true) { - if (!((_124 = iter4.start++) < iter4.end)) { - iter5 = { start: rt.i8Sub(124, (lo << 24) >> 24), end: 127 }; + if (!((_124 = iterStart3++) < iterEnd3)) { + iterStart4 = rt.i8Sub(124, (lo << 24) >> 24); + iterEnd4 = 127; while (true) { - if (!((_136 = iter5.start++) < iter5.end)) { + if (!((_136 = iterStart4++) < iterEnd4)) { rt.byteVecPush(out, firstRepeat(data)); rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); rt.byteVecPush(out, armLoop(data)); @@ -968,15 +982,17 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { /** A loop that only `return` leaves, returned itself, around loops that `break`. */ export function returnedLoop(data: Uint8Array): rt.u8 { let i!: rt.usize; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _11!: rt.u8 | rt.Done; let b!: rt.u8; i = 0; l0: while (true) { if (!(i >= data.length)) { - iter = { s: rt.sliceRange(data, i), i: 0 }; + iterS = rt.sliceRange(data, i); + iterI = 0; l2: while (true) { - _11 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _11 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_11 !== rt.DONE) { b = _11; if (!(b === 0)) { @@ -1047,7 +1063,8 @@ export function tailBreak(data: Uint8Array): rt.u16 { let b!: rt.u8; let _7!: rt.usize; let _11!: rt.u8; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _18!: rt.u8 | rt.Done; let c!: rt.u8; let n!: rt.u8; @@ -1062,9 +1079,10 @@ export function tailBreak(data: Uint8Array): rt.u16 { if (_11 === 0) { continue l0; } else if (_11 === 1) { - iter = { s: rt.sliceRange(data, i), i: 0 }; + iterS = rt.sliceRange(data, i); + iterI = 0; while (true) { - _18 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _18 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_18 === rt.DONE) { continue l0; } else { @@ -1166,7 +1184,8 @@ export function drain(data: Uint8Array, out: rt.ByteVec): void { /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ export function patterns(data: Uint8Array, out: rt.ByteVec): void { - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _33!: rt.u8 | rt.Done; let b!: rt.u8; let class_!: rt.u8; @@ -1204,9 +1223,10 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } else { rt.byteVecPush(out, 0); } - iter = { s: rt.sliceRange(data, 0, rt.min(data.length, 4)), i: 0 }; + iterS = rt.sliceRange(data, 0, rt.min(data.length, 4)); + iterI = 0; while (true) { - _33 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _33 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_33 === rt.DONE) { b5: { if (data.length >= 2) { @@ -1314,26 +1334,30 @@ export function early(n: rt.u8): rt.u8 { export function closures(data: Uint8Array, out: rt.ByteVec): void { let sum!: rt.u32; let add!: (a0: rt.u8) => void; - let iter!: { s: Uint8Array; i: number }; + let iterS!: Uint8Array; + let iterI!: number; let _8!: rt.u8 | rt.Done; let base!: rt.u32; let n!: rt.u32; let whole!: Uint8Array; let parsed!: Array; - let iter2!: { s: Uint8Array; i: number }; + let iterS2!: Uint8Array; + let iterI2!: number; let _53!: rt.u8 | rt.Done; let _59!: Dir.Dir | undefined; let tags!: rt.ByteVec; - let iter3!: { s: Array; i: number }; + let iterS3!: Array; + let iterI3!: number; let _64!: Dir.Dir | undefined | rt.Done; let _70!: rt.u8; sum = 0; add = (v: rt.u8): void => { sum = rt.u32Add(sum, v as rt.u32); }; - iter = { s: data, i: 0 }; + iterS = data; + iterI = 0; while (true) { - _8 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _8 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_8 === rt.DONE) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); base = data.length as rt.u32; @@ -1351,14 +1375,16 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { overwrite(whole); rt.byteVecPush(out, whole[0]); parsed = []; - iter2 = { s: data, i: 0 }; + iterS2 = data; + iterI2 = 0; while (true) { - _53 = iter2.i < iter2.s.length ? iter2.s[iter2.i++] : rt.DONE; + _53 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_53 === rt.DONE) { tags = new rt.ByteVec(); - iter3 = { s: parsed, i: 0 }; + iterS3 = parsed; + iterI3 = 0; while (true) { - _64 = iter3.i < iter3.s.length ? iter3.s[iter3.i++] : rt.DONE; + _64 = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; if (_64 === rt.DONE) { rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); return; diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index eb5a38ccc..af8a17feb 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -16,21 +16,24 @@ function new_(): WaiterList { export function register(self: WaiterList, waiter: Waiter.Waiter): void { let weak!: rt.Weak; - let iter!: { s: rt.Weak[]; i: number }; + let iterS!: rt.Weak[]; + let iterI!: number; let _8!: rt.Weak | rt.Done; let probes!: rt.usize; let _23!: rt.usize; let _24!: rt.Weak; let _27!: rt.usize; let live!: rt.Weak[]; - let iter2!: { s: rt.Weak[]; i: number }; + let iterS2!: rt.Weak[]; + let iterI2!: number; let _43!: rt.Weak | rt.Done; let entry!: rt.Weak; let _53!: rt.Weak[]; weak = new rt.Weak(waiter.shared); - iter = { s: self.entries, i: 0 }; + iterS = self.entries; + iterI = 0; l0: while (true) { - _8 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _8 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; b1: { b2: { if (_8 === rt.DONE) { @@ -42,9 +45,10 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { live = []; const taken = self.entries; self.entries = []; - iter2 = { s: taken, i: 0 }; + iterS2 = taken; + iterI2 = 0; while (true) { - _43 = iter2.i < iter2.s.length ? iter2.s[iter2.i++] : rt.DONE; + _43 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_43 === rt.DONE) { _53 = live; self.entries = _53; @@ -95,7 +99,8 @@ export function take(self: WaiterList): WaiterList { /** Wake every live waiter, draining the list. */ export function wake(self: WaiterList): void { - let iter!: { s: rt.Weak[]; i: number }; + let iterS!: rt.Weak[]; + let iterI!: number; let _6!: rt.Weak | rt.Done; let entry!: rt.Weak; let _10!: rt.Arc | undefined; @@ -105,9 +110,10 @@ export function wake(self: WaiterList): void { self.cursor = 0; const taken = self.entries; self.entries = []; - iter = { s: taken, i: 0 }; + iterS = taken; + iterI = 0; while (true) { - _6 = iter.i < iter.s.length ? iter.s[iter.i++] : rt.DONE; + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_6 === rt.DONE) { return; } else { diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index d52ee0c9f..4643883a1 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -58,8 +58,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.next_names.insert(name); } if self.stepped_array(&args[0].node) { - let it = self.path(recv, "iter", &mut pre); - (self.stepped_next(it), true) + (self.stepped_next(&recv), true) } else { (crate::lower::iter::next(self.b, iter_ty, recv), true) } @@ -485,8 +484,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { read: bool, out: &mut Vec, ) -> Option<(String, Expr)> { - let range = self.path(recv, "range", out); - let start = range.clone().member("start"); + let range = match recv { + Expr::Object(_) => recv, + recv => self.path(recv, "range", out), + }; + let start = super::step::stepped_field(&range, "start"); + let end = super::step::stepped_field(&range, "end"); let flag = self.b.fresh(&format!("{name}Some")); self.range_flags.insert(name.clone(), flag.clone()); if stepped { @@ -495,9 +498,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { true => Expr::ident(&name).assign(step), false => step, }; - return Some((flag, item.binary("<", range.member("end")))); + return Some((flag, item.binary("<", end))); } - let more = start.clone().binary("<", range.member("end")); + let more = start.clone().binary("<", end); out.push(StmtKind::Expr(Expr::ident(&flag).assign(more)).at(None)); let step = Expr::ident(&name).assign(Expr::Postfix(Box::new(start), "++")); out.push( diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index cf06f47c7..15aef60af 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -192,6 +192,10 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { stepped: FxHashSet, /// The borrows `next` steps them by, and what each borrows. stepped_borrows: FxHashMap, + /// The two variables each holds its fields in, by `step`. + stepped_vars: FxHashMap, + /// Those moved into another, which shares its variables. + stepped_into: FxHashMap, /// Statements that change nothing: a swap through a temporary nothing else names, as /// an async body moves its context at each `await`. noops: FxHashSet<(BasicBlock, usize)>, @@ -246,6 +250,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { range_flags: FxHashMap::default(), stepped: FxHashSet::default(), stepped_borrows: FxHashMap::default(), + stepped_vars: FxHashMap::default(), + stepped_into: FxHashMap::default(), noops: FxHashSet::default(), sole_pred: FxHashMap::default(), idx_of: FxHashMap::default(), @@ -407,6 +413,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.borrowed[local] { self.shared.insert(name.clone()); } + if self.stepped.contains(&local) { + self.name_stepped(local, &base); + } let owned = match mir.local_decls[local].ty.kind() { ty::Tuple(_) | ty::Array(..) => true, ty::Adt(adt, _) => { @@ -424,6 +433,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.slots[local] = Slot::Var(name); } } + self.share_stepped(); } /// Uncount the reads of what computes a local nothing reads without doing anything @@ -997,7 +1007,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.is_arg(local) || !self.assigned[local] { continue; } - if let Slot::Var(name) = self.slots[local].clone() { + if let Some(vars) = self.stepped_vars.get(&local).cloned() { + // Declared once, by the local that shares them. + if self.stepped_root(local) != local { + continue; + } + for (name, ty) in vars.into_iter().zip(self.stepped_tys(local)) { + out.push(StmtKind::Declare { name, ty }.at(None)); + } + } else if let Slot::Var(name) = self.slots[local].clone() { let ty = self.decl_ty(local); out.push(StmtKind::Declare { name, ty }.at(None)); } @@ -1089,9 +1107,6 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// A local's declared type: the value's, for a checked pair. fn decl_ty(&mut self, local: Local) -> Type { - if let Some(ty) = self.stepped_ty(local) { - return ty; - } let ty = self.mir.local_decls[local].ty; if self.next_results.contains(&local) && let ty::Adt(adt, args) = ty.kind() @@ -1489,6 +1504,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { parts: Option>, out: &mut Vec, ) { + if self.stepped_vars.contains_key(&local) { + self.set_stepped(local, value, out); + return; + } match self.slots[local].clone() { Slot::Var(name) => { if self.uses[local] == 0 { diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index a849356da..d56ae15cc 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -26,6 +26,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Env::Plain | Env::Shim => {} } } + if let Some(value) = self.stepped_value(local) { + return value; + } match &self.slots[local] { Slot::Var(name) => Expr::ident(name), // A value of type `!`, as a generic instantiated at `!` reads: native code never diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index f13e9c452..773174e46 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -1,7 +1,8 @@ //! Iterators stepped in place: a slice's or a `Vec`'s iterator, or a range of numbers, -//! that only `next` reads, as a `for` loop's is, is an object of the array and an index, -//! `{ s, i }`, or of the bounds, `{ start, end }`, rather than an `rt.Iter`, which a -//! bundler can't shake its adaptors from. +//! that only `next` reads, as a `for` loop's is, is two variables, of the array and an +//! index or of the bounds, rather than an `rt.Iter`, which a bundler can't shake its +//! adaptors from. Variables, not an object of both: V8 took up to 1.25x as long over a +//! `BTreeMap` stepping an object's fields. use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_middle::mir::{self, Local, Operand, Rvalue, StatementKind, TerminatorKind}; @@ -9,7 +10,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt}; use super::Fx; use crate::lower::library::{self, Std}; -use crate::ts::{Expr, Key, Type}; +use crate::ts::{Expr, Key, Stmt, StmtKind, Type}; /// The item type of a slice's or a `Vec`'s iterator, if `ty` is one. fn array_iter<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { @@ -163,9 +164,24 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.stepped_borrows.insert(b, from); } } + // One moved into another and read nowhere else shares its variables: the other is + // assigned only by the move, so neither is live while the other is. + for &(from, to) in &moves { + if ok.contains(&from) && self.uses[from] == 1 { + self.stepped_into.insert(from, to); + } + } self.stepped = ok; } + /// The local whose variables `local` holds its fields in: the last it is moved into. + pub(super) fn stepped_root(&self, mut local: Local) -> Local { + while let Some(&to) = self.stepped_into.get(&local) { + local = to; + } + local + } + /// The array iterator a `next` receiver `op` borrows, if it steps in place. A range's /// `next` steps one in place anyway. pub(super) fn stepped_array(&self, op: &Operand<'tcx>) -> bool { @@ -177,6 +193,74 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { .is_some_and(|&l| array_iter(self.tcx, self.mir.local_decls[l].ty).is_some()) } + /// The keys of `local`'s fields: its array and index, or its bounds. + fn stepped_keys(&self, local: Local) -> [&'static str; 2] { + match array_iter(self.tcx, self.mir.local_decls[local].ty) { + Some(_) => ["s", "i"], + None => ["start", "end"], + } + } + + /// Name the two variables `local` holds its fields in, unless it shares another's. A + /// read of either counts as one of memory, since `next` changes them in place. + pub(super) fn name_stepped(&mut self, local: Local, base: &str) { + if self.stepped_root(local) != local { + return; + } + let vars = self.stepped_keys(local).map(|key| { + let mut suffix = key.to_string(); + suffix[..1].make_ascii_uppercase(); + let name = self.b.fresh(&format!("{base}{suffix}")); + self.shared.insert(name.clone()); + name + }); + self.stepped_vars.insert(local, vars); + } + + /// Give each stepped local that shares its variables those of the local it shares. + pub(super) fn share_stepped(&mut self) { + for &local in &self.stepped { + let root = self.stepped_root(local); + if root != local { + let vars = self.stepped_vars[&root].clone(); + self.stepped_vars.insert(local, vars); + } + } + } + + /// `local` read whole, if it is stepped in place: an object of its variables, which + /// [`Self::set_stepped`] and [`stepped_field`] take apart again. + pub(super) fn stepped_value(&self, local: Local) -> Option { + let vars = self.stepped_vars.get(&local)?; + let keys = self.stepped_keys(local); + let fields = keys.into_iter().zip(vars); + Some(Expr::Object( + fields.map(|(k, v)| (Key::Name(k.into()), Expr::ident(v))).collect(), + )) + } + + /// Assign `local`'s variables the fields of `value`, as [`Self::stepped_make`] made it. + pub(super) fn set_stepped(&mut self, local: Local, value: Expr, out: &mut Vec) { + let value = match value { + Expr::Located(_, value) => *value, + value => value, + }; + // Anything else is refused already. + let Expr::Object(fields) = value else { + return; + }; + self.assigned[local] = true; + let vars = self.stepped_vars[&local].clone(); + for ((_, value), var) in fields.into_iter().zip(vars) { + // A move from a local that shares the variables. + if matches!(&value, Expr::Ident(name) if *name == var) { + continue; + } + let stmt = StmtKind::Expr(Expr::ident(&var).assign(value)).at(None); + self.emit(vec![stmt], Some(&var), false, out); + } + } + /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` /// from `rt.iterSlice(s)`, and `{ start, end }` from `new rt.Range(start, end)`. A /// moved one is already made. @@ -193,7 +277,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); object([("start", start), ("end", end)]) } - Expr::Ident(_) => value, + Expr::Object(_) => value, // Refused already. Expr::Lit(lit) if lit == "undefined" => Expr::undefined(), _ => self.err(span, "an iterator stepped in place that its mapping didn't make"), @@ -201,9 +285,9 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } /// The next item of `it`, stepped in place, or `rt.DONE`. - pub(super) fn stepped_next(&self, it: Expr) -> Expr { - let s = it.clone().member("s"); - let i = it.member("i"); + pub(super) fn stepped_next(&self, it: &Expr) -> Expr { + let s = stepped_field(it, "s"); + let i = stepped_field(it, "i"); Expr::Cond( Box::new(i.clone().binary("<", s.clone().member("length"))), Box::new(s.index(Expr::Postfix(Box::new(i), "++"))), @@ -211,25 +295,34 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) } - /// The type of a local stepped in place: its array and index, or its bounds. - pub(super) fn stepped_ty(&mut self, local: Local) -> Option { - if !self.stepped.contains(&local) { - return None; - } + /// The types of a stepped local's variables: its array and index, or its bounds. + pub(super) fn stepped_tys(&mut self, local: Local) -> [Type; 2] { let ty = self.mir.local_decls[local].ty; - let fields = match array_iter(self.tcx, ty) { + match array_iter(self.tcx, ty) { Some(item) => [ - ("s", self.b.t.ty(Ty::new_slice(self.tcx, item), self.span)), - ("i", Type::Builtin("number")), + self.b.t.ty(Ty::new_slice(self.tcx, item), self.span), + Type::Builtin("number"), ], None => { let ty::Adt(_, args) = ty.kind() else { unreachable!("a range is a struct") }; let bound = self.b.t.ty(args.type_at(0), self.span); - [("start", bound.clone()), ("end", bound)] + [bound.clone(), bound] } - }; - Some(Type::Object(fields.into_iter().map(|(k, t)| (k.into(), t)).collect())) + } + } +} + +/// The field `key` of an iterator stepped in place: its variable, from the object +/// [`Fx::stepped_value`] reads it as. +pub(super) fn stepped_field(it: &Expr, key: &str) -> Expr { + match it { + Expr::Object(fields) => fields + .iter() + .find(|(k, _)| matches!(k, Key::Name(n) if n == key)) + .map(|(_, v)| v.clone()) + .expect("a stepped iterator's field"), + it => it.clone().member(key), } } From 14f1a2479e4a10b7a3bddee2446d063d269121b0 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 20:26:17 -0700 Subject: [PATCH 14/17] docs(ts): describe the MIR lowering, and finish the ts-mir quest The README drops `--lower` and the THIR lowering's generators, scopes, and refusals, and records what MIR measured against THIR. The quest is done; what it leaves is two quests: the census refusals MIR has that THIR didn't, and the output size the coroutine classes and temporaries add. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- quest/m2/README.md | 3 +- quest/m2/ts-async.md | 2 - quest/m2/ts-drop.md | 4 -- quest/m2/ts-mir-census.md | 30 +++++++++++++ quest/m2/ts-mir-size.md | 26 +++++++++++ quest/m2/ts-mir.md | 49 --------------------- ts/README.md | 93 ++++++++++++++++++--------------------- 7 files changed, 101 insertions(+), 106 deletions(-) create mode 100644 quest/m2/ts-mir-census.md create mode 100644 quest/m2/ts-mir-size.md delete mode 100644 quest/m2/ts-mir.md diff --git a/quest/m2/README.md b/quest/m2/README.md index 2a57102ff..04887e15b 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -21,9 +21,10 @@ The fork's feature quests folded into the [exporter](/quest/m1/ffi-export.md); ## Required -- [Lower bodies from MIR](/quest/m2/ts-mir.md) - the MIR spike's prototype becomes the only lowering, and the THIR one goes - [Cheaper byte slices](/quest/m2/ts-byte-views.md) - splitting a `&[u8]` stops making a `Uint8Array` view per split - [Wide-integer fast paths](/quest/m2/ts-wide-fast.md) - a fused `from_halves` and an unboxed limb product, kept only if measured faster +- [MIR's own census refusals](/quest/m2/ts-mir-census.md) - the census refuses no function THIR translated, and points type refusals at their locals +- [Smaller output from MIR](/quest/m2/ts-mir-size.md) - the bench's bundles shrink back to THIR's sizes, coroutine classes first - [Drop in the TypeScript translator](/quest/m2/ts-drop.md) - every value that drops in moq-net and kio drops where Rust drops it - [Async in the TypeScript translator](/quest/m2/ts-async.md) - moq-net's and kio's async code translates with Rust's lazy futures - [Shared ownership](/quest/m2/ts-shared.md) - `Arc`/`Rc`/`Weak` keep exact counts, and locks and atomics become plain values diff --git a/quest/m2/ts-async.md b/quest/m2/ts-async.md index 49bbbaab4..064be2dcc 100644 --- a/quest/m2/ts-async.md +++ b/quest/m2/ts-async.md @@ -24,7 +24,6 @@ What moq-net still needs, by its census from MIR at the pinned revision: `map_err`), `pin!` (50 with `PinMacroHelper`), `poll_fn` (31), `future::pending` (5), and `Box::pin` (29, a boxed future that binds to hand-written TS at the boundary, per the [model](/quest/m2/ts-model.md)). -- `?` inside a function that returns `Poll`, as `ready!(..)?` writes it: 284 sites. - Async closures. - kio's own API, reached across crates (`Pending`, `Consumer::poll`, `Waiter::poll_future`, `Tasks`), with the atomics, `OnceLock`, and coop budget behind @@ -38,5 +37,4 @@ Public API: the translator's output for async code. ## Required -- [Lower bodies from MIR](/quest/m2/ts-mir.md) - async bodies come from the coroutine transform - [Drop in the TypeScript translator](/quest/m2/ts-drop.md) - async bodies hold the values that drop it still refuses diff --git a/quest/m2/ts-drop.md b/quest/m2/ts-drop.md index 97e183af0..93cf71880 100644 --- a/quest/m2/ts-drop.md +++ b/quest/m2/ts-drop.md @@ -45,7 +45,3 @@ before each call that can panic and wraps its body in a `try`; measure any chang the [TS benchmark](/ts/README.md#bench). Public API: the translator's output for values that drop. - -## Required - -- [Lower bodies from MIR](/quest/m2/ts-mir.md) - drops come from MIR's elaboration diff --git a/quest/m2/ts-mir-census.md b/quest/m2/ts-mir-census.md new file mode 100644 index 000000000..be4b2abba --- /dev/null +++ b/quest/m2/ts-mir-census.md @@ -0,0 +1,30 @@ +# [S] MIR's own census refusals + +## Goal + +[rust2-ts](/ts/README.md)'s census of moq-net and kio refuses no function the THIR +lowering translated, and each refusal of a type points at the local or expression that +holds it rather than at its function. + +## Plan + +At the move to MIR, 16 function instances of moq-net and kio that THIR translated +clean, before collections landed, are refused: + +- `unsupported type ... from another crate` for temporaries THIR never declared + (`Patterns`, `Duration`, kio's `Mut`, `Shared`, and `Consumer`, an atomic, + `MaybeUninit`), reported at the function's span. Each should carry its local's span, + from `local_decls`. +- Drops THIR's scopes never saw: `Option>`, `AdapterSend`, `Box<[..]>`, + `Box`'s `Drop`, and an `Option` replaced through a `&mut`. + +MIR also refuses constructs THIR wrote differently: + +- `ControlFlow` values other than the one `?` makes (27 sites): pick a representation, + such as `rt.Result`'s shape or a tagged object, by what `try_fold` and moq's own uses + need. +- A switch on, or a field of, a type from another crate without a mapping + (`kio::Unused`, `Bound`, `MaybeUninit`, `ManuallyDrop`). +- A switch on `char` (6), once `char` has a representation. + +Public API: the translator's output for the functions it newly translates. diff --git a/quest/m2/ts-mir-size.md b/quest/m2/ts-mir-size.md new file mode 100644 index 000000000..7c30a0e17 --- /dev/null +++ b/quest/m2/ts-mir-size.md @@ -0,0 +1,26 @@ +# [M] Smaller output from MIR + +## Goal + +[rust2-ts](/ts/README.md)'s bundles on `just ts bench` are no larger than the THIR +lowering's were, without giving up the speed MIR gained: the codec's at most 27483 +bytes minified and 8437 gzipped, and the async handoff's at most 10901 and 3446. + +## Plan + +At the move to MIR, the codec's bundle was 27750 bytes minified and 8876 gzipped (+1%, ++5%), and the async handoff's 18258 and 3993 (+67%, +16%), against THIR's numbers +above. Each candidate is measured on the bench's sizes and timings before it lands: + +- A coroutine's class, about 520 bytes minified each against about 140 for a THIR + generator: a base class in the runtime for the state and `poll` scaffolding, fields + only for what lives across an `.await`, and a resume function structured where the + graph allows (a dispatch at each loop header it enters) rather than a `switch` over + every block. Generators stay out: they measured 1.4-5.5x slower on the handoff. +- Tuple temporaries a destructuring `const [a, b] = ..` would avoid, and the `let` + list at the top of each function, where a local assigned once could be declared at + its assignment. +- The codec's `fill`, `encodeFrames`, and `decodeSplit`, whose blocks nest deeper than + THIR's loops did. + +Public API: the translator's output, which changes shape but not behavior. diff --git a/quest/m2/ts-mir.md b/quest/m2/ts-mir.md deleted file mode 100644 index e19027571..000000000 --- a/quest/m2/ts-mir.md +++ /dev/null @@ -1,49 +0,0 @@ -# [L] Lower bodies from MIR - -## Goal - -[rust2-ts](/ts/README.md) lowers every body from MIR, as the -[MIR spike](https://github.com/kixelated/rust2/pull/36) decided: `--lower` goes, -the THIR lowering (`src/lower/body.rs`, `pat.rs`, the drop scopes in `drop.rs`, and -`rt.future`'s generators) is deleted, and every fixture passes its snapshot, -differential, unwinding, and census tests from MIR. - -## Plan - -The spike's prototype (`src/lower/mir/`) already passes the codec, lang, and task -fixtures' differential tests and the task fixture's unwinding test. What the move -still needs: - -- The reject fixture and its census, rewritten to what MIR refuses (`reject_mir` - already checks MIR's errors), and snapshots of MIR's output. Constructs THIR refuses that MIR lowers move into the differential - fixtures, such as a `move` closure taking a reference from a variable assigned again - after (`a closure that copies a mutable variable`), which the prototype snapshots. -- The census to at least THIR's coverage of moq-net and kio. MIR types each - intermediate it holds, so a gap in the library or model shows up once more per - temporary; read the census by construct, not by total. MIR-only refusals to close: - `?` on `Poll>` (284, which THIR refused as 235 too), `ControlFlow` other - than from `?`, switches on and fields of types without a mapping, and a reference - copied out of a field and then passed on. -- `?` on an `Option` returned through a `next` whose item can be `undefined`, and the - other THIR special cases the prototype mirrors (`for` loops by the iterator protocol, - `from_be_bytes` of bytes made in place): keep each only where `just ts bench` - measures it. Ranges stepped in place stay: a `for` over `0..n` read through - `rt.Range.next` or as a number-or-`rt.DONE` was up to 1.3x slower in V8. -- A signed `%` by a constant leaves its overflow check's operands as statements - (`4 === -1;`), which `tsc` rejects. -- Size: the task fixture's bundle is 35% larger gzipped than THIR's, the codec's 9%. - Likely wins, each to measure: a coroutine resume function structured where the - graph allows (a dispatch at each loop header the resume enters, rather than a - `switch` over every block), temporaries folded through reads of borrowed places, and - `_0 = v; return _0` returned in place. -- Source maps: MIR spans point at calls and asserts; check stack traces read well. -- Panics unwind (`-C panic=unwind`), as decided in - [#36](https://github.com/kixelated/rust2/pull/36) at a measured 4-6% on V8's async - handoff; `RUST2_TS_ABORT`, kept only to measure aborting, goes with `--lower`. - -Watch what the prototype's comments say it relies on: MIR's single-assignment -temporaries, `Box` derefs elaborated into `BoxDerefTransmute`, and drop shims that -take a raw pointer. A nightly bump that changes them should fail loudly, as each does -now. - -Public API: the translator's whole output, and the `--lower` option, which goes. diff --git a/ts/README.md b/ts/README.md index 8ab020669..1c8c75874 100644 --- a/ts/README.md +++ b/ts/README.md @@ -3,7 +3,7 @@ A rustc driver that translates a subset of Rust to TypeScript with source maps. No WASM: the output is plain ES modules that Node, Bun, and bundlers run as is. ```bash -rust2-ts --config ts.toml (--out dir | --census file.md) [--manifest-path Cargo.toml] [--lower thir|mir] [-- cargo args] +rust2-ts --config ts.toml (--out dir | --census file.md) [--manifest-path Cargo.toml] [-- cargo args] ``` It runs `cargo check` on the package with itself as `RUSTC_WRAPPER`, for @@ -28,10 +28,6 @@ ignore-macros = ["tracing::trace"] moq consumes it as the `ts` package of this repository's flake. In this repository, `just ts run ...` runs it from source on the pinned nightly. -`--lower mir` lowers bodies from MIR instead of THIR: the prototype the MIR spike -built, which the translator is moving to ([quest](/quest/m2/ts-mir.md)). The rest of -this page describes the THIR lowering, the default, except where it says MIR. - ## Census `--census file.md` translates nothing. It treats every item in the library as a root, @@ -75,7 +71,7 @@ runtime: what std does that JS does not, with iterators in `rt/iter.ts`, collect | a type that drops | a class with `[Symbol.dispose]`: its `Drop` impl, then its fields | | a type's function | a function of the type's module, taking `self` first: `Decoder.slice(dec, 4)` after `import * as Decoder` | | `Arc`, `Weak`, `Mutex` | `rt.Arc`, counted; `rt.Weak`; `rt.Mutex`, its own guard | -| `async fn` | a function returning `rt.Future`, around a generator | +| `async fn` | a function returning `rt.Future`: a class of its own, its coroutine's state machine | | `Poll`, `Waker`, `Context` | `T \| typeof rt.Pending`, refused if `T` can already be pending; `rt.Waker`, which is also the context | `Vec` storage and `[x; N]` byte arrays up to 1 KiB share 8 KiB `ArrayBuffer`s, as Node's @@ -114,9 +110,10 @@ would: `rt.fmtToString((f) => DecodeError.fmt$Display(err, f))` and An iterator's `next()` returns its next item or `rt.DONE`, never `undefined`, so an iterator of `Option` keeps each `None` apart from its end. std's adaptors and consumers are runtime functions taking the iterator first, `rt.iterMap(it, f)`, lazy and -short-circuiting as std's are, and call their closures in the same order and as often. A `for` loop reads an iterator by that protocol, a slice, -array, `Vec`, or `slice.iter()` with `for ... of`, and a range written in place with a -counter. The crate's own `impl Iterator` returns `rt.DONE` from its `next` too, and joins +short-circuiting as std's are, and call their closures in the same order and as often. +An iterator over a slice, array, or `Vec`, or a small range, that only its `next` and +moves read steps in place, as two variables: the array and an index into it, or the +range's bounds, with no `rt.Iter` made. The crate's own `impl Iterator` returns `rt.DONE` from its `next` too, and joins std's adaptors through `rt.iterFrom`. A caller calls `next()` for one item, or iterates an `rt.Iter` with `for ... of`. @@ -145,16 +142,16 @@ calls a key's `Hash`, `Eq`, or `Ord`. Its iterators are `rt.Iter`s, so std's adaptors run over them. A value drops where Rust drops it, if dropping it does something JS can see: a `Drop` -impl, an `Arc`'s count, or a waker. A variable drops at the end of its scope through a -`finally`, so an early return, `?`, a panic, or a cancelled future drops it too, and a -move leaves `undefined` where it was, which drops as nothing. - -An `async fn` returns a future without running anything: `rt.future(body, drop, -...upvars)`, whose body is a module-level generator of what the function captured. Each -`.await` polls in a loop around `yield`. A poll after the future returned panics, and -dropping it cancels it: unpolled, it drops what it captured by value; suspended, its -generator returns through the `finally` blocks that drop its locals and captures. -`rt.spawn(future)` runs one as a promise, polling woken tasks in a batch from a +impl, an `Arc`'s count, or a waker. Bodies lower from MIR, so each drop is where drop +elaboration put it. A panic unwinds: a function with cleanup to run catches `rt.Panic`, +runs the cleanup blocks MIR has under `-C panic=unwind`, and throws it on, so what a +panic drops matches native Rust's. + +An `async fn` returns a future without running anything: an instance of a class of its +own (`sumFuture`), the state machine MIR's coroutine transform makes. Its fields are the +arguments and the locals held across an `.await`, and its `poll` resumes at the state it +stopped in. A poll after the future returned panics, and dropping it cancels it, +dropping what its state holds. `rt.spawn(future)` runs one as a promise, polling woken tasks in a batch from a microtask and yielding to a macrotask after 128 polls. A file's items follow the Rust source, whatever @@ -240,23 +237,23 @@ they need. by their translated hash, chained by `Eq`. `VecDeque` is a ring buffer over an array whose length is a power of two. - Iterators are the runtime's lazy classes rather than generators or ES iterator - helpers: std's adaptors have no THIR to lower, ES helpers lack most of them + helpers: std's adaptors would lower from std's own bodies, whose slice iterators are + raw pointers, ES helpers lack most of them (`rev`, `zip`, `peekable`), and a `next` returning an item or `rt.DONE` allocates nothing per item. `just ts bench` measures chains of `map`, `filter`, `any`, `skip`, and `take` 1.4-8x faster than the same ES helpers in Node, Bun, and Chrome. -- Bodies lower from MIR ([moving](/quest/m2/ts-mir.md)): drops are where drop - elaboration put them, exact by construction, with no `finally` per scope or - `undefined` left by a move, and a panic runs the cleanup blocks `-C panic=unwind` - MIR has, from a `catch`. Async bodies are the coroutine transform's state machines, - a class each. The MIR spike ([#36](https://github.com/kixelated/rust2/pull/36)) ported - the whole lowering and measured it against THIR's: every fixture's differential test - passes either way, but MIR closes about 1,100 of the 1,400 drop refusals in moq-net's - census, runs an async handoff 1.4-5.5x faster at depths 1 to 16 in Node, Bun, and - Chrome, and runs the codec 2-12% slower than THIR, for 9% more gzip on the codec's - bundle and 35% on the async fixture's. Blocks become nested blocks, loops, and `if`s by Ramsey's - "Beyond Relooper", except a coroutine's resume function, which enters loops in the - middle and becomes a loop over a `switch` on the next block. Temporaries assigned - once and read once fold back into the expression that reads them unless that +- Bodies lower from MIR, not THIR: drops are where drop elaboration put them, exact by + construction, with no `finally` per scope or `undefined` left by a move, and a panic + runs the cleanup blocks `-C panic=unwind` MIR has, from a `catch`. Async bodies are + the coroutine transform's state machines, a class each. Against the THIR lowering it + replaced, MIR closes about 1,100 of the 1,400 drop refusals in moq-net's census, and + runs `just ts bench`'s codec 1-8% faster at the geometric mean and the async handoff + 1.4-5.5x faster at depths 1 to 16 in Node, Bun, and Chrome, for 5% more gzip on the + codec's bundle and 16% on the async fixture's + ([size](/quest/m2/ts-mir-size.md)). Blocks become nested blocks, loops, and `if`s by + Ramsey's "Beyond Relooper", except a coroutine's resume function, which enters loops + in the middle and becomes a loop over a `switch` on the next block. Temporaries + assigned once and read once fold back into the expression that reads them unless that would reorder an effect. ## Never @@ -268,21 +265,20 @@ bind to hand-written TS through config ([model](/quest/m2/ts-model.md)). ## Not yet These fail translation: floats, `char`, statics, async blocks that borrow a number -mutably and async closures, values that drop as temporaries not moved whole, in a -closure's captures, in an iterator, in an enum, tuple, or generic `Drop` type, passed to -a std function that may discard them (`unwrap_or`), borrowed in an `Arc` or `Mutex`, or -moved ahead of an `.await` in the same call or assignment, or in a collection -([Drop](/quest/m2/ts-drop.md)), a collection holding a type that can be `undefined`, as -`()` and `Option` can, a collection's `capacity`, looking up a key by another type it -borrows as (`Arc` by `str`), `Hasher::write` of bytes, the adaptors without a mapping in -`src/lower/iter.rs` (such as `cycle`, `unzip`, and `partition`), an own -`impl Iterator` with `next_back`, `len`, or another provided method of its own, `while -let` or `match` on the `next` of an iterator of `Option`, or-patterns that bind, other +mutably and async closures, values that drop in a closure dropped without a call that +takes it, in an iterator, in an enum or generic `Drop` type, passed to a std function +that may discard them (`unwrap_or`), borrowed in an `Arc` or `Mutex`, or in a +collection ([Drop](/quest/m2/ts-drop.md)), a collection holding a type that can be +`undefined`, as `()` and `Option` can, a collection's `capacity`, looking up a key by +another type it borrows as (`Arc` by `str`), `Hasher::write` of bytes, the adaptors +without a mapping in `src/lower/iter.rs` (such as `cycle`, `unzip`, and `partition`), an +own `impl Iterator` with `next_back`, `len`, or another provided method of its own, other format specs (a precision, `+`, `{:b}`, `{:x?}`, and widths from arguments), writing to a -`String` with `write!`, a `move` closure copying a mutable variable, `mem::swap`, +`String` with `write!`, a copy of a closure that changes what it captured, `mem::swap`, `replace`, or `take` of a reference's whole pointee, assigning an `Arc`, a waker, a -`MutexGuard`, a pinned reference, or a future through a reference, and std functions -without a mapping in `src/lower/library.rs`. +`MutexGuard`, a pinned reference, or a future through a reference, a `ControlFlow` other +than the one `?` makes, a switch on or a field of another crate's type without a mapping, +and std functions without a mapping in `src/lower/library.rs`. ## Tests @@ -319,10 +315,7 @@ built natively for wasm32 and run beside its translation on the same inputs by unwinds, catching and logging each step's panic and going on, so what a panic drops must match too. - `reject` holds constructs outside the subset; its expected errors are `expected.txt`, - those from MIR `expected-mir.txt`, and its expected census is `census.md`. - -The codec, lang, and task fixtures also run their differential tests from MIR -(`codec_mir`, `lang_mir`, and `task_mir`), without snapshots. + and its expected census is `census.md`. `tests/spawn.ts` checks that `rt.spawn` yields to a timer after its 128-poll budget, and rejects when a future panics as it drops. `tests/retain.ts` panics in a collection's From 9c1a2d989279ed27625769282a886e7223074aef Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 20:42:39 -0700 Subject: [PATCH 15/17] chore(ts): remove rustc crash dumps committed by mistake Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/rustc-ice-2026-10-26T00_02_50-1147869.txt | 77 -------------------- ts/rustc-ice-2026-10-26T00_02_52-1149919.txt | 77 -------------------- ts/rustc-ice-2026-10-26T00_03_00-1156431.txt | 77 -------------------- ts/rustc-ice-2026-10-26T00_03_00-1157053.txt | 77 -------------------- 4 files changed, 308 deletions(-) delete mode 100644 ts/rustc-ice-2026-10-26T00_02_50-1147869.txt delete mode 100644 ts/rustc-ice-2026-10-26T00_02_52-1149919.txt delete mode 100644 ts/rustc-ice-2026-10-26T00_03_00-1156431.txt delete mode 100644 ts/rustc-ice-2026-10-26T00_03_00-1157053.txt diff --git a/ts/rustc-ice-2026-10-26T00_02_50-1147869.txt b/ts/rustc-ice-2026-10-26T00_02_50-1147869.txt deleted file mode 100644 index fd5a942a0..000000000 --- a/ts/rustc-ice-2026-10-26T00_02_50-1147869.txt +++ /dev/null @@ -1,77 +0,0 @@ -thread 'rustc' panicked at src/lower/mir/step.rs:21:95: -Box -stack backtrace: - 0: 0x7ffff4428975 - ::create - 1: 0x7ffff44288c5 - ::force_capture - 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} - 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook - 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} - 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> - 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: - 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl - 8: 0x5555559069db - >::type_at::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 - 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 - 10: 0x555555882728 - >::type_at - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 - 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 - 12: 0x55555587e6c3 - ::find_stepped::{closure#1} - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 - 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 - 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 - 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 - 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 - 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 - 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 - 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 - 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 - 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 - 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 - 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 - 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 - 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 - 26: 0x5555556a5e1e - ::find_stepped - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 - 27: 0x5555556945c0 - ::analyze - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 - 28: 0x55555568b6c5 - ::new - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 - 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 - 30: 0x555555767f1e - ::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 - 31: 0x555555761458 - ::drain - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 - 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 - 33: 0x55555591866f - ::after_expansion - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 - 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} - 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> - 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} - 37: 0x7ffff5d2d81b - ::new::thread_start - 38: 0x7fffeec9f751 - start_thread - 39: 0x7fffeed2ba4c - __clone3 - 40: 0x0 - - - -rustc version: 1.101.0-nightly (7df81381d 2026-10-14) -platform: x86_64-unknown-linux-gnu - -query stack during panic: -end of query stack diff --git a/ts/rustc-ice-2026-10-26T00_02_52-1149919.txt b/ts/rustc-ice-2026-10-26T00_02_52-1149919.txt deleted file mode 100644 index fd5a942a0..000000000 --- a/ts/rustc-ice-2026-10-26T00_02_52-1149919.txt +++ /dev/null @@ -1,77 +0,0 @@ -thread 'rustc' panicked at src/lower/mir/step.rs:21:95: -Box -stack backtrace: - 0: 0x7ffff4428975 - ::create - 1: 0x7ffff44288c5 - ::force_capture - 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} - 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook - 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} - 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> - 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: - 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl - 8: 0x5555559069db - >::type_at::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 - 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 - 10: 0x555555882728 - >::type_at - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 - 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 - 12: 0x55555587e6c3 - ::find_stepped::{closure#1} - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 - 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 - 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 - 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 - 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 - 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 - 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 - 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 - 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 - 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 - 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 - 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 - 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 - 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 - 26: 0x5555556a5e1e - ::find_stepped - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 - 27: 0x5555556945c0 - ::analyze - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 - 28: 0x55555568b6c5 - ::new - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 - 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 - 30: 0x555555767f1e - ::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 - 31: 0x555555761458 - ::drain - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 - 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 - 33: 0x55555591866f - ::after_expansion - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 - 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} - 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> - 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} - 37: 0x7ffff5d2d81b - ::new::thread_start - 38: 0x7fffeec9f751 - start_thread - 39: 0x7fffeed2ba4c - __clone3 - 40: 0x0 - - - -rustc version: 1.101.0-nightly (7df81381d 2026-10-14) -platform: x86_64-unknown-linux-gnu - -query stack during panic: -end of query stack diff --git a/ts/rustc-ice-2026-10-26T00_03_00-1156431.txt b/ts/rustc-ice-2026-10-26T00_03_00-1156431.txt deleted file mode 100644 index fd5a942a0..000000000 --- a/ts/rustc-ice-2026-10-26T00_03_00-1156431.txt +++ /dev/null @@ -1,77 +0,0 @@ -thread 'rustc' panicked at src/lower/mir/step.rs:21:95: -Box -stack backtrace: - 0: 0x7ffff4428975 - ::create - 1: 0x7ffff44288c5 - ::force_capture - 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} - 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook - 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} - 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> - 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: - 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl - 8: 0x5555559069db - >::type_at::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 - 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 - 10: 0x555555882728 - >::type_at - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 - 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 - 12: 0x55555587e6c3 - ::find_stepped::{closure#1} - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 - 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 - 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 - 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 - 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 - 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 - 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 - 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 - 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 - 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 - 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 - 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 - 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 - 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 - 26: 0x5555556a5e1e - ::find_stepped - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 - 27: 0x5555556945c0 - ::analyze - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 - 28: 0x55555568b6c5 - ::new - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 - 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 - 30: 0x555555767f1e - ::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 - 31: 0x555555761458 - ::drain - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 - 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 - 33: 0x55555591866f - ::after_expansion - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 - 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} - 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> - 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} - 37: 0x7ffff5d2d81b - ::new::thread_start - 38: 0x7fffeec9f751 - start_thread - 39: 0x7fffeed2ba4c - __clone3 - 40: 0x0 - - - -rustc version: 1.101.0-nightly (7df81381d 2026-10-14) -platform: x86_64-unknown-linux-gnu - -query stack during panic: -end of query stack diff --git a/ts/rustc-ice-2026-10-26T00_03_00-1157053.txt b/ts/rustc-ice-2026-10-26T00_03_00-1157053.txt deleted file mode 100644 index fd5a942a0..000000000 --- a/ts/rustc-ice-2026-10-26T00_03_00-1157053.txt +++ /dev/null @@ -1,77 +0,0 @@ -thread 'rustc' panicked at src/lower/mir/step.rs:21:95: -Box -stack backtrace: - 0: 0x7ffff4428975 - ::create - 1: 0x7ffff44288c5 - ::force_capture - 2: 0x7ffff31df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} - 3: 0x7ffff443ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook - 4: 0x7ffff3fd71c0 - std[76053f7ab5f7f410]::panicking::begin_panic::::{closure#0} - 5: 0x7ffff3fd522e - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> - 6: 0x7ffff3fd5202 - std[76053f7ab5f7f410]::panicking::begin_panic:: - 7: 0x7ffff04226c1 - rustc_span[84be90fd7ae9529b]::macros::bug_impl - 8: 0x5555559069db - >::type_at::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:542:16 - 9: 0x555555882728 - >::unwrap_or_else::<>::type_at::{closure#0}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/option.rs:1067:21 - 10: 0x555555882728 - >::type_at - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/rustc-src/rust/compiler/rustc_middle/src/ty/generic_args.rs:540:27 - 11: 0x5555558a68a3 - rust2_ts[fee175e3fc65a9e1]::lower::mir::step::array_iter - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:21:89 - 12: 0x55555587e6c3 - ::find_stepped::{closure#1} - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:46:17 - 13: 0x5555558ac71b - <&mut ::find_stepped::{closure#1} as core[68f4be281c81bf45]::ops::function::FnMut<(&rustc_middle[cafb698fa2df9d9f]::mir::Local,)>>::call_mut - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/ops/function.rs:298:21 - 14: 0x5555557edc37 - core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::::find_stepped::{closure#1}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2979:20 - 15: 0x55555587c7c1 - core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold::, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:86:44 - 16: 0x5555558353f8 - core[68f4be281c81bf45]::iter::adapters::map::map_try_fold::, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0} - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:95:21 - 17: 0x5555558c1391 - as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::map::map_try_fold, >::indices::{closure#0}, core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2504:21 - 18: 0x555555829668 - , >::indices::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::adapters::filter::filter_try_fold, ::find_stepped::{closure#0}, core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/map.rs:121:19 - 19: 0x555555878a25 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::try_fold::<(), core[68f4be281c81bf45]::iter::traits::iterator::Iterator::find::check::find_stepped::{closure#1}>::{closure#0}, core[68f4be281c81bf45]::ops::control_flow::ControlFlow> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:157:19 - 20: 0x55555587bb73 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::find::<&mut ::find_stepped::{closure#1}> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2983:14 - 21: 0x5555558ac761 - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::next - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:98:19 - 22: 0x555555673427 - as alloc[da66e3cb2157659a]::vec::spec_from_iter_nested::SpecFromIterNested, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter_nested.rs:24:41 - 23: 0x555555670eed - as alloc[da66e3cb2157659a]::vec::spec_from_iter::SpecFromIter, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>>>::from_iter - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/spec_from_iter.rs:33:9 - 24: 0x555555667495 - as core[68f4be281c81bf45]::iter::traits::collect::FromIterator>::from_iter::, >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}>> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:4109:9 - 25: 0x55555587bb2d - , >::indices::{closure#0}>, ::find_stepped::{closure#0}>, ::find_stepped::{closure#1}> as core[68f4be281c81bf45]::iter::traits::iterator::Iterator>::collect::> - at /nix/store/i222nr66l2r3xfahzfpp1m6mawvhxyl2-rust-default-1.101.0-nightly-2026-10-15/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2100:9 - 26: 0x5555556a5e1e - ::find_stepped - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/step.rs:47:5 - 27: 0x5555556945c0 - ::analyze - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:328:8 - 28: 0x55555568b6c5 - ::new - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:236:6 - 29: 0x5555556c4bfd - rust2_ts[fee175e3fc65a9e1]::lower::mir::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mir/mod.rs:46:15 - 30: 0x555555767f1e - ::function - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:1049:28 - 31: 0x555555761458 - ::drain - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:244:10 - 32: 0x555555787c2c - rust2_ts[fee175e3fc65a9e1]::lower::translate - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/lower/mod.rs:41:4 - 33: 0x55555591866f - ::after_expansion - at /home/kixelated/work/rust2/.claude/worktrees/agent-aaf6b882573e49c00/ts/src/driver.rs:80:30 - 34: 0x7ffff5d067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} - 35: 0x7ffff5d30764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> - 36: 0x7ffff5d304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} - 37: 0x7ffff5d2d81b - ::new::thread_start - 38: 0x7fffeec9f751 - start_thread - 39: 0x7fffeed2ba4c - __clone3 - 40: 0x0 - - - -rustc version: 1.101.0-nightly (7df81381d 2026-10-14) -platform: x86_64-unknown-linux-gnu - -query stack during panic: -end of query stack From 24b608b30b05760e7319ff820b127d36f0cd98ce Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 21:05:53 -0700 Subject: [PATCH 16/17] fix(ts): keep the reads of arithmetic that can panic, even unread drop_unread uncounted the operands of a checked operation nothing reads, though set_local still lowers it for its panic, leaving it reading a local never assigned or declared. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/fixtures/lang/expected/ints.ts | 384 ++++++++++++++++++------------ ts/fixtures/lang/src/ints.rs | 9 +- ts/src/lower/mir/mod.rs | 7 +- ts/tests/differential.ts | 2 +- 4 files changed, 243 insertions(+), 159 deletions(-) diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 2df4235c3..3f08d93d0 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -18,6 +18,7 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void; let _52!: rt.u8; let x!: rt.u8; + let x2!: rt.u8; _50 = (out2: rt.ByteVec, v: rt.u8): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); @@ -47,7 +48,7 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.u8, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 8)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u8Add(a, b); _50(out, part16); @@ -113,19 +114,24 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u8WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u8Add(a, b); + rt.u8Mul(x, b); + rt.u8Mul(rt.u8Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.u8Add(x, b); - x = rt.u8Sub(x, 1); - x = rt.u8Mul(x, 2); - x = x >> 1; - x = (x << 1) & 0xff; - x = x | (1 << 3); - x = x ^ b; - x = x & (~(1 << 2) & 0xff); - x = rt.u8Rem(x, 7); - x = rt.u8Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.u8Add(x2, b); + x2 = rt.u8Sub(x2, 1); + x2 = rt.u8Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) & 0xff; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & (~(1 << 2) & 0xff); + x2 = rt.u8Rem(x2, 7); + x2 = rt.u8Div(x2, 3); + _50(out, x2); } } @@ -145,6 +151,7 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.u16 | undefined) => void; let _52!: rt.u8; let x!: rt.u16; + let x2!: rt.u16; _50 = (out2: rt.ByteVec, v: rt.u16): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); @@ -174,7 +181,7 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.u16, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 16)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u16Add(a, b); _50(out, part16); @@ -240,19 +247,24 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u16WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u16Add(a, b); + rt.u16Mul(x, b); + rt.u16Mul(rt.u16Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.u16Add(x, b); - x = rt.u16Sub(x, 1); - x = rt.u16Mul(x, 2); - x = x >> 1; - x = (x << 1) & 0xffff; - x = x | (1 << 3); - x = x ^ b; - x = x & (~(1 << 2) & 0xffff); - x = rt.u16Rem(x, 7); - x = rt.u16Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.u16Add(x2, b); + x2 = rt.u16Sub(x2, 1); + x2 = rt.u16Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) & 0xffff; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & (~(1 << 2) & 0xffff); + x2 = rt.u16Rem(x2, 7); + x2 = rt.u16Div(x2, 3); + _50(out, x2); } } @@ -272,6 +284,7 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.u32 | undefined) => void; let _52!: rt.u8; let x!: rt.u32; + let x2!: rt.u32; _50 = (out2: rt.ByteVec, v: rt.u32): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); @@ -301,7 +314,7 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.u32, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u32Add(a, b); _50(out, part16); @@ -367,19 +380,24 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u32WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u32Add(a, b); + rt.u32Mul(x, b); + rt.u32Mul(rt.u32Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.u32Add(x, b); - x = rt.u32Sub(x, 1); - x = rt.u32Mul(x, 2); - x = x >>> 1; - x = (x << 1) >>> 0; - x = (x | (1 << 3)) >>> 0; - x = (x ^ b) >>> 0; - x = (x & (~(1 << 2) >>> 0)) >>> 0; - x = rt.u32Rem(x, 7); - x = rt.u32Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.u32Add(x2, b); + x2 = rt.u32Sub(x2, 1); + x2 = rt.u32Mul(x2, 2); + x2 = x2 >>> 1; + x2 = (x2 << 1) >>> 0; + x2 = (x2 | (1 << 3)) >>> 0; + x2 = (x2 ^ b) >>> 0; + x2 = (x2 & (~(1 << 2) >>> 0)) >>> 0; + x2 = rt.u32Rem(x2, 7); + x2 = rt.u32Div(x2, 3); + _50(out, x2); } } @@ -399,6 +417,7 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.u64 | undefined) => void; let _52!: rt.u8; let x!: rt.u64; + let x2!: rt.u64; _50 = (out2: rt.ByteVec, v: rt.u64): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(rt.u128Cast(v))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); @@ -428,7 +447,7 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.u64, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 64)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u64Add(a, b); _50(out, part16); @@ -494,19 +513,24 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.u64Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u64Add(a, b); + rt.u64Mul(x, b); + rt.u64Mul(rt.u64Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.u64Add(x, b); - x = rt.u64Sub(x, 1); - x = rt.u64Mul(x, 2); - x = rt.u64Shr(x, 1); - x = rt.u64Shl(x, 1); - x = rt.u64Or(x, 8); - x = rt.u64Xor(x, b); - x = rt.u64And(x, rt.u64Not(4)); - x = rt.u64Rem(x, 7); - x = rt.u64Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.u64Add(x2, b); + x2 = rt.u64Sub(x2, 1); + x2 = rt.u64Mul(x2, 2); + x2 = rt.u64Shr(x2, 1); + x2 = rt.u64Shl(x2, 1); + x2 = rt.u64Or(x2, 8); + x2 = rt.u64Xor(x2, b); + x2 = rt.u64And(x2, rt.u64Not(4)); + x2 = rt.u64Rem(x2, 7); + x2 = rt.u64Div(x2, 3); + _50(out, x2); } } @@ -526,6 +550,7 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.u128 | undefined) => void; let _52!: rt.u8; let x!: rt.u128; + let x2!: rt.u128; _50 = (out2: rt.ByteVec, v: rt.u128): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v)); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); @@ -555,7 +580,7 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.u128, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 128)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u128Add(a, b); _50(out, part16); @@ -621,19 +646,24 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.u128Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u128Add(a, b); + rt.u128Mul(x, b); + rt.u128Mul(rt.u128Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.u128Add(x, b); - x = rt.u128Sub(x, 1); - x = rt.u128Mul(x, 2); - x = rt.u128Shr(x, 1); - x = rt.u128Shl(x, 1); - x = rt.u128Or(x, rt.u128Shl(1, 3)); - x = rt.u128Xor(x, b); - x = rt.u128And(x, rt.u128Not(rt.u128Shl(1, 2))); - x = rt.u128Rem(x, 7); - x = rt.u128Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.u128Add(x2, b); + x2 = rt.u128Sub(x2, 1); + x2 = rt.u128Mul(x2, 2); + x2 = rt.u128Shr(x2, 1); + x2 = rt.u128Shl(x2, 1); + x2 = rt.u128Or(x2, rt.u128Shl(1, 3)); + x2 = rt.u128Xor(x2, b); + x2 = rt.u128And(x2, rt.u128Not(rt.u128Shl(1, 2))); + x2 = rt.u128Rem(x2, 7); + x2 = rt.u128Div(x2, 3); + _50(out, x2); } } @@ -653,6 +683,7 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.usize | undefined) => void; let _52!: rt.u8; let x!: rt.usize; + let x2!: rt.usize; _50 = (out2: rt.ByteVec, v: rt.usize): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); @@ -682,7 +713,7 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.usize, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.usizeAdd(a, b); _50(out, part16); @@ -748,19 +779,24 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.usizeWrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.usizeAdd(a, b); + rt.usizeMul(x, b); + rt.usizeMul(rt.usizeSub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.usizeAdd(x, b); - x = rt.usizeSub(x, 1); - x = rt.usizeMul(x, 2); - x = x >>> 1; - x = (x << 1) >>> 0; - x = (x | (1 << 3)) >>> 0; - x = (x ^ b) >>> 0; - x = (x & (~(1 << 2) >>> 0)) >>> 0; - x = rt.usizeRem(x, 7); - x = rt.usizeDiv(x, 3); - _50(out, x); + x2 = a; + x2 = rt.usizeAdd(x2, b); + x2 = rt.usizeSub(x2, 1); + x2 = rt.usizeMul(x2, 2); + x2 = x2 >>> 1; + x2 = (x2 << 1) >>> 0; + x2 = (x2 | (1 << 3)) >>> 0; + x2 = (x2 ^ b) >>> 0; + x2 = (x2 & (~(1 << 2) >>> 0)) >>> 0; + x2 = rt.usizeRem(x2, 7); + x2 = rt.usizeDiv(x2, 3); + _50(out, x2); } } @@ -780,6 +816,7 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.i8 | undefined) => void; let _52!: rt.u8; let x!: rt.i8; + let x2!: rt.i8; _50 = (out2: rt.ByteVec, v: rt.i8): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); @@ -809,7 +846,7 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.i8, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 8)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i8Add(a, b); _50(out, part16); @@ -875,19 +912,24 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i8WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i8Add(a, b); + rt.i8Mul(x, b); + rt.i8Mul(rt.i8Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.i8Add(x, b); - x = rt.i8Sub(x, 1); - x = rt.i8Mul(x, 2); - x = x >> 1; - x = (x << 1 << 24) >> 24; - x = x | (1 << 3); - x = x ^ b; - x = x & ~(1 << 2); - x = rt.i8Rem(x, 7); - x = rt.i8Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.i8Add(x2, b); + x2 = rt.i8Sub(x2, 1); + x2 = rt.i8Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1 << 24) >> 24; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.i8Rem(x2, 7); + x2 = rt.i8Div(x2, 3); + _50(out, x2); } } @@ -907,6 +949,7 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.i16 | undefined) => void; let _52!: rt.u8; let x!: rt.i16; + let x2!: rt.i16; _50 = (out2: rt.ByteVec, v: rt.i16): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); @@ -936,7 +979,7 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.i16, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 16)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i16Add(a, b); _50(out, part16); @@ -1002,19 +1045,24 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i16WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i16Add(a, b); + rt.i16Mul(x, b); + rt.i16Mul(rt.i16Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.i16Add(x, b); - x = rt.i16Sub(x, 1); - x = rt.i16Mul(x, 2); - x = x >> 1; - x = (x << 1 << 16) >> 16; - x = x | (1 << 3); - x = x ^ b; - x = x & ~(1 << 2); - x = rt.i16Rem(x, 7); - x = rt.i16Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.i16Add(x2, b); + x2 = rt.i16Sub(x2, 1); + x2 = rt.i16Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1 << 16) >> 16; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.i16Rem(x2, 7); + x2 = rt.i16Div(x2, 3); + _50(out, x2); } } @@ -1034,6 +1082,7 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.i32 | undefined) => void; let _52!: rt.u8; let x!: rt.i32; + let x2!: rt.i32; _50 = (out2: rt.ByteVec, v: rt.i32): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); @@ -1063,7 +1112,7 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i32Add(a, b); _50(out, part16); @@ -1129,19 +1178,24 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i32WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i32Add(a, b); + rt.i32Mul(x, b); + rt.i32Mul(rt.i32Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.i32Add(x, b); - x = rt.i32Sub(x, 1); - x = rt.i32Mul(x, 2); - x = x >> 1; - x = (x << 1) | 0; - x = x | (1 << 3); - x = x ^ b; - x = x & ~(1 << 2); - x = rt.i32Rem(x, 7); - x = rt.i32Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.i32Add(x2, b); + x2 = rt.i32Sub(x2, 1); + x2 = rt.i32Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) | 0; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.i32Rem(x2, 7); + x2 = rt.i32Div(x2, 3); + _50(out, x2); } } @@ -1161,6 +1215,7 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.i64 | undefined) => void; let _52!: rt.u8; let x!: rt.i64; + let x2!: rt.i64; _50 = (out2: rt.ByteVec, v: rt.i64): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(rt.i128Cast(v))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); @@ -1190,7 +1245,7 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.i64, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 64)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i64Add(a, b); _50(out, part16); @@ -1256,19 +1311,24 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.i64Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i64Add(a, b); + rt.i64Mul(x, b); + rt.i64Mul(rt.i64Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.i64Add(x, b); - x = rt.i64Sub(x, 1); - x = rt.i64Mul(x, 2); - x = rt.i64Shr(x, 1); - x = rt.i64Shl(x, 1); - x = rt.i64Or(x, 8); - x = rt.i64Xor(x, b); - x = rt.i64And(x, rt.i64Not(4)); - x = rt.i64Rem(x, 7); - x = rt.i64Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.i64Add(x2, b); + x2 = rt.i64Sub(x2, 1); + x2 = rt.i64Mul(x2, 2); + x2 = rt.i64Shr(x2, 1); + x2 = rt.i64Shl(x2, 1); + x2 = rt.i64Or(x2, 8); + x2 = rt.i64Xor(x2, b); + x2 = rt.i64And(x2, rt.i64Not(4)); + x2 = rt.i64Rem(x2, 7); + x2 = rt.i64Div(x2, 3); + _50(out, x2); } } @@ -1288,6 +1348,7 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.i128 | undefined) => void; let _52!: rt.u8; let x!: rt.i128; + let x2!: rt.i128; _50 = (out2: rt.ByteVec, v: rt.i128): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v)); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); @@ -1317,7 +1378,7 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.i128, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 128)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i128Add(a, b); _50(out, part16); @@ -1383,19 +1444,24 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.i128Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i128Add(a, b); + rt.i128Mul(x, b); + rt.i128Mul(rt.i128Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.i128Add(x, b); - x = rt.i128Sub(x, 1); - x = rt.i128Mul(x, 2); - x = rt.i128Shr(x, 1); - x = rt.i128Shl(x, 1); - x = rt.i128Or(x, rt.i128Shl(1, 3)); - x = rt.i128Xor(x, b); - x = rt.i128And(x, rt.i128Not(rt.i128Shl(1, 2))); - x = rt.i128Rem(x, 7); - x = rt.i128Div(x, 3); - _50(out, x); + x2 = a; + x2 = rt.i128Add(x2, b); + x2 = rt.i128Sub(x2, 1); + x2 = rt.i128Mul(x2, 2); + x2 = rt.i128Shr(x2, 1); + x2 = rt.i128Shl(x2, 1); + x2 = rt.i128Or(x2, rt.i128Shl(1, 3)); + x2 = rt.i128Xor(x2, b); + x2 = rt.i128And(x2, rt.i128Not(rt.i128Shl(1, 2))); + x2 = rt.i128Rem(x2, 7); + x2 = rt.i128Div(x2, 3); + _50(out, x2); } } @@ -1415,6 +1481,7 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { let _51!: (a0: rt.ByteVec, a1: rt.isize | undefined) => void; let _52!: rt.u8; let x!: rt.isize; + let x2!: rt.isize; _50 = (out2: rt.ByteVec, v: rt.isize): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); @@ -1444,7 +1511,7 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { [_38, rt.sliceRange(slice2, n2)] as [rt.isize, Uint8Array]; b = _38; shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); - _52 = rt.u8Rem(op, 24); + _52 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.isizeAdd(a, b); _50(out, part16); @@ -1510,19 +1577,24 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.isizeWrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.isizeAdd(a, b); + rt.isizeMul(x, b); + rt.isizeMul(rt.isizeSub(x, b), a); + rt.byteVecPush(out, 1); } else { - x = a; - x = rt.isizeAdd(x, b); - x = rt.isizeSub(x, 1); - x = rt.isizeMul(x, 2); - x = x >> 1; - x = (x << 1) | 0; - x = x | (1 << 3); - x = x ^ b; - x = x & ~(1 << 2); - x = rt.isizeRem(x, 7); - x = rt.isizeDiv(x, 3); - _50(out, x); + x2 = a; + x2 = rt.isizeAdd(x2, b); + x2 = rt.isizeSub(x2, 1); + x2 = rt.isizeMul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) | 0; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.isizeRem(x2, 7); + x2 = rt.isizeDiv(x2, 3); + _50(out, x2); } } diff --git a/ts/fixtures/lang/src/ints.rs b/ts/fixtures/lang/src/ints.rs index c206d2d72..14685a958 100644 --- a/ts/fixtures/lang/src/ints.rs +++ b/ts/fixtures/lang/src/ints.rs @@ -30,7 +30,7 @@ macro_rules! ops { } None => out.push(0), }; - match op % 24 { + match op % 25 { 0 => put(out, a + b), 1 => put(out, a - b), 2 => put(out, a * b), @@ -60,6 +60,13 @@ macro_rules! ops { // Against a literal, which a wide value equals only in one form. out.push((a.wrapping_sub(b) == 0) as u8); } + 23 => { + // Products nothing reads still overflow, of a sum that does too. + let x = a + b; + let _ = x * b; + let _ = (x - b) * a; + out.push(1); + } _ => { // Compound assignment, with constants folded beside variables. let mut x = a; diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 79ac40468..184fb279c 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -459,7 +459,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { && let Some(local) = assign.0.as_local() { match &assign.1 { - r @ (Rvalue::BinaryOp(..) | Rvalue::UnaryOp(..) | Rvalue::Use(..)) => computed[local].push(r), + // One that can throw is lowered even unread, so it keeps its reads. + r @ (Rvalue::BinaryOp(..) | Rvalue::UnaryOp(..) | Rvalue::Use(..)) + if !rvalue::effect(r, self) => + { + computed[local].push(r) + } _ => pure[local] = false, } } diff --git a/ts/tests/differential.ts b/ts/tests/differential.ts index 208b377b4..e23d70c1c 100644 --- a/ts/tests/differential.ts +++ b/ts/tests/differential.ts @@ -129,7 +129,7 @@ if (wideArg === "wide") { const u = i % 3 === 0 ? x : values[(i * 7) % values.length]; const v = values[(i * 13 + 5) % values.length]; const shift = shifts[i++ % shifts.length]; - for (let kind = 0; kind < 24; kind++) { + for (let kind = 0; kind < 25; kind++) { for (const op of [3, 9]) cases.push(Uint8Array.of(op, kind, ...be(x), ...be(y), shift)); for (const op of [4, 10]) cases.push(Uint8Array.of(op, kind, ...be(x), ...be(y), ...be(u), ...be(v), shift)); } From adfa30a851e9cbb5e3a934bf5cb8d82eb2ac2dc9 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 25 Oct 2026 21:24:09 -0700 Subject: [PATCH 17/17] docs(ts): measure MIR against THIR again after the wide-integer merge Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_0115AT2ue6x9cT5e5J9SZtCn --- ts/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ts/README.md b/ts/README.md index fa81cfc52..4516f2aa5 100644 --- a/ts/README.md +++ b/ts/README.md @@ -254,8 +254,8 @@ they need. runs the cleanup blocks `-C panic=unwind` MIR has, from a `catch`. Async bodies are the coroutine transform's state machines, a class each. Against the THIR lowering it replaced, MIR closes about 1,100 of the 1,400 drop refusals in moq-net's census, and - runs `just ts bench`'s codec 1-8% faster at the geometric mean and the async handoff - 1.4-5.5x faster at depths 1 to 16 in Node, Bun, and Chrome, for 5% more gzip on the + runs `just ts bench`'s codec 2-6% faster at the geometric mean and the async handoff + 1.4-5.9x faster at depths 1 to 16 in Node, Bun, and Chrome, for 4% more gzip on the codec's bundle and 16% on the async fixture's ([size](/quest/m2/ts-mir-size.md)). Blocks become nested blocks, loops, and `if`s by Ramsey's "Beyond Relooper", except a coroutine's resume function, which enters loops