From c1dcf6dc696800a7eb4bf3aa6842d099253af643 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 09:18:07 -0700 Subject: [PATCH 1/2] chore(quest): claim quest/m3/ts-try-from-infallible.md Quest-Claim: 92b1796078ac3a8f From 382a6b39f6199de8d8d6fc2620be159640b65fe8 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 09:33:42 -0700 Subject: [PATCH 2/2] feat(ts): type a try_from that can't fail by its Infallible Where `From` holds, std's blanket `TryFrom` converts by it and its error is `Infallible`, `!`: the call is now `rt.Ok` of the `From` conversion, typed `Result`, rather than an integer's checked `tryFrom`, typed with `TryFromIntError`. This covers every integer pair that can't fail on wasm32, a `char`'s conversions, and a crate's own `From`. Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 2 +- quest/m3/ts-try-from-infallible.md | 17 - quest/m3/ts-uninhabited-switch.md | 24 ++ ts/fixtures/lang/expected/core/result.ts | 110 ++++++ ts/fixtures/lang/expected/harness.ts | 6 +- ts/fixtures/lang/expected/ints.Scaled.ts | 14 + ts/fixtures/lang/expected/ints.ts | 422 ++++++++++++++++++++++- ts/fixtures/lang/src/harness.rs | 1 + ts/fixtures/lang/src/ints.rs | 71 ++++ ts/src/lower/library.rs | 9 + 10 files changed, 654 insertions(+), 22 deletions(-) delete mode 100644 quest/m3/ts-try-from-infallible.md create mode 100644 quest/m3/ts-uninhabited-switch.md create mode 100644 ts/fixtures/lang/expected/ints.Scaled.ts diff --git a/quest/m3/README.md b/quest/m3/README.md index 0eed7a053..327f40de5 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -22,7 +22,6 @@ generic std gap is planned here even when moq never calls it. - [The capacity of a BytesMut](/quest/m3/ts-bytes-capacity.md) - `BytesMut::capacity` and what reads it translate with `bytes`' values - [BufMut's provided writes through a &mut](/quest/m3/ts-buf-mut-forward.md) - `put`, `put_bytes`, `put_uint`, and `put_int` of a `&mut Vec` or `&mut BytesMut` translate - [Trait objects](/quest/m3/ts-dyn.md) - `dyn Error`, `dyn Iterator`, `dyn Buf`, and `Arc` translate, so a consumer neither rewrites nor binds them -- [A widening try_from typed by its Infallible](/quest/m3/ts-try-from-infallible.md) - an integer `try_from` that can't fail type-checks as `Result` - [Placeholders written to a crate's own fmt::Write](/quest/m3/ts-fmt-calls.md) - `write!` with placeholders into a crate's own writer translates, its `write_str` seeing each call std makes - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library - [An inclusive range folded through an adaptor](/quest/m3/ts-range-fold.md) - a `RangeInclusive` folded through `map`, `filter`, or `rev` ends in core's state, and `by_ref` of one type-checks @@ -36,4 +35,5 @@ generic std gap is planned here even when moq never calls it. - [Peekable::next_if_eq against another type](/quest/m3/ts-next-if-eq-other.md) - `next_if_eq` with an expected value of another type than the item, such as a `&str` of `String` items, translates - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form - [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does +- [A switch whose other variants are uninhabited](/quest/m3/ts-uninhabited-switch.md) - a tuple's `Result<_, Infallible>`s matched or bound by `let` type-checks, its discriminant reads no longer left unused - [A parameter read only where lowering leaves nothing](/quest/m3/ts-unread-params.md) - an instance whose lowering drops every read of a parameter marks it unused, so `tsc` accepts it diff --git a/quest/m3/ts-try-from-infallible.md b/quest/m3/ts-try-from-infallible.md deleted file mode 100644 index 751e4b445..000000000 --- a/quest/m3/ts-try-from-infallible.md +++ /dev/null @@ -1,17 +0,0 @@ -# [XS] A widening try_from typed by its Infallible - -## Goal - -[rust2-ts](/ts/README.md) types `u16::try_from(u8)` and every other integer `try_from` or -`try_into` that can't fail as std does, `Result`, so it type-checks where a -value of that type is named, proven by differential tests against native Rust. - -## Plan - -Found by the quest that made `Result` and std's errors comparable, on 2026-10-30: the mapping -returns `rt.u16TryFrom`'s `Result` whatever the conversion, and `tsc` -refuses it where the Rust type is `Result`, typed `Result`. - -- Where `From` holds, the conversion is `rt.Ok` of the widened value. - -Public API: the translator's output. diff --git a/quest/m3/ts-uninhabited-switch.md b/quest/m3/ts-uninhabited-switch.md new file mode 100644 index 000000000..b63709727 --- /dev/null +++ b/quest/m3/ts-uninhabited-switch.md @@ -0,0 +1,24 @@ +# [S] A switch whose other variants are uninhabited + +## Goal + +[rust2-ts](/ts/README.md) translates a match or `let` that tests a part of a tuple or +other non-path place whose other variants can't exist, such as +`let (Ok(a), Ok(b)) = (wide, wider);` of two `Result<_, Infallible>`s, without leaving the +discriminant it read unused, so `tsc` accepts it, proven by differential tests against +native Rust. + +## Plan + +Found by the quest that typed an infallible `try_from` by its `Infallible`, on 2026-10-30: +MIR reads each part's discriminant and switches to `unreachable` otherwise; lowering drops +that one-way switch, but the read was already spilled to a `const scrutinee` (the +`Slot::Discr` assignment in `ts/src/lower/mir/mod.rs`), which `noUnusedLocals` refuses. +A single `match` or `let Ok(x) = r` of such a `Result` already type-checks. No consumer +hits it at the pin. + +Public API: the translator's output. + +## Related + +- [A parameter read only where lowering leaves nothing](/quest/m3/ts-unread-params.md) - the same kind of read lowering leaves unused, of a parameter diff --git a/ts/fixtures/lang/expected/core/result.ts b/ts/fixtures/lang/expected/core/result.ts index e3062c95b..d88a3e060 100644 --- a/ts/fixtures/lang/expected/core/result.ts +++ b/ts/fixtures/lang/expected/core/result.ts @@ -101,6 +101,46 @@ export function eq$0pe0qmq(self: rt.Result, other: rt return eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); } +export function eq$0pee78b(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return rt.i128Eq(self.value, (other as { ok: true; value: rt.i128 }).value); + } + return true; +} + +export function eq$1mi4cle(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.i16 }).value; + } + return true; +} + +export function eq$1ukayff(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.i32 }).value; + } + return true; +} + +export function eq$1hy1is1(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return rt.i64Eq(self.value, (other as { ok: true; value: rt.i64 }).value); + } + return true; +} + export function eq$1mpp8xa(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; @@ -121,6 +161,26 @@ export function eq$0grmb7g(self: rt.Result, other: rt return eq$1nf2rde(self.error, (other as { ok: false; error: rt.TryFromIntError }).error); } +export function eq$1hd8lo9(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.i8 }).value; + } + return true; +} + +export function eq$0w2dfat(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.isize }).value; + } + return true; +} + export function eq$0rj0czq(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; @@ -131,6 +191,16 @@ export function eq$0rj0czq(self: rt.Result, other: rt.Resu return eq$1v93ipo(self.error, (other as { ok: false; error: rt.Utf8Error }).error); } +export function eq$06vyx9e(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return rt.u128Eq(self.value, (other as { ok: true; value: rt.u128 }).value); + } + return true; +} + export function eq$08241oi(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; @@ -141,6 +211,16 @@ export function eq$08241oi(self: rt.Result, other: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.u32 }).value; + } + return true; +} + export function eq$0bl30vt(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; @@ -151,6 +231,16 @@ export function eq$0bl30vt(self: rt.Result, other: rt. return eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); } +export function eq$1gq81ib(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return rt.u64Eq(self.value, (other as { ok: true; value: rt.u64 }).value); + } + return true; +} + export function eq$1fkhuzl(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; @@ -171,6 +261,16 @@ export function eq$0p1bb4y(self: rt.Result, other: rt.R return eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); } +export function eq$12e5exx(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.u8 }).value; + } + return true; +} + export function eq$03gbayb(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; @@ -181,6 +281,16 @@ export function eq$03gbayb(self: rt.Result, other: rt.Re return eq$08q6k9m(self.error, (other as { ok: false; error: rt.FmtError }).error); } +export function eq$1xhgva4(self: rt.Result, other: rt.Result): boolean { + if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { + return false; + } + if (self.ok) { + return self.value === (other as { ok: true; value: rt.usize }).value; + } + return true; +} + export function isOkAnd$0jj0nkw(self: rt.Result, f: (a0: rt.u8) => boolean): boolean { if (self.ok) { return f(self.value); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 16676cccb..b1b6e9e4b 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -23,7 +23,7 @@ import { ints, strings, derived, written, counts, rounding, panics, wrapped, wri import { methods } from "./generics.ts"; import { values, random, bytes as hashes_bytes } from "./hashes.ts"; import { holds } from "./holds.ts"; -import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses as ints_parses } from "./ints.ts"; +import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses as ints_parses, widenings } from "./ints.ts"; import { adaptors, consumers, reducers, skips, ranked, ranges, options, own, values as iters_values, returned } from "./iters.ts"; import { keys, overrides, bytes as keys_bytes } from "./keys.ts"; import { locals } from "./locals.ts"; @@ -90,7 +90,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) refs(data21, out21); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_2121: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { counts(data22, out22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_2122: rt.u8, _387: rt.ByteSlice, out23: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_2122: rt.u8, _390: rt.ByteSlice, out23: rt.ByteVec): void => { rounding(out23); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["atomics::atomics", atomics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::overrides", overrides] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { dyns(data23, out24); @@ -176,7 +176,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reducers(data63, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): void => { writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["errors::eqs", eqs] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["slices::edits", slices_edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::iters", iters] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::drains", strs_drains] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::hinted", hinted] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["errors::eqs", eqs] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["slices::edits", slices_edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::iters", iters] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::drains", strs_drains] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::hinted", hinted] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::widenings", widenings] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/ints.Scaled.ts b/ts/fixtures/lang/expected/ints.Scaled.ts new file mode 100644 index 000000000..50b4e7b48 --- /dev/null +++ b/ts/fixtures/lang/expected/ints.Scaled.ts @@ -0,0 +1,14 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** A type of the crate's own that `From` makes, which `try_from` converts by. */ +export interface Scaled { + _0: rt.u32; +} + +export function from$From_u8(b: rt.u8): Scaled { + return { _0: rt.u32Mul(b as rt.u32, 1000) }; +} + +//# sourceMappingURL=ints.Scaled.ts.map diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 70bf91913..68baf82bb 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -4,9 +4,10 @@ import * as rt from "./rt.ts"; import { toDigit$01k9ewn } from "./core/char/methods.ts"; import { fromStr$1ej7fl2, fromStr$076yg1t, fromStr$1dxzqb4, fromStr$09oey6q, fromStr$1m3wp28, fromStr$1gsa29j, fromStrRadix$1cxc8v7, fromStrRadix$0w5k2s7, fromStrRadix$1a42la1, fromStrRadix$0olne29, fromStrRadix$0snhnv5, fromStrRadix$1mq18rn, fromStr$0pnvd2c, fromStr$1bigolo, fromStr$1uzmhcw, fromStr$05sn9io, fromStr$0kn8g72, fromStr$0qgw0pl, fromStrRadix$1549erz, fromStrRadix$1x7yq9g, fromStrRadix$1gamglm, fromStrRadix$0bx9j5d, fromStrRadix$1ys3fwo, fromStrRadix$09ykvvv } from "./core/num.ts"; import { isSomeAnd$09tpccf, unwrapOr$11c0we2, unwrapOr$0r2bmpr } from "./core/option.ts"; -import { unwrapOr$01jdcm7, unwrapOr$0nhd29g, unwrapOr$09i71ei } from "./core/result.ts"; +import { eq$0pee78b, eq$1mi4cle, eq$1ukayff, eq$1hy1is1, eq$1hd8lo9, eq$0w2dfat, eq$06vyx9e, eq$08241oi, eq$0nbftnc, eq$1gq81ib, eq$12e5exx, eq$1xhgva4, unwrapOr$01jdcm7, unwrapOr$0nhd29g, unwrapOr$09i71ei } from "./core/result.ts"; import { parse$0zwe7sh, parse$1rrjn2d, parse$12n9p35, parse$1ilajpu, parse$1fq462u, parse$1g5tknx, parse$137ljop, parse$0mrlpzv, parse$1bassid, parse$1q1obm6, parse$0yt2578, parse$1m4h82x } from "./core/str.ts"; import { put } from "./fmt.ts"; +import * as Scaled from "./ints.Scaled.ts"; /** Apply operation `op` to operands taken from `data`. */ export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { @@ -5400,4 +5401,423 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } +/** + * Every integer conversion that can't fail on wasm32, from the type `kind` picks: to + * itself, wider, and to `usize` and `isize` where std has `From`; and a `char`'s and the + * crate's own, which convert the same way. + */ +export function widenings(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _4: rt.u8 = rt.u8Rem(kind, 13); + if (_4 === 0) { + const buf: Uint8Array = Uint8Array.of(0); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const iter: rt.Iter = rt.iterSlice(Uint8Array.of(([rt.u8FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u8, rt.ByteSlice])[0], 0, 255)); + while (true) { + const _27: rt.u8 | rt.Done = iter.next(); + if (_27 === rt.DONE) { + break; + } + const v: rt.u8 = _27; + const named: rt.Result = rt.Ok(v); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes((named as { ok: true; value: rt.u8 }).value))); + const into: rt.Result = rt.Ok(v); + const w2: rt.u8 = (into as { ok: true; value: rt.u8 }).value; + rt.byteVecPush(out, ((eq$12e5exx(into, named) ? 1 : 0)) | ((((w2 === v ? 1 : 0)) << 1) & 0xff)); + const named2: rt.Result = rt.Ok(v as rt.u16); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((named2 as { ok: true; value: rt.u16 }).value))); + const into2: rt.Result = rt.Ok(v as rt.u16); + const w4: rt.u16 = (into2 as { ok: true; value: rt.u16 }).value; + rt.byteVecPush(out, ((eq$08241oi(into2, named2) ? 1 : 0)) | ((((w4 === v as rt.u16 ? 1 : 0)) << 1) & 0xff)); + const named3: rt.Result = rt.Ok(v as rt.u32); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((named3 as { ok: true; value: rt.u32 }).value))); + const into3: rt.Result = rt.Ok(v as rt.u32); + const w6: rt.u32 = (into3 as { ok: true; value: rt.u32 }).value; + rt.byteVecPush(out, ((eq$0nbftnc(into3, named3) ? 1 : 0)) | ((((w6 === v as rt.u32 ? 1 : 0)) << 1) & 0xff)); + const named4: rt.Result = rt.Ok(v as rt.u64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named4 as { ok: true; value: rt.u64 }).value))); + const into4: rt.Result = rt.Ok(v as rt.u64); + const w8: rt.u64 = (into4 as { ok: true; value: rt.u64 }).value; + rt.byteVecPush(out, ((eq$1gq81ib(into4, named4) ? 1 : 0)) | ((((rt.u64Eq(w8, v as rt.u64) ? 1 : 0)) << 1) & 0xff)); + const named5: rt.Result = rt.Ok(v as rt.u128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named5 as { ok: true; value: rt.u128 }).value))); + const into5: rt.Result = rt.Ok(v as rt.u128); + const w10: rt.u128 = (into5 as { ok: true; value: rt.u128 }).value; + rt.byteVecPush(out, ((eq$06vyx9e(into5, named5) ? 1 : 0)) | ((((rt.u128Eq(w10, v as rt.u128) ? 1 : 0)) << 1) & 0xff)); + const named6: rt.Result = rt.Ok(v as rt.usize); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes((named6 as { ok: true; value: rt.usize }).value))); + const into6: rt.Result = rt.Ok(v as rt.usize); + const w12: rt.usize = (into6 as { ok: true; value: rt.usize }).value; + rt.byteVecPush(out, ((eq$1xhgva4(into6, named6) ? 1 : 0)) | ((((w12 === v as rt.usize ? 1 : 0)) << 1) & 0xff)); + const named7: rt.Result = rt.Ok(v as rt.i16); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((named7 as { ok: true; value: rt.i16 }).value))); + const into7: rt.Result = rt.Ok(v as rt.i16); + const w14: rt.i16 = (into7 as { ok: true; value: rt.i16 }).value; + rt.byteVecPush(out, ((eq$1mi4cle(into7, named7) ? 1 : 0)) | ((((w14 === v as rt.i16 ? 1 : 0)) << 1) & 0xff)); + const named8: rt.Result = rt.Ok(v as rt.i32); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named8 as { ok: true; value: rt.i32 }).value))); + const into8: rt.Result = rt.Ok(v as rt.i32); + const w16: rt.i32 = (into8 as { ok: true; value: rt.i32 }).value; + rt.byteVecPush(out, ((eq$1ukayff(into8, named8) ? 1 : 0)) | ((((w16 === v as rt.i32 ? 1 : 0)) << 1) & 0xff)); + const named9: rt.Result = rt.Ok(v as rt.i64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named9 as { ok: true; value: rt.i64 }).value))); + const into9: rt.Result = rt.Ok(v as rt.i64); + const w18: rt.i64 = (into9 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into9, named9) ? 1 : 0)) | ((((rt.i64Eq(w18, v as rt.i64) ? 1 : 0)) << 1) & 0xff)); + const named10: rt.Result = rt.Ok(v as rt.i128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named10 as { ok: true; value: rt.i128 }).value))); + const into10: rt.Result = rt.Ok(v as rt.i128); + const w20: rt.i128 = (into10 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into10, named10) ? 1 : 0)) | ((((rt.i128Eq(w20, v as rt.i128) ? 1 : 0)) << 1) & 0xff)); + const named11: rt.Result = rt.Ok(v as rt.isize); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named11 as { ok: true; value: rt.isize }).value))); + const into11: rt.Result = rt.Ok(v as rt.isize); + const w22: rt.isize = (into11 as { ok: true; value: rt.isize }).value; + rt.byteVecPush(out, ((eq$0w2dfat(into11, named11) ? 1 : 0)) | ((((w22 === v as rt.isize ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 1) { + const buf2: Uint8Array = rt.bytes(2); + const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(data, 0, n2)); + const iter2: rt.Iter = rt.iterSlice([([rt.u16FromBeBytes(buf2), rt.byteSliceRange(data, n2)] as [rt.u16, rt.ByteSlice])[0], 0, 65535]); + while (true) { + const _294: rt.u16 | rt.Done = iter2.next(); + if (_294 === rt.DONE) { + break; + } + const v2: rt.u16 = _294; + const named12: rt.Result = rt.Ok(v2); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((named12 as { ok: true; value: rt.u16 }).value))); + const into12: rt.Result = rt.Ok(v2); + const w24: rt.u16 = (into12 as { ok: true; value: rt.u16 }).value; + rt.byteVecPush(out, ((eq$08241oi(into12, named12) ? 1 : 0)) | ((((w24 === v2 ? 1 : 0)) << 1) & 0xff)); + const named13: rt.Result = rt.Ok(v2 as rt.u32); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((named13 as { ok: true; value: rt.u32 }).value))); + const into13: rt.Result = rt.Ok(v2 as rt.u32); + const w26: rt.u32 = (into13 as { ok: true; value: rt.u32 }).value; + rt.byteVecPush(out, ((eq$0nbftnc(into13, named13) ? 1 : 0)) | ((((w26 === v2 as rt.u32 ? 1 : 0)) << 1) & 0xff)); + const named14: rt.Result = rt.Ok(v2 as rt.u64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named14 as { ok: true; value: rt.u64 }).value))); + const into14: rt.Result = rt.Ok(v2 as rt.u64); + const w28: rt.u64 = (into14 as { ok: true; value: rt.u64 }).value; + rt.byteVecPush(out, ((eq$1gq81ib(into14, named14) ? 1 : 0)) | ((((rt.u64Eq(w28, v2 as rt.u64) ? 1 : 0)) << 1) & 0xff)); + const named15: rt.Result = rt.Ok(v2 as rt.u128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named15 as { ok: true; value: rt.u128 }).value))); + const into15: rt.Result = rt.Ok(v2 as rt.u128); + const w30: rt.u128 = (into15 as { ok: true; value: rt.u128 }).value; + rt.byteVecPush(out, ((eq$06vyx9e(into15, named15) ? 1 : 0)) | ((((rt.u128Eq(w30, v2 as rt.u128) ? 1 : 0)) << 1) & 0xff)); + const named16: rt.Result = rt.Ok(v2 as rt.usize); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes((named16 as { ok: true; value: rt.usize }).value))); + const into16: rt.Result = rt.Ok(v2 as rt.usize); + const w32: rt.usize = (into16 as { ok: true; value: rt.usize }).value; + rt.byteVecPush(out, ((eq$1xhgva4(into16, named16) ? 1 : 0)) | ((((w32 === v2 as rt.usize ? 1 : 0)) << 1) & 0xff)); + const named17: rt.Result = rt.Ok(v2 as rt.i32); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named17 as { ok: true; value: rt.i32 }).value))); + const into17: rt.Result = rt.Ok(v2 as rt.i32); + const w34: rt.i32 = (into17 as { ok: true; value: rt.i32 }).value; + rt.byteVecPush(out, ((eq$1ukayff(into17, named17) ? 1 : 0)) | ((((w34 === v2 as rt.i32 ? 1 : 0)) << 1) & 0xff)); + const named18: rt.Result = rt.Ok(v2 as rt.i64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named18 as { ok: true; value: rt.i64 }).value))); + const into18: rt.Result = rt.Ok(v2 as rt.i64); + const w36: rt.i64 = (into18 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into18, named18) ? 1 : 0)) | ((((rt.i64Eq(w36, v2 as rt.i64) ? 1 : 0)) << 1) & 0xff)); + const named19: rt.Result = rt.Ok(v2 as rt.i128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named19 as { ok: true; value: rt.i128 }).value))); + const into19: rt.Result = rt.Ok(v2 as rt.i128); + const w38: rt.i128 = (into19 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into19, named19) ? 1 : 0)) | ((((rt.i128Eq(w38, v2 as rt.i128) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 2) { + const buf3: Uint8Array = rt.bytes(4); + const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(data, 0, n3)); + const iter3: rt.Iter = rt.iterSlice([([rt.u32FromBeBytes(buf3), rt.byteSliceRange(data, n3)] as [rt.u32, rt.ByteSlice])[0], 0, 4294967295]); + while (true) { + const _495: rt.u32 | rt.Done = iter3.next(); + if (_495 === rt.DONE) { + break; + } + const v3: rt.u32 = _495; + const named20: rt.Result = rt.Ok(v3); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((named20 as { ok: true; value: rt.u32 }).value))); + const into20: rt.Result = rt.Ok(v3); + const w40: rt.u32 = (into20 as { ok: true; value: rt.u32 }).value; + rt.byteVecPush(out, ((eq$0nbftnc(into20, named20) ? 1 : 0)) | ((((w40 === v3 ? 1 : 0)) << 1) & 0xff)); + const named21: rt.Result = rt.Ok(v3 as rt.u64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named21 as { ok: true; value: rt.u64 }).value))); + const into21: rt.Result = rt.Ok(v3 as rt.u64); + const w42: rt.u64 = (into21 as { ok: true; value: rt.u64 }).value; + rt.byteVecPush(out, ((eq$1gq81ib(into21, named21) ? 1 : 0)) | ((((rt.u64Eq(w42, v3 as rt.u64) ? 1 : 0)) << 1) & 0xff)); + const named22: rt.Result = rt.Ok(v3 as rt.u128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named22 as { ok: true; value: rt.u128 }).value))); + const into22: rt.Result = rt.Ok(v3 as rt.u128); + const w44: rt.u128 = (into22 as { ok: true; value: rt.u128 }).value; + rt.byteVecPush(out, ((eq$06vyx9e(into22, named22) ? 1 : 0)) | ((((rt.u128Eq(w44, v3 as rt.u128) ? 1 : 0)) << 1) & 0xff)); + const named23: rt.Result = rt.Ok(v3 as rt.i64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named23 as { ok: true; value: rt.i64 }).value))); + const into23: rt.Result = rt.Ok(v3 as rt.i64); + const w46: rt.i64 = (into23 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into23, named23) ? 1 : 0)) | ((((rt.i64Eq(w46, v3 as rt.i64) ? 1 : 0)) << 1) & 0xff)); + const named24: rt.Result = rt.Ok(v3 as rt.i128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named24 as { ok: true; value: rt.i128 }).value))); + const into24: rt.Result = rt.Ok(v3 as rt.i128); + const w48: rt.i128 = (into24 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into24, named24) ? 1 : 0)) | ((((rt.i128Eq(w48, v3 as rt.i128) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 3) { + const buf4: Uint8Array = rt.bytes(8); + const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(data, 0, n4)); + const iter4: rt.Iter = rt.iterSlice([([rt.u64FromBeBytes(buf4), rt.byteSliceRange(data, n4)] as [rt.u64, rt.ByteSlice])[0], 0, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64]); + while (true) { + const _630: rt.u64 | rt.Done = iter4.next(); + if (_630 === rt.DONE) { + break; + } + const v4: rt.u64 = _630; + const named25: rt.Result = rt.Ok(v4); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named25 as { ok: true; value: rt.u64 }).value))); + const into25: rt.Result = rt.Ok(v4); + const w50: rt.u64 = (into25 as { ok: true; value: rt.u64 }).value; + rt.byteVecPush(out, ((eq$1gq81ib(into25, named25) ? 1 : 0)) | ((((rt.u64Eq(w50, v4) ? 1 : 0)) << 1) & 0xff)); + const named26: rt.Result = rt.Ok(rt.u128Cast(v4)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named26 as { ok: true; value: rt.u128 }).value))); + const into26: rt.Result = rt.Ok(rt.u128Cast(v4)); + const w52: rt.u128 = (into26 as { ok: true; value: rt.u128 }).value; + rt.byteVecPush(out, ((eq$06vyx9e(into26, named26) ? 1 : 0)) | ((((rt.u128Eq(w52, rt.u128Cast(v4)) ? 1 : 0)) << 1) & 0xff)); + const named27: rt.Result = rt.Ok(rt.i128Cast(v4)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named27 as { ok: true; value: rt.i128 }).value))); + const into27: rt.Result = rt.Ok(rt.i128Cast(v4)); + const w54: rt.i128 = (into27 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into27, named27) ? 1 : 0)) | ((((rt.i128Eq(w54, rt.i128Cast(v4)) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 4) { + const buf5: Uint8Array = rt.bytes(16); + const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(data, 0, n5)); + const iter5: rt.Iter = rt.iterSlice([([rt.u128FromBeBytes(buf5), rt.byteSliceRange(data, n5)] as [rt.u128, rt.ByteSlice])[0], 0, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128]); + while (true) { + const _721: rt.u128 | rt.Done = iter5.next(); + if (_721 === rt.DONE) { + break; + } + const v5: rt.u128 = _721; + const named28: rt.Result = rt.Ok(v5); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named28 as { ok: true; value: rt.u128 }).value))); + const into28: rt.Result = rt.Ok(v5); + const w56: rt.u128 = (into28 as { ok: true; value: rt.u128 }).value; + rt.byteVecPush(out, ((eq$06vyx9e(into28, named28) ? 1 : 0)) | ((((rt.u128Eq(w56, v5) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 5) { + const buf6: Uint8Array = rt.bytes(4); + const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(data, 0, n6)); + const iter6: rt.Iter = rt.iterSlice([([rt.usizeFromBeBytes(buf6), rt.byteSliceRange(data, n6)] as [rt.usize, rt.ByteSlice])[0], 0, 4294967295]); + while (true) { + const _768: rt.usize | rt.Done = iter6.next(); + if (_768 === rt.DONE) { + break; + } + const v6: rt.usize = _768; + const named29: rt.Result = rt.Ok(v6); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes((named29 as { ok: true; value: rt.usize }).value))); + const into29: rt.Result = rt.Ok(v6); + const w58: rt.usize = (into29 as { ok: true; value: rt.usize }).value; + rt.byteVecPush(out, ((eq$1xhgva4(into29, named29) ? 1 : 0)) | ((((w58 === v6 ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 6) { + const buf7: Uint8Array = Uint8Array.of(0); + const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(data, 0, n7)); + const iter7: rt.Iter = rt.iterSlice([([rt.i8FromBeBytes(buf7), rt.byteSliceRange(data, n7)] as [rt.i8, rt.ByteSlice])[0], -128, 127]); + while (true) { + const _815: rt.i8 | rt.Done = iter7.next(); + if (_815 === rt.DONE) { + break; + } + const v7: rt.i8 = _815; + const named30: rt.Result = rt.Ok(v7); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes((named30 as { ok: true; value: rt.i8 }).value))); + const into30: rt.Result = rt.Ok(v7); + const w60: rt.i8 = (into30 as { ok: true; value: rt.i8 }).value; + rt.byteVecPush(out, ((eq$1hd8lo9(into30, named30) ? 1 : 0)) | ((((w60 === v7 ? 1 : 0)) << 1) & 0xff)); + const named31: rt.Result = rt.Ok(v7 as rt.i16); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((named31 as { ok: true; value: rt.i16 }).value))); + const into31: rt.Result = rt.Ok(v7 as rt.i16); + const w62: rt.i16 = (into31 as { ok: true; value: rt.i16 }).value; + rt.byteVecPush(out, ((eq$1mi4cle(into31, named31) ? 1 : 0)) | ((((w62 === v7 as rt.i16 ? 1 : 0)) << 1) & 0xff)); + const named32: rt.Result = rt.Ok(v7 as rt.i32); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named32 as { ok: true; value: rt.i32 }).value))); + const into32: rt.Result = rt.Ok(v7 as rt.i32); + const w64: rt.i32 = (into32 as { ok: true; value: rt.i32 }).value; + rt.byteVecPush(out, ((eq$1ukayff(into32, named32) ? 1 : 0)) | ((((w64 === v7 as rt.i32 ? 1 : 0)) << 1) & 0xff)); + const named33: rt.Result = rt.Ok(v7 as rt.i64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named33 as { ok: true; value: rt.i64 }).value))); + const into33: rt.Result = rt.Ok(v7 as rt.i64); + const w66: rt.i64 = (into33 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into33, named33) ? 1 : 0)) | ((((rt.i64Eq(w66, v7 as rt.i64) ? 1 : 0)) << 1) & 0xff)); + const named34: rt.Result = rt.Ok(v7 as rt.i128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named34 as { ok: true; value: rt.i128 }).value))); + const into34: rt.Result = rt.Ok(v7 as rt.i128); + const w68: rt.i128 = (into34 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into34, named34) ? 1 : 0)) | ((((rt.i128Eq(w68, v7 as rt.i128) ? 1 : 0)) << 1) & 0xff)); + const named35: rt.Result = rt.Ok(v7 as rt.isize); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named35 as { ok: true; value: rt.isize }).value))); + const into35: rt.Result = rt.Ok(v7 as rt.isize); + const w70: rt.isize = (into35 as { ok: true; value: rt.isize }).value; + rt.byteVecPush(out, ((eq$0w2dfat(into35, named35) ? 1 : 0)) | ((((w70 === v7 as rt.isize ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 7) { + const buf8: Uint8Array = rt.bytes(2); + const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(data, 0, n8)); + const iter8: rt.Iter = rt.iterSlice([([rt.i16FromBeBytes(buf8), rt.byteSliceRange(data, n8)] as [rt.i16, rt.ByteSlice])[0], -32768, 32767]); + while (true) { + const _972: rt.i16 | rt.Done = iter8.next(); + if (_972 === rt.DONE) { + break; + } + const v8: rt.i16 = _972; + const named36: rt.Result = rt.Ok(v8); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((named36 as { ok: true; value: rt.i16 }).value))); + const into36: rt.Result = rt.Ok(v8); + const w72: rt.i16 = (into36 as { ok: true; value: rt.i16 }).value; + rt.byteVecPush(out, ((eq$1mi4cle(into36, named36) ? 1 : 0)) | ((((w72 === v8 ? 1 : 0)) << 1) & 0xff)); + const named37: rt.Result = rt.Ok(v8 as rt.i32); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named37 as { ok: true; value: rt.i32 }).value))); + const into37: rt.Result = rt.Ok(v8 as rt.i32); + const w74: rt.i32 = (into37 as { ok: true; value: rt.i32 }).value; + rt.byteVecPush(out, ((eq$1ukayff(into37, named37) ? 1 : 0)) | ((((w74 === v8 as rt.i32 ? 1 : 0)) << 1) & 0xff)); + const named38: rt.Result = rt.Ok(v8 as rt.i64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named38 as { ok: true; value: rt.i64 }).value))); + const into38: rt.Result = rt.Ok(v8 as rt.i64); + const w76: rt.i64 = (into38 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into38, named38) ? 1 : 0)) | ((((rt.i64Eq(w76, v8 as rt.i64) ? 1 : 0)) << 1) & 0xff)); + const named39: rt.Result = rt.Ok(v8 as rt.i128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named39 as { ok: true; value: rt.i128 }).value))); + const into39: rt.Result = rt.Ok(v8 as rt.i128); + const w78: rt.i128 = (into39 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into39, named39) ? 1 : 0)) | ((((rt.i128Eq(w78, v8 as rt.i128) ? 1 : 0)) << 1) & 0xff)); + const named40: rt.Result = rt.Ok(v8 as rt.isize); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named40 as { ok: true; value: rt.isize }).value))); + const into40: rt.Result = rt.Ok(v8 as rt.isize); + const w80: rt.isize = (into40 as { ok: true; value: rt.isize }).value; + rt.byteVecPush(out, ((eq$0w2dfat(into40, named40) ? 1 : 0)) | ((((w80 === v8 as rt.isize ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 8) { + const buf9: Uint8Array = rt.bytes(4); + const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(data, 0, n9)); + const iter9: rt.Iter = rt.iterSlice([([rt.i32FromBeBytes(buf9), rt.byteSliceRange(data, n9)] as [rt.i32, rt.ByteSlice])[0], -2147483648, 2147483647]); + while (true) { + const _1107: rt.i32 | rt.Done = iter9.next(); + if (_1107 === rt.DONE) { + break; + } + const v9: rt.i32 = _1107; + const named41: rt.Result = rt.Ok(v9); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named41 as { ok: true; value: rt.i32 }).value))); + const into41: rt.Result = rt.Ok(v9); + const w82: rt.i32 = (into41 as { ok: true; value: rt.i32 }).value; + rt.byteVecPush(out, ((eq$1ukayff(into41, named41) ? 1 : 0)) | ((((w82 === v9 ? 1 : 0)) << 1) & 0xff)); + const named42: rt.Result = rt.Ok(v9 as rt.i64); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named42 as { ok: true; value: rt.i64 }).value))); + const into42: rt.Result = rt.Ok(v9 as rt.i64); + const w84: rt.i64 = (into42 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into42, named42) ? 1 : 0)) | ((((rt.i64Eq(w84, v9 as rt.i64) ? 1 : 0)) << 1) & 0xff)); + const named43: rt.Result = rt.Ok(v9 as rt.i128); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named43 as { ok: true; value: rt.i128 }).value))); + const into43: rt.Result = rt.Ok(v9 as rt.i128); + const w86: rt.i128 = (into43 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into43, named43) ? 1 : 0)) | ((((rt.i128Eq(w86, v9 as rt.i128) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 9) { + const buf10: Uint8Array = rt.bytes(8); + const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(data, 0, n10)); + const iter10: rt.Iter = rt.iterSlice([([rt.i64FromBeBytes(buf10), rt.byteSliceRange(data, n10)] as [rt.i64, rt.ByteSlice])[0], { hi: -0x80000000, lo: 0 } as rt.i64, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64]); + while (true) { + const _1198: rt.i64 | rt.Done = iter10.next(); + if (_1198 === rt.DONE) { + break; + } + const v10: rt.i64 = _1198; + const named44: rt.Result = rt.Ok(v10); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named44 as { ok: true; value: rt.i64 }).value))); + const into44: rt.Result = rt.Ok(v10); + const w88: rt.i64 = (into44 as { ok: true; value: rt.i64 }).value; + rt.byteVecPush(out, ((eq$1hy1is1(into44, named44) ? 1 : 0)) | ((((rt.i64Eq(w88, v10) ? 1 : 0)) << 1) & 0xff)); + const named45: rt.Result = rt.Ok(rt.i128Cast(v10)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named45 as { ok: true; value: rt.i128 }).value))); + const into45: rt.Result = rt.Ok(rt.i128Cast(v10)); + const w90: rt.i128 = (into45 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into45, named45) ? 1 : 0)) | ((((rt.i128Eq(w90, rt.i128Cast(v10)) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 10) { + const buf11: Uint8Array = rt.bytes(16); + const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(data, 0, n11)); + const iter11: rt.Iter = rt.iterSlice([([rt.i128FromBeBytes(buf11), rt.byteSliceRange(data, n11)] as [rt.i128, rt.ByteSlice])[0], { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128]); + while (true) { + const _1267: rt.i128 | rt.Done = iter11.next(); + if (_1267 === rt.DONE) { + break; + } + const v11: rt.i128 = _1267; + const named46: rt.Result = rt.Ok(v11); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named46 as { ok: true; value: rt.i128 }).value))); + const into46: rt.Result = rt.Ok(v11); + const w92: rt.i128 = (into46 as { ok: true; value: rt.i128 }).value; + rt.byteVecPush(out, ((eq$0pee78b(into46, named46) ? 1 : 0)) | ((((rt.i128Eq(w92, v11) ? 1 : 0)) << 1) & 0xff)); + } + } else if (_4 === 11) { + const buf12: Uint8Array = rt.bytes(4); + const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(data, 0, n12)); + const iter12: rt.Iter = rt.iterSlice([([rt.isizeFromBeBytes(buf12), rt.byteSliceRange(data, n12)] as [rt.isize, rt.ByteSlice])[0], -2147483648, 2147483647]); + while (true) { + const _1314: rt.isize | rt.Done = iter12.next(); + if (_1314 === rt.DONE) { + break; + } + const v12: rt.isize = _1314; + const named47: rt.Result = rt.Ok(v12); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named47 as { ok: true; value: rt.isize }).value))); + const into47: rt.Result = rt.Ok(v12); + const w94: rt.isize = (into47 as { ok: true; value: rt.isize }).value; + rt.byteVecPush(out, ((eq$0w2dfat(into47, named47) ? 1 : 0)) | ((((w94 === v12 ? 1 : 0)) << 1) & 0xff)); + } + } else { + const buf13: Uint8Array = Uint8Array.of(0); + const n13: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf13).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf13), 0, n13), rt.byteSliceRange(data, 0, n13)); + const iter13: rt.Iter = rt.iterSlice(Uint8Array.of(([rt.u8FromBeBytes(buf13), rt.byteSliceRange(data, n13)] as [rt.u8, rt.ByteSlice])[0], 0, 255)); + while (true) { + const _1361: rt.u8 | rt.Done = iter13.next(); + if (_1361 === rt.DONE) { + break; + } + const b2: rt.u8 = _1361; + const iter14: rt.Iter = rt.iterSlice([b2 as rt.char, 0, 1114111]); + while (true) { + const _1371: rt.char | rt.Done = iter14.next(); + if (_1371 === rt.DONE) { + break; + } + const c2: rt.char = _1371; + const wide: rt.Result = rt.Ok(c2 as rt.u32); + const wider: rt.Result = rt.Ok(c2 as rt.u64); + const widest: rt.Result = rt.Ok(c2 as rt.u128); + const a: rt.u32 = (wide as { ok: true; value: rt.u32 }).value; + const b3: rt.u64 = (wider as { ok: true; value: rt.u64 }).value; + const c3: rt.u128 = (widest as { ok: true; value: rt.u128 }).value; + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b3))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(c3))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(Scaled.from$From_u8(b2)._0))); + } + } +} + //# sourceMappingURL=ints.ts.map diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 92622d60d..24801bde2 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -151,6 +151,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("strs::iters", strs::iters), ("strs::drains", strs::drains), ("strs::hinted", strs::hinted), + ("ints::widenings", ints::widenings), ] } diff --git a/ts/fixtures/lang/src/ints.rs b/ts/fixtures/lang/src/ints.rs index 572ba1013..8d6940811 100644 --- a/ts/fixtures/lang/src/ints.rs +++ b/ts/fixtures/lang/src/ints.rs @@ -1,6 +1,7 @@ //! Every integer type's arithmetic, one operation per case so a panic hides nothing, and //! its parsing. +use std::convert::Infallible; use std::num::IntErrorKind; /// Take an integer's big-endian bytes from the front of `data`, zero-padded. @@ -452,3 +453,73 @@ pub fn parses(kind: u8, data: &[u8], out: &mut Vec) { 11 => isize, 32, isize::MAX as u128 + 1; } } + +/// Each conversion from `$from` that can't fail, of what `data` holds and the type's +/// limits: `try_from` and `try_into` as std types them, `Result<_, Infallible>`. +macro_rules! widen { + ($data:expr, $out:expr, $from:ty => $($to:ty),+) => {{ + let (taken, _) = take!($from, $data); + for v in [taken, <$from>::MIN, <$from>::MAX] { + $( + let named: Result<$to, Infallible> = <$to>::try_from(v); + match named { + Ok(w) => $out.extend_from_slice(&w.to_be_bytes()), + Err(never) => match never {}, + } + let into: Result<$to, Infallible> = v.try_into(); + let Ok(w) = into; + $out.push(u8::from(into == named) | u8::from(w == <$to>::from(v)) << 1); + )+ + } + }}; +} + +/// Every integer conversion that can't fail on wasm32, from the type `kind` picks: to +/// itself, wider, and to `usize` and `isize` where std has `From`; and a `char`'s and the +/// crate's own, which convert the same way. +pub fn widenings(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 13 { + 0 => widen!(data, out, u8 => u8, u16, u32, u64, u128, usize, i16, i32, i64, i128, isize), + 1 => widen!(data, out, u16 => u16, u32, u64, u128, usize, i32, i64, i128), + 2 => widen!(data, out, u32 => u32, u64, u128, i64, i128), + 3 => widen!(data, out, u64 => u64, u128, i128), + 4 => widen!(data, out, u128 => u128), + 5 => widen!(data, out, usize => usize), + 6 => widen!(data, out, i8 => i8, i16, i32, i64, i128, isize), + 7 => widen!(data, out, i16 => i16, i32, i64, i128, isize), + 8 => widen!(data, out, i32 => i32, i64, i128), + 9 => widen!(data, out, i64 => i64, i128), + 10 => widen!(data, out, i128 => i128), + 11 => widen!(data, out, isize => isize), + _ => { + let (b, _) = take!(u8, data); + for b in [b, u8::MIN, u8::MAX] { + let named: Result = char::try_from(b); + let Ok(c) = named; + for c in [c, char::MIN, char::MAX] { + let wide: Result = u32::try_from(c); + let wider: Result = c.try_into(); + let widest: Result = c.try_into(); + let Ok(a) = wide; + let Ok(b) = wider; + let Ok(c) = widest; + out.extend_from_slice(&a.to_be_bytes()); + out.extend_from_slice(&b.to_be_bytes()); + out.extend_from_slice(&c.to_be_bytes()); + } + let own: Result = b.try_into(); + let Ok(Scaled(s)) = own; + out.extend_from_slice(&s.to_be_bytes()); + } + } + } +} + +/// A type of the crate's own that `From` makes, which `try_from` converts by. +struct Scaled(u32); + +impl From for Scaled { + fn from(b: u8) -> Self { + Scaled(u32::from(b) * 1000) + } +} diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 308a9a110..2ab4394b6 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1161,6 +1161,15 @@ fn mapping<'tcx>( "TryFrom" => (targ(gargs, 0), targ(gargs, 1)), _ => (targ(gargs, 1), targ(gargs, 0)), }; + // Where `From` holds, std's blanket impl converts by it and can't fail: its error + // is `Infallible`, which is `!`. + if let ty::Adt(_, result) = b.t.sig(call.def_id, call.args).output().kind() + && result.type_at(1).is_never() + { + let mut values = args; + let value = b.convert(values.pop()?, from, to, span, out); + return Some(Expr::rt("Ok", vec![value])); + } let (Some(int), Some(_)) = (Int::of(to), Int::of(from)) else { return None; };