diff --git a/quest/m3/README.md b/quest/m3/README.md index 5d90063f4..73b49b14e 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -32,7 +32,6 @@ generic std gap is planned here even when moq never calls it. - [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 - [Folds from the back, and a crate's own folds](/quest/m3/ts-iter-back-folds.md) - `rfold` and `try_rfold` translate, and so does a crate's iterator that overrides `fold` or `nth_back` -- [A comparison of two constants](/quest/m3/ts-constant-compares.md) - `size_of::() == 1` in a generic function translates to TypeScript `tsc` accepts - [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number - [Rc and Arc of a slice](/quest/m3/ts-shared-slices.md) - `Rc<[T]>` and `Arc<[T]>` from a `Vec`, a slice, or an iterator translate diff --git a/quest/m3/ts-constant-compares.md b/quest/m3/ts-constant-compares.md deleted file mode 100644 index 7f3e67e24..000000000 --- a/quest/m3/ts-constant-compares.md +++ /dev/null @@ -1,18 +0,0 @@ -# [S] A comparison of two constants - -## Goal - -[rust2-ts](/ts/README.md) translates a comparison whose sides are both constants once a -generic function is monomorphized, such as `size_of::() == 1` in a function generic -over `T`, into TypeScript `tsc` accepts, proven by a fixture that runs it for a `T` of each -outcome against native Rust. - -## Plan - -Found writing the deque's slices fixture -([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): each instance writes -`12 === 1`, which `tsc` rejects as TS2367, two literal types with no overlap, so the -crate fails to translate. Fold the comparison to its value, or widen a side, where both are -literals. - -Public API: the translator's output. diff --git a/ts/Cargo.lock b/ts/Cargo.lock index e808baebe..3f4c54c6e 100644 --- a/ts/Cargo.lock +++ b/ts/Cargo.lock @@ -223,6 +223,10 @@ version = "0.0.0" name = "lang-combinators-fixture" version = "0.0.0" +[[package]] +name = "lang-constants-fixture" +version = "0.0.0" + [[package]] name = "lang-conversions-fixture" version = "0.0.0" diff --git a/ts/fixtures/lang/constants/Cargo.toml b/ts/fixtures/lang/constants/Cargo.toml new file mode 100644 index 000000000..b5fb15606 --- /dev/null +++ b/ts/fixtures/lang/constants/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "lang-constants-fixture" +description = "A part of the language rust2-ts translates, exercised against native Rust" +version = "0.0.0" +edition.workspace = true +license.workspace = true +publish = false + +[lib] +# The cdylib is the native side of the differential test, built for wasm32. +crate-type = ["lib", "cdylib"] + +[lints] +workspace = true diff --git a/ts/fixtures/lang/constants/expected/constants.ts b/ts/fixtures/lang/constants/expected/constants.ts new file mode 100644 index 000000000..0bd10ec33 --- /dev/null +++ b/ts/fixtures/lang/constants/expected/constants.ts @@ -0,0 +1,253 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** `T`'s constants compared with [`Mid`]'s. */ +export function against$u16(out: rt.ByteVec): void { + let _255!: rt.u8; + let _259!: rt.u8; + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a0: boolean): rt.u8 => { + return a0 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a02: boolean): rt.u8 => { + return a02 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a03: boolean): rt.u8 => { + return a03 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a04: boolean): rt.u8 => { + return a04 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, rt.u64Lt(2, 2), rt.u64Le(2, 2), rt.u64Gt(2, 2), rt.u64Ge(2, 2)], (a05: boolean): rt.u8 => { + return a05 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, rt.i128Lt(0, 0), rt.i128Le(0, 0), rt.i128Gt(0, 0), rt.i128Ge(0, 0)], (a06: boolean): rt.u8 => { + return a06 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a07: boolean): rt.u8 => { + return a07 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a08: boolean): rt.u8 => { + return a08 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a09: boolean): rt.u8 => { + return a09 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a010: boolean): rt.u8 => { + return a010 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-2, -2), rt.i128Ne(-2, -2), rt.i128Lt(-2, -2), rt.i128Le(-2, -2), rt.i128Gt(-2, -2), rt.i128Ge(-2, -2)], (a011: boolean): rt.u8 => { + return a011 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(2 as rt.char) === 2 as rt.char, (2 as rt.char) !== 2 as rt.char, (2 as rt.char) < (2 as rt.char), (2 as rt.char) <= (2 as rt.char), (2 as rt.char) > (2 as rt.char), (2 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + return a012 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a013: boolean): rt.u8 => { + return a013 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a014: boolean): rt.u8 => { + return a014 ? 1 : 0; + })), undefined, true); + if (false) { + _255 = 0; + } else { + _255 = 1; + } + rt.byteVecPush(out, _255); + if (true) { + _259 = 4; + } else { + _259 = 3; + } + rt.byteVecPush(out, _259); +} + +/** `T`'s constants compared with [`Mid`]'s. */ +export function against$u64(out: rt.ByteVec): void { + let _255!: rt.u8; + let _259!: rt.u8; + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a0: boolean): rt.u8 => { + return a0 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a02: boolean): rt.u8 => { + return a02 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a03: boolean): rt.u8 => { + return a03 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a04: boolean): rt.u8 => { + return a04 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.u64Lt(3, 2), rt.u64Le(3, 2), rt.u64Gt(3, 2), rt.u64Ge(3, 2)], (a05: boolean): rt.u8 => { + return a05 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.i128Lt(1, 0), rt.i128Le(1, 0), rt.i128Gt(1, 0), rt.i128Ge(1, 0)], (a06: boolean): rt.u8 => { + return a06 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a07: boolean): rt.u8 => { + return a07 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a08: boolean): rt.u8 => { + return a08 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a09: boolean): rt.u8 => { + return a09 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a010: boolean): rt.u8 => { + return a010 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-1, -2), rt.i128Ne(-1, -2), rt.i128Lt(-1, -2), rt.i128Le(-1, -2), rt.i128Gt(-1, -2), rt.i128Ge(-1, -2)], (a011: boolean): rt.u8 => { + return a011 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(3 as rt.char) === 2 as rt.char, (3 as rt.char) !== 2 as rt.char, (3 as rt.char) < (2 as rt.char), (3 as rt.char) <= (2 as rt.char), (3 as rt.char) > (2 as rt.char), (3 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + return a012 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a013: boolean): rt.u8 => { + return a013 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a014: boolean): rt.u8 => { + return a014 ? 1 : 0; + })), undefined, true); + if (true) { + _255 = 0; + } else { + _255 = 1; + } + rt.byteVecPush(out, _255); + if (true) { + _259 = 4; + } else { + _259 = 3; + } + rt.byteVecPush(out, _259); +} + +/** `T`'s constants compared with [`Mid`]'s. */ +export function against$u8(out: rt.ByteVec): void { + let _255!: rt.u8; + let _259!: rt.u8; + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a0: boolean): rt.u8 => { + return a0 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a02: boolean): rt.u8 => { + return a02 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a03: boolean): rt.u8 => { + return a03 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a04: boolean): rt.u8 => { + return a04 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.u64Lt(1, 2), rt.u64Le(1, 2), rt.u64Gt(1, 2), rt.u64Ge(1, 2)], (a05: boolean): rt.u8 => { + return a05 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.i128Lt(-1, 0), rt.i128Le(-1, 0), rt.i128Gt(-1, 0), rt.i128Ge(-1, 0)], (a06: boolean): rt.u8 => { + return a06 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a07: boolean): rt.u8 => { + return a07 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a08: boolean): rt.u8 => { + return a08 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a09: boolean): rt.u8 => { + return a09 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a010: boolean): rt.u8 => { + return a010 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-3, -2), rt.i128Ne(-3, -2), rt.i128Lt(-3, -2), rt.i128Le(-3, -2), rt.i128Gt(-3, -2), rt.i128Ge(-3, -2)], (a011: boolean): rt.u8 => { + return a011 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(1 as rt.char) === 2 as rt.char, (1 as rt.char) !== 2 as rt.char, (1 as rt.char) < (2 as rt.char), (1 as rt.char) <= (2 as rt.char), (1 as rt.char) > (2 as rt.char), (1 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + return a012 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a013: boolean): rt.u8 => { + return a013 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a014: boolean): rt.u8 => { + return a014 ? 1 : 0; + })), undefined, true); + if (true) { + _255 = 0; + } else { + _255 = 1; + } + rt.byteVecPush(out, _255); + if (false) { + _259 = 4; + } else { + _259 = 3; + } + rt.byteVecPush(out, _259); +} + +/** `T`'s constants compared with [`Mid`]'s. */ +export function against$unit(out: rt.ByteVec): void { + let _255!: rt.u8; + let _259!: rt.u8; + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a0: boolean): rt.u8 => { + return a0 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a02: boolean): rt.u8 => { + return a02 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a03: boolean): rt.u8 => { + return a03 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a04: boolean): rt.u8 => { + return a04 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64) === 2, ({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64) !== 2, rt.u64Lt({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2), rt.u64Le({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2), rt.u64Gt({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2), rt.u64Ge({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2)], (a05: boolean): rt.u8 => { + return a05 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) === 0, ({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) !== 0, rt.i128Lt({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0), rt.i128Le({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0), rt.i128Gt({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0), rt.i128Ge({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0)], (a06: boolean): rt.u8 => { + return a06 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a07: boolean): rt.u8 => { + return a07 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a08: boolean): rt.u8 => { + return a08 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a09: boolean): rt.u8 => { + return a09 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, false, false], (a010: boolean): rt.u8 => { + return a010 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-2147483648, -2), rt.i128Ne(-2147483648, -2), rt.i128Lt(-2147483648, -2), rt.i128Le(-2147483648, -2), rt.i128Gt(-2147483648, -2), rt.i128Ge(-2147483648, -2)], (a011: boolean): rt.u8 => { + return a011 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(255 as rt.char) === 2 as rt.char, (255 as rt.char) !== 2 as rt.char, (255 as rt.char) < (2 as rt.char), (255 as rt.char) <= (2 as rt.char), (255 as rt.char) > (2 as rt.char), (255 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + return a012 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a013: boolean): rt.u8 => { + return a013 ? 1 : 0; + })), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a014: boolean): rt.u8 => { + return a014 ? 1 : 0; + })), undefined, true); + if (true) { + _255 = 0; + } else { + _255 = 1; + } + rt.byteVecPush(out, _255); + if (true) { + _259 = 4; + } else { + _259 = 3; + } + rt.byteVecPush(out, _259); +} + +/** The constants of each type compared with [`Mid`]'s. */ +export function compares(out: rt.ByteVec): void { + against$u8(out); + against$u16(out); + against$u64(out); + against$unit(out); +} + +//# sourceMappingURL=constants.ts.map diff --git a/ts/fixtures/lang/constants/expected/harness.ts b/ts/fixtures/lang/constants/expected/harness.ts new file mode 100644 index 000000000..58ec1cf62 --- /dev/null +++ b/ts/fixtures/lang/constants/expected/harness.ts @@ -0,0 +1,40 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { cases } from "./lib.ts"; + +/** Run one case. */ +export function run(input: rt.ByteSlice): rt.ByteVec { + const out: rt.ByteVec = new rt.ByteVec(); + if (!(input.length >= 3)) { + return out; + } + const cases_: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] = cases(); + cases_[rt.idx(cases_, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + return out; +} + +/** + * The first two bytes, as one big-endian number, that pick the case named `name`, which + * `lang.ts` targets by. + */ +export function op(name: string): rt.u16 { + const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases()), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { + return _2[0] === name; + }); + if (_11 !== undefined) { + const _20: rt.Result = rt.u16TryFrom(_11); + if (_20.ok) { + if ((_20.value >> 8) !== 255) { + return _20.value; + } + } + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; + rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + } else { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; + rt.panicFmt(["no case ", args2[0]]); + } +} + +//# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/constants/expected/lib.ts b/ts/fixtures/lang/constants/expected/lib.ts new file mode 100644 index 000000000..b4f74630c --- /dev/null +++ b/ts/fixtures/lang/constants/expected/lib.ts @@ -0,0 +1,16 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { compares } from "./constants.ts"; + +/** + * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo + * their count, so a case added at the end moves no other. + */ +export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] { + return [["constants::compares", (_22: rt.u8, _32: rt.ByteSlice, out: rt.ByteVec): undefined => { + compares(out); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; +} + +//# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/constants/src/constants.rs b/ts/fixtures/lang/constants/src/constants.rs new file mode 100644 index 000000000..43061ce92 --- /dev/null +++ b/ts/fixtures/lang/constants/src/constants.rs @@ -0,0 +1,109 @@ +//! Comparisons whose sides are both constants once a generic function is instantiated, as +//! `size_of::() == 1` is: each operator on each kind of constant, written in place, +//! cast, and held in a temporary, for a `T` of each outcome. + +use std::mem::size_of; + +/// A type's constant of each kind. +trait Consts { + const U8: u8; + const I32: i32; + const U64: u64; + const I128: i128; + const BOOL: bool; + const CHAR: char; + const F32: f32; + const F64: f64; +} + +/// Below [`Mid`] in each. +type Low = u8; + +/// What each compares with. +type Mid = u16; + +/// Above [`Mid`] in each. +type High = u64; + +/// The limits, a NaN, and a negative zero. +type Edge = (); + +impl Consts for Low { + const U8: u8 = 1; + const I32: i32 = -3; + const U64: u64 = 1; + const I128: i128 = -1; + const BOOL: bool = false; + const CHAR: char = 'a'; + const F32: f32 = -1.5; + const F64: f64 = -1.5; +} + +impl Consts for Mid { + const U8: u8 = 2; + const I32: i32 = -2; + const U64: u64 = 2; + const I128: i128 = 0; + const BOOL: bool = true; + const CHAR: char = 'b'; + const F32: f32 = 0.0; + const F64: f64 = 0.0; +} + +impl Consts for High { + const U8: u8 = 3; + const I32: i32 = -1; + const U64: u64 = 3; + const I128: i128 = 1; + const BOOL: bool = true; + const CHAR: char = 'c'; + const F32: f32 = 1.5; + const F64: f64 = 1.5; +} + +impl Consts for Edge { + const U8: u8 = u8::MAX; + const I32: i32 = i32::MIN; + const U64: u64 = u64::MAX; + const I128: i128 = i128::MAX; + const BOOL: bool = false; + const CHAR: char = char::MAX; + const F32: f32 = -0.0; + const F64: f64 = f64::NAN; +} + +/// Each operator on `$a` and `$b`, a byte each. +macro_rules! compare { + ($out:ident, $a:expr, $b:expr) => { + $out.extend([$a == $b, $a != $b, $a < $b, $a <= $b, $a > $b, $a >= $b].map(u8::from)) + }; +} + +/// `T`'s constants compared with [`Mid`]'s. +fn against(out: &mut Vec) { + compare!(out, size_of::(), 2); + compare!(out, size_of::(), size_of::()); + compare!(out, T::U8, Mid::U8); + compare!(out, T::I32, Mid::I32); + compare!(out, T::U64, Mid::U64); + compare!(out, T::I128, Mid::I128); + compare!(out, T::BOOL, Mid::BOOL); + compare!(out, T::CHAR, Mid::CHAR); + compare!(out, T::F32, Mid::F32); + compare!(out, T::F64, Mid::F64); + compare!(out, T::I32 as i128, Mid::I32 as i128); + compare!(out, T::U8 as char, Mid::U8 as char); + // Folded into a literal, the quotient compares from its temporary. + compare!(out, T::U8 / 2, Mid::U8 / 2); + compare!(out, T::I32 % 2, Mid::I32 % 2); + out.push(if size_of::() == 2 { 1 } else { 0 }); + out.push(if T::CHAR < 'b' { 3 } else { 4 }); +} + +/// The constants of each type compared with [`Mid`]'s. +pub fn compares(out: &mut Vec) { + against::(out); + against::(out); + against::(out); + against::(out); +} diff --git a/ts/fixtures/lang/constants/src/lib.rs b/ts/fixtures/lang/constants/src/lib.rs new file mode 100644 index 000000000..ce9b2f36c --- /dev/null +++ b/ts/fixtures/lang/constants/src/lib.rs @@ -0,0 +1,19 @@ +//! A part of the language the driver translates, exercised against native Rust: what +//! each of its modules says. + +mod constants; +#[path = "../../harness.rs"] +pub mod harness; +#[cfg(target_arch = "wasm32")] +#[path = "../../../wasm.rs"] +mod wasm; +#[cfg(target_arch = "wasm32")] +use harness::run as entry; + +use harness::Case; + +/// Each case's name and what it runs. The first two bytes, big-endian, pick one modulo +/// their count, so a case added at the end moves no other. +fn cases() -> Vec<(&'static str, Case)> { + vec![("constants::compares", |_, _, out| constants::compares(out))] +} diff --git a/ts/fixtures/lang/constants/ts.toml b/ts/fixtures/lang/constants/ts.toml new file mode 100644 index 000000000..5fd371a73 --- /dev/null +++ b/ts/fixtures/lang/constants/ts.toml @@ -0,0 +1,2 @@ +package = "lang-constants-fixture" +roots = ["harness::run", "harness::op"] diff --git a/ts/fixtures/lang/errors/expected/core/num.ts b/ts/fixtures/lang/errors/expected/core/num.ts index 29c91af3f..1824fd8bb 100644 --- a/ts/fixtures/lang/errors/expected/core/num.ts +++ b/ts/fixtures/lang/errors/expected/core/num.ts @@ -196,7 +196,7 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -204,7 +204,7 @@ export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -128; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -352,19 +352,19 @@ export function fromStr$0zyj6he(src: string): rt.Result { - return fromStrRadix$0s9rspw(src, 10); +export function fromStr$029r9bb(src: string): rt.Result { + return fromStrRadix$0dg9fx3(src, 10); } export function fromStrRadix$0366bau(src: string, radix: rt.u32): rt.Result { return fromAsciiBytesRadixImpl$0xhcrxt(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0s9rspw(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$18og5o1(rt.stringAsBytes(src), radix); +export function fromStrRadix$0dg9fx3(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0k9pjln(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -372,7 +372,7 @@ export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { @@ -668,7 +668,7 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -676,7 +676,7 @@ export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -824,16 +824,16 @@ export function fromStr$1ypcnp8(src: string): rt.Result { - return fromStrRadix$0nj08um(src, 10); +export function fromStr$1s51v8m(src: string): rt.Result { + return fromStrRadix$1s6gdoj(src, 10); } export function fromStrRadix$1gp4jqq(src: string, radix: rt.u32): rt.Result { return fromAsciiBytesRadixImpl$02xpj41(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0nj08um(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1n9fygl(rt.stringAsBytes(src), radix); +export function fromStrRadix$1s6gdoj(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$037x42t(rt.stringAsBytes(src), radix); } //# sourceMappingURL=num.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/num/nonzero.ts b/ts/fixtures/lang/errors/expected/core/num/nonzero.ts index 18d557d6e..84efe0fe9 100644 --- a/ts/fixtures/lang/errors/expected/core/num/nonzero.ts +++ b/ts/fixtures/lang/errors/expected/core/num/nonzero.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../../rt.ts"; -import { fromAsciiBytesRadixImpl$0ax4wbr as num_fromAsciiBytesRadixImpl$0ax4wbr } from "../../core/num.ts"; +import { fromAsciiBytesRadixImpl$1xmrosk as num_fromAsciiBytesRadixImpl$1xmrosk } from "../../core/num.ts"; -export function fromAsciiBytesRadixImpl$0v1vsb2(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0ax4wbr(src, radix); +export function fromAsciiBytesRadixImpl$1e6dyne(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1xmrosk(src, radix); if (_3.ok) { const _7: rt.u32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -15,12 +15,12 @@ export function fromAsciiBytesRadixImpl$0v1vsb2(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0gvyqp3(src: string): rt.Result { - return fromStrRadix$18imw6k(src, 10); +export function fromStr$0pscojv(src: string): rt.Result { + return fromStrRadix$14vzugb(src, 10); } -export function fromStrRadix$18imw6k(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0v1vsb2(rt.stringAsBytes(src), radix); +export function fromStrRadix$14vzugb(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1e6dyne(rt.stringAsBytes(src), radix); } //# sourceMappingURL=nonzero.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/str.ts b/ts/fixtures/lang/errors/expected/core/str.ts index 36543d824..9624812ec 100644 --- a/ts/fixtures/lang/errors/expected/core/str.ts +++ b/ts/fixtures/lang/errors/expected/core/str.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa } from "../core/num.ts"; -import { fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3 } from "../core/num/nonzero.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$029r9bb as num_fromStr$029r9bb, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1s51v8m as num_fromStr$1s51v8m } from "../core/num.ts"; +import { fromStr$0pscojv as nonzero_fromStr$0pscojv } from "../core/num/nonzero.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "../core/str/traits.ts"; export function parse$0vh4cry(self: string): rt.Result { @@ -13,20 +13,20 @@ export function parse$082ztwj(self: string): rt.Result { - return num_fromStr$0ovlgjd(self); +export function parse$14z7a72(self: string): rt.Result { + return num_fromStr$029r9bb(self); } -export function parse$1s5pqso(self: string): rt.Result { - return nonzero_fromStr$0gvyqp3(self); +export function parse$00ibreq(self: string): rt.Result { + return nonzero_fromStr$0pscojv(self); } export function parse$0o4ono0(self: string): rt.Result { return num_fromStr$1ypcnp8(self); } -export function parse$0at0fdl(self: string): rt.Result { - return num_fromStr$1hq0zfa(self); +export function parse$0vh70p5(self: string): rt.Result { + return num_fromStr$1s51v8m(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/errors/expected/errors.ts b/ts/fixtures/lang/errors/expected/errors.ts index 8c1fb0712..10f27c8d6 100644 --- a/ts/fixtures/lang/errors/expected/errors.ts +++ b/ts/fixtures/lang/errors/expected/errors.ts @@ -5,11 +5,11 @@ import { drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send, drop$errors import { then$0afp4no } from "./core/bool.ts"; import { eq$09vw48j as convert_eq$09vw48j } from "./core/char/convert.ts"; import type * as Error from "./core/error.Error.ts"; -import { fromStr$1hq0zfa as num_fromStr$1hq0zfa } from "./core/num.ts"; +import { fromStr$1s51v8m as num_fromStr$1s51v8m } from "./core/num.ts"; import { eq$18sin5z as num_error_eq$18sin5z } from "./core/num/error.ts"; import { map$0frk5o8 as option_map$0frk5o8, map$03ygfmn as option_map$03ygfmn, map$0ukfexb as option_map$0ukfexb } from "./core/option.ts"; import { eq$04qb8k3 as result_eq$04qb8k3, eq$10fppe8 as result_eq$10fppe8, eq$0ecfqx9 as result_eq$0ecfqx9, eq$0nlhjpf as result_eq$0nlhjpf, eq$04iua4k as result_eq$04iua4k, eq$1dhtbkj as result_eq$1dhtbkj, eq$0pe0qmq as result_eq$0pe0qmq, eq$1mpp8xa as result_eq$1mpp8xa, eq$0grmb7g as result_eq$0grmb7g, eq$19kc15f as result_eq$19kc15f, eq$0rj0czq as result_eq$0rj0czq, eq$1hq3neq as result_eq$1hq3neq, eq$08241oi as result_eq$08241oi, eq$0bl30vt as result_eq$0bl30vt, eq$1fkhuzl as result_eq$1fkhuzl, eq$0p1bb4y as result_eq$0p1bb4y, eq$03gbayb as result_eq$03gbayb, err$1ujom0k, err$02r96h1, err$0jf6smd, map$0fm1w6u as result_map$0fm1w6u, map$0d23w2b as result_map$0d23w2b, map$0r57egs as result_map$0r57egs, mapErr$1ibyj9t as result_mapErr$1ibyj9t, mapErr$0pzoye2 as result_mapErr$0pzoye2, mapErr$09yhde7 as result_mapErr$09yhde7, mapErr$1ff8zoy as result_mapErr$1ff8zoy, mapErr$0u5yxjj as result_mapErr$0u5yxjj } from "./core/result.ts"; -import { parse$0vh4cry, parse$082ztwj, parse$1ci7nyc, parse$1s5pqso, parse$0o4ono0, parse$0at0fdl } from "./core/str.ts"; +import { parse$0vh4cry, parse$082ztwj, parse$14z7a72, parse$00ibreq, parse$0o4ono0, parse$0vh70p5 } from "./core/str.ts"; import { eq$1f3e51k as str_error_eq$1f3e51k } from "./core/str/error.ts"; import type * as Coded from "./errors.Coded.ts"; import * as Failure from "./errors.Failure.ts"; @@ -412,13 +412,13 @@ export function parsed$i128(all: string[]): rt.Result export function parsed$i8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1ci7nyc(s); + return parse$14z7a72(s); }), undefined, 2, true); } export function parsed$num_NonZero_u32(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1s5pqso(s); + return parse$00ibreq(s); }), undefined, 8, true); } @@ -430,7 +430,7 @@ export function parsed$u64(all: string[]): rt.Result[] export function parsed$u8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0at0fdl(s); + return parse$0vh70p5(s); }), undefined, 2, true); } @@ -495,7 +495,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true), out); } else if (_32 === 12) { pairs$Result_Option_u8_num_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s6: string): rt.Result => { - return result_map$0r57egs(parse$0at0fdl(s6), (v10: rt.u8): rt.u8 | undefined => { + return result_map$0r57egs(parse$0vh70p5(s6), (v10: rt.u8): rt.u8 | undefined => { return rt.u8CheckedSub(v10, 1); }); }), undefined, 2, true), out); @@ -506,7 +506,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); }), undefined, 8, true), out); pairs$Result_u8_num_IntErrorKind(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s8: string): rt.Result => { - return result_mapErr$0u5yxjj(parse$0at0fdl(s8), (e: rt.ParseIntError): rt.IntErrorKind => { + return result_mapErr$0u5yxjj(parse$0vh70p5(s8), (e: rt.ParseIntError): rt.IntErrorKind => { return e.kind; }); }), undefined, 2, true), out); @@ -524,7 +524,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { pairs$Option_Result_u8_num_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result | undefined => { const _73: string = s; return then$0afp4no(!((s.length === 0)), (): rt.Result => { - return parse$0at0fdl(_73); + return parse$0vh70p5(_73); }); }), undefined, 2, true), out); pairs$Vec_Result_bool_str_ParseBoolError(rt.iterToArray(rt.iterMap(rt.sliceChunks(all, 2), parsed$bool), undefined, 12, true), out); @@ -538,7 +538,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return err$1ujom0k(parse$0vh4cry(s4)); }), "next", 0), out); pairs$num_ParseIntError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s5: string): rt.ParseIntError | undefined => { - return err$0jf6smd(parse$1ci7nyc(s5)); + return err$0jf6smd(parse$14z7a72(s5)); }), "next", 1), out); } } @@ -579,14 +579,14 @@ export function failure(kind: rt.u8, n: rt.u8): Failure.Failure { if (!(_11 < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _11); } - return { tag: "Parse", _0: rt.resultUnwrapErr(num_fromStr$1hq0zfa(["", "x", "999"][_11]), rt.u8Debug) } as Failure.Failure; + return { tag: "Parse", _0: rt.resultUnwrapErr(num_fromStr$1s51v8m(["", "x", "999"][_11]), rt.u8Debug) } as Failure.Failure; } /** `?` boxes a `Failure` as a `dyn Error`, as does `into`. */ export function checked(kind: rt.u8, n: rt.u8): rt.Result { if (!(rt.u8Rem(n, 4) === 0)) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - const _8: rt.Result = result_mapErr$1ff8zoy(num_fromStr$1hq0zfa(rt.fmtFormat([args2[0], args2[0]])), (a0: rt.ParseIntError): Failure.Failure => { + const _8: rt.Result = result_mapErr$1ff8zoy(num_fromStr$1s51v8m(rt.fmtFormat([args2[0], args2[0]])), (a0: rt.ParseIntError): Failure.Failure => { return { tag: "Parse", _0: a0 }; }); if (_8.ok) { @@ -612,7 +612,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number _29[Symbol.dispose](); drop$errors_Failure(_24); put(out, _17); - const part = chain(new of$num_ParseIntError(rt.resultUnwrapErr(num_fromStr$1hq0zfa("x"), rt.u8Debug))); + const part = chain(new of$num_ParseIntError(rt.resultUnwrapErr(num_fromStr$1s51v8m("x"), rt.u8Debug))); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; put(out, rt.fmtFormat([args4[0], " | "])); const held: Failure.Failure = failure(a, b); @@ -668,7 +668,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const part7 = downcast(coded2); const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part7)]; put(out, rt.fmtFormat([args24[0], " "])); - const errors: Error.Error[] = [coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rt.resultUnwrapErr(num_fromStr$1hq0zfa("x"), rt.u8Debug))]; + const errors: Error.Error[] = [coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rt.resultUnwrapErr(num_fromStr$1s51v8m("x"), rt.u8Debug))]; for (const _255 of errors) { const part8 = downcast(_255); const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part8)]; diff --git a/ts/fixtures/lang/ints/expected/core/num.ts b/ts/fixtures/lang/ints/expected/core/num.ts index 73e77f237..000e4a96c 100644 --- a/ts/fixtures/lang/ints/expected/core/num.ts +++ b/ts/fixtures/lang/ints/expected/core/num.ts @@ -203,7 +203,7 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -211,7 +211,7 @@ export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -32768; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -355,7 +355,7 @@ export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0p2idzk(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -363,7 +363,7 @@ export function fromAsciiBytesRadixImpl$0p2idzk(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -2147483648; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -659,7 +659,7 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -667,7 +667,7 @@ export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -128; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -811,7 +811,7 @@ export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$05ylgyc(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -819,7 +819,7 @@ export function fromAsciiBytesRadixImpl$05ylgyc(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -2147483648; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -967,48 +967,48 @@ export function fromStr$0zyj6he(src: string): rt.Result { - return fromStrRadix$02mhuxs(src, 10); +export function fromStr$15pqb75(src: string): rt.Result { + return fromStrRadix$0rk2yr6(src, 10); } -export function fromStr$0zhqfgx(src: string): rt.Result { - return fromStrRadix$1bgm1z0(src, 10); +export function fromStr$0lmxi6o(src: string): rt.Result { + return fromStrRadix$1newkmi(src, 10); } export function fromStr$116mp4t(src: string): rt.Result { return fromStrRadix$11y6fsf(src, 10); } -export function fromStr$0ovlgjd(src: string): rt.Result { - return fromStrRadix$0s9rspw(src, 10); +export function fromStr$029r9bb(src: string): rt.Result { + return fromStrRadix$0dg9fx3(src, 10); } -export function fromStr$1grmucc(src: string): rt.Result { - return fromStrRadix$1473bi0(src, 10); +export function fromStr$1v63ugw(src: string): rt.Result { + return fromStrRadix$16jk9zm(src, 10); } export function fromStrRadix$0366bau(src: string, radix: rt.u32): rt.Result { return fromAsciiBytesRadixImpl$0xhcrxt(rt.stringAsBytes(src), radix); } -export function fromStrRadix$02mhuxs(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0jbbuu8(rt.stringAsBytes(src), radix); +export function fromStrRadix$0rk2yr6(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0ut8llb(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1bgm1z0(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0p2idzk(rt.stringAsBytes(src), radix); +export function fromStrRadix$1newkmi(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1ykgy6m(rt.stringAsBytes(src), radix); } export function fromStrRadix$11y6fsf(src: string, radix: rt.u32): rt.Result { return fromAsciiBytesRadixImpl$01tfvb9(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0s9rspw(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$18og5o1(rt.stringAsBytes(src), radix); +export function fromStrRadix$0dg9fx3(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0k9pjln(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1473bi0(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$05ylgyc(rt.stringAsBytes(src), radix); +export function fromStrRadix$16jk9zm(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1hpkcx2(rt.stringAsBytes(src), radix); } export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32): rt.Result { @@ -1163,7 +1163,7 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1171,7 +1171,7 @@ export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -1315,7 +1315,7 @@ export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1323,7 +1323,7 @@ export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { @@ -1619,7 +1619,7 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1627,7 +1627,7 @@ export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -1771,7 +1771,7 @@ export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$00hojjd(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1779,7 +1779,7 @@ export function fromAsciiBytesRadixImpl$00hojjd(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -1927,48 +1927,48 @@ export function fromStr$0qvzsmz(src: string): rt.Result { - return fromStrRadix$1ku3myt(src, 10); +export function fromStr$0wy2fla(src: string): rt.Result { + return fromStrRadix$0ra6q5p(src, 10); } -export function fromStr$08wf09w(src: string): rt.Result { - return fromStrRadix$05zvwcf(src, 10); +export function fromStr$07skih7(src: string): rt.Result { + return fromStrRadix$1xyg67b(src, 10); } export function fromStr$1ypcnp8(src: string): rt.Result { return fromStrRadix$1gp4jqq(src, 10); } -export function fromStr$1hq0zfa(src: string): rt.Result { - return fromStrRadix$0nj08um(src, 10); +export function fromStr$1s51v8m(src: string): rt.Result { + return fromStrRadix$1s6gdoj(src, 10); } -export function fromStr$10ypyht(src: string): rt.Result { - return fromStrRadix$0tjqkb6(src, 10); +export function fromStr$047hkg7(src: string): rt.Result { + return fromStrRadix$146bkjv(src, 10); } export function fromStrRadix$0g0g31i(src: string, radix: rt.u32): rt.Result { return fromAsciiBytesRadixImpl$0r1q6uy(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1ku3myt(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1ukmfx2(rt.stringAsBytes(src), radix); +export function fromStrRadix$0ra6q5p(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0q4dbht(rt.stringAsBytes(src), radix); } -export function fromStrRadix$05zvwcf(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0ax4wbr(rt.stringAsBytes(src), radix); +export function fromStrRadix$1xyg67b(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1xmrosk(rt.stringAsBytes(src), radix); } export function fromStrRadix$1gp4jqq(src: string, radix: rt.u32): rt.Result { return fromAsciiBytesRadixImpl$02xpj41(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0nj08um(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1n9fygl(rt.stringAsBytes(src), radix); +export function fromStrRadix$1s6gdoj(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$037x42t(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0tjqkb6(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$00hojjd(rt.stringAsBytes(src), radix); +export function fromStrRadix$146bkjv(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1cdwgun(rt.stringAsBytes(src), radix); } //# sourceMappingURL=num.ts.map diff --git a/ts/fixtures/lang/ints/expected/core/str.ts b/ts/fixtures/lang/ints/expected/core/str.ts index 1ac4d1abd..daa507169 100644 --- a/ts/fixtures/lang/ints/expected/core/str.ts +++ b/ts/fixtures/lang/ints/expected/core/str.ts @@ -1,54 +1,54 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$17ewwma as num_fromStr$17ewwma, fromStr$0zhqfgx as num_fromStr$0zhqfgx, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1grmucc as num_fromStr$1grmucc, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0yqu2i9 as num_fromStr$0yqu2i9, fromStr$08wf09w as num_fromStr$08wf09w, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa, fromStr$10ypyht as num_fromStr$10ypyht } from "../core/num.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$15pqb75 as num_fromStr$15pqb75, fromStr$0lmxi6o as num_fromStr$0lmxi6o, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$029r9bb as num_fromStr$029r9bb, fromStr$1v63ugw as num_fromStr$1v63ugw, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0wy2fla as num_fromStr$0wy2fla, fromStr$07skih7 as num_fromStr$07skih7, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1s51v8m as num_fromStr$1s51v8m, fromStr$047hkg7 as num_fromStr$047hkg7 } from "../core/num.ts"; export function parse$082ztwj(self: string): rt.Result { return num_fromStr$0zyj6he(self); } -export function parse$0xnscjy(self: string): rt.Result { - return num_fromStr$17ewwma(self); +export function parse$15bt1cx(self: string): rt.Result { + return num_fromStr$15pqb75(self); } -export function parse$12szghw(self: string): rt.Result { - return num_fromStr$0zhqfgx(self); +export function parse$072345g(self: string): rt.Result { + return num_fromStr$0lmxi6o(self); } export function parse$11m1f1e(self: string): rt.Result { return num_fromStr$116mp4t(self); } -export function parse$1ci7nyc(self: string): rt.Result { - return num_fromStr$0ovlgjd(self); +export function parse$14z7a72(self: string): rt.Result { + return num_fromStr$029r9bb(self); } -export function parse$07xyv4i(self: string): rt.Result { - return num_fromStr$1grmucc(self); +export function parse$0uguq9k(self: string): rt.Result { + return num_fromStr$1v63ugw(self); } export function parse$069o3rw(self: string): rt.Result { return num_fromStr$0qvzsmz(self); } -export function parse$0fi19ig(self: string): rt.Result { - return num_fromStr$0yqu2i9(self); +export function parse$1kk1wco(self: string): rt.Result { + return num_fromStr$0wy2fla(self); } -export function parse$1aq2uo0(self: string): rt.Result { - return num_fromStr$08wf09w(self); +export function parse$0wgc3xh(self: string): rt.Result { + return num_fromStr$07skih7(self); } export function parse$0o4ono0(self: string): rt.Result { return num_fromStr$1ypcnp8(self); } -export function parse$0at0fdl(self: string): rt.Result { - return num_fromStr$1hq0zfa(self); +export function parse$0vh70p5(self: string): rt.Result { + return num_fromStr$1s51v8m(self); } -export function parse$08wetap(self: string): rt.Result { - return num_fromStr$10ypyht(self); +export function parse$1i990qj(self: string): rt.Result { + return num_fromStr$047hkg7(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/ints/expected/ints.ts b/ts/fixtures/lang/ints/expected/ints.ts index f3490b02b..a0d443f2e 100644 --- a/ts/fixtures/lang/ints/expected/ints.ts +++ b/ts/fixtures/lang/ints/expected/ints.ts @@ -2,10 +2,10 @@ import * as rt from "./rt.ts"; import { toDigit$01k9ewn } from "./core/char/methods.ts"; -import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$17ewwma as num_fromStr$17ewwma, fromStr$0zhqfgx as num_fromStr$0zhqfgx, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1grmucc as num_fromStr$1grmucc, fromStrRadix$0366bau as num_fromStrRadix$0366bau, fromStrRadix$02mhuxs as num_fromStrRadix$02mhuxs, fromStrRadix$1bgm1z0 as num_fromStrRadix$1bgm1z0, fromStrRadix$11y6fsf as num_fromStrRadix$11y6fsf, fromStrRadix$0s9rspw as num_fromStrRadix$0s9rspw, fromStrRadix$1473bi0 as num_fromStrRadix$1473bi0, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0yqu2i9 as num_fromStr$0yqu2i9, fromStr$08wf09w as num_fromStr$08wf09w, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa, fromStr$10ypyht as num_fromStr$10ypyht, fromStrRadix$0g0g31i as num_fromStrRadix$0g0g31i, fromStrRadix$1ku3myt as num_fromStrRadix$1ku3myt, fromStrRadix$05zvwcf as num_fromStrRadix$05zvwcf, fromStrRadix$1gp4jqq as num_fromStrRadix$1gp4jqq, fromStrRadix$0nj08um as num_fromStrRadix$0nj08um, fromStrRadix$0tjqkb6 as num_fromStrRadix$0tjqkb6 } from "./core/num.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$15pqb75 as num_fromStr$15pqb75, fromStr$0lmxi6o as num_fromStr$0lmxi6o, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$029r9bb as num_fromStr$029r9bb, fromStr$1v63ugw as num_fromStr$1v63ugw, fromStrRadix$0366bau as num_fromStrRadix$0366bau, fromStrRadix$0rk2yr6 as num_fromStrRadix$0rk2yr6, fromStrRadix$1newkmi as num_fromStrRadix$1newkmi, fromStrRadix$11y6fsf as num_fromStrRadix$11y6fsf, fromStrRadix$0dg9fx3 as num_fromStrRadix$0dg9fx3, fromStrRadix$16jk9zm as num_fromStrRadix$16jk9zm, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0wy2fla as num_fromStr$0wy2fla, fromStr$07skih7 as num_fromStr$07skih7, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1s51v8m as num_fromStr$1s51v8m, fromStr$047hkg7 as num_fromStr$047hkg7, fromStrRadix$0g0g31i as num_fromStrRadix$0g0g31i, fromStrRadix$0ra6q5p as num_fromStrRadix$0ra6q5p, fromStrRadix$1xyg67b as num_fromStrRadix$1xyg67b, fromStrRadix$1gp4jqq as num_fromStrRadix$1gp4jqq, fromStrRadix$1s6gdoj as num_fromStrRadix$1s6gdoj, fromStrRadix$146bkjv as num_fromStrRadix$146bkjv } from "./core/num.ts"; import { isSomeAnd$09tpccf, unwrapOr$11c0we2 as option_unwrapOr$11c0we2, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; import { eq$0pee78b as result_eq$0pee78b, eq$1mi4cle as result_eq$1mi4cle, eq$1ukayff as result_eq$1ukayff, eq$1hy1is1 as result_eq$1hy1is1, eq$1hd8lo9 as result_eq$1hd8lo9, eq$0w2dfat as result_eq$0w2dfat, eq$06vyx9e as result_eq$06vyx9e, eq$08241oi as result_eq$08241oi, eq$0nbftnc as result_eq$0nbftnc, eq$1gq81ib as result_eq$1gq81ib, eq$12e5exx as result_eq$12e5exx, eq$1xhgva4 as result_eq$1xhgva4, unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7, unwrapOr$0nhd29g as result_unwrapOr$0nhd29g, unwrapOr$09i71ei as result_unwrapOr$09i71ei } from "./core/result.ts"; -import { parse$082ztwj, parse$0xnscjy, parse$12szghw, parse$11m1f1e, parse$1ci7nyc, parse$07xyv4i, parse$069o3rw, parse$0fi19ig, parse$1aq2uo0, parse$0o4ono0, parse$0at0fdl, parse$08wetap } from "./core/str.ts"; +import { parse$082ztwj, parse$15bt1cx, parse$072345g, parse$11m1f1e, parse$14z7a72, parse$0uguq9k, parse$069o3rw, parse$1kk1wco, parse$0wgc3xh, parse$0o4ono0, parse$0vh70p5, parse$1i990qj } from "./core/str.ts"; import { put } from "./harness.ts"; import * as Scaled from "./ints.Scaled.ts"; @@ -3061,7 +3061,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_25, radix), 99)))); } const radix2: rt.u32 = radix; - const _40: rt.Result = num_fromStrRadix$0nj08um(_19.value, radix2); + const _40: rt.Result = num_fromStrRadix$1s6gdoj(_19.value, radix2); if (_40.ok) { const arg48 = _40.value; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg48, f)]; @@ -3090,8 +3090,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); } if (radix2 === 10) { - const parsed: rt.Result = parse$0at0fdl(_19.value); - const from: rt.Result = num_fromStr$1hq0zfa(_19.value); + const parsed: rt.Result = parse$0vh70p5(_19.value); + const from: rt.Result = num_fromStr$1s51v8m(_19.value); if (from.ok) { max = rt.u8Mul(from.value === 255 ? 1 : 0, 4); } else { @@ -3110,7 +3110,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _128: string = s; const radix3: rt.u32 = radix; - const _131: rt.Result = num_fromStrRadix$0nj08um(_128, radix3); + const _131: rt.Result = num_fromStrRadix$1s6gdoj(_128, radix3); if (_131.ok) { const arg47 = _131.value; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg47, f)]; @@ -3139,8 +3139,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); } if (radix3 === 10) { - const parsed2: rt.Result = parse$0at0fdl(_128); - const from2: rt.Result = num_fromStr$1hq0zfa(_128); + const parsed2: rt.Result = parse$0vh70p5(_128); + const from2: rt.Result = num_fromStr$1s51v8m(_128); if (from2.ok) { max2 = rt.u8Mul(from2.value === 255 ? 1 : 0, 4); } else { @@ -3159,7 +3159,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix4: rt.u32 = _199; for (const _207 of edges(255, 0, 8, radix4)) { const radix5: rt.u32 = radix4; - const _218: rt.Result = num_fromStrRadix$0nj08um(_207, radix5); + const _218: rt.Result = num_fromStrRadix$1s6gdoj(_207, radix5); if (_218.ok) { const arg46 = _218.value; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg46, f)]; @@ -3188,8 +3188,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); } if (radix5 === 10) { - const parsed3: rt.Result = parse$0at0fdl(_207); - const from3: rt.Result = num_fromStr$1hq0zfa(_207); + const parsed3: rt.Result = parse$0vh70p5(_207); + const from3: rt.Result = num_fromStr$1s51v8m(_207); if (from3.ok) { max3 = rt.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { @@ -3213,7 +3213,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text), "1"); const radix7: rt.u32 = radix6; - const _315: rt.Result = num_fromStrRadix$0nj08um(_310, radix7); + const _315: rt.Result = num_fromStrRadix$1s6gdoj(_310, radix7); if (_315.ok) { const arg45 = _315.value; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg45, f)]; @@ -3242,8 +3242,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); } if (radix7 === 10) { - const parsed4: rt.Result = parse$0at0fdl(_310); - const from4: rt.Result = num_fromStr$1hq0zfa(_310); + const parsed4: rt.Result = parse$0vh70p5(_310); + const from4: rt.Result = num_fromStr$1s51v8m(_310); if (from4.ok) { max4 = rt.u8Mul(from4.value === 255 ? 1 : 0, 4); } else { @@ -3271,7 +3271,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_399, radix8), 99)))); } const radix9: rt.u32 = radix8; - const _414: rt.Result = num_fromStrRadix$1ku3myt(_393.value, radix9); + const _414: rt.Result = num_fromStrRadix$0ra6q5p(_393.value, radix9); if (_414.ok) { const arg44 = _414.value; const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg44, f)]; @@ -3300,8 +3300,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); } if (radix9 === 10) { - const parsed5: rt.Result = parse$0fi19ig(_393.value); - const from5: rt.Result = num_fromStr$0yqu2i9(_393.value); + const parsed5: rt.Result = parse$1kk1wco(_393.value); + const from5: rt.Result = num_fromStr$0wy2fla(_393.value); if (from5.ok) { max5 = rt.u8Mul(from5.value === 65535 ? 1 : 0, 4); } else { @@ -3320,7 +3320,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _502: string = s3; const radix10: rt.u32 = radix8; - const _505: rt.Result = num_fromStrRadix$1ku3myt(_502, radix10); + const _505: rt.Result = num_fromStrRadix$0ra6q5p(_502, radix10); if (_505.ok) { const arg43 = _505.value; const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg43, f)]; @@ -3349,8 +3349,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); } if (radix10 === 10) { - const parsed6: rt.Result = parse$0fi19ig(_502); - const from6: rt.Result = num_fromStr$0yqu2i9(_502); + const parsed6: rt.Result = parse$1kk1wco(_502); + const from6: rt.Result = num_fromStr$0wy2fla(_502); if (from6.ok) { max6 = rt.u8Mul(from6.value === 65535 ? 1 : 0, 4); } else { @@ -3369,7 +3369,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix11: rt.u32 = _573; for (const _581 of edges(65535, 0, 16, radix11)) { const radix12: rt.u32 = radix11; - const _592: rt.Result = num_fromStrRadix$1ku3myt(_581, radix12); + const _592: rt.Result = num_fromStrRadix$0ra6q5p(_581, radix12); if (_592.ok) { const arg42 = _592.value; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg42, f)]; @@ -3398,8 +3398,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); } if (radix12 === 10) { - const parsed7: rt.Result = parse$0fi19ig(_581); - const from7: rt.Result = num_fromStr$0yqu2i9(_581); + const parsed7: rt.Result = parse$1kk1wco(_581); + const from7: rt.Result = num_fromStr$0wy2fla(_581); if (from7.ok) { max7 = rt.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { @@ -3423,7 +3423,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _684: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text2), "1"); const radix14: rt.u32 = radix13; - const _689: rt.Result = num_fromStrRadix$1ku3myt(_684, radix14); + const _689: rt.Result = num_fromStrRadix$0ra6q5p(_684, radix14); if (_689.ok) { const arg41 = _689.value; const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg41, f)]; @@ -3452,8 +3452,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); } if (radix14 === 10) { - const parsed8: rt.Result = parse$0fi19ig(_684); - const from8: rt.Result = num_fromStr$0yqu2i9(_684); + const parsed8: rt.Result = parse$1kk1wco(_684); + const from8: rt.Result = num_fromStr$0wy2fla(_684); if (from8.ok) { max8 = rt.u8Mul(from8.value === 65535 ? 1 : 0, 4); } else { @@ -3481,7 +3481,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_773, radix15), 99)))); } const radix16: rt.u32 = radix15; - const _788: rt.Result = num_fromStrRadix$05zvwcf(_767.value, radix16); + const _788: rt.Result = num_fromStrRadix$1xyg67b(_767.value, radix16); if (_788.ok) { const arg40 = _788.value; const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg40, f)]; @@ -3510,8 +3510,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); } if (radix16 === 10) { - const parsed9: rt.Result = parse$1aq2uo0(_767.value); - const from9: rt.Result = num_fromStr$08wf09w(_767.value); + const parsed9: rt.Result = parse$0wgc3xh(_767.value); + const from9: rt.Result = num_fromStr$07skih7(_767.value); if (from9.ok) { max9 = rt.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); } else { @@ -3530,7 +3530,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _876: string = s5; const radix17: rt.u32 = radix15; - const _879: rt.Result = num_fromStrRadix$05zvwcf(_876, radix17); + const _879: rt.Result = num_fromStrRadix$1xyg67b(_876, radix17); if (_879.ok) { const arg39 = _879.value; const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg39, f)]; @@ -3559,8 +3559,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); } if (radix17 === 10) { - const parsed10: rt.Result = parse$1aq2uo0(_876); - const from10: rt.Result = num_fromStr$08wf09w(_876); + const parsed10: rt.Result = parse$0wgc3xh(_876); + const from10: rt.Result = num_fromStr$07skih7(_876); if (from10.ok) { max10 = rt.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); } else { @@ -3579,7 +3579,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix18: rt.u32 = _947; for (const _955 of edges(4294967295, 0, 32, radix18)) { const radix19: rt.u32 = radix18; - const _966: rt.Result = num_fromStrRadix$05zvwcf(_955, radix19); + const _966: rt.Result = num_fromStrRadix$1xyg67b(_955, radix19); if (_966.ok) { const arg38 = _966.value; const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg38, f)]; @@ -3608,8 +3608,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); } if (radix19 === 10) { - const parsed11: rt.Result = parse$1aq2uo0(_955); - const from11: rt.Result = num_fromStr$08wf09w(_955); + const parsed11: rt.Result = parse$0wgc3xh(_955); + const from11: rt.Result = num_fromStr$07skih7(_955); if (from11.ok) { max11 = rt.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { @@ -3633,7 +3633,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1058: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text3), "1"); const radix21: rt.u32 = radix20; - const _1063: rt.Result = num_fromStrRadix$05zvwcf(_1058, radix21); + const _1063: rt.Result = num_fromStrRadix$1xyg67b(_1058, radix21); if (_1063.ok) { const arg37 = _1063.value; const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg37, f)]; @@ -3662,8 +3662,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); } if (radix21 === 10) { - const parsed12: rt.Result = parse$1aq2uo0(_1058); - const from12: rt.Result = num_fromStr$08wf09w(_1058); + const parsed12: rt.Result = parse$0wgc3xh(_1058); + const from12: rt.Result = num_fromStr$07skih7(_1058); if (from12.ok) { max12 = rt.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); } else { @@ -4111,7 +4111,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1894, radix36), 99)))); } const radix37: rt.u32 = radix36; - const _1909: rt.Result = num_fromStrRadix$0tjqkb6(_1888.value, radix37); + const _1909: rt.Result = num_fromStrRadix$146bkjv(_1888.value, radix37); if (_1909.ok) { const arg28 = _1909.value; const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg28, f)]; @@ -4140,8 +4140,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); } if (radix37 === 10) { - const parsed21: rt.Result = parse$08wetap(_1888.value); - const from21: rt.Result = num_fromStr$10ypyht(_1888.value); + const parsed21: rt.Result = parse$1i990qj(_1888.value); + const from21: rt.Result = num_fromStr$047hkg7(_1888.value); if (from21.ok) { max21 = rt.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); } else { @@ -4160,7 +4160,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _1997: string = s11; const radix38: rt.u32 = radix36; - const _2000: rt.Result = num_fromStrRadix$0tjqkb6(_1997, radix38); + const _2000: rt.Result = num_fromStrRadix$146bkjv(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg27, f)]; @@ -4189,8 +4189,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); } if (radix38 === 10) { - const parsed22: rt.Result = parse$08wetap(_1997); - const from22: rt.Result = num_fromStr$10ypyht(_1997); + const parsed22: rt.Result = parse$1i990qj(_1997); + const from22: rt.Result = num_fromStr$047hkg7(_1997); if (from22.ok) { max22 = rt.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); } else { @@ -4209,7 +4209,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix39: rt.u32 = _2068; for (const _2076 of edges(4294967295, 0, 32, radix39)) { const radix40: rt.u32 = radix39; - const _2087: rt.Result = num_fromStrRadix$0tjqkb6(_2076, radix40); + const _2087: rt.Result = num_fromStrRadix$146bkjv(_2076, radix40); if (_2087.ok) { const arg26 = _2087.value; const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg26, f)]; @@ -4238,8 +4238,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); } if (radix40 === 10) { - const parsed23: rt.Result = parse$08wetap(_2076); - const from23: rt.Result = num_fromStr$10ypyht(_2076); + const parsed23: rt.Result = parse$1i990qj(_2076); + const from23: rt.Result = num_fromStr$047hkg7(_2076); if (from23.ok) { max23 = rt.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { @@ -4263,7 +4263,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2179: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text6), "1"); const radix42: rt.u32 = radix41; - const _2184: rt.Result = num_fromStrRadix$0tjqkb6(_2179, radix42); + const _2184: rt.Result = num_fromStrRadix$146bkjv(_2179, radix42); if (_2184.ok) { const arg25 = _2184.value; const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg25, f)]; @@ -4292,8 +4292,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); } if (radix42 === 10) { - const parsed24: rt.Result = parse$08wetap(_2179); - const from24: rt.Result = num_fromStr$10ypyht(_2179); + const parsed24: rt.Result = parse$1i990qj(_2179); + const from24: rt.Result = num_fromStr$047hkg7(_2179); if (from24.ok) { max24 = rt.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); } else { @@ -4321,7 +4321,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2268, radix43), 99)))); } const radix44: rt.u32 = radix43; - const _2283: rt.Result = num_fromStrRadix$0s9rspw(_2262.value, radix44); + const _2283: rt.Result = num_fromStrRadix$0dg9fx3(_2262.value, radix44); if (_2283.ok) { const arg24 = _2283.value; const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg24, f)]; @@ -4350,8 +4350,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); } if (radix44 === 10) { - const parsed25: rt.Result = parse$1ci7nyc(_2262.value); - const from25: rt.Result = num_fromStr$0ovlgjd(_2262.value); + const parsed25: rt.Result = parse$14z7a72(_2262.value); + const from25: rt.Result = num_fromStr$029r9bb(_2262.value); if (from25.ok) { max25 = rt.u8Mul(from25.value === 127 ? 1 : 0, 4); } else { @@ -4370,7 +4370,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2371: string = s13; const radix45: rt.u32 = radix43; - const _2374: rt.Result = num_fromStrRadix$0s9rspw(_2371, radix45); + const _2374: rt.Result = num_fromStrRadix$0dg9fx3(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg23, f)]; @@ -4399,8 +4399,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); } if (radix45 === 10) { - const parsed26: rt.Result = parse$1ci7nyc(_2371); - const from26: rt.Result = num_fromStr$0ovlgjd(_2371); + const parsed26: rt.Result = parse$14z7a72(_2371); + const from26: rt.Result = num_fromStr$029r9bb(_2371); if (from26.ok) { max26 = rt.u8Mul(from26.value === 127 ? 1 : 0, 4); } else { @@ -4419,7 +4419,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix46: rt.u32 = _2442; for (const _2453 of edges(127, rt.u128Add(127, 1), 8, radix46)) { const radix47: rt.u32 = radix46; - const _2464: rt.Result = num_fromStrRadix$0s9rspw(_2453, radix47); + const _2464: rt.Result = num_fromStrRadix$0dg9fx3(_2453, radix47); if (_2464.ok) { const arg22 = _2464.value; const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg22, f)]; @@ -4448,8 +4448,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); } if (radix47 === 10) { - const parsed27: rt.Result = parse$1ci7nyc(_2453); - const from27: rt.Result = num_fromStr$0ovlgjd(_2453); + const parsed27: rt.Result = parse$14z7a72(_2453); + const from27: rt.Result = num_fromStr$029r9bb(_2453); if (from27.ok) { max27 = rt.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { @@ -4473,7 +4473,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2556: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text7), "1"); const radix49: rt.u32 = radix48; - const _2561: rt.Result = num_fromStrRadix$0s9rspw(_2556, radix49); + const _2561: rt.Result = num_fromStrRadix$0dg9fx3(_2556, radix49); if (_2561.ok) { const arg21 = _2561.value; const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg21, f)]; @@ -4502,8 +4502,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); } if (radix49 === 10) { - const parsed28: rt.Result = parse$1ci7nyc(_2556); - const from28: rt.Result = num_fromStr$0ovlgjd(_2556); + const parsed28: rt.Result = parse$14z7a72(_2556); + const from28: rt.Result = num_fromStr$029r9bb(_2556); if (from28.ok) { max28 = rt.u8Mul(from28.value === 127 ? 1 : 0, 4); } else { @@ -4531,7 +4531,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2645, radix50), 99)))); } const radix51: rt.u32 = radix50; - const _2660: rt.Result = num_fromStrRadix$02mhuxs(_2639.value, radix51); + const _2660: rt.Result = num_fromStrRadix$0rk2yr6(_2639.value, radix51); if (_2660.ok) { const arg20 = _2660.value; const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg20, f)]; @@ -4560,8 +4560,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); } if (radix51 === 10) { - const parsed29: rt.Result = parse$0xnscjy(_2639.value); - const from29: rt.Result = num_fromStr$17ewwma(_2639.value); + const parsed29: rt.Result = parse$15bt1cx(_2639.value); + const from29: rt.Result = num_fromStr$15pqb75(_2639.value); if (from29.ok) { max29 = rt.u8Mul(from29.value === 32767 ? 1 : 0, 4); } else { @@ -4580,7 +4580,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2748: string = s15; const radix52: rt.u32 = radix50; - const _2751: rt.Result = num_fromStrRadix$02mhuxs(_2748, radix52); + const _2751: rt.Result = num_fromStrRadix$0rk2yr6(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg19, f)]; @@ -4609,8 +4609,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); } if (radix52 === 10) { - const parsed30: rt.Result = parse$0xnscjy(_2748); - const from30: rt.Result = num_fromStr$17ewwma(_2748); + const parsed30: rt.Result = parse$15bt1cx(_2748); + const from30: rt.Result = num_fromStr$15pqb75(_2748); if (from30.ok) { max30 = rt.u8Mul(from30.value === 32767 ? 1 : 0, 4); } else { @@ -4629,7 +4629,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix53: rt.u32 = _2819; for (const _2830 of edges(32767, rt.u128Add(32767, 1), 16, radix53)) { const radix54: rt.u32 = radix53; - const _2841: rt.Result = num_fromStrRadix$02mhuxs(_2830, radix54); + const _2841: rt.Result = num_fromStrRadix$0rk2yr6(_2830, radix54); if (_2841.ok) { const arg18 = _2841.value; const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg18, f)]; @@ -4658,8 +4658,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); } if (radix54 === 10) { - const parsed31: rt.Result = parse$0xnscjy(_2830); - const from31: rt.Result = num_fromStr$17ewwma(_2830); + const parsed31: rt.Result = parse$15bt1cx(_2830); + const from31: rt.Result = num_fromStr$15pqb75(_2830); if (from31.ok) { max31 = rt.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { @@ -4683,7 +4683,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _2933: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text8), "1"); const radix56: rt.u32 = radix55; - const _2938: rt.Result = num_fromStrRadix$02mhuxs(_2933, radix56); + const _2938: rt.Result = num_fromStrRadix$0rk2yr6(_2933, radix56); if (_2938.ok) { const arg17 = _2938.value; const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg17, f)]; @@ -4712,8 +4712,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); } if (radix56 === 10) { - const parsed32: rt.Result = parse$0xnscjy(_2933); - const from32: rt.Result = num_fromStr$17ewwma(_2933); + const parsed32: rt.Result = parse$15bt1cx(_2933); + const from32: rt.Result = num_fromStr$15pqb75(_2933); if (from32.ok) { max32 = rt.u8Mul(from32.value === 32767 ? 1 : 0, 4); } else { @@ -4741,7 +4741,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3022, radix57), 99)))); } const radix58: rt.u32 = radix57; - const _3037: rt.Result = num_fromStrRadix$1bgm1z0(_3016.value, radix58); + const _3037: rt.Result = num_fromStrRadix$1newkmi(_3016.value, radix58); if (_3037.ok) { const arg16 = _3037.value; const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg16, f)]; @@ -4770,8 +4770,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); } if (radix58 === 10) { - const parsed33: rt.Result = parse$12szghw(_3016.value); - const from33: rt.Result = num_fromStr$0zhqfgx(_3016.value); + const parsed33: rt.Result = parse$072345g(_3016.value); + const from33: rt.Result = num_fromStr$0lmxi6o(_3016.value); if (from33.ok) { max33 = rt.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); } else { @@ -4790,7 +4790,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3125: string = s17; const radix59: rt.u32 = radix57; - const _3128: rt.Result = num_fromStrRadix$1bgm1z0(_3125, radix59); + const _3128: rt.Result = num_fromStrRadix$1newkmi(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg15, f)]; @@ -4819,8 +4819,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); } if (radix59 === 10) { - const parsed34: rt.Result = parse$12szghw(_3125); - const from34: rt.Result = num_fromStr$0zhqfgx(_3125); + const parsed34: rt.Result = parse$072345g(_3125); + const from34: rt.Result = num_fromStr$0lmxi6o(_3125); if (from34.ok) { max34 = rt.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); } else { @@ -4839,7 +4839,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix60: rt.u32 = _3196; for (const _3207 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix60)) { const radix61: rt.u32 = radix60; - const _3218: rt.Result = num_fromStrRadix$1bgm1z0(_3207, radix61); + const _3218: rt.Result = num_fromStrRadix$1newkmi(_3207, radix61); if (_3218.ok) { const arg14 = _3218.value; const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg14, f)]; @@ -4868,8 +4868,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); } if (radix61 === 10) { - const parsed35: rt.Result = parse$12szghw(_3207); - const from35: rt.Result = num_fromStr$0zhqfgx(_3207); + const parsed35: rt.Result = parse$072345g(_3207); + const from35: rt.Result = num_fromStr$0lmxi6o(_3207); if (from35.ok) { max35 = rt.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { @@ -4893,7 +4893,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _3310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text9), "1"); const radix63: rt.u32 = radix62; - const _3315: rt.Result = num_fromStrRadix$1bgm1z0(_3310, radix63); + const _3315: rt.Result = num_fromStrRadix$1newkmi(_3310, radix63); if (_3315.ok) { const arg13 = _3315.value; const args142: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg13, f)]; @@ -4922,8 +4922,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); } if (radix63 === 10) { - const parsed36: rt.Result = parse$12szghw(_3310); - const from36: rt.Result = num_fromStr$0zhqfgx(_3310); + const parsed36: rt.Result = parse$072345g(_3310); + const from36: rt.Result = num_fromStr$0lmxi6o(_3310); if (from36.ok) { max36 = rt.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); } else { @@ -5371,7 +5371,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_4153, radix78), 99)))); } const radix79: rt.u32 = radix78; - const _4168: rt.Result = num_fromStrRadix$1473bi0(_4147.value, radix79); + const _4168: rt.Result = num_fromStrRadix$16jk9zm(_4147.value, radix79); if (_4168.ok) { const arg4 = _4168.value; const args178: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg4, f)]; @@ -5400,8 +5400,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); } if (radix79 === 10) { - const parsed45: rt.Result = parse$07xyv4i(_4147.value); - const from45: rt.Result = num_fromStr$1grmucc(_4147.value); + const parsed45: rt.Result = parse$0uguq9k(_4147.value); + const from45: rt.Result = num_fromStr$1v63ugw(_4147.value); if (from45.ok) { max45 = rt.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); } else { @@ -5420,7 +5420,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _4256: string = s23; const radix80: rt.u32 = radix78; - const _4259: rt.Result = num_fromStrRadix$1473bi0(_4256, radix80); + const _4259: rt.Result = num_fromStrRadix$16jk9zm(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; const args182: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg3, f)]; @@ -5449,8 +5449,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); } if (radix80 === 10) { - const parsed46: rt.Result = parse$07xyv4i(_4256); - const from46: rt.Result = num_fromStr$1grmucc(_4256); + const parsed46: rt.Result = parse$0uguq9k(_4256); + const from46: rt.Result = num_fromStr$1v63ugw(_4256); if (from46.ok) { max46 = rt.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); } else { @@ -5469,7 +5469,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat const radix81: rt.u32 = _4327; for (const _4338 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix81)) { const radix82: rt.u32 = radix81; - const _4349: rt.Result = num_fromStrRadix$1473bi0(_4338, radix82); + const _4349: rt.Result = num_fromStrRadix$16jk9zm(_4338, radix82); if (_4349.ok) { const arg2 = _4349.value; const args186: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; @@ -5498,8 +5498,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); } if (radix82 === 10) { - const parsed47: rt.Result = parse$07xyv4i(_4338); - const from47: rt.Result = num_fromStr$1grmucc(_4338); + const parsed47: rt.Result = parse$0uguq9k(_4338); + const from47: rt.Result = num_fromStr$1v63ugw(_4338); if (from47.ok) { max47 = rt.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); } else { @@ -5523,7 +5523,7 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const _4441: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text12), "1"); const radix84: rt.u32 = radix83; - const _4446: rt.Result = num_fromStrRadix$1473bi0(_4441, radix84); + const _4446: rt.Result = num_fromStrRadix$16jk9zm(_4441, radix84); if (_4446.ok) { const arg = _4446.value; const args190: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg, f)]; @@ -5552,8 +5552,8 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat put(out, rt.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); } if (radix84 === 10) { - const parsed48: rt.Result = parse$07xyv4i(_4441); - const from48: rt.Result = num_fromStr$1grmucc(_4441); + const parsed48: rt.Result = parse$0uguq9k(_4441); + const from48: rt.Result = num_fromStr$1v63ugw(_4441); if (from48.ok) { max48 = rt.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); } else { diff --git a/ts/fixtures/lang/strs/expected/core/num.ts b/ts/fixtures/lang/strs/expected/core/num.ts index fc2cf0169..f5aeda954 100644 --- a/ts/fixtures/lang/strs/expected/core/num.ts +++ b/ts/fixtures/lang/strs/expected/core/num.ts @@ -203,7 +203,7 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -211,7 +211,7 @@ export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -32768; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -355,7 +355,7 @@ export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0p2idzk(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -363,7 +363,7 @@ export function fromAsciiBytesRadixImpl$0p2idzk(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -2147483648; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -659,7 +659,7 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -667,7 +667,7 @@ export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -128; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -811,7 +811,7 @@ export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$05ylgyc(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -819,7 +819,7 @@ export function fromAsciiBytesRadixImpl$05ylgyc(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > -2147483648; + const isSignedTy: boolean = true; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -1115,7 +1115,7 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1123,7 +1123,7 @@ export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -1267,7 +1267,7 @@ export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1275,7 +1275,7 @@ export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { @@ -1571,7 +1571,7 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1579,7 +1579,7 @@ export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { @@ -1723,7 +1723,7 @@ export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$00hojjd(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1731,7 +1731,7 @@ export function fromAsciiBytesRadixImpl$00hojjd(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = 0 > 0; + const isSignedTy: boolean = false; if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { diff --git a/ts/fixtures/lang/strs/expected/core/num/nonzero.ts b/ts/fixtures/lang/strs/expected/core/num/nonzero.ts index cf00ca76f..a82efebc6 100644 --- a/ts/fixtures/lang/strs/expected/core/num/nonzero.ts +++ b/ts/fixtures/lang/strs/expected/core/num/nonzero.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../../rt.ts"; -import { fromAsciiBytesRadixImpl$0xhcrxt as num_fromAsciiBytesRadixImpl$0xhcrxt, fromAsciiBytesRadixImpl$0jbbuu8 as num_fromAsciiBytesRadixImpl$0jbbuu8, fromAsciiBytesRadixImpl$0p2idzk as num_fromAsciiBytesRadixImpl$0p2idzk, fromAsciiBytesRadixImpl$01tfvb9 as num_fromAsciiBytesRadixImpl$01tfvb9, fromAsciiBytesRadixImpl$18og5o1 as num_fromAsciiBytesRadixImpl$18og5o1, fromAsciiBytesRadixImpl$05ylgyc as num_fromAsciiBytesRadixImpl$05ylgyc, fromAsciiBytesRadixImpl$0r1q6uy as num_fromAsciiBytesRadixImpl$0r1q6uy, fromAsciiBytesRadixImpl$1ukmfx2 as num_fromAsciiBytesRadixImpl$1ukmfx2, fromAsciiBytesRadixImpl$0ax4wbr as num_fromAsciiBytesRadixImpl$0ax4wbr, fromAsciiBytesRadixImpl$02xpj41 as num_fromAsciiBytesRadixImpl$02xpj41, fromAsciiBytesRadixImpl$1n9fygl as num_fromAsciiBytesRadixImpl$1n9fygl, fromAsciiBytesRadixImpl$00hojjd as num_fromAsciiBytesRadixImpl$00hojjd } from "../../core/num.ts"; +import { fromAsciiBytesRadixImpl$0xhcrxt as num_fromAsciiBytesRadixImpl$0xhcrxt, fromAsciiBytesRadixImpl$0ut8llb as num_fromAsciiBytesRadixImpl$0ut8llb, fromAsciiBytesRadixImpl$1ykgy6m as num_fromAsciiBytesRadixImpl$1ykgy6m, fromAsciiBytesRadixImpl$01tfvb9 as num_fromAsciiBytesRadixImpl$01tfvb9, fromAsciiBytesRadixImpl$0k9pjln as num_fromAsciiBytesRadixImpl$0k9pjln, fromAsciiBytesRadixImpl$1hpkcx2 as num_fromAsciiBytesRadixImpl$1hpkcx2, fromAsciiBytesRadixImpl$0r1q6uy as num_fromAsciiBytesRadixImpl$0r1q6uy, fromAsciiBytesRadixImpl$0q4dbht as num_fromAsciiBytesRadixImpl$0q4dbht, fromAsciiBytesRadixImpl$1xmrosk as num_fromAsciiBytesRadixImpl$1xmrosk, fromAsciiBytesRadixImpl$02xpj41 as num_fromAsciiBytesRadixImpl$02xpj41, fromAsciiBytesRadixImpl$037x42t as num_fromAsciiBytesRadixImpl$037x42t, fromAsciiBytesRadixImpl$1cdwgun as num_fromAsciiBytesRadixImpl$1cdwgun } from "../../core/num.ts"; -export function fromAsciiBytesRadixImpl$1kc6lwg(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1n9fygl(src, radix); +export function fromAsciiBytesRadixImpl$046b3ez(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$037x42t(src, radix); if (_3.ok) { const _7: rt.u8 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -15,16 +15,16 @@ export function fromAsciiBytesRadixImpl$1kc6lwg(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0evev4b(src: string): rt.Result { - return fromStrRadix$1dc3cul(src, 10); +export function fromStr$1ka76tk(src: string): rt.Result { + return fromStrRadix$1c1a5i0(src, 10); } -export function fromStrRadix$1dc3cul(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1kc6lwg(rt.stringAsBytes(src), radix); +export function fromStrRadix$1c1a5i0(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$046b3ez(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0gd2ptq(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1ukmfx2(src, radix); +export function fromAsciiBytesRadixImpl$0yik78r(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0q4dbht(src, radix); if (_3.ok) { const _7: rt.u16 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -35,16 +35,16 @@ export function fromAsciiBytesRadixImpl$0gd2ptq(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$1lm2uzl(src: string): rt.Result { - return fromStrRadix$1cv6o7i(src, 10); +export function fromStr$1bidi2n(src: string): rt.Result { + return fromStrRadix$13ngn1e(src, 10); } -export function fromStrRadix$1cv6o7i(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0gd2ptq(rt.stringAsBytes(src), radix); +export function fromStrRadix$13ngn1e(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0yik78r(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0v1vsb2(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0ax4wbr(src, radix); +export function fromAsciiBytesRadixImpl$1e6dyne(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1xmrosk(src, radix); if (_3.ok) { const _7: rt.u32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -55,12 +55,12 @@ export function fromAsciiBytesRadixImpl$0v1vsb2(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0gvyqp3(src: string): rt.Result { - return fromStrRadix$18imw6k(src, 10); +export function fromStr$0pscojv(src: string): rt.Result { + return fromStrRadix$14vzugb(src, 10); } -export function fromStrRadix$18imw6k(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0v1vsb2(rt.stringAsBytes(src), radix); +export function fromStrRadix$14vzugb(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1e6dyne(rt.stringAsBytes(src), radix); } export function fromAsciiBytesRadixImpl$0573ey0(src: rt.ByteSlice, radix: rt.u32): rt.Result { @@ -103,8 +103,8 @@ export function fromStrRadix$0yvapq5(src: string, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$00hojjd(src, radix); +export function fromAsciiBytesRadixImpl$0fwjjdv(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1cdwgun(src, radix); if (_3.ok) { const _7: rt.usize | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -115,16 +115,16 @@ export function fromAsciiBytesRadixImpl$0fv7s51(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$06k4xxy(src: string): rt.Result { - return fromStrRadix$0rmwudb(src, 10); +export function fromStr$0b146n7(src: string): rt.Result { + return fromStrRadix$0tal612(src, 10); } -export function fromStrRadix$0rmwudb(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0fv7s51(rt.stringAsBytes(src), radix); +export function fromStrRadix$0tal612(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0fwjjdv(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0o9g9le(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$18og5o1(src, radix); +export function fromAsciiBytesRadixImpl$1xnyrsk(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0k9pjln(src, radix); if (_3.ok) { const _7: rt.i8 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -135,16 +135,16 @@ export function fromAsciiBytesRadixImpl$0o9g9le(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0xht6mx(src: string): rt.Result { - return fromStrRadix$0qjnxek(src, 10); +export function fromStr$1uo2nx5(src: string): rt.Result { + return fromStrRadix$0cahq64(src, 10); } -export function fromStrRadix$0qjnxek(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0o9g9le(rt.stringAsBytes(src), radix); +export function fromStrRadix$0cahq64(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1xnyrsk(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$067wd9q(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0jbbuu8(src, radix); +export function fromAsciiBytesRadixImpl$1ju244m(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0ut8llb(src, radix); if (_3.ok) { const _7: rt.i16 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -155,16 +155,16 @@ export function fromAsciiBytesRadixImpl$067wd9q(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$021o7ki(src: string): rt.Result { - return fromStrRadix$0dk3w71(src, 10); +export function fromStr$05o7gm9(src: string): rt.Result { + return fromStrRadix$10ztqkr(src, 10); } -export function fromStrRadix$0dk3w71(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$067wd9q(rt.stringAsBytes(src), radix); +export function fromStrRadix$10ztqkr(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1ju244m(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$09l5q1f(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0p2idzk(src, radix); +export function fromAsciiBytesRadixImpl$0w0p9k6(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1ykgy6m(src, radix); if (_3.ok) { const _7: rt.i32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -175,12 +175,12 @@ export function fromAsciiBytesRadixImpl$09l5q1f(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$1myv2t6(src: string): rt.Result { - return fromStrRadix$0o6ntrm(src, 10); +export function fromStr$1cmdtf2(src: string): rt.Result { + return fromStrRadix$1vk8c0u(src, 10); } -export function fromStrRadix$0o6ntrm(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$09l5q1f(rt.stringAsBytes(src), radix); +export function fromStrRadix$1vk8c0u(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0w0p9k6(rt.stringAsBytes(src), radix); } export function fromAsciiBytesRadixImpl$1tchpbx(src: rt.ByteSlice, radix: rt.u32): rt.Result { @@ -223,8 +223,8 @@ export function fromStrRadix$17xzbib(src: string, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$05ylgyc(src, radix); +export function fromAsciiBytesRadixImpl$0c07bbl(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1hpkcx2(src, radix); if (_3.ok) { const _7: rt.isize | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -235,12 +235,12 @@ export function fromAsciiBytesRadixImpl$1ylh0b8(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$1gsgexo(src: string): rt.Result { - return fromStrRadix$0k1ynqn(src, 10); +export function fromStr$1nddmw0(src: string): rt.Result { + return fromStrRadix$07izbug(src, 10); } -export function fromStrRadix$0k1ynqn(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1ylh0b8(rt.stringAsBytes(src), radix); +export function fromStrRadix$07izbug(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0c07bbl(rt.stringAsBytes(src), radix); } //# sourceMappingURL=nonzero.ts.map diff --git a/ts/fixtures/lang/strs/expected/core/str.ts b/ts/fixtures/lang/strs/expected/core/str.ts index 4004f68f2..a08f495ee 100644 --- a/ts/fixtures/lang/strs/expected/core/str.ts +++ b/ts/fixtures/lang/strs/expected/core/str.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import { fromStr$0evev4b as nonzero_fromStr$0evev4b, fromStr$1lm2uzl as nonzero_fromStr$1lm2uzl, fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStr$06k4xxy as nonzero_fromStr$06k4xxy, fromStr$0xht6mx as nonzero_fromStr$0xht6mx, fromStr$021o7ki as nonzero_fromStr$021o7ki, fromStr$1myv2t6 as nonzero_fromStr$1myv2t6, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStr$081k88g as nonzero_fromStr$081k88g, fromStr$1gsgexo as nonzero_fromStr$1gsgexo } from "../core/num/nonzero.ts"; +import { fromStr$1ka76tk as nonzero_fromStr$1ka76tk, fromStr$1bidi2n as nonzero_fromStr$1bidi2n, fromStr$0pscojv as nonzero_fromStr$0pscojv, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStr$0b146n7 as nonzero_fromStr$0b146n7, fromStr$1uo2nx5 as nonzero_fromStr$1uo2nx5, fromStr$05o7gm9 as nonzero_fromStr$05o7gm9, fromStr$1cmdtf2 as nonzero_fromStr$1cmdtf2, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStr$081k88g as nonzero_fromStr$081k88g, fromStr$1nddmw0 as nonzero_fromStr$1nddmw0 } from "../core/num/nonzero.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "../core/str/traits.ts"; export function parse$0vh4cry(self: string): rt.Result { @@ -12,48 +12,48 @@ export function parse$1bh1yup(self: string): rt.Result { - return nonzero_fromStr$021o7ki(self); +export function parse$08t7361(self: string): rt.Result { + return nonzero_fromStr$05o7gm9(self); } -export function parse$1wp6z3o(self: string): rt.Result { - return nonzero_fromStr$1myv2t6(self); +export function parse$0bf4pzp(self: string): rt.Result { + return nonzero_fromStr$1cmdtf2(self); } export function parse$00wf0ig(self: string): rt.Result { return nonzero_fromStr$10p52cj(self); } -export function parse$1bfudtm(self: string): rt.Result { - return nonzero_fromStr$0xht6mx(self); +export function parse$0wtmhwf(self: string): rt.Result { + return nonzero_fromStr$1uo2nx5(self); } -export function parse$16jvjal(self: string): rt.Result { - return nonzero_fromStr$1gsgexo(self); +export function parse$11q43n4(self: string): rt.Result { + return nonzero_fromStr$1nddmw0(self); } export function parse$0y8gj7z(self: string): rt.Result { return nonzero_fromStr$1lyc2jq(self); } -export function parse$0y6waa4(self: string): rt.Result { - return nonzero_fromStr$1lm2uzl(self); +export function parse$00ea569(self: string): rt.Result { + return nonzero_fromStr$1bidi2n(self); } -export function parse$1s5pqso(self: string): rt.Result { - return nonzero_fromStr$0gvyqp3(self); +export function parse$00ibreq(self: string): rt.Result { + return nonzero_fromStr$0pscojv(self); } export function parse$129b0a7(self: string): rt.Result { return nonzero_fromStr$19lq810(self); } -export function parse$150tkxc(self: string): rt.Result { - return nonzero_fromStr$0evev4b(self); +export function parse$0r5638o(self: string): rt.Result { + return nonzero_fromStr$1ka76tk(self); } -export function parse$02m155k(self: string): rt.Result { - return nonzero_fromStr$06k4xxy(self); +export function parse$1kzahs9(self: string): rt.Result { + return nonzero_fromStr$0b146n7(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 03f93827d..85e51c302 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -2,9 +2,9 @@ import * as rt from "./rt.ts"; import { then$0havnzo } from "./core/bool.ts"; -import { fromStr$0evev4b as nonzero_fromStr$0evev4b, fromStrRadix$1dc3cul as nonzero_fromStrRadix$1dc3cul, fromStr$1lm2uzl as nonzero_fromStr$1lm2uzl, fromStrRadix$1cv6o7i as nonzero_fromStrRadix$1cv6o7i, fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3, fromStrRadix$18imw6k as nonzero_fromStrRadix$18imw6k, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStrRadix$1u3fi38 as nonzero_fromStrRadix$1u3fi38, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStrRadix$0yvapq5 as nonzero_fromStrRadix$0yvapq5, fromStr$06k4xxy as nonzero_fromStr$06k4xxy, fromStrRadix$0rmwudb as nonzero_fromStrRadix$0rmwudb, fromStr$0xht6mx as nonzero_fromStr$0xht6mx, fromStrRadix$0qjnxek as nonzero_fromStrRadix$0qjnxek, fromStr$021o7ki as nonzero_fromStr$021o7ki, fromStrRadix$0dk3w71 as nonzero_fromStrRadix$0dk3w71, fromStr$1myv2t6 as nonzero_fromStr$1myv2t6, fromStrRadix$0o6ntrm as nonzero_fromStrRadix$0o6ntrm, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStrRadix$0ebk8xe as nonzero_fromStrRadix$0ebk8xe, fromStr$081k88g as nonzero_fromStr$081k88g, fromStrRadix$17xzbib as nonzero_fromStrRadix$17xzbib, fromStr$1gsgexo as nonzero_fromStr$1gsgexo, fromStrRadix$0k1ynqn as nonzero_fromStrRadix$0k1ynqn } from "./core/num/nonzero.ts"; +import { fromStr$1ka76tk as nonzero_fromStr$1ka76tk, fromStrRadix$1c1a5i0 as nonzero_fromStrRadix$1c1a5i0, fromStr$1bidi2n as nonzero_fromStr$1bidi2n, fromStrRadix$13ngn1e as nonzero_fromStrRadix$13ngn1e, fromStr$0pscojv as nonzero_fromStr$0pscojv, fromStrRadix$14vzugb as nonzero_fromStrRadix$14vzugb, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStrRadix$1u3fi38 as nonzero_fromStrRadix$1u3fi38, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStrRadix$0yvapq5 as nonzero_fromStrRadix$0yvapq5, fromStr$0b146n7 as nonzero_fromStr$0b146n7, fromStrRadix$0tal612 as nonzero_fromStrRadix$0tal612, fromStr$1uo2nx5 as nonzero_fromStr$1uo2nx5, fromStrRadix$0cahq64 as nonzero_fromStrRadix$0cahq64, fromStr$05o7gm9 as nonzero_fromStr$05o7gm9, fromStrRadix$10ztqkr as nonzero_fromStrRadix$10ztqkr, fromStr$1cmdtf2 as nonzero_fromStr$1cmdtf2, fromStrRadix$1vk8c0u as nonzero_fromStrRadix$1vk8c0u, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStrRadix$0ebk8xe as nonzero_fromStrRadix$0ebk8xe, fromStr$081k88g as nonzero_fromStr$081k88g, fromStrRadix$17xzbib as nonzero_fromStrRadix$17xzbib, fromStr$1nddmw0 as nonzero_fromStr$1nddmw0, fromStrRadix$07izbug as nonzero_fromStrRadix$07izbug } from "./core/num/nonzero.ts"; import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0gl6wke as option_map$0gl6wke, mapOr$16umieg as option_mapOr$16umieg, mapOr$147z9gi as option_mapOr$147z9gi } from "./core/option.ts"; -import { parse$0vh4cry, parse$1bh1yup, parse$034rhh2, parse$1wp6z3o, parse$00wf0ig, parse$1bfudtm, parse$16jvjal, parse$0y8gj7z, parse$0y6waa4, parse$1s5pqso, parse$129b0a7, parse$150tkxc, parse$02m155k } from "./core/str.ts"; +import { parse$0vh4cry, parse$1bh1yup, parse$08t7361, parse$0bf4pzp, parse$00wf0ig, parse$0wtmhwf, parse$11q43n4, parse$0y8gj7z, parse$00ea569, parse$00ibreq, parse$129b0a7, parse$0r5638o, parse$1kzahs9 } from "./core/str.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "./core/str/traits.ts"; import { put, text } from "./harness.ts"; import * as Counted from "./strs.Counted.ts"; @@ -782,7 +782,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.charFromStr(_49); } else if (_53 === 2) { const radix2: rt.u32 = radix; - const iter5: rt.Iter> = rt.iterSlice([parse$150tkxc(_49), nonzero_fromStr$0evev4b(_49)]); + const iter5: rt.Iter> = rt.iterSlice([parse$0r5638o(_49), nonzero_fromStr$1ka76tk(_49)]); while (true) { const _149: rt.Result | rt.Done = iter5.next(); if (_149 === rt.DONE) { @@ -799,13 +799,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rt.fmtSpec({ alternate: true }, args12[1])])); } } - const _139: rt.Result = parse$150tkxc(_49); + const _139: rt.Result = parse$0r5638o(_49); if (!_139.ok) { const part12 = _139.error.kind; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part12)]; put(out, rt.fmtFormat([args14[0]])); } - const _195: rt.Result = nonzero_fromStrRadix$1dc3cul(_49, radix2); + const _195: rt.Result = nonzero_fromStrRadix$1c1a5i0(_49, radix2); if (_195.ok) { const arg24 = _195.value; const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg24, f)]; @@ -817,7 +817,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 3) { const radix3: rt.u32 = radix; - const iter6: rt.Iter> = rt.iterSlice([parse$0y6waa4(_49), nonzero_fromStr$1lm2uzl(_49)]); + const iter6: rt.Iter> = rt.iterSlice([parse$00ea569(_49), nonzero_fromStr$1bidi2n(_49)]); while (true) { const _236: rt.Result | rt.Done = iter6.next(); if (_236 === rt.DONE) { @@ -834,13 +834,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args22[0], "|", args22[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rt.fmtSpec({ alternate: true }, args22[1])])); } } - const _226: rt.Result = parse$0y6waa4(_49); + const _226: rt.Result = parse$00ea569(_49); if (!_226.ok) { const part11 = _226.error.kind; const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part11)]; put(out, rt.fmtFormat([args24[0]])); } - const _282: rt.Result = nonzero_fromStrRadix$1cv6o7i(_49, radix3); + const _282: rt.Result = nonzero_fromStrRadix$13ngn1e(_49, radix3); if (_282.ok) { const arg22 = _282.value; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg22, f)]; @@ -852,7 +852,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 4) { const radix4: rt.u32 = radix; - const iter7: rt.Iter> = rt.iterSlice([parse$1s5pqso(_49), nonzero_fromStr$0gvyqp3(_49)]); + const iter7: rt.Iter> = rt.iterSlice([parse$00ibreq(_49), nonzero_fromStr$0pscojv(_49)]); while (true) { const _323: rt.Result | rt.Done = iter7.next(); if (_323 === rt.DONE) { @@ -869,13 +869,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rt.fmtSpec({ alternate: true }, args32[1])])); } } - const _313: rt.Result = parse$1s5pqso(_49); + const _313: rt.Result = parse$00ibreq(_49); if (!_313.ok) { const part10 = _313.error.kind; const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part10)]; put(out, rt.fmtFormat([args34[0]])); } - const _369: rt.Result = nonzero_fromStrRadix$18imw6k(_49, radix4); + const _369: rt.Result = nonzero_fromStrRadix$14vzugb(_49, radix4); if (_369.ok) { const arg20 = _369.value; const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg20, f)]; @@ -957,7 +957,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 7) { const radix7: rt.u32 = radix; - const iter10: rt.Iter> = rt.iterSlice([parse$02m155k(_49), nonzero_fromStr$06k4xxy(_49)]); + const iter10: rt.Iter> = rt.iterSlice([parse$1kzahs9(_49), nonzero_fromStr$0b146n7(_49)]); while (true) { const _584: rt.Result | rt.Done = iter10.next(); if (_584 === rt.DONE) { @@ -974,13 +974,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args62[0], "|", args62[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rt.fmtSpec({ alternate: true }, args62[1])])); } } - const _574: rt.Result = parse$02m155k(_49); + const _574: rt.Result = parse$1kzahs9(_49); if (!_574.ok) { const part7 = _574.error.kind; const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part7)]; put(out, rt.fmtFormat([args64[0]])); } - const _630: rt.Result = nonzero_fromStrRadix$0rmwudb(_49, radix7); + const _630: rt.Result = nonzero_fromStrRadix$0tal612(_49, radix7); if (_630.ok) { const arg14 = _630.value; const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg14, f)]; @@ -992,7 +992,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 8) { const radix8: rt.u32 = radix; - const iter11: rt.Iter> = rt.iterSlice([parse$1bfudtm(_49), nonzero_fromStr$0xht6mx(_49)]); + const iter11: rt.Iter> = rt.iterSlice([parse$0wtmhwf(_49), nonzero_fromStr$1uo2nx5(_49)]); while (true) { const _671: rt.Result | rt.Done = iter11.next(); if (_671 === rt.DONE) { @@ -1009,13 +1009,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rt.fmtSpec({ alternate: true }, args72[1])])); } } - const _661: rt.Result = parse$1bfudtm(_49); + const _661: rt.Result = parse$0wtmhwf(_49); if (!_661.ok) { const part6 = _661.error.kind; const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part6)]; put(out, rt.fmtFormat([args74[0]])); } - const _717: rt.Result = nonzero_fromStrRadix$0qjnxek(_49, radix8); + const _717: rt.Result = nonzero_fromStrRadix$0cahq64(_49, radix8); if (_717.ok) { const arg12 = _717.value; const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg12, f)]; @@ -1027,7 +1027,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 9) { const radix9: rt.u32 = radix; - const iter12: rt.Iter> = rt.iterSlice([parse$034rhh2(_49), nonzero_fromStr$021o7ki(_49)]); + const iter12: rt.Iter> = rt.iterSlice([parse$08t7361(_49), nonzero_fromStr$05o7gm9(_49)]); while (true) { const _758: rt.Result | rt.Done = iter12.next(); if (_758 === rt.DONE) { @@ -1044,13 +1044,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args82[0], "|", args82[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rt.fmtSpec({ alternate: true }, args82[1])])); } } - const _748: rt.Result = parse$034rhh2(_49); + const _748: rt.Result = parse$08t7361(_49); if (!_748.ok) { const part5 = _748.error.kind; const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part5)]; put(out, rt.fmtFormat([args84[0]])); } - const _804: rt.Result = nonzero_fromStrRadix$0dk3w71(_49, radix9); + const _804: rt.Result = nonzero_fromStrRadix$10ztqkr(_49, radix9); if (_804.ok) { const arg10 = _804.value; const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg10, f)]; @@ -1062,7 +1062,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 10) { const radix10: rt.u32 = radix; - const iter13: rt.Iter> = rt.iterSlice([parse$1wp6z3o(_49), nonzero_fromStr$1myv2t6(_49)]); + const iter13: rt.Iter> = rt.iterSlice([parse$0bf4pzp(_49), nonzero_fromStr$1cmdtf2(_49)]); while (true) { const _845: rt.Result | rt.Done = iter13.next(); if (_845 === rt.DONE) { @@ -1079,13 +1079,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rt.fmtSpec({ alternate: true }, args92[1])])); } } - const _835: rt.Result = parse$1wp6z3o(_49); + const _835: rt.Result = parse$0bf4pzp(_49); if (!_835.ok) { const part4 = _835.error.kind; const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part4)]; put(out, rt.fmtFormat([args94[0]])); } - const _891: rt.Result = nonzero_fromStrRadix$0o6ntrm(_49, radix10); + const _891: rt.Result = nonzero_fromStrRadix$1vk8c0u(_49, radix10); if (_891.ok) { const arg8 = _891.value; const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg8, f)]; @@ -1167,7 +1167,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else { const radix13: rt.u32 = radix; - const iter16: rt.Iter> = rt.iterSlice([parse$16jvjal(_49), nonzero_fromStr$1gsgexo(_49)]); + const iter16: rt.Iter> = rt.iterSlice([parse$11q43n4(_49), nonzero_fromStr$1nddmw0(_49)]); while (true) { const _1106: rt.Result | rt.Done = iter16.next(); if (_1106 === rt.DONE) { @@ -1184,13 +1184,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args122[0], "|", args122[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rt.fmtSpec({ alternate: true }, args122[1])])); } } - const _1096: rt.Result = parse$16jvjal(_49); + const _1096: rt.Result = parse$11q43n4(_49); if (!_1096.ok) { const part = _1096.error.kind; const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part)]; put(out, rt.fmtFormat([args124[0]])); } - const _1152: rt.Result = nonzero_fromStrRadix$0k1ynqn(_49, radix13); + const _1152: rt.Result = nonzero_fromStrRadix$07izbug(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index 4885d84e4..c1f3ddf9b 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -421,7 +421,7 @@ export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { /** Whether `p` equals another `PhantomData`, which it always does. */ export function phantomEq$String(_1: undefined, n: rt.u8): rt.u8 { - if (!true) { + if (false) { return 0; } return n; @@ -429,7 +429,7 @@ export function phantomEq$String(_1: undefined, n: rt.u8): rt.u8 { /** Whether `u` is `()`, which it always is. */ export function unitEq(_u: undefined, n: rt.u8): rt.u8 { - if (!true) { + if (false) { return 0; } return n; @@ -437,7 +437,7 @@ export function unitEq(_u: undefined, n: rt.u8): rt.u8 { /** `n` if `p`, reassigned, equals another `PhantomData`, which it always does. */ export function rewritten(_1: undefined, n: rt.u8): rt.u8 { - if (!true) { + if (false) { return 0; } return n; @@ -448,7 +448,7 @@ export function rewritten(_1: undefined, n: rt.u8): rt.u8 { * std's `flatten` makes, whose own parameter is `value` too. */ export function flattened(_value: undefined, xs: rt.ByteVec[]): rt.u8 { - if (!true) { + if (false) { return 0; } return rt.iterCount(rt.iterFlatten(rt.iterSlice(xs), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)))) & 0xff; diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 3ace9fd18..ad5db6023 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -3515,7 +3515,17 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { Expr::Unary(_, e) | Expr::Located(_, e) | Expr::As(e, _) | Expr::Instantiate(e, _) | Expr::Postfix(e, _) => { subst(e, name, value) } - Expr::Binary(l, _, r) | Expr::Assign(l, r) => subst(l, name, value) || subst(r, name, value), + Expr::Binary(l, op, r) => { + if !(subst(l, name, value) || subst(r, name, value)) { + return false; + } + // A constant held in a temporary compares as one written in place. + if compares(op) { + *e = fold(std::mem::replace(e, Expr::This)); + } + true + } + Expr::Assign(l, r) => subst(l, name, value) || subst(r, name, value), Expr::Cond(c, a, b) => subst(c, name, value) || subst(a, name, value) || subst(b, name, value), Expr::Arrow(..) | Expr::Lambda(..) => false, } @@ -3884,19 +3894,37 @@ fn parts_of(value: &Expr, slices: &FxHashSet) -> Option bool { + matches!(op, "<" | "<=" | ">" | ">=" | "===" | "!==") +} + +/// `e` with comparisons of two number literals or two boolean ones, and their negations, +/// worked out. `tsc` refuses an equality of two literals that differ, as an instance of a +/// generic function can compare its constants. pub fn fold(e: Expr) -> Expr { match e { Expr::Binary(l, op, r) => { let (l, r) = (fold(*l), fold(*r)); - let num = |e: &Expr| match e { + let num = |e: &Expr| match e.unlocated() { Expr::Lit(t) => t.parse::().ok(), _ => None, }; + // A boolean compares as JS does, as the number it converts to. + let boolean = |e: &Expr| match e.unlocated() { + Expr::Lit(t) if t == "true" => Some(1.0), + Expr::Lit(t) if t == "false" => Some(0.0), + _ => None, + }; + if let (Some(a), Some(b)) = (boolean(&l), boolean(&r)) + && compares(op) + { + return Expr::lit(compare(op, a, b).to_string()); + } if let (Some(a), Some(b)) = (num(&l), num(&r)) { // Integer arithmetic JS does exactly, in 32 bits for the bitwise operators. An // `f64` literal is spelled with a point or an exponent, and its -0.0 is no integer. - let int = |e: &Expr| matches!(e, Expr::Lit(t) if !t.contains(['.', 'e'])); + let int = |e: &Expr| matches!(e.unlocated(), Expr::Lit(t) if !t.contains(['.', 'e'])); let small = |v: f64| v.fract() == 0.0 && v.abs() < 2f64.powi(31); if int(&l) && int(&r) && small(a) && small(b) { let (x, y) = (a as i64, b as i64); @@ -3916,17 +3944,8 @@ pub fn fold(e: Expr) -> Expr { return Expr::lit(v.to_string()); } } - let value = match op { - "<" => Some(a < b), - "<=" => Some(a <= b), - ">" => Some(a > b), - ">=" => Some(a >= b), - "===" => Some(a == b), - "!==" => Some(a != b), - _ => None, - }; - if let Some(value) = value { - return Expr::lit(value.to_string()); + if compares(op) { + return Expr::lit(compare(op, a, b).to_string()); } } Expr::Binary(Box::new(l), op, Box::new(r)) @@ -3956,10 +3975,26 @@ pub fn fold(e: Expr) -> Expr { Expr::Lit(t) if t == "false" => Expr::lit("true"), inner => Expr::Unary("!", Box::new(inner)), }, + Expr::Located(loc, inner) => match fold(*inner) { + lit @ Expr::Lit(_) => lit, + inner => Expr::Located(loc, Box::new(inner)), + }, e => e, } } +/// `a op b`, for an `op` that [`compares`]. +fn compare(op: &str, a: f64, b: f64) -> bool { + match op { + "<" => a < b, + "<=" => a <= b, + ">" => a > b, + ">=" => a >= b, + "===" => a == b, + _ => a != b, + } +} + /// Whether an assert checks what the runtime's division, remainder, negation, or shift /// checks as the operation it guards runs next, which panics with the same message. fn redundant(msg: &mir::AssertMessage<'_>) -> bool { diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 8f3692b1b..ab71b6bfa 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -215,7 +215,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { expr: rv, value: self.const_int(r), }; - num::binary(self.b, op, l, r, lty, rty, span) + let value = num::binary(self.b, op, l, r, lty, rty, span); + match op { + BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge => super::fold(value), + _ => value, + } } Rvalue::UnaryOp(op, operand) => { let aty = operand.ty(&self.mir.local_decls, tcx); diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 0b7c0838b..6a8857644 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -143,6 +143,8 @@ impl Expr { pub fn not(self) -> Self { match self { Self::Unary("!", inner) => *inner, + Self::Lit(t) if t == "true" => Self::lit("false"), + Self::Lit(t) if t == "false" => Self::lit("true"), Self::Binary(l, "===", r) => Self::Binary(l, "!==", r), Self::Binary(l, "!==", r) => Self::Binary(l, "===", r), other => Self::unary("!", other), diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 44c890172..7392598f3 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -390,6 +390,7 @@ mod lang { clones, collections, combinators, + constants, conversions, counts, cows,