From 4d36f4914bbe98c851852e4a6c3a590b012d973a Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 23:27:20 -0800 Subject: [PATCH 01/11] chore(quest): claim quest/m3/ts-string-capacity.md Quest-Claim: 235c0d59cc4969ea From aa2e239820fffeea3d26cce1d9e82ff2183c0826 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 02:55:04 -0800 Subject: [PATCH 02/11] bench(ts): str/ workloads, and prototype routes of a String Ops 17 to 20 of the codec fixture's bench code a broadcast path as moq-net's Encoder and Decoder do, join and strip one as Path::concat and strip_prefix do, and key a HashMap by String, each over an ASCII path and one with multi-byte chars. str-routes.py rewrites a translation into two models of a String for just ts bench --route: a JS string with its UTF-8 length and capacity, and UTF-8 bytes in an rt.ByteVec. Prototype only, for the decision in the PR. Co-Authored-By: Claude Opus 5.5 --- ts/bench/main.ts | 5 +- ts/bench/moq.ts | 9 ++ ts/bench/prototype/str-js.ts | 131 +++++++++++++++++ ts/bench/prototype/str-ratios.py | 54 +++++++ ts/bench/prototype/str-routes.py | 95 +++++++++++++ ts/bench/prototype/str-utf8.ts | 212 ++++++++++++++++++++++++++++ ts/bench/strings.ts | 79 +++++++++++ ts/bench/workloads.ts | 11 +- ts/fixtures/codec/expected/bench.ts | 147 ++++++++++++++++++- ts/fixtures/codec/src/bench.rs | 92 +++++++++++- 10 files changed, 830 insertions(+), 5 deletions(-) create mode 100644 ts/bench/prototype/str-js.ts create mode 100644 ts/bench/prototype/str-ratios.py create mode 100644 ts/bench/prototype/str-routes.py create mode 100644 ts/bench/prototype/str-utf8.ts create mode 100644 ts/bench/strings.ts diff --git a/ts/bench/main.ts b/ts/bench/main.ts index a5deecf87..4e345fe15 100644 --- a/ts/bench/main.ts +++ b/ts/bench/main.ts @@ -359,7 +359,7 @@ function render(): string { `- moq: ${text(["git", "-C", checkout, "rev-parse", "HEAD"])}`, ...engines.map((e) => `- ${e.engine}`), "", - "Each cell is nanoseconds per item (a varint, a frame header, a message, a byte iterated, a key, a timestamp converted, added, or compared, or a line formatted): the median", + "Each cell is nanoseconds per item (a varint, a frame header, a message, a byte iterated, a key, a timestamp converted, added, or compared, a line formatted, or a string coded, joined, or keyed): the median", `of ${rounds} samples of at least ${sampleMs} ms, ± half their interquartile range. Each round runs`, `the JS routes and workloads in a new random order, from seed ${seed}. \`native\` is a release`, "build on the host, its workloads in a fixed order. `wasm` is the same", @@ -368,7 +368,8 @@ function render(): string { "`js/net`, called as its own benchmarks call it, for `iter/` the same chain with ES", "iterator helpers (`bench/iter.ts`), for `btree/` a sorted array (`bench/sorted.ts`), for `hash/` a `Map` (`bench/hashed.ts`), and", "for `time/` conversions `bigint`, as moq's `js/hang` converts timescales (`bench/rescale.ts`),", - "for `time/checked-add` and `time/ord` moq's own `Timestamp` (`bench/timestamp.ts`), and for `fmt/` a template literal (`bench/fmt.ts`).", + "for `time/checked-add` and `time/ord` moq's own `Timestamp` (`bench/timestamp.ts`), for `fmt/` a template literal (`bench/fmt.ts`), and for `str/`", + "moq's Writer and Cursor, a template literal, and a `Map` (`bench/strings.ts`).", "Each JS route and `wasm` runs alone in a worker of its own, a fresh one each round. `A/A` is the translation again: its", "gap from `translated` is the noise. A `reads` decode is the frame headers above as they", "arrive that many bytes at a time, so a header cut by a read comes up short and is", diff --git a/ts/bench/moq.ts b/ts/bench/moq.ts index 7d8090801..38c10854f 100644 --- a/ts/bench/moq.ts +++ b/ts/bench/moq.ts @@ -17,6 +17,7 @@ import { iterate } from "./iter.ts"; import { order } from "./order.ts"; import { hashed } from "./hashed.ts"; import { packets } from "./packets.ts"; +import { decodeStrings, encodeStrings, join, keyed } from "./strings.ts"; import { push } from "./push.ts"; import { rescale } from "./rescale.ts"; import { ordered } from "./sorted.ts"; @@ -74,6 +75,14 @@ export function run(input: Uint8Array): Uint8Array | Promise { return packets(selector, data); case 16: return format(data); + case 17: + return encodeStrings(selector, data, Lite.DRAFT_06); + case 18: + return decodeStrings(data, Lite.DRAFT_06); + case 19: + return join(selector, data); + case 20: + return keyed(selector, data); default: throw new Error(`unknown workload ${op}`); } diff --git a/ts/bench/prototype/str-js.ts b/ts/bench/prototype/str-js.ts new file mode 100644 index 000000000..feff51325 --- /dev/null +++ b/ts/bench/prototype/str-js.ts @@ -0,0 +1,131 @@ +// Prototype only, for moq-dev/rust2#574's decision: a `String` as a JS string with its +// UTF-8 length and std's exact capacity. `&str` and `Box` stay JS strings. Copied to +// a translation's `rt/proto.ts` by str-routes.py. + +import { type Arguments, Err, type FmtResult, FromUtf8Error, type Formatter, type HashMap, OK, Ok, type Result, type Write, byteVecView, type ByteVec, type char } from "../rt.ts"; + +const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }); + + +/** A `String`: its text, its length in UTF-8 bytes, and its capacity. */ +export class PString { + s: string; + len: number; + cap: number; + + constructor(s: string, len: number, cap: number) { + this.s = s; + this.len = len; + this.cap = cap; + } +} + +/** The UTF-8 length of `s`. */ +export function pStrLen(s: string): number { + let n = s.length; + for (let i = 0; i < s.length; i++) { + const u = s.charCodeAt(i); + if (u >= 0x80) n += u < 0x800 || (u >= 0xd800 && u <= 0xdfff) ? 1 : 2; + } + return n; +} + +/** Room for `add` more bytes, as `RawVec::grow_amortized` makes it. */ +function grow(v: PString, add: number): void { + const needed = v.len + add; + if (needed > v.cap) v.cap = Math.max(v.cap * 2, needed, 8); +} + +/** `String::with_capacity`. */ +export function pStringNew(cap: number): PString { + return new PString("", 0, cap); +} + +/** `String::push_str`. */ +export function pStringPushStr(v: PString, t: string): void { + const n = pStrLen(t); + grow(v, n); + v.len += n; + v.s += t; +} + +/** `String::push_str` of a literal, whose length the translator knows. */ +export function pStringPushLit(v: PString, t: string, n: number): void { + grow(v, n); + v.len += n; + v.s += t; +} + +/** `String::clone`: room for exactly its bytes. */ +export function pStringClone(v: PString): PString { + return new PString(v.s, v.len, v.len); +} + +/** `String::from_utf8`, which keeps the vector's capacity. */ +export function pStringFromUtf8(bytes: ByteVec): Result { + try { + return Ok(new PString(decoder.decode(byteVecView(bytes)), bytes.length, bytes.data.length)); + } catch { + return Err(new FromUtf8Error(bytes)); + } +} + + +class Writer implements Write { + readonly v: PString; + + constructor(v: PString) { + this.v = v; + } + + writeStr(s: string): FmtResult { + pStringPushStr(this.v, s); + return OK; + } + + writeChar(c: char): FmtResult { + const n = c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; + grow(this.v, n); + this.v.len += n; + this.v.s += String.fromCodePoint(c); + return OK; + } +} + +function write(out: Write, args: Arguments): FmtResult { + for (const part of args) { + const r = typeof part === "string" ? out.writeStr(part) : part({ out, spec: {} } as Formatter); + if (!r.ok) return r; + } + return OK; +} + +/** `write!` into a `String`. */ +export function pFmtWriteString(v: PString, args: Arguments): FmtResult { + return write(new Writer(v), args); +} + +/** `Arguments::estimated_capacity`, of the literal pieces' lengths, which the translator knows. */ +function estimate(args: Arguments, pieces: number): number { + if (args.every((a) => typeof a === "string")) return pieces; + return typeof args[0] !== "string" && pieces < 16 ? 0 : pieces * 2; +} + +/** `format!`, its pieces' length given. */ +export function pFmtFormat(args: Arguments, pieces: number): PString { + const v = new PString("", 0, estimate(args, pieces)); + write(new Writer(v), args); + return v; +} + +/** `HashMap::insert` of a `String` key: the map goes by its text, and keeps the key with its value. */ +export function pHashInsertString(m: HashMap, key: PString, value: V): V | undefined { + const old = m.p.get(key.s); + m.p.set(key.s, { k: key, v: value }); + return old?.v; +} + +/** `HashMap::get` by a `&str`. */ +export function pHashGetString(m: HashMap, key: string): V | undefined { + return m.p.get(key)?.v; +} diff --git a/ts/bench/prototype/str-ratios.py b/ts/bench/prototype/str-ratios.py new file mode 100644 index 000000000..1661272a9 --- /dev/null +++ b/ts/bench/prototype/str-ratios.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +"""Per-run median ratios to `translated`, summarized over runs: median (min-max). Prototype +only, for moq-dev/rust2#574. Each run's ratio is the median over its rounds of the route's +time over `translated`'s in the same round. + +usage: str-ratios.py :,... ... +""" +import json, math, statistics, sys + +ENG = ["Node", "Bun", "Chromium", "Firefox"] + + +def engine(name): + return "Firefox" if "Firefox" in name else "Chromium" if "Chrome" in name else name.split(" ")[0] + + +def geomean(xs): + return math.exp(sum(map(math.log, xs)) / len(xs)) + + +for spec in sys.argv[1:]: + route, files = spec.split(":") + per = {} + names = [] + for f in files.split(","): + for e in json.load(open(f))["engines"]: + eng = engine(e["engine"]) + by = {} + for t in e["timings"]: + by.setdefault(f"{t['workload']} {t['op']}", {})[t["route"]] = t["ns"] + rest, aa = [], [] + for name, rs in by.items(): + if route not in rs: + continue + m = statistics.median(x / b for x, b in zip(rs[route], rs["translated"])) + a = statistics.median(x / b for x, b in zip(rs["A/A"], rs["translated"])) + aa.append(a) + if name.startswith(("str/", "fmt/")): + if name not in names: + names.append(name) + per.setdefault((eng, name), []).append(m) + per.setdefault((eng, f"A/A {name}"), []).append(a) + else: + rest.append(m) + per.setdefault((eng, "every other workload, geomean"), []).append(geomean(rest)) + per.setdefault((eng, "A/A, geomean of all"), []).append(geomean(aa)) + print(f"### {route} ÷ translated ({len(files.split(','))} runs)\n\n| workload | " + " | ".join(ENG) + " |\n|---|" + "---|" * len(ENG)) + for name in names + ["every other workload, geomean", "A/A, geomean of all"]: + cells = [] + for e in ENG: + xs = per.get((e, name), []) + cells.append(f"{statistics.median(xs):.2f} ({min(xs):.2f}-{max(xs):.2f})" if xs else "-") + print(f"| {name} | " + " | ".join(cells) + " |") + print() diff --git a/ts/bench/prototype/str-routes.py b/ts/bench/prototype/str-routes.py new file mode 100644 index 000000000..8af6a33fb --- /dev/null +++ b/ts/bench/prototype/str-routes.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +"""Rewrite a fresh translation of the codec and task fixtures into one prototype model of +a `String`, for `just ts bench --route =` to time against main. Prototype only, +for moq-dev/rust2#574's decision. + +usage: str-routes.py js|utf8 + + holds `translated/` and `task/` as `just ts run` wrote them. Each edit is what the +translator would emit for that model on the paths the `str/` and `fmt/` workloads run; +every edit must match as often as it says. + +- js: a `String` as `rt.PString`, a JS string with its UTF-8 length and capacity; a `&str` + stays a JS string. +- utf8: a `String` as an `rt.ByteVec`, a `&str` as an `rt.ByteSlice`, each literal's bytes + made once where its module loads. +""" +import re +import shutil +import sys +from pathlib import Path + +root, model = Path(sys.argv[1]), sys.argv[2] +here = Path(__file__).parent +utf8 = model == "utf8" +assert model in ("js", "utf8"), model + + +def edit(path, pairs): + p = root / "translated" / path + text = p.read_text() + for old, new, *n in pairs: + want = n[0] if n else 1 + got = len(re.findall(old, text)) if isinstance(old, re.Pattern) else text.count(old) + if got != want: + sys.exit(f"{path}: {got} matches, not {want}, for {old!r}") + text = old.sub(new, text) if isinstance(old, re.Pattern) else text.replace(old, new) + p.write_text(text) + + +shutil.copy(here / f"str-{model}.ts", root / "translated" / "rt" / "proto.ts") +edit("rt.ts", [('export * from "./rt/time.ts";\n', 'export * from "./rt/time.ts";\nexport * from "./rt/proto.ts";\n')]) + +NAMES = '["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]' +TRACKS = '["video", "audio", "catalog.json", "字幕"]' +SET = re.compile(r"s = rt\.fmtWriteString\(s, (\[.*\])\)\.s;") + +if utf8: + edit("coding/encode.Encoder.ts", [("return bytes(self, rt.stringAsBytes(v));", "return bytes(self, v);")]) +edit("coding/decode.Decoder.ts", [("rt.stringFromUtf8(", "rt.pStringFromUtf8(")]) + +bench = [ + # decode_strings + ('let last: string = "";', "let last = new rt.ByteVec(0);" if utf8 else "let last = rt.pStringNew(0);"), + ("rt.stringLen(last)", "last.length" if utf8 else "last.len", 2), + # join + ( + "let path: string = rt.stringWithCapacity(rt.usizeAdd(rt.usizeAdd(rt.stringLen(_7[_8]), 1), rt.stringLen(_30[_31])));", + "const path = new rt.ByteVec(rt.usizeAdd(rt.usizeAdd(_7[_8].length, 1), _30[_31].length));" if utf8 + else "const path = rt.pStringNew(rt.usizeAdd(rt.usizeAdd(rt.pStrLen(_7[_8]), 1), rt.pStrLen(_30[_31])));", + ), + ("path = path + _7[_8];", "rt.pStringPushStr(path, _7[_8]);"), + ('path = path + "/";', "rt.pStringPushAscii(path, 0x2f);" if utf8 else 'rt.pStringPushLit(path, "/", 1);'), + ("path = path + _30[_31];", "rt.pStringPushStr(path, _30[_31]);"), + ("rt.usizeAdd(total, rt.stringLen(path))", "rt.usizeAdd(total, path.length)" if utf8 else "rt.usizeAdd(total, path.len)"), + ("rt.strStripPrefix(path, _7[_8])", "rt.pStrStripPrefix(rt.pStringAsStr(path), _7[_8])" if utf8 else "rt.strStripPrefix(path.s, _7[_8])"), + ('rt.strStripPrefix(_53, "/")', "rt.pStrStripAscii(_53, 0x2f)" if utf8 else 'rt.strStripPrefix(_53, "/")'), + ("rt.stringLen(_58)", "_58.length" if utf8 else "rt.pStrLen(_58)"), + # keyed + ("rt.fmtPad(f, part)", "rt.pFmtPadStr(f, part)" if utf8 else "rt.fmtPad(f, part)"), + ('return rt.fmtFormat([args2[0], "/", args2[1]]);', 'return rt.pFmtFormat([args2[0], "/", args2[1]], 1);'), + ("rt.hashNew() as rt.HashMap", "rt.hashNew(rt.P_STR_HASHING) as rt.HashMap" if utf8 else "rt.hashNew() as rt.HashMap"), + ( + "rt.hashInsert(map, _32[1], _32[0] as rt.u64);", + "rt.hashInsert(map, rt.pStringClone(_32[1]), _32[0] as rt.u64);" if utf8 else "rt.pHashInsertString(map, rt.pStringClone(_32[1]), _32[0] as rt.u64);", + ), + ("rt.hashGet(map, _51)", "rt.hashGet(map, rt.pStringAsStr(_51))" if utf8 else "rt.pHashGetString(map, _51.s)"), + # format + ('const count2: rt.i64 = rt.i64Cast(rt.u64Min(takeU64(data)[0], 65536));\n\tlet s: string = "";', + "const count2: rt.i64 = rt.i64Cast(rt.u64Min(takeU64(data)[0], 65536));\n\tlet s = " + ("new rt.ByteVec(0);" if utf8 else "rt.pStringNew(0);")), + (SET, r"rt.pFmtWriteString(s, \1);"), + ("putUsize(out, rt.stringLen(s));", "putUsize(out, s.length);" if utf8 else "putUsize(out, s.len);"), + ("rt.strBytes(s)", "rt.iterSlice(rt.byteVecView(s))" if utf8 else "rt.strBytes(s.s)"), +] +if utf8: + # Each literal's bytes, made once where the module loads. + bench += [(NAMES, "[P_NAME0, P_NAME1]", 6), (TRACKS, "[P_TRACK0, P_TRACK1, P_TRACK2, P_TRACK3]", 2)] +edit("bench.ts", bench) +if utf8: + p = root / "translated" / "bench.ts" + text = p.read_text() + lits = [("P_NAME0", "demo/room-42/alice/camera"), ("P_NAME1", "démo/salle-42/アリス/📷"), + ("P_TRACK0", "video"), ("P_TRACK1", "audio"), ("P_TRACK2", "catalog.json"), ("P_TRACK3", "字幕")] + decl = "".join(f'const {n} = /* @__PURE__ */ rt.pLit("{s}");\n' for n, s in lits) + at = text.index("\nexport function ") + p.write_text(text[: at + 1] + decl + text[at + 1 :]) diff --git a/ts/bench/prototype/str-utf8.ts b/ts/bench/prototype/str-utf8.ts new file mode 100644 index 000000000..43101a449 --- /dev/null +++ b/ts/bench/prototype/str-utf8.ts @@ -0,0 +1,212 @@ +// Prototype only, for moq-dev/rust2#574's decision: a `String` as its UTF-8 bytes, an +// `rt.ByteVec`, whose storage's length is std's exact capacity, and a `&str` as an +// `rt.ByteSlice`. Copied to a translation's `rt/proto.ts` by str-routes.py. + +import { + type Arguments, + ByteSlice, + ByteVec, + byteVecExtendFromSlice, + byteVecPush, + byteVecView, + Err, + type FmtResult, + FromUtf8Error, + type Formatter, + fmtPad, + hashing, + OK, + Ok, + type Result, + utf8Check, + type Write, + type char, +} from "../rt.ts"; + +const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { ignoreBOM: true }); +const encoder = /* @__PURE__ */ new TextEncoder(); + +/** A literal's bytes, made once where the module loads. */ +export function pLit(s: string): ByteSlice { + const b = encoder.encode(s); + return new ByteSlice(b, 0, b.length); +} + +/** A `String`'s or a `&str`'s bytes. */ +function view(s: ByteVec | ByteSlice): Uint8Array { + return s instanceof ByteVec ? s.data.subarray(0, s.length) : s.data.subarray(s.start, s.start + s.length); +} + +/** `String::push_str`. */ +export function pStringPushStr(v: ByteVec, t: ByteSlice): void { + byteVecExtendFromSlice(v, t); +} + +/** `String::push` of an ASCII char. */ +export function pStringPushAscii(v: ByteVec, c: number): void { + byteVecPush(v, c); +} + +/** `&**s`: a `String`'s text. */ +export function pStringAsStr(v: ByteVec): ByteSlice { + return new ByteSlice(v.data, 0, v.length); +} + +/** `String::clone`: room for exactly its bytes. */ +export function pStringClone(v: ByteVec): ByteVec { + const c = new ByteVec(v.length); + c.data.set(byteVecView(v)); + c.length = v.length; + return c; +} + +/** `String::from_utf8`: the vector itself, checked. */ +export function pStringFromUtf8(bytes: ByteVec): Result { + return utf8Check(byteVecView(bytes)) === undefined ? Ok(bytes) : Err(new FromUtf8Error(bytes)); +} + +/** `str::strip_prefix` of a `&str`. */ +export function pStrStripPrefix(s: ByteSlice, p: ByteSlice): ByteSlice | undefined { + if (p.length > s.length) return undefined; + for (let i = 0; i < p.length; i++) if (s.data[s.start + i] !== p.data[p.start + i]) return undefined; + return new ByteSlice(s.data, s.start + p.length, s.length - p.length); +} + +/** `str::strip_prefix` of an ASCII char. */ +export function pStrStripAscii(s: ByteSlice, c: number): ByteSlice | undefined { + return s.length > 0 && s.data[s.start] === c ? new ByteSlice(s.data, s.start + 1, s.length - 1) : undefined; +} + +/** The UTF-8 length of `s`. */ +function utf8Len(s: string): number { + let n = s.length; + for (let i = 0; i < s.length; i++) { + const u = s.charCodeAt(i); + if (u >= 0x80) n += u < 0x800 || (u >= 0xd800 && u <= 0xdfff) ? 1 : 2; + } + return n; +} + +/** Room for `add` more bytes, as `RawVec::grow_amortized` makes it. */ +function reserve(v: ByteVec, add: number): void { + const needed = v.length + add; + if (needed <= v.data.length) return; + const grown = new Uint8Array(Math.max(needed, v.data.length * 2, 8)); + grown.set(v.data); + v.data = grown; +} + +/** Encode a JS string onto `v`, growing it as std's `push_str` of its UTF-8 would. */ +function pushJs(v: ByteVec, s: string): void { + // Room for three bytes a code unit holds it whatever it is, and no growth would happen. + if (v.data.length - v.length < 3 * s.length) reserve(v, utf8Len(s)); + if (s.length <= 16) { + const d = v.data; + let at = v.length; + for (let i = 0; i < s.length; i++) { + let c = s.charCodeAt(i); + if (c < 0x80) { + d[at++] = c; + continue; + } + if (c >= 0xd800 && c <= 0xdbff) c = s.codePointAt(i++) as number; + at = putChar(d, at, c); + } + v.length = at; + } else { + v.length += encoder.encodeInto(s, v.data.subarray(v.length)).written; + } +} + +function putChar(d: Uint8Array, at: number, c: number): number { + if (c < 0x80) d[at++] = c; + else if (c < 0x800) { + d[at++] = 0xc0 | (c >> 6); + d[at++] = 0x80 | (c & 0x3f); + } else if (c < 0x10000) { + d[at++] = 0xe0 | (c >> 12); + d[at++] = 0x80 | ((c >> 6) & 0x3f); + d[at++] = 0x80 | (c & 0x3f); + } else { + d[at++] = 0xf0 | (c >> 18); + d[at++] = 0x80 | ((c >> 12) & 0x3f); + d[at++] = 0x80 | ((c >> 6) & 0x3f); + d[at++] = 0x80 | (c & 0x3f); + } + return at; +} + +/** Writes into a `String`'s bytes, and takes a `&str`'s bytes as they are. */ +class Writer implements Write { + readonly v: ByteVec; + + constructor(v: ByteVec) { + this.v = v; + } + + writeStr(s: string): FmtResult { + pushJs(this.v, s); + return OK; + } + + writeBytes(s: ByteSlice): FmtResult { + byteVecExtendFromSlice(this.v, s); + return OK; + } + + writeChar(c: char): FmtResult { + reserve(this.v, c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4); + this.v.length = putChar(this.v.data, this.v.length, c); + return OK; + } +} + +/** A `&str`'s `Display`: its bytes as they are into a `String`, else decoded. */ +export function pFmtPadStr(f: Formatter, s: ByteSlice): FmtResult { + if (f.out instanceof Writer && f.spec.width === undefined && f.spec.precision === undefined) return f.out.writeBytes(s); + return fmtPad(f, decoder.decode(view(s))); +} + +function write(out: Write, args: Arguments): FmtResult { + for (const part of args) { + const r = typeof part === "string" ? out.writeStr(part) : part({ out, spec: {} } as Formatter); + if (!r.ok) return r; + } + return OK; +} + +/** `write!` into a `String`. */ +export function pFmtWriteString(v: ByteVec, args: Arguments): FmtResult { + return write(new Writer(v), args); +} + +/** `Arguments::estimated_capacity`, of the literal pieces' lengths, which the translator knows. */ +function estimate(args: Arguments, pieces: number): number { + if (args.every((a) => typeof a === "string")) return pieces; + return typeof args[0] !== "string" && pieces < 16 ? 0 : pieces * 2; +} + +/** `format!`, its pieces' length given. */ +export function pFmtFormat(args: Arguments, pieces: number): ByteVec { + const v = new ByteVec(estimate(args, pieces)); + write(new Writer(v), args); + return v; +} + +const FF = [0xff]; + +/** A `String` or `&str` key: its bytes, then 0xff, as `Hash for str` writes them. */ +export const P_STR_HASHING = /* @__PURE__ */ hashing( + (k, s) => { + s.ints(view(k), 1); + s.ints(FF, 1); + }, + (a, b) => { + if (a.length !== b.length) return false; + const x = view(a); + const y = view(b); + for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false; + return true; + }, + true, +); diff --git a/ts/bench/strings.ts b/ts/bench/strings.ts new file mode 100644 index 000000000..1427cd3ae --- /dev/null +++ b/ts/bench/strings.ts @@ -0,0 +1,79 @@ +// The `str/` workloads' hand-written route: `bench.rs`'s ops 17 to 20, as moq's TypeScript +// codes a path through its Writer and Cursor, joins it with a template literal, and keys a +// `Map` by it. + +import { Cursor, type StreamVersion, Writer } from "moq/js/net/src/stream.ts"; + +const NAMES = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; +const TRACKS = ["video", "audio", "catalog.json", "字幕"]; +const encoder = new TextEncoder(); + +/** Op 17: the `selector`th name, as many times as `data`'s count, each size-prefixed. */ +export function encodeStrings(selector: number, data: Uint8Array, version: StreamVersion): Promise { + const count = Number(u64(data, 0)); + const name = NAMES[selector % NAMES.length] as string; + return Writer.collect(version, async (w) => { + for (let i = 0; i < count; i++) await w.string(name); + }); +} + +/** Op 18: every string on the wire. */ +export function decodeStrings(wire: Uint8Array, version: StreamVersion): Uint8Array { + const cursor = new Cursor(wire, version); + let count = 0; + let total = 0; + let last = ""; + while (cursor.remaining > 0) { + const start = cursor.offset; + last = cursor.string(); + total += cursor.offset - start; + count++; + } + const size = encoder.encode(last).byteLength; + // Each prefix is the one byte of a QUIC varint under 64. + return u64s(count, total - count, size); +} + +/** Op 19: each path joined and stripped of its name. */ +export function join(selector: number, data: Uint8Array): Uint8Array { + const count = Math.min(Number(u64(data, 0)), 1 << 16); + const name = NAMES[selector % NAMES.length] as string; + // Rust counts UTF-8 bytes: each part's, measured once. + const nameLen = encoder.encode(name).byteLength; + const trackLens = TRACKS.map((t) => encoder.encode(t).byteLength); + let total = 0; + let stripped = 0; + for (let i = 0; i < count; i++) { + const track = TRACKS[i % TRACKS.length] as string; + const path = `${name}/${track}`; + const trackLen = trackLens[i % TRACKS.length] as number; + total += nameLen + 1 + trackLen; + if (path.startsWith(name) && path[name.length] === "/") stripped += trackLen; + } + return u64s(total, stripped); +} + +/** Op 20: each path a key of a `Map`, looked up four times. */ +export function keyed(selector: number, data: Uint8Array): Uint8Array { + const count = Math.min(Number(u64(data, 0)), 1 << 16); + const name = NAMES[selector % NAMES.length] as string; + const keys = Array.from({ length: count }, (_, i) => `${name}/${i}`); + const map = new Map(); + keys.forEach((key, i) => map.set(key, i)); + let sum = 0; + for (let round = 0; round < 4; round++) for (const key of keys) sum += map.get(key) ?? 0; + return u64s(sum, map.size); +} + +function u64(data: Uint8Array, i: number): bigint { + const bytes = new Uint8Array(8); + bytes.set(data.subarray(i * 8, i * 8 + 8)); + return new DataView(bytes.buffer).getBigUint64(0); +} + +function u64s(...values: number[]): Uint8Array { + const out = new Uint8Array(values.length * 8); + const view = new DataView(out.buffer); + values.forEach((v, i) => view.setBigUint64(i * 8, BigInt(v))); + return out; +} diff --git a/ts/bench/workloads.ts b/ts/bench/workloads.ts index 6cd46aa02..94500ba58 100644 --- a/ts/bench/workloads.ts +++ b/ts/bench/workloads.ts @@ -5,7 +5,7 @@ export interface Workload { /** What is coded, such as `varint/quic/2B` or `frames/video/lite-07`, iterated, or converted. */ name: string; - op: "encode" | "decode" | "iterate" | "map" | "convert" | "add" | "compare" | "order" | "push" | "number" | "format" | "handoff"; + op: "encode" | "decode" | "iterate" | "map" | "convert" | "add" | "compare" | "order" | "push" | "number" | "format" | "join" | "handoff"; /** Varints, frame headers, messages, items, keys, timestamps, integers, packets, lines, or handoffs per call, which each time is divided by. */ items: number; input: Uint8Array; @@ -120,6 +120,15 @@ export function workloads(encode: (input: Uint8Array) => Uint8Array): Workload[] // `bench.rs`'s op 16: log lines formatted into one `String`. out.push({ name: "fmt/lines", op: "format", items: count, input: Uint8Array.of(16, 0, ...u64(BigInt(count))) }); + + // `bench.rs`'s ops 17 to 20 over a broadcast path, ASCII or not: coded as moq-net codes + // one, joined to a track and stripped, and a `HashMap`'s keys. + const strings = 256; + ["ascii", "utf8"].forEach((name, selector) => { + pair(`str/${name}`, strings, 17, selector, [BigInt(strings)]); + out.push({ name: `str/join/${name}`, op: "join", items: strings, input: Uint8Array.of(19, selector, ...u64(BigInt(strings))) }); + out.push({ name: `str/keyed/${name}`, op: "map", items: strings, input: Uint8Array.of(20, selector, ...u64(BigInt(strings))) }); + }); return out; } diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 9de8a24d4..786ebcd5e 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -10,7 +10,7 @@ import type * as EncodeError from "./coding/encode.EncodeError.ts"; import * as Encoder from "./coding/encode.Encoder.ts"; import { zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as Form from "./coding/varint.Form.ts"; -import { unwrapOr$11c0we2 as option_unwrapOr$11c0we2, map$1cf8u0y as option_map$1cf8u0y, mapOr$1jt76jv as option_mapOr$1jt76jv } from "./core/option.ts"; +import { unwrapOr$11c0we2 as option_unwrapOr$11c0we2, unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, map$1cf8u0y as option_map$1cf8u0y, mapOr$1jt76jv as option_mapOr$1jt76jv } from "./core/option.ts"; import { form, liteVersion, putU64 as harness_putU64, putUsize, takeU64, decodeError, encodeError } from "./harness.ts"; import * as Group from "./lite/group.Group.ts"; import type * as lite_version_Version from "./lite/version.Version.ts"; @@ -54,6 +54,14 @@ export function run(input: rt.ByteSlice): rt.ByteVec { packets(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 16) { format(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 17) { + encoded(encodeStrings(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 18) { + decoded(decodeStrings(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 19) { + join(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 20) { + keyed(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { decoded(decodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } @@ -496,6 +504,143 @@ export function format(data: rt.ByteSlice, out: rt.ByteVec): void { }), rt.u64Add, 0)); } +/** + * The `selector`th name of [`NAMES`], `count` times, each size-prefixed, as moq-net's + * `Encoder::string` writes a path. + */ +export function encodeStrings(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): rt.Result { + const count: rt.u64 = takeU64(data)[0]; + const _8: rt.usize = rt.usizeRem(selector as rt.usize, ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"].length); + if (!(_8 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const w: Encoder.Encoder = Encoder.new(out, { tag: "Quic" } as Form.Form); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = rt.u64Low(count); + while (true) { + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + if (!(iterStart++ < iterEnd)) { + break; + } + const _24: rt.Result = Encoder.string(w, _7[_8]); + if (!_24.ok) { + return _24; + } + } + return rt.OK; +} + +/** + * Every string on the wire, each an owned `String`, as moq-net decodes a path: how many, + * their total length, and the last one's. + */ +export function decodeStrings(wire: rt.ByteSlice, out: rt.ByteVec): rt.Result { + const r: Decoder.Decoder = Decoder.new(wire, { tag: "Quic" } as Form.Form); + let count: rt.usize = 0; + let total: rt.usize = 0; + let last: string = ""; + while (!Decoder.isEmpty(r)) { + const _10: rt.Result = Decoder.string(r); + if (_10.ok) { + last = _10.value; + total = rt.usizeAdd(total, rt.stringLen(last)); + count = rt.usizeAdd(count, 1); + } else { + return _10; + } + } + putUsize(out, count); + putUsize(out, total); + putUsize(out, rt.stringLen(last)); + return rt.OK; +} + +/** + * `count` paths, each the `selector`th name of [`NAMES`] and a track joined into a + * `String` sized up front, as moq-net's `Path::concat` builds one, then stripped of the + * name at a segment boundary, as `Path::strip_prefix` is: their total length, and the + * stripped tracks'. + */ +export function join(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let _25!: rt.usize; + const count: rt.u64 = takeU64(data)[0]; + const _8: rt.usize = rt.usizeRem(selector as rt.usize, ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"].length); + if (!(_8 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + let total: rt.usize = 0; + let stripped: rt.usize = 0; + const _19: rt.usize = rt.u64Low(rt.u64Min(count, 65536)); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = _19; + while ((_25 = iterStart++) < iterEnd) { + const _31: rt.usize = rt.usizeRem(_25, ["video", "audio", "catalog.json", "字幕"].length); + if (!(_31 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _31); + } + const _30: string[] = ["video", "audio", "catalog.json", "字幕"]; + let path: string = rt.stringWithCapacity(rt.usizeAdd(rt.usizeAdd(rt.stringLen(_7[_8]), 1), rt.stringLen(_30[_31]))); + path = path + _7[_8]; + path = path + "/"; + path = path + _30[_31]; + total = rt.usizeAdd(total, rt.stringLen(path)); + const _53: string | undefined = rt.strStripPrefix(path, _7[_8]); + if (_53 !== undefined) { + const _58: string | undefined = rt.strStripPrefix(_53, "/"); + if (_58 !== undefined) { + stripped = rt.usizeAdd(stripped, rt.stringLen(_58)); + } + } + } + putUsize(out, total); + putUsize(out, stripped); +} + +/** + * `count` paths, the `selector`th name of [`NAMES`] and a number, each a key of a + * `HashMap` and looked up by its `&str` four times, as moq-net finds a broadcast by its + * path: the sum of what the lookups found. + */ +export function keyed(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const count: rt.u64 = takeU64(data)[0]; + const _8: rt.usize = rt.usizeRem(selector as rt.usize, ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"].length); + if (!(_8 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + const keys: string[] = rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u64Low(rt.u64Min(count, 65536))), (i2: rt.u32): string => { + const part = _7[_8]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part), (f: rt.Formatter) => rt.u32Display(i2, f)]; + return rt.fmtFormat([args2[0], "/", args2[1]]); + }), undefined, 12, true); + const map: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, string]> = rt.iterEnumerate(rt.iterSlice(keys)); + while (true) { + const _32: [rt.usize, string] | rt.Done = iter.next(); + if (_32 === rt.DONE) { + break; + } + rt.hashInsert(map, _32[1], _32[0] as rt.u64); + } + let sum: rt.u64 = 0; + let iterStart: rt.i32 = 0; + const iterEnd: rt.i32 = 4; + l3: while (iterStart++ < iterEnd) { + const iterS: string[] = keys; + let iterI: number = 0; + while (true) { + const _51: string | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_51 === rt.DONE) { + continue l3; + } + sum = rt.u64Add(sum, option_unwrapOr$1tvry1i(rt.hashGet(map, _51), 0)); + } + } + harness_putU64(out, sum); + putUsize(out, rt.hashLen(map)); +} + /** * `count` TS packets of 188 bytes, each written by element through `as_chunks_mut`, then * numbered by continuity counter as moq-mux's `container/ts/export.rs` numbers them; with diff --git a/ts/fixtures/codec/src/bench.rs b/ts/fixtures/codec/src/bench.rs index 5c4d002c2..5ecb7fed5 100644 --- a/ts/fixtures/codec/src/bench.rs +++ b/ts/fixtures/codec/src/bench.rs @@ -6,7 +6,9 @@ //! keeps a `BTreeMap`, as moq-net's model keeps its state, op 9 converts timestamps //! between timescales, ops 10 and 11 add and order them as moq-net's `Timestamp` does, //! op 12 orders integers by std's own `Ord`, op 13 pushes onto vectors, op 14 keeps a -//! `HashMap`, op 15 numbers TS packets as moq-mux does, and op 16 formats log lines. +//! `HashMap`, op 15 numbers TS packets as moq-mux does, op 16 formats log lines, ops 17 +//! and 18 code strings as moq-net codes a path, op 19 joins and strips paths, and op 20 +//! keeps a `HashMap` keyed by `String`. use std::cmp::Ordering; use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, VecDeque}; @@ -43,6 +45,10 @@ pub fn run(input: &[u8]) -> Vec { 14 => hashed(selector, data, &mut out), 15 => packets(selector, data, &mut out), 16 => format(data, &mut out), + 17 => encoded(encode_strings(selector, data, &mut out), &mut out), + 18 => decoded(decode_strings(data, &mut out), &mut out), + 19 => join(selector, data, &mut out), + 20 => keyed(selector, data, &mut out), _ => decoded(decode_group(data, lite_version(selector), &mut out), &mut out), } out @@ -320,6 +326,90 @@ fn format(data: &[u8], out: &mut Vec) { put_u64(out, s.bytes().map(u64::from).sum()); } +/// Broadcast paths as moq names them: one ASCII, and one with chars of two, three, and four +/// bytes. +const NAMES: [&str; 2] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + +/// The tracks `join` appends to a broadcast's path. +const TRACKS: [&str; 4] = ["video", "audio", "catalog.json", "字幕"]; + +/// The `selector`th name of [`NAMES`], `count` times, each size-prefixed, as moq-net's +/// `Encoder::string` writes a path. +fn encode_strings(selector: u8, data: &[u8], out: &mut Vec) -> Result<(), EncodeError> { + let (count, _) = take_u64(data); + let name = NAMES[selector as usize % NAMES.len()]; + let mut w = Encoder::new(out, Form::Quic); + for _ in 0..count as usize { + w.string(name)?; + } + Ok(()) +} + +/// Every string on the wire, each an owned `String`, as moq-net decodes a path: how many, +/// their total length, and the last one's. +fn decode_strings(wire: &[u8], out: &mut Vec) -> Result<(), DecodeError> { + let mut r = Decoder::new(wire, Form::Quic); + let mut count = 0; + let mut total = 0; + let mut last = String::new(); + while !r.is_empty() { + last = r.string()?; + total += last.len(); + count += 1; + } + put_usize(out, count); + put_usize(out, total); + put_usize(out, last.len()); + Ok(()) +} + +/// `count` paths, each the `selector`th name of [`NAMES`] and a track joined into a +/// `String` sized up front, as moq-net's `Path::concat` builds one, then stripped of the +/// name at a segment boundary, as `Path::strip_prefix` is: their total length, and the +/// stripped tracks'. +fn join(selector: u8, data: &[u8], out: &mut Vec) { + let (count, _) = take_u64(data); + let name = NAMES[selector as usize % NAMES.len()]; + let mut total = 0; + let mut stripped = 0; + for i in 0..count.min(1 << 16) as usize { + let track = TRACKS[i % TRACKS.len()]; + let mut path = String::with_capacity(name.len() + 1 + track.len()); + path.push_str(name); + path.push('/'); + path.push_str(track); + total += path.len(); + if let Some(rest) = path.strip_prefix(name) + && let Some(rest) = rest.strip_prefix('/') + { + stripped += rest.len(); + } + } + put_usize(out, total); + put_usize(out, stripped); +} + +/// `count` paths, the `selector`th name of [`NAMES`] and a number, each a key of a +/// `HashMap` and looked up by its `&str` four times, as moq-net finds a broadcast by its +/// path: the sum of what the lookups found. +fn keyed(selector: u8, data: &[u8], out: &mut Vec) { + let (count, _) = take_u64(data); + let name = NAMES[selector as usize % NAMES.len()]; + let keys: Vec = (0..count.min(1 << 16) as u32).map(|i| format!("{name}/{i}")).collect(); + let mut map = HashMap::new(); + for (i, key) in keys.iter().enumerate() { + map.insert(key.clone(), i as u64); + } + let mut sum = 0u64; + for _ in 0..4 { + for key in &keys { + sum += map.get(key.as_str()).copied().unwrap_or(0); + } + } + put_u64(out, sum); + put_usize(out, map.len()); +} + /// A pair `format` writes with its derived `Debug`. #[derive(Debug)] struct Point { From 8458a07cfb0e161d411561ef23cb66560d0585c1 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 02:59:58 -0800 Subject: [PATCH 03/11] chore(ts): name the prototypes' runtime rs, after main's rename Co-Authored-By: Claude Opus 5.5 --- ts/bench/prototype/str-js.ts | 4 +- ts/bench/prototype/str-routes.py | 62 ++++++------ ts/bench/prototype/str-utf8.ts | 6 +- ts/fixtures/codec/expected/bench.ts | 147 +++++++++++++++++++++++++++- 4 files changed, 182 insertions(+), 37 deletions(-) diff --git a/ts/bench/prototype/str-js.ts b/ts/bench/prototype/str-js.ts index feff51325..4a52b2e22 100644 --- a/ts/bench/prototype/str-js.ts +++ b/ts/bench/prototype/str-js.ts @@ -1,8 +1,8 @@ // Prototype only, for moq-dev/rust2#574's decision: a `String` as a JS string with its // UTF-8 length and std's exact capacity. `&str` and `Box` stay JS strings. Copied to -// a translation's `rt/proto.ts` by str-routes.py. +// a translation's `rs/proto.ts` by str-routes.py. -import { type Arguments, Err, type FmtResult, FromUtf8Error, type Formatter, type HashMap, OK, Ok, type Result, type Write, byteVecView, type ByteVec, type char } from "../rt.ts"; +import { type Arguments, Err, type FmtResult, FromUtf8Error, type Formatter, type HashMap, OK, Ok, type Result, type Write, byteVecView, type ByteVec, type char } from "../rs.ts"; const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }); diff --git a/ts/bench/prototype/str-routes.py b/ts/bench/prototype/str-routes.py index 8af6a33fb..6cb4b7835 100644 --- a/ts/bench/prototype/str-routes.py +++ b/ts/bench/prototype/str-routes.py @@ -9,9 +9,9 @@ translator would emit for that model on the paths the `str/` and `fmt/` workloads run; every edit must match as often as it says. -- js: a `String` as `rt.PString`, a JS string with its UTF-8 length and capacity; a `&str` +- js: a `String` as `rs.PString`, a JS string with its UTF-8 length and capacity; a `&str` stays a JS string. -- utf8: a `String` as an `rt.ByteVec`, a `&str` as an `rt.ByteSlice`, each literal's bytes +- utf8: a `String` as an `rs.ByteVec`, a `&str` as an `rs.ByteSlice`, each literal's bytes made once where its module loads. """ import re @@ -37,49 +37,49 @@ def edit(path, pairs): p.write_text(text) -shutil.copy(here / f"str-{model}.ts", root / "translated" / "rt" / "proto.ts") -edit("rt.ts", [('export * from "./rt/time.ts";\n', 'export * from "./rt/time.ts";\nexport * from "./rt/proto.ts";\n')]) +shutil.copy(here / f"str-{model}.ts", root / "translated" / "rs" / "proto.ts") +edit("rs.ts", [('export * from "./rs/time.ts";\n', 'export * from "./rs/time.ts";\nexport * from "./rs/proto.ts";\n')]) NAMES = '["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]' TRACKS = '["video", "audio", "catalog.json", "字幕"]' -SET = re.compile(r"s = rt\.fmtWriteString\(s, (\[.*\])\)\.s;") +SET = re.compile(r"s = rs\.fmtWriteString\(s, (\[.*\])\)\.s;") if utf8: - edit("coding/encode.Encoder.ts", [("return bytes(self, rt.stringAsBytes(v));", "return bytes(self, v);")]) -edit("coding/decode.Decoder.ts", [("rt.stringFromUtf8(", "rt.pStringFromUtf8(")]) + edit("coding/encode.Encoder.ts", [("return bytes(self, rs.stringAsBytes(v));", "return bytes(self, v);")]) +edit("coding/decode.Decoder.ts", [("rs.stringFromUtf8(", "rs.pStringFromUtf8(")]) bench = [ # decode_strings - ('let last: string = "";', "let last = new rt.ByteVec(0);" if utf8 else "let last = rt.pStringNew(0);"), - ("rt.stringLen(last)", "last.length" if utf8 else "last.len", 2), + ('let last: string = "";', "let last = new rs.ByteVec(0);" if utf8 else "let last = rs.pStringNew(0);"), + ("rs.stringLen(last)", "last.length" if utf8 else "last.len", 2), # join ( - "let path: string = rt.stringWithCapacity(rt.usizeAdd(rt.usizeAdd(rt.stringLen(_7[_8]), 1), rt.stringLen(_30[_31])));", - "const path = new rt.ByteVec(rt.usizeAdd(rt.usizeAdd(_7[_8].length, 1), _30[_31].length));" if utf8 - else "const path = rt.pStringNew(rt.usizeAdd(rt.usizeAdd(rt.pStrLen(_7[_8]), 1), rt.pStrLen(_30[_31])));", + "let path: string = rs.stringWithCapacity(rs.usizeAdd(rs.usizeAdd(rs.stringLen(_7[_8]), 1), rs.stringLen(_30[_31])));", + "const path = new rs.ByteVec(rs.usizeAdd(rs.usizeAdd(_7[_8].length, 1), _30[_31].length));" if utf8 + else "const path = rs.pStringNew(rs.usizeAdd(rs.usizeAdd(rs.pStrLen(_7[_8]), 1), rs.pStrLen(_30[_31])));", ), - ("path = path + _7[_8];", "rt.pStringPushStr(path, _7[_8]);"), - ('path = path + "/";', "rt.pStringPushAscii(path, 0x2f);" if utf8 else 'rt.pStringPushLit(path, "/", 1);'), - ("path = path + _30[_31];", "rt.pStringPushStr(path, _30[_31]);"), - ("rt.usizeAdd(total, rt.stringLen(path))", "rt.usizeAdd(total, path.length)" if utf8 else "rt.usizeAdd(total, path.len)"), - ("rt.strStripPrefix(path, _7[_8])", "rt.pStrStripPrefix(rt.pStringAsStr(path), _7[_8])" if utf8 else "rt.strStripPrefix(path.s, _7[_8])"), - ('rt.strStripPrefix(_53, "/")', "rt.pStrStripAscii(_53, 0x2f)" if utf8 else 'rt.strStripPrefix(_53, "/")'), - ("rt.stringLen(_58)", "_58.length" if utf8 else "rt.pStrLen(_58)"), + ("path = path + _7[_8];", "rs.pStringPushStr(path, _7[_8]);"), + ('path = path + "/";', "rs.pStringPushAscii(path, 0x2f);" if utf8 else 'rs.pStringPushLit(path, "/", 1);'), + ("path = path + _30[_31];", "rs.pStringPushStr(path, _30[_31]);"), + ("rs.usizeAdd(total, rs.stringLen(path))", "rs.usizeAdd(total, path.length)" if utf8 else "rs.usizeAdd(total, path.len)"), + ("rs.strStripPrefix(path, _7[_8])", "rs.pStrStripPrefix(rs.pStringAsStr(path), _7[_8])" if utf8 else "rs.strStripPrefix(path.s, _7[_8])"), + ('rs.strStripPrefix(_53, "/")', "rs.pStrStripAscii(_53, 0x2f)" if utf8 else 'rs.strStripPrefix(_53, "/")'), + ("rs.stringLen(_58)", "_58.length" if utf8 else "rs.pStrLen(_58)"), # keyed - ("rt.fmtPad(f, part)", "rt.pFmtPadStr(f, part)" if utf8 else "rt.fmtPad(f, part)"), - ('return rt.fmtFormat([args2[0], "/", args2[1]]);', 'return rt.pFmtFormat([args2[0], "/", args2[1]], 1);'), - ("rt.hashNew() as rt.HashMap", "rt.hashNew(rt.P_STR_HASHING) as rt.HashMap" if utf8 else "rt.hashNew() as rt.HashMap"), + ("rs.fmtPad(f, part)", "rs.pFmtPadStr(f, part)" if utf8 else "rs.fmtPad(f, part)"), + ('return rs.fmtFormat([args2[0], "/", args2[1]]);', 'return rs.pFmtFormat([args2[0], "/", args2[1]], 1);'), + ("rs.hashNew() as rs.HashMap", "rs.hashNew(rs.P_STR_HASHING) as rs.HashMap" if utf8 else "rs.hashNew() as rs.HashMap"), ( - "rt.hashInsert(map, _32[1], _32[0] as rt.u64);", - "rt.hashInsert(map, rt.pStringClone(_32[1]), _32[0] as rt.u64);" if utf8 else "rt.pHashInsertString(map, rt.pStringClone(_32[1]), _32[0] as rt.u64);", + "rs.hashInsert(map, _32[1], _32[0] as rs.u64);", + "rs.hashInsert(map, rs.pStringClone(_32[1]), _32[0] as rs.u64);" if utf8 else "rs.pHashInsertString(map, rs.pStringClone(_32[1]), _32[0] as rs.u64);", ), - ("rt.hashGet(map, _51)", "rt.hashGet(map, rt.pStringAsStr(_51))" if utf8 else "rt.pHashGetString(map, _51.s)"), + ("rs.hashGet(map, _51)", "rs.hashGet(map, rs.pStringAsStr(_51))" if utf8 else "rs.pHashGetString(map, _51.s)"), # format - ('const count2: rt.i64 = rt.i64Cast(rt.u64Min(takeU64(data)[0], 65536));\n\tlet s: string = "";', - "const count2: rt.i64 = rt.i64Cast(rt.u64Min(takeU64(data)[0], 65536));\n\tlet s = " + ("new rt.ByteVec(0);" if utf8 else "rt.pStringNew(0);")), - (SET, r"rt.pFmtWriteString(s, \1);"), - ("putUsize(out, rt.stringLen(s));", "putUsize(out, s.length);" if utf8 else "putUsize(out, s.len);"), - ("rt.strBytes(s)", "rt.iterSlice(rt.byteVecView(s))" if utf8 else "rt.strBytes(s.s)"), + ('const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536));\n\tlet s: string = "";', + "const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536));\n\tlet s = " + ("new rs.ByteVec(0);" if utf8 else "rs.pStringNew(0);")), + (SET, r"rs.pFmtWriteString(s, \1);"), + ("putUsize(out, rs.stringLen(s));", "putUsize(out, s.length);" if utf8 else "putUsize(out, s.len);"), + ("rs.strBytes(s)", "rs.iterSlice(rs.byteVecView(s))" if utf8 else "rs.strBytes(s.s)"), ] if utf8: # Each literal's bytes, made once where the module loads. @@ -90,6 +90,6 @@ def edit(path, pairs): text = p.read_text() lits = [("P_NAME0", "demo/room-42/alice/camera"), ("P_NAME1", "démo/salle-42/アリス/📷"), ("P_TRACK0", "video"), ("P_TRACK1", "audio"), ("P_TRACK2", "catalog.json"), ("P_TRACK3", "字幕")] - decl = "".join(f'const {n} = /* @__PURE__ */ rt.pLit("{s}");\n' for n, s in lits) + decl = "".join(f'const {n} = /* @__PURE__ */ rs.pLit("{s}");\n' for n, s in lits) at = text.index("\nexport function ") p.write_text(text[: at + 1] + decl + text[at + 1 :]) diff --git a/ts/bench/prototype/str-utf8.ts b/ts/bench/prototype/str-utf8.ts index 43101a449..764a1f4d5 100644 --- a/ts/bench/prototype/str-utf8.ts +++ b/ts/bench/prototype/str-utf8.ts @@ -1,6 +1,6 @@ // Prototype only, for moq-dev/rust2#574's decision: a `String` as its UTF-8 bytes, an -// `rt.ByteVec`, whose storage's length is std's exact capacity, and a `&str` as an -// `rt.ByteSlice`. Copied to a translation's `rt/proto.ts` by str-routes.py. +// `rs.ByteVec`, whose storage's length is std's exact capacity, and a `&str` as an +// `rs.ByteSlice`. Copied to a translation's `rs/proto.ts` by str-routes.py. import { type Arguments, @@ -21,7 +21,7 @@ import { utf8Check, type Write, type char, -} from "../rt.ts"; +} from "../rs.ts"; const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { ignoreBOM: true }); const encoder = /* @__PURE__ */ new TextEncoder(); diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 458d7413f..85afcfa3c 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -10,7 +10,7 @@ import type * as EncodeError from "./coding/encode.EncodeError.ts"; import * as Encoder from "./coding/encode.Encoder.ts"; import { zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as Form from "./coding/varint.Form.ts"; -import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; +import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; import { form, liteVersion, putU64 as harness_putU64, putUsize, takeU64, decodeError, encodeError } from "./harness.ts"; import * as Group from "./lite/group.Group.ts"; import type * as lite_version_Version from "./lite/version.Version.ts"; @@ -54,6 +54,14 @@ export function run(input: rs.ByteSlice): rs.ByteVec { packets(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 16) { format(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 17) { + encoded(encodeStrings(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 18) { + decoded(decodeStrings(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 19) { + join(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 20) { + keyed(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { decoded(decodeGroup(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } @@ -519,6 +527,143 @@ export function format(data: rs.ByteSlice, out: rs.ByteVec): void { }), rs.u64Add, 0)); } +/** + * The `selector`th name of [`NAMES`], `count` times, each size-prefixed, as moq-net's + * `Encoder::string` writes a path. + */ +export function encodeStrings(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): rs.Result { + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"].length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const w: Encoder.Encoder = Encoder.new(out, { tag: "Quic" } as Form.Form); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = rs.u64Low(count); + while (true) { + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + if (!(iterStart++ < iterEnd)) { + break; + } + const _24: rs.Result = Encoder.string(w, _7[_8]); + if (!_24.ok) { + return _24; + } + } + return rs.OK; +} + +/** + * Every string on the wire, each an owned `String`, as moq-net decodes a path: how many, + * their total length, and the last one's. + */ +export function decodeStrings(wire: rs.ByteSlice, out: rs.ByteVec): rs.Result { + const r: Decoder.Decoder = Decoder.new(wire, { tag: "Quic" } as Form.Form); + let count: rs.usize = 0; + let total: rs.usize = 0; + let last: string = ""; + while (!Decoder.isEmpty(r)) { + const _10: rs.Result = Decoder.string(r); + if (_10.ok) { + last = _10.value; + total = rs.usizeAdd(total, rs.stringLen(last)); + count = rs.usizeAdd(count, 1); + } else { + return _10; + } + } + putUsize(out, count); + putUsize(out, total); + putUsize(out, rs.stringLen(last)); + return rs.OK; +} + +/** + * `count` paths, each the `selector`th name of [`NAMES`] and a track joined into a + * `String` sized up front, as moq-net's `Path::concat` builds one, then stripped of the + * name at a segment boundary, as `Path::strip_prefix` is: their total length, and the + * stripped tracks'. + */ +export function join(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _25!: rs.usize; + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"].length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + let total: rs.usize = 0; + let stripped: rs.usize = 0; + const _19: rs.usize = rs.u64Low(rs.u64Min(count, 65536)); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _19; + while ((_25 = iterStart++) < iterEnd) { + const _31: rs.usize = rs.usizeRem(_25, ["video", "audio", "catalog.json", "字幕"].length); + if (!(_31 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _31); + } + const _30: string[] = ["video", "audio", "catalog.json", "字幕"]; + let path: string = rs.stringWithCapacity(rs.usizeAdd(rs.usizeAdd(rs.stringLen(_7[_8]), 1), rs.stringLen(_30[_31]))); + path = path + _7[_8]; + path = path + "/"; + path = path + _30[_31]; + total = rs.usizeAdd(total, rs.stringLen(path)); + const _53: string | undefined = rs.strStripPrefix(path, _7[_8]); + if (_53 !== undefined) { + const _58: string | undefined = rs.strStripPrefix(_53, "/"); + if (_58 !== undefined) { + stripped = rs.usizeAdd(stripped, rs.stringLen(_58)); + } + } + } + putUsize(out, total); + putUsize(out, stripped); +} + +/** + * `count` paths, the `selector`th name of [`NAMES`] and a number, each a key of a + * `HashMap` and looked up by its `&str` four times, as moq-net finds a broadcast by its + * path: the sum of what the lookups found. + */ +export function keyed(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"].length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + const keys: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u64Low(rs.u64Min(count, 65536))), (i2: rs.u32): string => { + const part = _7[_8]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part), (f: rs.Formatter) => rs.u32Display(i2, f)]; + return rs.fmtFormat([args2[0], "/", args2[1]]); + }), undefined, 12, true); + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(keys.items)); + while (true) { + const _32: [rs.usize, string] | rs.Done = iter.next(); + if (_32 === rs.DONE) { + break; + } + rs.hashInsert(map, _32[1], _32[0] as rs.u64); + } + let sum: rs.u64 = 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 4; + l3: while (iterStart++ < iterEnd) { + const iterS: string[] = keys.items; + let iterI: number = 0; + while (true) { + const _51: string | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_51 === rs.DONE) { + continue l3; + } + sum = rs.u64Add(sum, option_unwrapOr$15hbiwd(rs.hashGet(map, _51), 0)); + } + } + harness_putU64(out, sum); + putUsize(out, rs.hashLen(map)); +} + /** * `count` TS packets of 188 bytes, each written by element through `as_chunks_mut`, then * numbered by continuity counter as moq-mux's `container/ts/export.rs` numbers them; with From af5887420842b73de4f33ac07e0b88552ea38d7f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 11:53:33 -0800 Subject: [PATCH 04/11] feat(ts): translate String as rs.String, with std's exact capacity A String is a JS string beside its UTF-8 length and capacity, edited in place, so capacity reads, into_bytes, Vec::from, and Bytes::from give std's. &str and Box stay JS strings. Lifts the Bytes capacity refusal and drops the utf8 prototype. Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 - quest/m3/ts-slice-object.md | 1 - quest/m3/ts-string-capacity.md | 43 - ts/Cargo.lock | 3 - ts/README.md | 61 +- ts/bench/prototype/str-js.ts | 131 --- ts/bench/prototype/str-ratios.py | 54 - ts/bench/prototype/str-routes.py | 95 -- ts/bench/prototype/str-utf8.ts | 212 ---- ts/fixtures/codec/expected/bench.ts | 158 ++- .../codec/expected/coding/decode.Decoder.ts | 4 +- ts/fixtures/codec/expected/harness.ts | 24 +- ts/fixtures/crates/dep/Cargo.toml | 3 - ts/fixtures/crates/dep/src/lib.rs | 9 +- ts/fixtures/crates/src/lib.rs | 5 - ts/fixtures/crates/strings.toml | 4 - ts/fixtures/crates/strings.txt | 1 - ts/fixtures/lang/arrays/expected/arrays.ts | 82 +- ts/fixtures/lang/ascii/expected/ascii.Held.ts | 2 +- ts/fixtures/lang/ascii/expected/ascii.ts | 182 +-- .../lang/ascii/expected/core/option.ts | 10 +- .../lang/borrows/expected/borrows.Parts.ts | 4 +- ts/fixtures/lang/borrows/expected/borrows.ts | 108 +- ts/fixtures/lang/borrows/expected/lib.ts | 2 +- .../lang/boxes/expected/boxes.Owner.ts | 2 +- ts/fixtures/lang/boxes/expected/boxes.ts | 83 +- ts/fixtures/lang/boxes/expected/harness.ts | 6 +- ts/fixtures/lang/capacity/caller.ts | 8 +- .../lang/capacity/expected/capacity.ts | 279 ++++- .../lang/capacity/expected/core/option.ts | 14 + ts/fixtures/lang/capacity/expected/lib.ts | 8 +- ts/fixtures/lang/capacity/src/capacity.rs | 153 +++ ts/fixtures/lang/capacity/src/lib.rs | 1 + ts/fixtures/lang/cells/expected/cells.ts | 312 ++--- .../lang/cells/expected/core/result.ts | 2 +- ts/fixtures/lang/chars/expected/chars.ts | 141 +-- ts/fixtures/lang/chars/expected/harness.ts | 6 +- ts/fixtures/lang/chunks/expected/chunks.ts | 4 +- .../lang/clones/expected/clones.Pair.ts | 6 +- ts/fixtures/lang/clones/expected/clones.ts | 95 +- ts/fixtures/lang/clones/expected/lib.ts | 8 +- .../expected/collections.Cloned.ts | 4 +- .../lang/collections/expected/collections.ts | 168 +-- .../lang/collections/expected/core/option.ts | 6 +- .../lang/combinators/expected/combinators.ts | 44 +- .../lang/combinators/expected/core/option.ts | 20 +- .../lang/combinators/expected/core/result.ts | 6 +- .../conversions/expected/conversions.Named.ts | 4 +- .../lang/conversions/expected/conversions.ts | 326 +++--- .../lang/conversions/expected/core/option.ts | 7 - ts/fixtures/lang/cows/expected/core/option.ts | 6 +- ts/fixtures/lang/cows/expected/cows.Named.ts | 8 +- ts/fixtures/lang/cows/expected/cows.ts | 184 +-- ts/fixtures/lang/cows/expected/harness.ts | 6 +- .../lang/defaults/expected/defaults.Made.ts | 6 +- .../lang/defaults/expected/defaults.ts | 8 +- .../lang/durations/expected/durations.ts | 8 +- ts/fixtures/lang/dyns/expected/dyns.Named.ts | 2 +- ts/fixtures/lang/dyns/expected/dyns.Over.ts | 10 +- ts/fixtures/lang/dyns/expected/dyns.Square.ts | 2 +- ts/fixtures/lang/dyns/expected/dyns.Tri.ts | 17 +- ts/fixtures/lang/dyns/expected/dyns.ts | 622 +++++----- ts/fixtures/lang/dyns/expected/lib.ts | 82 +- ts/fixtures/lang/dyns/expected/stds.Key.ts | 2 +- ts/fixtures/lang/dyns/expected/stds.Upper.ts | 10 +- ts/fixtures/lang/dyns/expected/stds.ts | 58 +- .../lang/edits/expected/edits.Named.ts | 6 +- .../lang/edits/expected/edits.Tally.ts | 4 +- ts/fixtures/lang/edits/expected/edits.ts | 230 ++-- ts/fixtures/lang/edits/expected/harness.ts | 6 +- .../lang/errors/expected/core/result.ts | 12 +- ts/fixtures/lang/errors/expected/errors.ts | 122 +- ts/fixtures/lang/fields/expected/fields.ts | 6 +- ts/fixtures/lang/floats/expected/floats.ts | 36 +- ts/fixtures/lang/folds/expected/folds.ts | 44 +- ts/fixtures/lang/futures/expected/futures.ts | 88 +- ts/fixtures/lang/futures/expected/harness.ts | 6 +- ts/fixtures/lang/hashes/expected/harness.ts | 6 +- .../lang/hashes/expected/hashes.Index.ts | 4 +- .../lang/hashes/expected/hashes.Key.ts | 6 +- .../lang/hashes/expected/hashes.Packet.ts | 2 +- ts/fixtures/lang/hashes/expected/hashes.ts | 65 +- ts/fixtures/lang/heap/expected/heap.ts | 10 +- ts/fixtures/lang/hints/expected/hints.ts | 15 +- ts/fixtures/lang/ints/expected/ints.ts | 711 +++++------ .../lang/iters/expected/core/option.ts | 25 +- ts/fixtures/lang/iters/expected/iters.ts | 317 ++--- ts/fixtures/lang/joins/expected/harness.ts | 6 +- ts/fixtures/lang/joins/expected/joins.ts | 40 +- ts/fixtures/lang/keys/expected/keys.ts | 12 +- ts/fixtures/lang/lists/expected/lists.ts | 17 +- ts/fixtures/lang/locks/expected/locks.Held.ts | 6 +- .../lang/locks/expected/locks.Shared.ts | 4 +- ts/fixtures/lang/locks/expected/locks.ts | 126 +- ts/fixtures/lang/manual/expected/manual.ts | 13 +- ts/fixtures/lang/nested/expected/nested.ts | 10 +- ts/fixtures/lang/orders/expected/core/cmp.ts | 4 +- ts/fixtures/lang/orders/expected/orders.ts | 44 +- ts/fixtures/lang/panics/caller.ts | 6 +- ts/fixtures/lang/panics/expected/harness.ts | 6 +- ts/fixtures/lang/panics/expected/lib.ts | 18 +- ts/fixtures/lang/panics/expected/located.ts | 20 +- ts/fixtures/lang/panics/expected/panics.ts | 26 +- .../lang/panics/hook/expected/harness.ts | 6 +- .../lang/panics/hook/expected/hooked.Shown.ts | 6 +- .../lang/panics/hook/expected/hooked.ts | 36 +- ts/fixtures/lang/panics/hook/expected/lib.ts | 26 +- .../lang/panics/hook/expected/located.ts | 20 +- .../lang/panics/hook/expected/panics.ts | 26 +- ts/fixtures/lang/pointers/expected/lib.ts | 4 +- .../lang/pointers/expected/pointers.List.ts | 79 +- .../lang/pointers/expected/pointers.Named.ts | 5 +- .../lang/pointers/expected/pointers.Node.ts | 8 +- .../lang/pointers/expected/pointers.ts | 49 +- ts/fixtures/lang/refs/expected/core/option.ts | 6 +- ts/fixtures/lang/refs/expected/refs.ts | 71 +- ts/fixtures/lang/rings/expected/rings.ts | 248 ++-- .../lang/saturates/expected/saturates.ts | 48 +- ts/fixtures/lang/searches/expected/harness.ts | 6 +- .../lang/searches/expected/searches.ts | 87 +- .../lang/separated/expected/core/option.ts | 4 +- .../lang/separated/expected/separated.ts | 55 +- ts/fixtures/lang/shapes/caller.ts | 2 +- .../lang/shapes/expected/fmt.Capped.ts | 6 +- .../lang/shapes/expected/fmt.Dropper.ts | 2 +- ts/fixtures/lang/shapes/expected/fmt.Log.ts | 16 +- .../lang/shapes/expected/fmt.Nested.ts | 6 +- ts/fixtures/lang/shapes/expected/fmt.Twice.ts | 8 +- ts/fixtures/lang/shapes/expected/fmt.ts | 1035 ++++++++--------- ts/fixtures/lang/shapes/expected/generics.ts | 16 +- ts/fixtures/lang/shapes/expected/shapes.ts | 18 +- ts/fixtures/lang/shares/expected/harness.ts | 6 +- ts/fixtures/lang/shares/expected/shares.ts | 61 +- ts/fixtures/lang/singles/expected/singles.ts | 40 +- ts/fixtures/lang/statics/expected/statics.ts | 92 +- .../lang/statics/expected/std/thread/local.ts | 14 +- ts/fixtures/lang/strs/expected/harness.ts | 6 +- .../lang/strs/expected/strs.Counted.ts | 10 +- ts/fixtures/lang/strs/expected/strs.Named.ts | 4 +- ts/fixtures/lang/strs/expected/strs.ts | 910 +++++++-------- ts/fixtures/lang/tuples/expected/tuples.ts | 89 +- ts/fixtures/lang/utf8/expected/utf8.ts | 32 +- .../lang/wrappers/expected/wrappers.ts | 4 +- ts/fixtures/lang/wraps/expected/wraps.ts | 48 +- .../lang/zeros/expected/core/option.ts | 2 +- .../lang/zeros/expected/zeros.Tagged.ts | 14 +- ts/fixtures/lang/zeros/expected/zeros.ts | 40 +- ts/fixtures/model/expected/harness.ts | 4 +- ts/fixtures/names/expected/lib.ts | 2 +- ts/fixtures/reject/census.txt | 8 - ts/fixtures/reject/expected.txt | 8 - ts/fixtures/stock/caller.ts | 10 +- ts/fixtures/stock/expected/buf.Ops.ts | 1 - ts/fixtures/stock/expected/buf.ts | 61 +- ts/fixtures/stock/expected/core/bool.ts | 12 + ts/fixtures/stock/expected/harness.ts | 8 +- ts/fixtures/stock/expected/lib.ts | 8 + ts/fixtures/stock/expected/maps.ts | 12 +- ts/fixtures/stock/src/buf.rs | 31 + ts/fixtures/stock/src/harness.rs | 1 + ts/fixtures/task/expected/closures.ts | 22 +- ts/fixtures/task/expected/drops.Key.ts | 6 +- ts/fixtures/task/expected/drops.Wrap.ts | 12 +- ts/fixtures/task/expected/drops.ts | 56 +- ts/fixtures/task/expected/drops/called.ts | 14 +- ts/fixtures/task/expected/drops/flattened.ts | 4 +- ts/fixtures/task/expected/drops/folds.Pile.ts | 21 +- ts/fixtures/task/expected/drops/folds.ts | 4 +- ts/fixtures/task/expected/drops/inside.ts | 39 +- ts/fixtures/task/expected/drops/iters.ts | 6 +- ts/fixtures/task/expected/drops/lists.ts | 48 +- ts/fixtures/task/expected/drops/objects.ts | 8 +- ts/fixtures/task/expected/drops/once.ts | 8 +- .../task/expected/drops/orders.Ranked.ts | 8 +- ts/fixtures/task/expected/drops/orders.ts | 30 +- ts/fixtures/task/expected/drops/released.ts | 12 +- ts/fixtures/task/expected/drops/searched.ts | 60 +- ts/fixtures/task/expected/futures.ts | 16 +- ts/fixtures/task/expected/log.Log.ts | 16 +- ts/fixtures/task/expected/model.Guard.ts | 4 +- ts/fixtures/task/expected/model.ts | 26 +- ts/runtime/rs.ts | 164 ++- ts/runtime/rs/char.ts | 10 +- ts/runtime/rs/collections.ts | 22 +- ts/runtime/rs/float.ts | 2 +- ts/runtime/rs/hash.ts | 7 +- ts/runtime/rs/hook.ts | 10 +- ts/runtime/rs/str.ts | 529 ++++++--- ts/src/lower/collections.rs | 41 +- ts/src/lower/fmt.rs | 43 +- ts/src/lower/iter.rs | 42 +- ts/src/lower/library.rs | 225 ++-- ts/src/lower/mir/call.rs | 119 +- ts/src/lower/mir/place.rs | 4 +- ts/src/lower/mod.rs | 38 +- ts/src/lower/stock.rs | 32 +- ts/tests/fixtures.rs | 5 +- ts/tests/reserve.ts | 4 +- ts/tests/task.ts | 15 +- 199 files changed, 5830 insertions(+), 5361 deletions(-) delete mode 100644 quest/m3/ts-string-capacity.md delete mode 100644 ts/bench/prototype/str-js.ts delete mode 100644 ts/bench/prototype/str-ratios.py delete mode 100644 ts/bench/prototype/str-routes.py delete mode 100644 ts/bench/prototype/str-utf8.ts delete mode 100644 ts/fixtures/crates/strings.toml delete mode 100644 ts/fixtures/crates/strings.txt create mode 100644 ts/fixtures/stock/expected/core/bool.ts diff --git a/quest/m3/README.md b/quest/m3/README.md index 572b298bb..0a2e8410f 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -21,5 +21,4 @@ generic std gap is planned here even when moq never calls it. - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library - [rs.Slice](/quest/m3/ts-slice-object.md) - references to arrays of other values are a runtime slice too, and pointers compare by where they point - [Writes through iter_mut without a Place per item](/quest/m3/ts-iter-mut-places.md) - a loop over `iter_mut()` of copy values writes the slice's array by index -- [rs.String](/quest/m3/ts-string-capacity.md) - `String`, `Box`, and `&str` are a runtime type holding std's capacity - [Slices not yet written](/quest/m3/ts-uninit-slices.md) - `Box::new_uninit_slice` and `write_clone_of_slice` translate diff --git a/quest/m3/ts-slice-object.md b/quest/m3/ts-slice-object.md index 0209480c2..2986b77f0 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -42,4 +42,3 @@ reference to an array. ## Related -- [rs.String](/quest/m3/ts-string-capacity.md) - the other native mapping becoming a wrapper diff --git a/quest/m3/ts-string-capacity.md b/quest/m3/ts-string-capacity.md deleted file mode 100644 index 638839636..000000000 --- a/quest/m3/ts-string-capacity.md +++ /dev/null @@ -1,43 +0,0 @@ -# [L] rs.String - -## Goal - -[rust2-ts](/ts/README.md) translates `String`, `Box`, and `&str` as a runtime type -rather than a JS `string`, holding what std's do: a `String`'s exact capacity through -`with_capacity`, `reserve`, `reserve_exact`, push growth, `shrink_to_fit`, `shrink_to`, -`format!`'s estimate, and `into_bytes`, `Vec::from`, and `Bytes::from`, which take it. -Differential tests against native Rust prove it, and the refusal of reading a `Bytes`' -capacity where a `String`'s bytes may reach it is lifted. Hand-written callers convert at -the boundary with helpers, as for `rs.Vec`. - -## Plan - -Decided with the maintainer on 2026-11-03: Rust types the runtime can't hold as std's do -get a runtime wrapper, converted at API boundaries, rather than a JS native type. In their -words on [#555](https://github.com/moq-dev/rust2/pull/555), "trying to support native -types is probably a mistake". `Vec` became one there and `Cow` in -[#567](https://github.com/moq-dev/rust2/pull/567). Primitives, `Option`, tuples, and -closures stay native. A native type, aliased or branded, stays where it holds all of std's -semantics with no extra allocation, as a branded `number` does for an integer and a -`Uint8Array` for a `[u8; N]`; prefer one if it holds them, but capacity and the like -usually need a wrapper. - -What it holds: - -- ✅ Measure both, and bring the numbers back as a decision. -- A JS string and its capacity: engine string operations and `Display` stay cheap, but - byte offsets still convert from UTF-16. -- UTF-8 bytes, as `rs.ByteVec` holds: byte indexing and in-place edits are as Rust's, but - every `Display` and JS boundary decodes. - -Measure on `just ts bench` and moq's translated codec in Node, Chrome, Bun, and Firefox, -with an A/A run of main for noise, as #555 did. - -Earlier, on [#532](https://github.com/moq-dev/rust2/pull/532), the maintainer chose to -track capacity rather than refuse it; until this lands, the refusal stays. - -Public API: the translator's output and what a hand-written caller passes for a string. - -## Related - -- [rs.Slice](/quest/m3/ts-slice-object.md) - the other native mapping becoming a wrapper diff --git a/ts/Cargo.lock b/ts/Cargo.lock index 716de715c..41f35cdf8 100644 --- a/ts/Cargo.lock +++ b/ts/Cargo.lock @@ -80,9 +80,6 @@ dependencies = [ [[package]] name = "crates-dep" version = "0.0.0" -dependencies = [ - "bytes", -] [[package]] name = "crates-fixture" diff --git a/ts/README.md b/ts/README.md index 648549913..48c73b0ff 100644 --- a/ts/README.md +++ b/ts/README.md @@ -89,7 +89,8 @@ crate translation reaches is refused, and so are two versions of one crate it re | Rust | TypeScript | | --- | --- | -| `bool`, `str`, `String`, `Box` | `boolean`, `string` | +| `bool`, `str`, `Box` | `boolean`, `string` | +| `String` | `rs.String`: its text, `v`, its length in UTF-8 bytes, `len`, and the capacity std's holds, `cap`; `rs.stringFrom(text)` makes one of a JS string with room for exactly its bytes | | `char` | `rs.char`: a `number` branded so, its Unicode scalar value | | `u8`-`u32`, `i8`-`i32`, `usize`, `isize` | `rs.u8` and so on: a `number` branded with its type, checked: overflow panics | | `u64`, `i64`, `u128`, `i128` | `rs.u64` and so on: a branded `number` while a safe integer, 32-bit limbs past 2^53, checked the same way | @@ -107,8 +108,8 @@ crate translation reaches is refused, and so are two versions of one crate it re | tuple, `[T; N]`, `&[T; N]` | an array; for bytes, `u8` or `MaybeUninit`, `Uint8Array` for `[u8; N]`, and `rs.ByteSlice` for `&[u8; N]` | | `&[T]`, `&mut [T]`, `Box<[T]>` | `rs.Slice`, a range of an array; `rs.ByteSlice` for bytes | | `Vec` | `rs.Vec`: its items, the array `items`, and the capacity std's holds; `rs.vecFrom(items)` makes one of an array with room for exactly them. `rs.ByteVec` of bytes | -| `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | -| `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | +| `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the `rs.String` it owns or an `rs.Borrowed` holding the string it borrows, whose text `rs.strCowStr` reads | +| `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | | `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the buffer and offset they are at, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to an array of other values than bytes, which a slice lends as a copy of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | | `MaybeUninit` | `T`: `undefined` until written, `0` for a byte, or an object whose parts kept as objects are there, holding `undefined` | | `ManuallyDrop` | `T`, which nothing drops but its own `drop`; its `Debug`, comparisons, and constants are refused | @@ -253,7 +254,8 @@ invalid sequence, as std's does, and borrows the text of valid UTF-8, as std's d where `str::from_utf8` fails, so each `Utf8Chunk`'s `invalid` bytes are std's, and `Debug` of it writes what is left as std's does, each invalid byte as `\xNN`. `from_utf8_unchecked`, of a `str` or a `String`, decodes as `from_utf8_lossy` does the UTF-8 its contract promises. -`String::into_bytes` and `Vec::::from` a string encode its UTF-8 anew. +`String::into_bytes` and `Vec::::from` of one encode its UTF-8 into storage of its +capacity, and `Vec::::from` a `&str` into exactly its bytes. An `f64` is a JS number, so its operators are JS's, which round as Rust's do. Where JS differs from std, the runtime has std's: `round` halves away from zero, `max` and @@ -406,23 +408,31 @@ closure, which it calls on each char it reads, in the order std reads them, and returns, or with the iterator it returns, as `split` does, leaving one it borrows to its owner. An offset it returns, from `rfind` or `match_indices`, counts UTF-8 bytes, as Rust's does, and so does one `&s[a..b]` or `&s[a..=b]` takes, which reads the string up to it and panics as std -does inside a char, where `get` gives `None`. A JS string can't change in place, so `String`'s edits, `push_str`, `truncate`, -`insert`, `retain`, `replace_range`, and the rest, assign the edited one to the local or -field the `&mut` borrows, taking and checking byte offsets as std does, and `retain` then -drops its closure. `+`, of a `String`, is JS's `+` of the moved text, as `+=` is, and of a -`Cow` takes either side whole when the other is empty, as std's does. A `&mut str` is -the `rs.Place` of its `String` wherever that is, and a part of one, from `&mut s[a..b]`, +does inside a char, where `get` gives `None`. A `String` is an object, so a `&mut` to one +is that object, and its edits, `push_str`, `truncate`, `insert`, `retain`, +`replace_range`, and the rest, change it in place, taking and checking byte offsets as +std does, and `retain` then drops its closure. Each grows its capacity as `RawVec` grows +a `Vec`'s, by `reserve` of what it adds, or by `push` of each char where std's pushes +each, and `with_capacity`, `reserve`, `reserve_exact`, `shrink_to`, and their `try_` forms +are std's, so `capacity` reads std's. What makes a new one gives it std's room: exactly +its bytes from `to_owned`, `clone`, `join`, and `to_string` of text, a `char`, a `bool`, +or an unsigned integer; a signed integer's most digits and its sign; `format!`'s +estimate, and growth by each write from none for any other `to_string`; the first +item's of a `collect` of `String`s; and std's own reserve and pushes for `replace`, +`to_lowercase`, `from_utf16`, `from_utf8_lossy`, and the rest. `+`, of a `String`, pushes +onto the moved one, as `+=` does, and of a `Cow` takes either side whole when the +other is empty, as std's does. A `&mut str` of a `String` is the `String`, an `rs.Place` +of its text, and a part of one, from `&mut s[a..b]`, `get_mut`, or `split_at_mut`, is `rs.strPart(p, a, b)`, a place of its own that writes the whole string anew, checking its offsets as `&s[a..b]` does. `as_bytes_mut`, `get_unchecked_mut`, and `str::from_utf8_mut` are refused. `extend` and `collect` read their iterator by `for_each`, as std's do, and of chars first reserve its size hint's lower bound, which panics past `isize::MAX`. A `drain` holds the `&mut`'s place and writes the string without the drained text as it drops, so one that -`mem::forget` leaks leaves it as it was, as std's does. A `String` keeps no capacity: -`with_capacity`, `reserve`, and `shrink_to_fit` do nothing, and `capacity` is refused. A `Cow` keeps its +`mem::forget` leaks leaves it as it was, as std's does. A `Cow` keeps its variant in its class, so a `match` reads it, and `to_mut` of a borrowed one stores what it owns in the `Cow`'s place before lending it: a `Cow<[T]>`'s clone of its slice, or a -`Cow`'s text, which a `String` is, so the `&mut` borrows the `Cow`'s own place. A +`Cow`'s `String` of its text, which the `&mut` is. A `Cow<[T]>`'s `clone_from` of an owned one over an owned one clones into the `Vec` it owns, keeping its buffer, as std's does. `Cow::is_borrowed` and `is_owned` are unstable, and refused. @@ -477,7 +487,7 @@ one kept other than in a local, counts as a write into what it points at. A writ not change in place what it passes to or gets from the translation either. A `&mut` to a value JS copies, which no JS value can point at, such as a number, an -`Option`, an enum, a tuple, a `Box`, or a `String`, is an `rs.Place` whose `v` reads and +`Option`, an enum, a tuple, or a `Box`, is an `rs.Place` whose `v` reads and writes where it points. Where it is only read and written through, in the function that borrows it, it is the place it borrows, so a body that passes none on makes none. Passed on, returned, kept in a field, or captured by a value, it is @@ -699,11 +709,8 @@ of them: `Clone`, `Deref`, `AsRef`, `PartialEq` with bytes, `Default`, `Debug`, and `From` between it and `Vec`, `String`, `&'static [u8]`, and `&'static str` map to `rs/bytes.ts`, panicking as `bytes` does, and so do `split_to`, `split_off`, - `truncate`, `clear`, and `slice_ref`, whose panic names no addresses. A `String`'s - bytes are in storage of its capacity, which JS keeps none of, so where any crate makes a - `Bytes` or a `Vec` of them, every crate is refused what reads a `Bytes`' capacity: - `is_unique`, `try_into_mut`, `truncate`, `clear`, `From` into a `BytesMut` or a - `Vec`, and `put` of a `Buf` but a `BytesMut` or a slice into a `BytesMut`. `slice_ref` of + `truncate`, `clear`, and `slice_ref`, whose panic names no addresses. A `Bytes` of a + `String` takes storage of its capacity, as `bytes` does. `slice_ref` of bytes from other storage throws, since Rust may share what JS copied, as a `&'static str`'s bytes that `as_bytes` encodes anew. `Bytes::from_owner` reads its owner's bytes once, as `bytes` does, and is refused for an owner that drops, @@ -902,13 +909,17 @@ they need. the `Some` can already be `undefined`: there it is `rs.None`, as `Pending` is `rs.Pending`, chosen by the type alone, so every function agrees on it. A `rs.None` for every `Option` would cost callers `?.` and `??` everywhere for the few that need it. -- A `Cow` is a JS string, as `str` and `String` are, rather than an object tagged by - its variant: no `Cow` in moq-net or kio tells its variants apart, and a tag would - wrap every value and unwrap it at every read. -- A `Cow<[T]>` is told apart by class, an owned one bare and a borrowed one in an +- A `String` is an `rs.String`, its text as a JS string beside its UTF-8 length and + capacity, rather than a bare JS string, which holds no capacity, or UTF-8 bytes, which + every `Display` and JS boundary would decode. Measured on + [#574](https://github.com/moq-dev/rust2/pull/574), it matched or beat a JS string at + encoding, decoding, and joining, and cost 7-22% writing lines and up to 2.3x in a map + keyed by one, where UTF-8 bytes cost 5.6-9.8x. A `&str` and a `Box` stay JS + strings, which hold all they do. +- A `Cow` is told apart by class, an owned one bare and a borrowed one in an `rs.Borrowed`, so it clones and drops as std's does and only the borrowed side pays a - wrapper. Untagged, as `Cow` is, `to_mut` would clone on every call and a `match` - would be refused; tagged, every `Cow` would be wrapped. + wrapper. Untagged, `to_mut` would clone on every call and a `match` would be refused; + tagged, every `Cow` would be wrapped. - A `Duration` keeps std's fields, whole seconds and nanoseconds, rather than one count of nanoseconds, so its overflow, `checked_*`, and ordering are std's exactly, and a lowering of its methods from core's MIR would read the same fields. diff --git a/ts/bench/prototype/str-js.ts b/ts/bench/prototype/str-js.ts deleted file mode 100644 index 4a52b2e22..000000000 --- a/ts/bench/prototype/str-js.ts +++ /dev/null @@ -1,131 +0,0 @@ -// Prototype only, for moq-dev/rust2#574's decision: a `String` as a JS string with its -// UTF-8 length and std's exact capacity. `&str` and `Box` stay JS strings. Copied to -// a translation's `rs/proto.ts` by str-routes.py. - -import { type Arguments, Err, type FmtResult, FromUtf8Error, type Formatter, type HashMap, OK, Ok, type Result, type Write, byteVecView, type ByteVec, type char } from "../rs.ts"; - -const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }); - - -/** A `String`: its text, its length in UTF-8 bytes, and its capacity. */ -export class PString { - s: string; - len: number; - cap: number; - - constructor(s: string, len: number, cap: number) { - this.s = s; - this.len = len; - this.cap = cap; - } -} - -/** The UTF-8 length of `s`. */ -export function pStrLen(s: string): number { - let n = s.length; - for (let i = 0; i < s.length; i++) { - const u = s.charCodeAt(i); - if (u >= 0x80) n += u < 0x800 || (u >= 0xd800 && u <= 0xdfff) ? 1 : 2; - } - return n; -} - -/** Room for `add` more bytes, as `RawVec::grow_amortized` makes it. */ -function grow(v: PString, add: number): void { - const needed = v.len + add; - if (needed > v.cap) v.cap = Math.max(v.cap * 2, needed, 8); -} - -/** `String::with_capacity`. */ -export function pStringNew(cap: number): PString { - return new PString("", 0, cap); -} - -/** `String::push_str`. */ -export function pStringPushStr(v: PString, t: string): void { - const n = pStrLen(t); - grow(v, n); - v.len += n; - v.s += t; -} - -/** `String::push_str` of a literal, whose length the translator knows. */ -export function pStringPushLit(v: PString, t: string, n: number): void { - grow(v, n); - v.len += n; - v.s += t; -} - -/** `String::clone`: room for exactly its bytes. */ -export function pStringClone(v: PString): PString { - return new PString(v.s, v.len, v.len); -} - -/** `String::from_utf8`, which keeps the vector's capacity. */ -export function pStringFromUtf8(bytes: ByteVec): Result { - try { - return Ok(new PString(decoder.decode(byteVecView(bytes)), bytes.length, bytes.data.length)); - } catch { - return Err(new FromUtf8Error(bytes)); - } -} - - -class Writer implements Write { - readonly v: PString; - - constructor(v: PString) { - this.v = v; - } - - writeStr(s: string): FmtResult { - pStringPushStr(this.v, s); - return OK; - } - - writeChar(c: char): FmtResult { - const n = c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; - grow(this.v, n); - this.v.len += n; - this.v.s += String.fromCodePoint(c); - return OK; - } -} - -function write(out: Write, args: Arguments): FmtResult { - for (const part of args) { - const r = typeof part === "string" ? out.writeStr(part) : part({ out, spec: {} } as Formatter); - if (!r.ok) return r; - } - return OK; -} - -/** `write!` into a `String`. */ -export function pFmtWriteString(v: PString, args: Arguments): FmtResult { - return write(new Writer(v), args); -} - -/** `Arguments::estimated_capacity`, of the literal pieces' lengths, which the translator knows. */ -function estimate(args: Arguments, pieces: number): number { - if (args.every((a) => typeof a === "string")) return pieces; - return typeof args[0] !== "string" && pieces < 16 ? 0 : pieces * 2; -} - -/** `format!`, its pieces' length given. */ -export function pFmtFormat(args: Arguments, pieces: number): PString { - const v = new PString("", 0, estimate(args, pieces)); - write(new Writer(v), args); - return v; -} - -/** `HashMap::insert` of a `String` key: the map goes by its text, and keeps the key with its value. */ -export function pHashInsertString(m: HashMap, key: PString, value: V): V | undefined { - const old = m.p.get(key.s); - m.p.set(key.s, { k: key, v: value }); - return old?.v; -} - -/** `HashMap::get` by a `&str`. */ -export function pHashGetString(m: HashMap, key: string): V | undefined { - return m.p.get(key)?.v; -} diff --git a/ts/bench/prototype/str-ratios.py b/ts/bench/prototype/str-ratios.py deleted file mode 100644 index 1661272a9..000000000 --- a/ts/bench/prototype/str-ratios.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python3 -"""Per-run median ratios to `translated`, summarized over runs: median (min-max). Prototype -only, for moq-dev/rust2#574. Each run's ratio is the median over its rounds of the route's -time over `translated`'s in the same round. - -usage: str-ratios.py :,... ... -""" -import json, math, statistics, sys - -ENG = ["Node", "Bun", "Chromium", "Firefox"] - - -def engine(name): - return "Firefox" if "Firefox" in name else "Chromium" if "Chrome" in name else name.split(" ")[0] - - -def geomean(xs): - return math.exp(sum(map(math.log, xs)) / len(xs)) - - -for spec in sys.argv[1:]: - route, files = spec.split(":") - per = {} - names = [] - for f in files.split(","): - for e in json.load(open(f))["engines"]: - eng = engine(e["engine"]) - by = {} - for t in e["timings"]: - by.setdefault(f"{t['workload']} {t['op']}", {})[t["route"]] = t["ns"] - rest, aa = [], [] - for name, rs in by.items(): - if route not in rs: - continue - m = statistics.median(x / b for x, b in zip(rs[route], rs["translated"])) - a = statistics.median(x / b for x, b in zip(rs["A/A"], rs["translated"])) - aa.append(a) - if name.startswith(("str/", "fmt/")): - if name not in names: - names.append(name) - per.setdefault((eng, name), []).append(m) - per.setdefault((eng, f"A/A {name}"), []).append(a) - else: - rest.append(m) - per.setdefault((eng, "every other workload, geomean"), []).append(geomean(rest)) - per.setdefault((eng, "A/A, geomean of all"), []).append(geomean(aa)) - print(f"### {route} ÷ translated ({len(files.split(','))} runs)\n\n| workload | " + " | ".join(ENG) + " |\n|---|" + "---|" * len(ENG)) - for name in names + ["every other workload, geomean", "A/A, geomean of all"]: - cells = [] - for e in ENG: - xs = per.get((e, name), []) - cells.append(f"{statistics.median(xs):.2f} ({min(xs):.2f}-{max(xs):.2f})" if xs else "-") - print(f"| {name} | " + " | ".join(cells) + " |") - print() diff --git a/ts/bench/prototype/str-routes.py b/ts/bench/prototype/str-routes.py deleted file mode 100644 index 6cb4b7835..000000000 --- a/ts/bench/prototype/str-routes.py +++ /dev/null @@ -1,95 +0,0 @@ -#!/usr/bin/env python3 -"""Rewrite a fresh translation of the codec and task fixtures into one prototype model of -a `String`, for `just ts bench --route =` to time against main. Prototype only, -for moq-dev/rust2#574's decision. - -usage: str-routes.py js|utf8 - - holds `translated/` and `task/` as `just ts run` wrote them. Each edit is what the -translator would emit for that model on the paths the `str/` and `fmt/` workloads run; -every edit must match as often as it says. - -- js: a `String` as `rs.PString`, a JS string with its UTF-8 length and capacity; a `&str` - stays a JS string. -- utf8: a `String` as an `rs.ByteVec`, a `&str` as an `rs.ByteSlice`, each literal's bytes - made once where its module loads. -""" -import re -import shutil -import sys -from pathlib import Path - -root, model = Path(sys.argv[1]), sys.argv[2] -here = Path(__file__).parent -utf8 = model == "utf8" -assert model in ("js", "utf8"), model - - -def edit(path, pairs): - p = root / "translated" / path - text = p.read_text() - for old, new, *n in pairs: - want = n[0] if n else 1 - got = len(re.findall(old, text)) if isinstance(old, re.Pattern) else text.count(old) - if got != want: - sys.exit(f"{path}: {got} matches, not {want}, for {old!r}") - text = old.sub(new, text) if isinstance(old, re.Pattern) else text.replace(old, new) - p.write_text(text) - - -shutil.copy(here / f"str-{model}.ts", root / "translated" / "rs" / "proto.ts") -edit("rs.ts", [('export * from "./rs/time.ts";\n', 'export * from "./rs/time.ts";\nexport * from "./rs/proto.ts";\n')]) - -NAMES = '["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]' -TRACKS = '["video", "audio", "catalog.json", "字幕"]' -SET = re.compile(r"s = rs\.fmtWriteString\(s, (\[.*\])\)\.s;") - -if utf8: - edit("coding/encode.Encoder.ts", [("return bytes(self, rs.stringAsBytes(v));", "return bytes(self, v);")]) -edit("coding/decode.Decoder.ts", [("rs.stringFromUtf8(", "rs.pStringFromUtf8(")]) - -bench = [ - # decode_strings - ('let last: string = "";', "let last = new rs.ByteVec(0);" if utf8 else "let last = rs.pStringNew(0);"), - ("rs.stringLen(last)", "last.length" if utf8 else "last.len", 2), - # join - ( - "let path: string = rs.stringWithCapacity(rs.usizeAdd(rs.usizeAdd(rs.stringLen(_7[_8]), 1), rs.stringLen(_30[_31])));", - "const path = new rs.ByteVec(rs.usizeAdd(rs.usizeAdd(_7[_8].length, 1), _30[_31].length));" if utf8 - else "const path = rs.pStringNew(rs.usizeAdd(rs.usizeAdd(rs.pStrLen(_7[_8]), 1), rs.pStrLen(_30[_31])));", - ), - ("path = path + _7[_8];", "rs.pStringPushStr(path, _7[_8]);"), - ('path = path + "/";', "rs.pStringPushAscii(path, 0x2f);" if utf8 else 'rs.pStringPushLit(path, "/", 1);'), - ("path = path + _30[_31];", "rs.pStringPushStr(path, _30[_31]);"), - ("rs.usizeAdd(total, rs.stringLen(path))", "rs.usizeAdd(total, path.length)" if utf8 else "rs.usizeAdd(total, path.len)"), - ("rs.strStripPrefix(path, _7[_8])", "rs.pStrStripPrefix(rs.pStringAsStr(path), _7[_8])" if utf8 else "rs.strStripPrefix(path.s, _7[_8])"), - ('rs.strStripPrefix(_53, "/")', "rs.pStrStripAscii(_53, 0x2f)" if utf8 else 'rs.strStripPrefix(_53, "/")'), - ("rs.stringLen(_58)", "_58.length" if utf8 else "rs.pStrLen(_58)"), - # keyed - ("rs.fmtPad(f, part)", "rs.pFmtPadStr(f, part)" if utf8 else "rs.fmtPad(f, part)"), - ('return rs.fmtFormat([args2[0], "/", args2[1]]);', 'return rs.pFmtFormat([args2[0], "/", args2[1]], 1);'), - ("rs.hashNew() as rs.HashMap", "rs.hashNew(rs.P_STR_HASHING) as rs.HashMap" if utf8 else "rs.hashNew() as rs.HashMap"), - ( - "rs.hashInsert(map, _32[1], _32[0] as rs.u64);", - "rs.hashInsert(map, rs.pStringClone(_32[1]), _32[0] as rs.u64);" if utf8 else "rs.pHashInsertString(map, rs.pStringClone(_32[1]), _32[0] as rs.u64);", - ), - ("rs.hashGet(map, _51)", "rs.hashGet(map, rs.pStringAsStr(_51))" if utf8 else "rs.pHashGetString(map, _51.s)"), - # format - ('const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536));\n\tlet s: string = "";', - "const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536));\n\tlet s = " + ("new rs.ByteVec(0);" if utf8 else "rs.pStringNew(0);")), - (SET, r"rs.pFmtWriteString(s, \1);"), - ("putUsize(out, rs.stringLen(s));", "putUsize(out, s.length);" if utf8 else "putUsize(out, s.len);"), - ("rs.strBytes(s)", "rs.iterSlice(rs.byteVecView(s))" if utf8 else "rs.strBytes(s.s)"), -] -if utf8: - # Each literal's bytes, made once where the module loads. - bench += [(NAMES, "[P_NAME0, P_NAME1]", 6), (TRACKS, "[P_TRACK0, P_TRACK1, P_TRACK2, P_TRACK3]", 2)] -edit("bench.ts", bench) -if utf8: - p = root / "translated" / "bench.ts" - text = p.read_text() - lits = [("P_NAME0", "demo/room-42/alice/camera"), ("P_NAME1", "démo/salle-42/アリス/📷"), - ("P_TRACK0", "video"), ("P_TRACK1", "audio"), ("P_TRACK2", "catalog.json"), ("P_TRACK3", "字幕")] - decl = "".join(f'const {n} = /* @__PURE__ */ rs.pLit("{s}");\n' for n, s in lits) - at = text.index("\nexport function ") - p.write_text(text[: at + 1] + decl + text[at + 1 :]) diff --git a/ts/bench/prototype/str-utf8.ts b/ts/bench/prototype/str-utf8.ts deleted file mode 100644 index 764a1f4d5..000000000 --- a/ts/bench/prototype/str-utf8.ts +++ /dev/null @@ -1,212 +0,0 @@ -// Prototype only, for moq-dev/rust2#574's decision: a `String` as its UTF-8 bytes, an -// `rs.ByteVec`, whose storage's length is std's exact capacity, and a `&str` as an -// `rs.ByteSlice`. Copied to a translation's `rs/proto.ts` by str-routes.py. - -import { - type Arguments, - ByteSlice, - ByteVec, - byteVecExtendFromSlice, - byteVecPush, - byteVecView, - Err, - type FmtResult, - FromUtf8Error, - type Formatter, - fmtPad, - hashing, - OK, - Ok, - type Result, - utf8Check, - type Write, - type char, -} from "../rs.ts"; - -const decoder = /* @__PURE__ */ new TextDecoder("utf-8", { ignoreBOM: true }); -const encoder = /* @__PURE__ */ new TextEncoder(); - -/** A literal's bytes, made once where the module loads. */ -export function pLit(s: string): ByteSlice { - const b = encoder.encode(s); - return new ByteSlice(b, 0, b.length); -} - -/** A `String`'s or a `&str`'s bytes. */ -function view(s: ByteVec | ByteSlice): Uint8Array { - return s instanceof ByteVec ? s.data.subarray(0, s.length) : s.data.subarray(s.start, s.start + s.length); -} - -/** `String::push_str`. */ -export function pStringPushStr(v: ByteVec, t: ByteSlice): void { - byteVecExtendFromSlice(v, t); -} - -/** `String::push` of an ASCII char. */ -export function pStringPushAscii(v: ByteVec, c: number): void { - byteVecPush(v, c); -} - -/** `&**s`: a `String`'s text. */ -export function pStringAsStr(v: ByteVec): ByteSlice { - return new ByteSlice(v.data, 0, v.length); -} - -/** `String::clone`: room for exactly its bytes. */ -export function pStringClone(v: ByteVec): ByteVec { - const c = new ByteVec(v.length); - c.data.set(byteVecView(v)); - c.length = v.length; - return c; -} - -/** `String::from_utf8`: the vector itself, checked. */ -export function pStringFromUtf8(bytes: ByteVec): Result { - return utf8Check(byteVecView(bytes)) === undefined ? Ok(bytes) : Err(new FromUtf8Error(bytes)); -} - -/** `str::strip_prefix` of a `&str`. */ -export function pStrStripPrefix(s: ByteSlice, p: ByteSlice): ByteSlice | undefined { - if (p.length > s.length) return undefined; - for (let i = 0; i < p.length; i++) if (s.data[s.start + i] !== p.data[p.start + i]) return undefined; - return new ByteSlice(s.data, s.start + p.length, s.length - p.length); -} - -/** `str::strip_prefix` of an ASCII char. */ -export function pStrStripAscii(s: ByteSlice, c: number): ByteSlice | undefined { - return s.length > 0 && s.data[s.start] === c ? new ByteSlice(s.data, s.start + 1, s.length - 1) : undefined; -} - -/** The UTF-8 length of `s`. */ -function utf8Len(s: string): number { - let n = s.length; - for (let i = 0; i < s.length; i++) { - const u = s.charCodeAt(i); - if (u >= 0x80) n += u < 0x800 || (u >= 0xd800 && u <= 0xdfff) ? 1 : 2; - } - return n; -} - -/** Room for `add` more bytes, as `RawVec::grow_amortized` makes it. */ -function reserve(v: ByteVec, add: number): void { - const needed = v.length + add; - if (needed <= v.data.length) return; - const grown = new Uint8Array(Math.max(needed, v.data.length * 2, 8)); - grown.set(v.data); - v.data = grown; -} - -/** Encode a JS string onto `v`, growing it as std's `push_str` of its UTF-8 would. */ -function pushJs(v: ByteVec, s: string): void { - // Room for three bytes a code unit holds it whatever it is, and no growth would happen. - if (v.data.length - v.length < 3 * s.length) reserve(v, utf8Len(s)); - if (s.length <= 16) { - const d = v.data; - let at = v.length; - for (let i = 0; i < s.length; i++) { - let c = s.charCodeAt(i); - if (c < 0x80) { - d[at++] = c; - continue; - } - if (c >= 0xd800 && c <= 0xdbff) c = s.codePointAt(i++) as number; - at = putChar(d, at, c); - } - v.length = at; - } else { - v.length += encoder.encodeInto(s, v.data.subarray(v.length)).written; - } -} - -function putChar(d: Uint8Array, at: number, c: number): number { - if (c < 0x80) d[at++] = c; - else if (c < 0x800) { - d[at++] = 0xc0 | (c >> 6); - d[at++] = 0x80 | (c & 0x3f); - } else if (c < 0x10000) { - d[at++] = 0xe0 | (c >> 12); - d[at++] = 0x80 | ((c >> 6) & 0x3f); - d[at++] = 0x80 | (c & 0x3f); - } else { - d[at++] = 0xf0 | (c >> 18); - d[at++] = 0x80 | ((c >> 12) & 0x3f); - d[at++] = 0x80 | ((c >> 6) & 0x3f); - d[at++] = 0x80 | (c & 0x3f); - } - return at; -} - -/** Writes into a `String`'s bytes, and takes a `&str`'s bytes as they are. */ -class Writer implements Write { - readonly v: ByteVec; - - constructor(v: ByteVec) { - this.v = v; - } - - writeStr(s: string): FmtResult { - pushJs(this.v, s); - return OK; - } - - writeBytes(s: ByteSlice): FmtResult { - byteVecExtendFromSlice(this.v, s); - return OK; - } - - writeChar(c: char): FmtResult { - reserve(this.v, c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4); - this.v.length = putChar(this.v.data, this.v.length, c); - return OK; - } -} - -/** A `&str`'s `Display`: its bytes as they are into a `String`, else decoded. */ -export function pFmtPadStr(f: Formatter, s: ByteSlice): FmtResult { - if (f.out instanceof Writer && f.spec.width === undefined && f.spec.precision === undefined) return f.out.writeBytes(s); - return fmtPad(f, decoder.decode(view(s))); -} - -function write(out: Write, args: Arguments): FmtResult { - for (const part of args) { - const r = typeof part === "string" ? out.writeStr(part) : part({ out, spec: {} } as Formatter); - if (!r.ok) return r; - } - return OK; -} - -/** `write!` into a `String`. */ -export function pFmtWriteString(v: ByteVec, args: Arguments): FmtResult { - return write(new Writer(v), args); -} - -/** `Arguments::estimated_capacity`, of the literal pieces' lengths, which the translator knows. */ -function estimate(args: Arguments, pieces: number): number { - if (args.every((a) => typeof a === "string")) return pieces; - return typeof args[0] !== "string" && pieces < 16 ? 0 : pieces * 2; -} - -/** `format!`, its pieces' length given. */ -export function pFmtFormat(args: Arguments, pieces: number): ByteVec { - const v = new ByteVec(estimate(args, pieces)); - write(new Writer(v), args); - return v; -} - -const FF = [0xff]; - -/** A `String` or `&str` key: its bytes, then 0xff, as `Hash for str` writes them. */ -export const P_STR_HASHING = /* @__PURE__ */ hashing( - (k, s) => { - s.ints(view(k), 1); - s.ints(FF, 1); - }, - (a, b) => { - if (a.length !== b.length) return false; - const x = view(a); - const y = view(b); - for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false; - return true; - }, - true, -); diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 4a91334df..94e114d12 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -10,7 +10,7 @@ import type * as EncodeError from "./coding/encode.EncodeError.ts"; import * as Encoder from "./coding/encode.Encoder.ts"; import { zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as Form from "./coding/varint.Form.ts"; -import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; +import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; import { form, liteVersion, putU64 as harness_putU64, putUsize, takeU64, decodeError, encodeError } from "./harness.ts"; import * as Group from "./lite/group.Group.ts"; import type * as lite_version_Version from "./lite/version.Version.ts"; @@ -56,6 +56,14 @@ export function run(input: rs.ByteSlice): rs.ByteVec { format(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 17) { parts(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 18) { + encoded(encodeStrings(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 19) { + decoded(decodeStrings(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 20) { + join(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 21) { + keyed(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { decoded(decodeGroup(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } @@ -501,7 +509,7 @@ export function push(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void */ export function format(data: rs.ByteSlice, out: rs.ByteVec): void { const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536)); - let s: string = ""; + const s: rs.String = rs.stringNew(); const iter: rs.Range = new rs.Range(0, count2, rs.i64Step); while (true) { const _14: rs.i64 | rs.Done = iter.next(); @@ -513,14 +521,154 @@ export function format(data: rs.ByteSlice, out: rs.ByteVec): void { const _26: rs.f64 = rs.i64ToF64(i) / 3.0; const _29: rs.i64 = rs.i64Neg(i); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(i, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => rs.f64Display(_26, f), (f: rs.Formatter) => rs.i64Display(_29, f)]; - s = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ precision: 2 }, args2[2]), "|", args2[3], "\n"]).s; + const _23: rs.Arguments = [rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ precision: 2 }, args2[2]), "|", args2[3], "\n"]; + rs.fmtWriteString(s, _23); } - putUsize(out, rs.stringLen(s)); - harness_putU64(out, rs.iterSum(rs.iterMap(rs.strBytes(s), (a0: rs.u8): rs.u64 => { + putUsize(out, s.len); + harness_putU64(out, rs.iterSum(rs.iterMap(rs.strBytes(s.v), (a0: rs.u8): rs.u64 => { return a0 as rs.u64; }), rs.u64Add, 0)); } +/** + * The `selector`th name of [`NAMES`], `count` times, each size-prefixed, as moq-net's + * `Encoder::string` writes a path. + */ +export function encodeStrings(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): rs.Result { + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, rs.sliceFrom(["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]).length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const w: Encoder.Encoder = Encoder.new(out, { tag: "Quic" } as Form.Form); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = rs.u64Low(count); + while (true) { + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + if (!(iterStart++ < iterEnd)) { + break; + } + const _24: rs.Result = Encoder.string(w, _7[_8]); + if (!_24.ok) { + return _24; + } + } + return rs.OK; +} + +/** + * Every string on the wire, each an owned `String`, as moq-net decodes a path: how many, + * their total length, and the last one's. + */ +export function decodeStrings(wire: rs.ByteSlice, out: rs.ByteVec): rs.Result { + const r: Decoder.Decoder = Decoder.new(wire, { tag: "Quic" } as Form.Form); + let count: rs.usize = 0; + let total: rs.usize = 0; + let last: rs.String = rs.stringNew(); + while (!Decoder.isEmpty(r)) { + const _10: rs.Result = Decoder.string(r); + if (_10.ok) { + last = _10.value; + total = rs.usizeAdd(total, last.len); + count = rs.usizeAdd(count, 1); + } else { + return _10; + } + } + putUsize(out, count); + putUsize(out, total); + putUsize(out, last.len); + return rs.OK; +} + +/** + * `count` paths, each the `selector`th name of [`NAMES`] and a track joined into a + * `String` sized up front, as moq-net's `Path::concat` builds one, then stripped of the + * name at a segment boundary, as `Path::strip_prefix` is: their total length, and the + * stripped tracks'. + */ +export function join(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _25!: rs.usize; + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, rs.sliceFrom(["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]).length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + let total: rs.usize = 0; + let stripped: rs.usize = 0; + const _19: rs.usize = rs.u64Low(rs.u64Min(count, 65536)); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _19; + while ((_25 = iterStart++) < iterEnd) { + const _31: rs.usize = rs.usizeRem(_25, rs.sliceFrom(["video", "audio", "catalog.json", "字幕"]).length); + if (!(_31 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _31); + } + const _30: string[] = ["video", "audio", "catalog.json", "字幕"]; + const path: rs.String = rs.stringWithCapacity(rs.usizeAdd(rs.usizeAdd(rs.stringLen(_7[_8]), 1), rs.stringLen(_30[_31]))); + rs.stringPushStr(path, _7[_8]); + rs.stringPush(path, 47); + rs.stringPushStr(path, _30[_31]); + total = rs.usizeAdd(total, path.len); + const _53: string | undefined = rs.strStripPrefix(path.v, _7[_8]); + if (_53 !== undefined) { + const _58: string | undefined = rs.strStripPrefix(_53, "/"); + if (_58 !== undefined) { + stripped = rs.usizeAdd(stripped, rs.stringLen(_58)); + } + } + } + putUsize(out, total); + putUsize(out, stripped); +} + +/** + * `count` paths, the `selector`th name of [`NAMES`] and a number, each a key of a + * `HashMap` and looked up by its `&str` four times, as moq-net finds a broadcast by its + * path: the sum of what the lookups found. + */ +export function keyed(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, rs.sliceFrom(["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]).length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + const keys: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u64Low(rs.u64Min(count, 65536))), (i2: rs.u32): rs.String => { + const part = _7[_8]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part), (f: rs.Formatter) => rs.u32Display(i2, f)]; + return rs.fmtFormat([args2[0], "/", args2[1]]); + }), undefined, 12, true); + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(keys.items)); + while (true) { + const _32: [rs.usize, rs.String] | rs.Done = iter.next(); + if (_32 === rs.DONE) { + break; + } + const i: rs.usize = _32[0]; + const _39: rs.String = rs.stringClone(_32[1]); + rs.hashInsert(map, _39, i as rs.u64); + } + let sum: rs.u64 = 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 4; + l3: while (iterStart++ < iterEnd) { + const iterS: rs.String[] = keys.items; + let iterI: number = 0; + while (true) { + const _51: rs.String | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_51 === rs.DONE) { + continue l3; + } + sum = rs.u64Add(sum, option_unwrapOr$15hbiwd(rs.hashGet(map, (_51.v as unknown) as rs.String), 0)); + } + } + harness_putU64(out, sum); + putUsize(out, rs.hashLen(map)); +} + /** * `count` TS packets of 188 bytes, each written by element through `as_chunks_mut`, then * numbered by continuity counter as moq-mux's `container/ts/export.rs` numbers them; with diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 702625c71..e24464964 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -241,13 +241,13 @@ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { } /** Read a varint length, then that many bytes of UTF-8. */ -export function string(self: Decoder): rs.Result { +export function string(self: Decoder): rs.Result { const err: DecodeError.DecodeError | undefined = bytes(self); const part: Uint8Array = out$ref_slice_u8.pData; const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { - const _2: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(new rs.ByteSlice(part, part2, part3))); + const _2: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(new rs.ByteSlice(part, part2, part3))); if (_2.ok) { return rs.Ok(_2.value); } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 563fce646..d6fb3ac1f 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -104,7 +104,7 @@ export function takeU64(data: rs.ByteSlice): [rs.u64, rs.ByteSlice] { /** A decode error's code, then its text. */ export function decodeFailed(out: rs.ByteVec, err: DecodeError.DecodeError): void { decodeError(out, err); - const _5: string = rs.fmtToString((f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)); + const _5: rs.String = rs.fmtToString((f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)); const args2: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; putText(out, _5, rs.fmtFormat([args2[0]])); } @@ -112,16 +112,16 @@ export function decodeFailed(out: rs.ByteVec, err: DecodeError.DecodeError): voi /** An encode error's code, then its text. */ export function encodeFailed(out: rs.ByteVec, err: EncodeError.EncodeError): void { encodeError(out, err); - const _5: string = rs.fmtToString((f: rs.Formatter) => EncodeError.fmt$fmt_Display(err, f)); + const _5: rs.String = rs.fmtToString((f: rs.Formatter) => EncodeError.fmt$fmt_Display(err, f)); const args2: rs.Fmt[] = [(f: rs.Formatter) => EncodeError.fmt$fmt_Debug(err, f)]; putText(out, _5, rs.fmtFormat([args2[0]])); } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ -export function putText(out: rs.ByteVec, display: string, debug: string): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(display)); +export function putText(out: rs.ByteVec, display: rs.String, debug: rs.String): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(display.v)); rs.byteVecPush(out, 0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(debug)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(debug.v)); rs.byteVecPush(out, 0); } @@ -282,9 +282,9 @@ export function decodeStep(r: Decoder.Decoder, step: rs.u8, out: rs.ByteVec): rs return rs.Err(err3 as DecodeError.DecodeError); } } else if (_5 === 6) { - const _49: rs.Result = Decoder.string(r); + const _49: rs.Result = Decoder.string(r); if (_49.ok) { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_49.value)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_49.value.v)); } else { return _49; } @@ -366,9 +366,9 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n const _51: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.u64ToBeBytes(value)), 0, rs.u8Rem(rs.u8Div(step, 10), 9) as rs.usize); result = Encoder.bytes(w, _51); } else if (_33 === 6) { - const _60: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rs.byteSliceFrom(rs.u64ToBeBytes(value)))); + const _60: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rs.byteSliceFrom(rs.u64ToBeBytes(value)))); if (_60.ok) { - result = Encoder.string(w, _60.value); + result = Encoder.string(w, _60.value.v); } else { result = Encoder.string(w, "not utf-8"); } @@ -578,7 +578,7 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, } else if (_10 === 3) { err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; } else if (_10 === 4) { - const _20: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data2)); + const _20: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data2)); if (_20.ok) { err = { tag: "Missing" } as DecodeError.DecodeError; } else { @@ -589,7 +589,7 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, } else { if (_10 === 6) { const arg = {}; - const _26: string = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); + const _26: rs.String = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); const arg2 = {}; const args2: rs.Fmt[] = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; putText(out, _26, rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])])); @@ -598,7 +598,7 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; } const args4: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)]; - const _38: string = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); + const _38: rs.String = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); const args6: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; putText(out, _38, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args6[0])])); decodeFailed(out, err); diff --git a/ts/fixtures/crates/dep/Cargo.toml b/ts/fixtures/crates/dep/Cargo.toml index 1885525be..f715c28b6 100644 --- a/ts/fixtures/crates/dep/Cargo.toml +++ b/ts/fixtures/crates/dep/Cargo.toml @@ -6,8 +6,5 @@ edition.workspace = true license.workspace = true publish = false -[dependencies] -bytes = "1.12.1" - [lints] workspace = true diff --git a/ts/fixtures/crates/dep/src/lib.rs b/ts/fixtures/crates/dep/src/lib.rs index 893c10b74..9bfac05e4 100644 --- a/ts/fixtures/crates/dep/src/lib.rs +++ b/ts/fixtures/crates/dep/src/lib.rs @@ -1,7 +1,6 @@ //! The dependency `crates-fixture` translates with: a type the package copies, which only //! this crate writes into, a generic function over the package's type, drops, an iterator, -//! `unsafe` with a safe twin where it translates and without one, a trait for objects, and -//! a `Bytes` of a `String`'s bytes. +//! `unsafe` with a safe twin where it translates and without one, and a trait for objects. use std::sync::{Arc, Mutex}; @@ -171,9 +170,3 @@ pub fn tally(tallies: &mut [&mut dyn Tally], by: u8) -> u32 { } sum } - -/// A `String`'s bytes, in storage of its capacity, which JS keeps none of, so the package's -/// reads of a `Bytes`' capacity are refused too. -pub fn string_bytes(text: String) -> bytes::Bytes { - bytes::Bytes::from(text) -} diff --git a/ts/fixtures/crates/src/lib.rs b/ts/fixtures/crates/src/lib.rs index bb760c241..84d42731e 100644 --- a/ts/fixtures/crates/src/lib.rs +++ b/ts/fixtures/crates/src/lib.rs @@ -20,11 +20,6 @@ pub fn alike() -> u8 { } one(fmt::Error) + one(std::fmt::Error) } -/// Whether the dependency's `Bytes` of a `String`'s bytes is the one handle of its storage, -/// which the `String`'s capacity decides: translation refuses it, as the bytes cross crates. -pub fn unique(text: String) -> bool { - ::crates_dep::string_bytes(text).is_unique() -} #[cfg(target_arch = "wasm32")] #[path = "../../wasm.rs"] diff --git a/ts/fixtures/crates/strings.toml b/ts/fixtures/crates/strings.toml deleted file mode 100644 index 6e0d17dac..000000000 --- a/ts/fixtures/crates/strings.toml +++ /dev/null @@ -1,4 +0,0 @@ -# A `Bytes` of a `String`'s bytes that the dependency makes, and the package's read of its -# capacity: `strings.txt` holds the error. -package = "crates-fixture" -roots = ["unique"] diff --git a/ts/fixtures/crates/strings.txt b/ts/fixtures/crates/strings.txt deleted file mode 100644 index 465023241..000000000 --- a/ts/fixtures/crates/strings.txt +++ /dev/null @@ -1 +0,0 @@ -fixtures/crates/src/lib.rs:unique+1:35: `Bytes::is_unique` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index f7d480a40..3b29a79f2 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -10,7 +10,7 @@ import { isSomeAnd$1s2u5lz, unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapO /** Each byte an operation, its value the operand; each puts what it read. */ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { - let s!: string; + let s!: rs.String; for (const op of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(op, 5); if (_10 === 0) { @@ -53,14 +53,14 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_10 === 2) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(op, f)]; const captured = rs.fmtFormat(["w", args6[0]]); - const words: string[] = rs.arrayFromFn(3, (i2: rs.usize): string => { - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; + const words: rs.String[] = rs.arrayFromFn(3, (i2: rs.usize): rs.String => { + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured.v), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; return rs.fmtFormat([args14[0], args14[1]]); }); - const _79: string[] = rs.arrayFromFn(0, (i3: rs.usize): string => { - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(i3, f)); + const _79: rs.String[] = rs.arrayFromFn(0, (i3: rs.usize): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(i3, f), 0); }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_79, f, rs.fmtStr)]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(_79, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; s = rs.fmtFormat([args8[0], " ", args8[1]]); } else if (_10 === 3) { const grid: Uint8Array[] = rs.arrayFromFn(3, (i: rs.usize): Uint8Array => { @@ -77,7 +77,7 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_108, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(_110, f, rs.usizeDebug)]; s = rs.fmtFormat([args12[0], " ", args12[1]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); rs.byteVecPush(out, 10); } } @@ -107,7 +107,7 @@ export function counted$5(op: rs.u8): rs.usize[] { * and of arrays, each element the closure's own to change. */ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { - let s!: string; + let s!: rs.String; for (const op of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(op, 5); if (_10 === 0) { @@ -138,25 +138,25 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const _47: Uint8Array = rs.bytesMap([], (w2: rs.u16): rs.u8 => { return w2 & 0xff; }); - const _48: string[] = rs.arrayMap([], (n: rs.u32): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(n, f)); + const _48: rs.String[] = rs.arrayMap([], (n: rs.u32): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(n, f), 0); }); const _53: rs.ByteSlice = rs.byteSliceFrom(_47); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_46, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_53), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_48, f, rs.fmtStr)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_46, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_53), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_48, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; s = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); } else if (_10 === 2) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(op, f)]; const captured = rs.fmtFormat(["w", args6[0]]); - const words2: string[] = rs.arrayMap(Uint8Array.of(1, 2, 3), (i: rs.u8): string => { - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.u8Display(i, f)]; + const words2: rs.String[] = rs.arrayMap(Uint8Array.of(1, 2, 3), (i: rs.u8): rs.String => { + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured.v), (f: rs.Formatter) => rs.u8Display(i, f)]; return rs.fmtFormat([args16[0], args16[1]]); }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words2, f, rs.fmtStr)]; - const shown: string = rs.fmtFormat([args8[0]]); - const _89: rs.ByteSlice = rs.byteSliceFrom(rs.bytesMap(words2, (w: string): rs.u8 => { - return rs.u8Add(rs.stringLen(w) & 0xff, rs.u8Rem(op, 3)); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words2, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + const shown: rs.String = rs.fmtFormat([args8[0]]); + const _89: rs.ByteSlice = rs.byteSliceFrom(rs.bytesMap(words2, (w: rs.String): rs.u8 => { + return rs.u8Add(w.len & 0xff, rs.u8Rem(op, 3)); })); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, shown), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, shown.v), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; s = rs.fmtFormat([args10[0], " ", args10[1]]); } else if (_10 === 3) { const options: Array = [op, undefined, rs.u8WrappingAdd(op, 60)]; @@ -199,7 +199,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(flipped, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(sums, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(same2, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(_134, f, rs.u64Debug)]; s = rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); rs.byteVecPush(out, 10); } } @@ -221,7 +221,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return 0; }); - const words: string[] = ["", ""]; + const words: rs.String[] = [rs.stringNew(), rs.stringNew()]; const item = copy$array_u8(rs.bytes(2)); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); @@ -257,12 +257,12 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { _40[0].v = _40[1].v; _40[1].v = swapped; } else if (_21 === 2) { - const _49: rs.Place[] = rs.arrayPlaces(words); + const _49: rs.String[] = rs.arrayFrom(words); const _51: rs.usize = rs.usizeRem(i, 2); if (!(_51 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _51); } - _49[_51].v = _49[_51].v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.stringPush(_49[_51], rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_21 === 3) { const rows: rs.ByteSlice[] = rs.arrayMap(grid, rs.byteSliceFrom); const _61: rs.usize = rs.usizeRem(i, 2); @@ -298,8 +298,8 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } _99.v = op; } - const lens: Uint8Array = rs.bytesMap(rs.arrayFrom(words), (w: string): rs.u8 => { - return rs.stringLen(w) & 0xff; + const lens: Uint8Array = rs.bytesMap(rs.arrayFrom(words), (w: rs.String): rs.u8 => { + return w.len & 0xff; }); const rows2: Uint8Array = rs.bytesMap(rs.arrayMap(grid, rs.byteSliceFrom), (row: rs.ByteSlice): rs.u8 => { return row.data[row.start] ^ row.data[row.start + 1]; @@ -319,13 +319,13 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const wides: rs.u16[] = rs.arrayFrom(wide); const _135: rs.u8[] = rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wides, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(_135, f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v)); } } - [rs.byteSliceFrom(bytes), wide, words, grid, pairs] as [rs.ByteSlice, rs.u16[], string[], Uint8Array[], rs.u32[][]]; + [rs.byteSliceFrom(bytes), wide, words, grid, pairs] as [rs.ByteSlice, rs.u16[], rs.String[], Uint8Array[], rs.u32[][]]; const arg = rs.byteSliceFrom(bytes); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(pairs, f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]]))); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(words, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(pairs, f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]]).v)); } /** @@ -337,7 +337,7 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.u16[] = Array.from({ length: 3 }, (): rs.u16 => { return 0; }); - const words: string[] = ["", ""]; + const words: rs.String[] = [rs.stringNew(), rs.stringNew()]; const item = copy$array_u8(rs.bytes(2)); const grid: Uint8Array[] = Array.from({ length: 3 }, (): Uint8Array => { return copy$array_u8(item); @@ -365,10 +365,10 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { _35.data[_35.start + _37] = (_32 << 7) & 0xffff; rs.sliceRotateRight(rs.sliceFrom(wide), 1); } else if (_22 === 2) { - const _46: rs.Slice = rs.sliceFrom(words); + const _46: rs.Slice = rs.sliceFrom(words); const _48: rs.usize = rs.usizeRem(i, 2); rs.idx(_46, _48); - _46.data[_46.start + _48] = _46.data[_46.start + _48] + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.stringPush(_46.data[_46.start + _48], rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_22 === 3) { const _59: rs.Slice = rs.sliceFrom(grid); const _61: rs.usize = rs.usizeRem(i, 3); @@ -408,13 +408,13 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { } const _143: rs.ByteSlice = rs.byteSliceFrom(bytes); const _146: rs.Slice = rs.sliceFrom(wide); - const _149: rs.Slice = rs.sliceFrom(words); + const _149: rs.Slice = rs.sliceFrom(words); const _152: rs.Slice = rs.sliceFrom(grid); const _155: rs.Slice = rs.sliceFrom(pairs); const _158: rs.Slice = rs.sliceFrom([]); const _161: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of()); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6]]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6]]).v)); } /** Arrays lent by `&mut`, written through their slices. */ @@ -696,7 +696,7 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -813,7 +813,7 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -930,7 +930,7 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -1047,7 +1047,7 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -1085,12 +1085,12 @@ export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { put$3(out, rs.sliceFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)])); const part = { _0: copy$array_u8(held.bytes) }; const args2: rs.Fmt[] = [(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]; - const shown: string = rs.fmtFormat([args2[0]]); + const shown: rs.String = rs.fmtFormat([args2[0]]); const _41: rs.ByteSlice = rs.byteSliceFrom(held.bytes); const taken2 = rs.byteSliceToArray(_41); _41.data.set(rs.bytes(3), _41.start); put$3(out, rs.sliceFrom([taken2, copy$array_u8(held.bytes)])); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown.v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d: rs.u8): boolean => { return rs.u8Rem(d, 3) === 1; })) { @@ -1192,7 +1192,7 @@ export function flattened(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } const part = [{ _0: bytesAt$3(data, 1) }, { _0: undefined }]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: Listed.Listed, f: rs.Formatter) => Listed.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** [`flattened`] of `N` bytes. */ diff --git a/ts/fixtures/lang/ascii/expected/ascii.Held.ts b/ts/fixtures/lang/ascii/expected/ascii.Held.ts index c5f7fcf96..e438ea48a 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.Held.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.Held.ts @@ -5,7 +5,7 @@ import * as rs from "./rs.ts"; /** A struct whose fields change case where they are. */ export interface Held { n: rs.u8; - text: string; + text: rs.String; } //# sourceMappingURL=ascii.Held.ts.map diff --git a/ts/fixtures/lang/ascii/expected/ascii.ts b/ts/fixtures/lang/ascii/expected/ascii.ts index ef57202d7..c58b0cec9 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.ts @@ -2,7 +2,7 @@ import * as rs from "./rs.ts"; import type * as Held from "./ascii.Held.ts"; -import { isSomeAnd$1s2u5lz, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0p20wlb as option_mapOr$0p20wlb, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i } from "./core/option.ts"; +import { isSomeAnd$1s2u5lz, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0p20wlb as option_mapOr$0p20wlb, mapOr$188iunt as option_mapOr$188iunt, asDeref$0wpj87j as option_asDeref$0wpj87j } from "./core/option.ts"; import { put } from "./harness.ts"; /** Each test of `b`, a bit apiece. */ @@ -27,8 +27,9 @@ export function lowerChar(c: rs.Place): void { c.v = rs.toAsciiLowercase(c.v); } -export function upperText(s: rs.Place): void { - s.v = rs.strToAsciiUppercase(s.v); +export function upperText(s: rs.String): void { + const _3: rs.Place = s; + _3.v = rs.strToAsciiUppercase(_3.v); } /** @@ -57,12 +58,11 @@ export function steps$ascii_EscapeDefault(e: rs.Iter, data: rs.ByteSlice, } if (next !== undefined) { rs.byteVecPush(out, next); - let shown: string = ""; + const shown: rs.String = rs.stringNew(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f)]; - const written = rs.fmtWriteString(shown, [args2[0]]); - shown = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug); - put(out, shown); + const _36: rs.Arguments = [args2[0]]; + rs.resultUnwrap(rs.fmtWriteString(shown, _36), rs.fmtErrorDebug); + put(out, shown.v); i = rs.usizeAdd(i, 1); } else { return; @@ -139,18 +139,17 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } const b3: rs.u8 = _101; const e: rs.Iter = rs.escapeAscii(b3); - let shown: string = ""; + const shown: rs.String = rs.stringNew(); const _113: rs.Iter = rs.escapeAscii(b3); const _115: rs.usize = rs.iterCount(e.clone()); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; - const written = rs.fmtWriteString(shown, [args2[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", args2[2]]); - shown = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug); - put(out, shown); + const _110: rs.Arguments = [args2[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", args2[2]]; + rs.resultUnwrap(rs.fmtWriteString(shown, _110), rs.fmtErrorDebug); + put(out, shown.v); rs.iterExtendBytes(out, e.clone(), "next"); rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); rs.byteVecPush(out, rs.optionUnwrap(rs.iterLast(e.clone()))); - rs.byteVecPush(out, rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))) & 0xff); + rs.byteVecPush(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f)).len & 0xff); } } const iter6: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); @@ -252,48 +251,52 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceMakeAsciiUppercase(rs.byteSliceFrom(array)); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(array)); } else if (_10 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const _95 of rs.byteSliceView(data)) { const _103: rs.usize = rs.usizeRem(_95 as rs.usize, rs.sliceFrom([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111]).length); if (!(_103 < 41)) { rs.panic("index out of bounds: the len is " + 41 + " but the index is " + _103); } - s = s + String.fromCodePoint([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111][_103]); + rs.stringPush(s, [0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111][_103]); } - const mid: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(rs.iterRev(new rs.RangeInclusive(0, rs.usizeDiv(rs.stringLen(s), 2), rs.usizeStep)), (_2: rs.usize): boolean => { - return rs.strIsCharBoundary(s, _2); + const mid: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(rs.iterRev(new rs.RangeInclusive(0, rs.usizeDiv(s.len, 2), rs.usizeStep)), (_2: rs.usize): boolean => { + return rs.strIsCharBoundary(s.v, _2); }), 0); - const _124: string = rs.strSlice(s, 0, mid); - const _127: string = rs.strSlice(s, mid); - rs.byteVecPush(out, rs.strIsAscii(s) ? 1 : 0); + const _124: string = rs.strSlice(s.v, 0, mid); + const _127: string = rs.strSlice(s.v, mid); + rs.byteVecPush(out, rs.strIsAscii(s.v) ? 1 : 0); rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, _127) ? 1 : 0); - rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, rs.strToAsciiUppercase(_127)) ? 1 : 0); - put(out, rs.strToAsciiUppercase(s)); - put(out, rs.stringExtendChars("", rs.iterFilter(rs.strChars(s), (a0: rs.char): boolean => { + rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, rs.stringFrom(rs.strToAsciiUppercase(_127)).v) ? 1 : 0); + put(out, rs.stringFrom(rs.strToAsciiUppercase(s.v)).v); + const _154: rs.Iter = rs.iterFilter(rs.strChars(s.v), (a0: rs.char): boolean => { return rs.isAsciiAlphanumeric(a0); - }))); - put(out, rs.strToAsciiLowercase(s)); - put(out, rs.strTrimAsciiStart(s)); - put(out, rs.strTrimAsciiEnd(s)); - put(out, rs.strTrimAscii(s)); - let t: string = s; - t = rs.strToAsciiUppercase(t); - put(out, t); - t = rs.strToAsciiLowercase(t); - put(out, t); + }); + put(out, rs.stringExtendChars(rs.stringNew(), _154).v); + put(out, rs.stringFrom(rs.strToAsciiLowercase(s.v)).v); + put(out, rs.strTrimAsciiStart(s.v)); + put(out, rs.strTrimAsciiEnd(s.v)); + put(out, rs.strTrimAscii(s.v)); + const t: rs.String = rs.stringClone(s); + const _179: rs.Place = t; + _179.v = rs.strToAsciiUppercase(_179.v); + put(out, t.v); + const _186: rs.Place = t; + _186.v = rs.strToAsciiLowercase(_186.v); + put(out, t.v); const held: Held.Held = { n: 0, text: t }; - upperText(rs.place(() => held.text, (value) => held.text = value)); - put(out, held.text); - held.text = rs.strToAsciiLowercase(held.text); - put(out, held.text); + upperText(held.text); + put(out, held.text.v); + const _198: rs.Place = held.text; + _198.v = rs.strToAsciiLowercase(_198.v); + put(out, held.text.v); held.n = rs.toAsciiUppercase(held.n); rs.byteVecPush(out, held.n); } else if (_10 === 2) { const e: rs.Iter = rs.byteSliceEscapeAscii(data); - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f)).v); const _221: rs.usize = rs.iterCount(e.clone()); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.usizeDisplay(_221, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1]])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1]]).v); rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(e.clone()), 255)); } else { @@ -316,7 +319,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } if (next !== undefined) { rs.byteVecPush(out, next); - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e2, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e2, f)).v); rs.iterExtendBytes(out, e2.clone(), "next"); i = rs.usizeAdd(i, 1); } else { @@ -368,50 +371,52 @@ export function parts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _10: [rs.usize, rs.usize] = [at(0), at(1)]; const a: rs.usize = _10[0]; const b: rs.usize = _10[1]; - let s: string = text; - const pair: [rs.u8, string] = [7, text]; - const array: string[] = ["q", text]; - const v: rs.Vec = rs.vecFrom([text, text]); + const s: rs.String = rs.stringFrom(text); + const pair: [rs.u8, rs.String] = [7, rs.stringFrom(text)]; + const array: rs.String[] = [rs.stringFrom("q"), rs.stringFrom(text)]; + const v: rs.Vec = rs.vecFrom([rs.stringFrom(text), rs.stringFrom(text)]); const _32: rs.u8 = rs.u8Rem(kind, 8); if (_32 === 0) { - s = rs.strToAsciiUppercase(s); - put(out, s); - const _41: rs.Place = rs.strPart(rs.place(() => s, (value15) => s = value15), a, b); + const _35: rs.Place = s; + _35.v = rs.strToAsciiUppercase(_35.v); + put(out, s.v); + const _41: rs.Place = rs.strPart(s, a, b); _41.v = rs.strToAsciiLowercase(_41.v); - put(out, s); + put(out, s.v); } else if (_32 === 1) { - pair[1] = rs.strToAsciiUppercase(pair[1]); - put(out, pair[1]); - const _54: rs.Place = rs.strPart(rs.place(() => pair[1], (value14) => pair[1] = value14), a); + const _48: rs.Place = pair[1]; + _48.v = rs.strToAsciiUppercase(_48.v); + put(out, pair[1].v); + const _54: rs.Place = rs.strPart(pair[1], a); _54.v = rs.strToAsciiLowercase(_54.v); - put(out, pair[1]); + put(out, pair[1].v); rs.byteVecPush(out, pair[0]); } else if (_32 === 2) { - array[1] = rs.strToAsciiUppercase(array[1]); - put(out, array[1]); - const _73: rs.Place = rs.strPart(rs.place(() => array[1], (value13) => array[1] = value13), 0, b); + const _63: rs.Place = array[1]; + _63.v = rs.strToAsciiUppercase(_63.v); + put(out, array[1].v); + const _73: rs.Place = rs.strPart(array[1], 0, b); _73.v = rs.strToAsciiLowercase(_73.v); - put(out, array[1]); - put(out, array[0]); + put(out, array[1].v); + put(out, array[0].v); } else if (_32 === 3) { - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(v.items)); + const iter: rs.Iter = rs.iterSlice(v.items); while (true) { - const _93: rs.Place | rs.Done = iter.next(); + const _93: rs.String | rs.Done = iter.next(); if (_93 === rs.DONE) { break; } - _93.v = rs.strToAsciiUppercase(_93.v); + const _98: rs.Place = _93; + _98.v = rs.strToAsciiUppercase(_98.v); } - const at6 = rs.idx(v.items, 0); - const _100: rs.Place = rs.strPart(rs.place(() => v.items[at6], (value11) => v.items[at6] = value11), 0); + const _100: rs.Place = rs.strPart(v.items[rs.idx(v.items, 0)], 0); _100.v = rs.strToAsciiLowercase(_100.v); - const at7 = rs.idx(v.items, 1); - const _105: rs.Place = rs.strPart(rs.place(() => v.items[at7], (value12) => v.items[at7] = value12), a, b); + const _105: rs.Place = rs.strPart(v.items[rs.idx(v.items, 1)], a, b); _105.v = rs.strToAsciiLowercase(_105.v); - put(out, v.items[rs.idx(v.items, 0)]); - put(out, v.items[rs.idx(v.items, 1)]); + put(out, v.items[rs.idx(v.items, 0)].v); + put(out, v.items[rs.idx(v.items, 1)].v); } else if (_32 === 4) { - const _119: [rs.Place, rs.Place] = rs.strSplitAtMut(rs.place(() => s, (value10) => s = value10), a); + const _119: [rs.Place, rs.Place] = rs.strSplitAtMut(s, a); _119[0].v = rs.strToAsciiUppercase(_119[0].v); _119[1].v = rs.strToAsciiUppercase(_119[1].v); _119[0].v = rs.strToAsciiLowercase(_119[0].v); @@ -421,38 +426,37 @@ export function parts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { _131[1].v = rs.strToAsciiLowercase(_131[1].v); put(out, _131[0].v); put(out, _131[1].v); - put(out, s); + put(out, s.v); } else if (_32 === 5) { - putUpper(out, rs.strGetMut(rs.place(() => s, (value7) => s = value7), a, b)); - putUpper(out, rs.strGetMut(rs.place(() => pair[1], (value8) => pair[1] = value8), a)); - const at4 = rs.idx(v.items, 1); - putUpper(out, rs.strGetMut(rs.place(() => v.items[at4], (value9) => v.items[at4] = value9), 0, b)); - put(out, s); - put(out, pair[1]); - put(out, v.items[rs.idx(v.items, 1)]); + putUpper(out, rs.strGetMut(s, a, b)); + putUpper(out, rs.strGetMut(pair[1], a)); + putUpper(out, rs.strGetMut(v.items[rs.idx(v.items, 1)], 0, b)); + put(out, s.v); + put(out, pair[1].v); + put(out, v.items[rs.idx(v.items, 1)].v); } else if (_32 === 6) { - const _168: [rs.Place, rs.Place] | undefined = rs.strSplitAtMutChecked(rs.place(() => array[1], (value5) => array[1] = value5), a); + const _168: [rs.Place, rs.Place] | undefined = rs.strSplitAtMutChecked(array[1], a); if (_168 === undefined) { rs.byteVecPush(out, 253); } else { _168[1].v = rs.strToAsciiUppercase(_168[1].v); putUpper(out, rs.strGetMut(_168[0], rs.min(b, rs.stringLen(_168[0].v)))); } - put(out, array[1]); - let held: string | undefined = text; - const _191: rs.Place | undefined = held === undefined ? undefined : rs.place(() => held as string, (value6) => held = value6); + put(out, array[1].v); + const held: rs.String | undefined = rs.stringFrom(text); + const _191: rs.String | undefined = held; if (_191 !== undefined) { - _191.v = rs.strToAsciiUppercase(_191.v); + const _196: rs.Place = _191; + _196.v = rs.strToAsciiUppercase(_196.v); } - put(out, option_unwrapOr$1iemzn8(option_asDeref$0w8at8i(held), "-")); + put(out, option_unwrapOr$1iemzn8(option_asDeref$0wpj87j(held), "-")); } else { - const at2 = rs.idx(v.items, 1); - upperPart(rs.strPart(rs.place(() => v.items[at2], (value) => v.items[at2] = value), a), 0, rs.usizeSaturatingSub(b, a)); - put(out, v.items[rs.idx(v.items, 1)]); - upperPart(rs.place(() => s, (value2) => s = value2), a, b); - put(out, rs.strPart(rs.place(() => s, (value3) => s = value3), 0, a).v); - put(out, rs.strPart(rs.place(() => s, (value4) => s = value4), a).v); - const leaked: rs.Place = { v: pair[1] }; + upperPart(rs.strPart(v.items[rs.idx(v.items, 1)], a), 0, rs.usizeSaturatingSub(b, a)); + put(out, v.items[rs.idx(v.items, 1)].v); + upperPart(s, a, b); + put(out, rs.stringFrom(rs.strPart(s, 0, a).v).v); + put(out, rs.stringFrom(rs.strPart(s, a).v).v); + const leaked: rs.Place = pair[1]; const _234: rs.Place = rs.strPart(leaked, rs.min(b, a)); _234.v = rs.strToAsciiUppercase(_234.v); put(out, leaked.v); diff --git a/ts/fixtures/lang/ascii/expected/core/option.ts b/ts/fixtures/lang/ascii/expected/core/option.ts index 40c09ab17..d7d77c238 100644 --- a/ts/fixtures/lang/ascii/expected/core/option.ts +++ b/ts/fixtures/lang/ascii/expected/core/option.ts @@ -30,11 +30,11 @@ export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize) return self; } -export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string): string | undefined { +export function map$06og5bz(self: rs.String | undefined, _: (a0: rs.String) => string): string | undefined { if (self === undefined) { return undefined; } - return self; + return self.v; } export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { @@ -58,9 +58,9 @@ export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a return f(self); } -export function asDeref$0w8at8i(self: string | undefined): string | undefined { - return map$1uo1d4o(self, (a0: string): string => { - return a0; +export function asDeref$0wpj87j(self: rs.String | undefined): string | undefined { + return map$06og5bz(self, (a0: rs.String): string => { + return a0.v; }); } diff --git a/ts/fixtures/lang/borrows/expected/borrows.Parts.ts b/ts/fixtures/lang/borrows/expected/borrows.Parts.ts index b39700456..dceb6dadf 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Parts.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Parts.ts @@ -9,13 +9,13 @@ import type * as Tagged from "./borrows.Tagged.ts"; */ export class Parts { n: rs.u32; - text: string; + text: rs.String; bytes: rs.ByteVec; tagged: Tagged.Tagged; maybe: rs.u16 | undefined; quad: Uint8Array; - constructor(n: rs.u32, text: string, bytes: rs.ByteVec, tagged: Tagged.Tagged, maybe: rs.u16 | undefined, quad: Uint8Array) { + constructor(n: rs.u32, text: rs.String, bytes: rs.ByteVec, tagged: Tagged.Tagged, maybe: rs.u16 | undefined, quad: Uint8Array) { this.n = n; this.text = text; this.bytes = bytes; diff --git a/ts/fixtures/lang/borrows/expected/borrows.ts b/ts/fixtures/lang/borrows/expected/borrows.ts index b8b370277..0b9630050 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.ts @@ -178,7 +178,7 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const part3 = new rs.BorrowMutError(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(part3, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(part3, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); } if (_116.ok) { drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_116); @@ -192,7 +192,7 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const part4 = new rs.BorrowError(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.borrowErrorDisplay(part4, f), (f: rs.Formatter) => rs.borrowErrorDebug(part4, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); } if (_141.ok) { drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_141); @@ -313,7 +313,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const tag: (a0: rs.u8) => Tagged.Tagged = (id: rs.u8): Tagged.Tagged => { return new Tagged.Tagged(id, 0, rs.arcClone(log)); }; - const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, "", new rs.ByteVec(), tag(1), undefined, rs.bytes(4))); + const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, rs.stringNew(), new rs.ByteVec(), tag(1), undefined, rs.bytes(4))); const number: rs.RefCell = new rs.RefCell(0); const bytes4: rs.RefCell = new rs.RefCell(Uint8Array.of(1, 2, 3, 4)); const slot: rs.RefCell = new rs.RefCell(undefined as Tagged.Tagged | undefined); @@ -322,7 +322,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { if (_29 === 0) { const _32: rs.RefCell = rs.refCellBorrowMut(parts); const n: rs.RefCell = rs.refMutMap(_32, ((p16: Parts.Parts): rs.Place => { - return rs.place(() => p16.n, (value8) => p16.n = value8); + return rs.place(() => p16.n, (value6) => p16.n = value6); })(_32.value)); n.value = rs.u32Add(n.value, op as rs.u32); rs.byteVecPush(out, borrowed$borrows_Parts(parts)); @@ -348,17 +348,18 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.refRelease(_78); } else if (_29 === 1) { const _81: rs.RefCell = rs.refCellBorrowMut(parts); - const text: rs.RefCell = rs.refMutMap(_81, ((p15: Parts.Parts): rs.Place => { - return rs.place(() => p15.text, (value7) => p15.text = value7); - })(_81.value)); - text.value = text.value + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + const text: rs.RefCell = rs.refMutMap(_81, rs.partPlace(((p15: Parts.Parts): rs.String => { + return p15.text; + })(_81.value))); + rs.stringPush(text.value, rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); if ((op >> 4) === 15) { - text.value = "z"; + const _95: rs.String = rs.stringFrom("z"); + text.value = _95; } - rs.byteVecPush(out, rs.stringLen(text.value) & 0xff); + rs.byteVecPush(out, text.value.len & 0xff); rs.refMutRelease(text); const _110: rs.RefCell = rs.refCellBorrow(parts); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_110.value.text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_110.value.text.v)); rs.refRelease(_110); } else if (_29 === 2) { const _113: rs.RefCell = rs.refCellBorrowMut(parts); @@ -395,7 +396,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_29 === 3) { const _170: rs.RefCell = rs.refCellBorrowMut(parts); const _169: rs.Result, rs.RefCell> = rs.refMutFilterMap(_170, ((p11: Parts.Parts): rs.Place | undefined => { - return p11.maybe === undefined ? undefined : rs.place(() => p11.maybe as rs.u16, (value6) => p11.maybe = value6); + return p11.maybe === undefined ? undefined : rs.place(() => p11.maybe as rs.u16, (value5) => p11.maybe = value5); })(_170.value)); if (_169.ok) { const m: rs.RefCell = _169.value; @@ -461,13 +462,14 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } else if (_29 === 5) { const _274: rs.RefCell = rs.refCellBorrowMut(parts); - const _273: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_274, ((p8: Parts.Parts): [rs.Place, rs.Place] => { - return [rs.place(() => p8.n, (value4) => p8.n = value4), rs.place(() => p8.text, (value5) => p8.text = value5)] as [rs.Place, rs.Place]; - })(_274.value)); + const parts3 = ((p8: Parts.Parts): [rs.Place, rs.String] => { + return [rs.place(() => p8.n, (value4) => p8.n = value4), p8.text] as [rs.Place, rs.String]; + })(_274.value); + const _273: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_274, [parts3[0], rs.partPlace(parts3[1])]); const n3: rs.RefCell = _273[0]; - const text2: rs.RefCell = _273[1]; + const text2: rs.RefCell = _273[1]; n3.value = rs.u32Add(n3.value, 1); - text2.value = text2.value + "s"; + rs.stringPush(text2.value, 115); rs.byteVecPush(out, borrowed$borrows_Parts(parts)); if (!((op & 16) === 0)) { rs.refMutRelease(text2); @@ -483,11 +485,11 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_305, _311.value.n & 0xff))); rs.refRelease(_311); const _316: rs.RefCell = rs.refCellBorrowMut(parts); - const parts3 = ((p9: Parts.Parts): [rs.ByteSlice, rs.ByteSlice] => { + const parts4 = ((p9: Parts.Parts): [rs.ByteSlice, rs.ByteSlice] => { const half: rs.usize = rs.usizeDiv(p9.bytes.length, 2); return rs.byteSliceSplitAt(rs.byteVecSlice(p9.bytes), half); })(_316.value); - const _315: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_316, [rs.partPlace(parts3[0]), rs.partPlace(parts3[1])]); + const _315: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_316, [rs.partPlace(parts4[0]), rs.partPlace(parts4[1])]); const low: rs.RefCell = _315[0]; const high: rs.RefCell = _315[1]; const _318: rs.Place | undefined = rs.sliceFirstMut(low.value); @@ -531,8 +533,8 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { drop$Result_cell_Ref_u32_cell_Ref_borrows_Parts(_f); } else if (_341 === 15) { const _365: rs.RefCell = rs.refCellBorrow(parts); - const _364: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_365, ((p4: Parts.Parts): [rs.u32, string] => { - return [p4.n, p4.text] as [rs.u32, string]; + const _364: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_365, ((p4: Parts.Parts): [rs.u32, rs.String] => { + return [p4.n, p4.text] as [rs.u32, rs.String]; })(_365.value)); const _a: rs.RefCell = _364[0]; rs.refRelease(_364[1]); @@ -544,7 +546,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const _373: rs.RefCell = rs.refCellBorrow(parts); const text3: rs.RefCell = rs.refMap(_373, ((p: Parts.Parts): string => { - return p.text; + return p.text.v; })(_373.value)); const _376: rs.RefCell = rs.refCellBorrowMut(number); const n4: rs.RefCell = rs.refMutMap(_376, ((n5: rs.Place): rs.Place => { @@ -553,7 +555,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const _387: string = text3.value; const _390: rs.u32 = rs.u32Add(n4.value, 1); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _387), (f: rs.Formatter) => rs.u32Display(_390, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(borrowed$borrows_Parts(parts), borrowed$u32(number)))); drop$tuple2_cell_Ref_str_cell_RefMut_u32([text3, n4] as [rs.RefCell, rs.RefCell]); const _411: rs.RefCell = rs.refCellBorrowMut(parts); @@ -611,7 +613,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last2.n & 0xff, last2.tagged.id, option_mapOr$031uhqp(last2.maybe, 253, (m2: rs.u16): rs.u8 => { return m2 & 0xff; })))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text.v)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.bytes)); last2[Symbol.dispose](); slot[Symbol.dispose](); @@ -627,7 +629,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); - const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, "", new rs.ByteVec(), new Tagged.Tagged(1, 0, rs.arcClone(log)), undefined, Uint8Array.of(1, 2, 3, 4))); + const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, rs.stringNew(), new rs.ByteVec(), new Tagged.Tagged(1, 0, rs.arcClone(log)), undefined, Uint8Array.of(1, 2, 3, 4))); const number: rs.RefCell = new rs.RefCell(0); for (const op of rs.byteSliceView(data)) { const _23: rs.u8 = rs.u8Rem(op, 4); @@ -729,10 +731,10 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } else if (_23 === 2) { const _175: rs.RefCell = rs.refCellBorrowMut(parts); - _175.value.text = _175.value.text + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.stringPush(_175.value.text, rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); rs.refMutRelease(_175); const _183: rs.RefCell = rs.refCellBorrow(parts); - const text: rs.RefCell = rs.refMap(_183, ((p3: Parts.Parts): string => { + const text: rs.RefCell = rs.refMap(_183, ((p3: Parts.Parts): rs.String => { return p3.text; })(_183.value)); const _186: rs.RefCell = rs.refCellBorrow(parts); @@ -740,15 +742,15 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.byteSliceFrom(p4.quad); })(_186.value))); const n2: rs.RefCell = rs.refCellBorrow(number); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text.value), (f: rs.Formatter) => rs.fmtStr(text.value, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "] ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", args2[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args2[4])]))); - drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rs.RefCell, rs.RefCell, rs.RefCell]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text.value.v), (f: rs.Formatter) => rs.fmtStr(text.value.v, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "] ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", args2[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args2[4])]).v)); + drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rs.RefCell, rs.RefCell, rs.RefCell]); const _211: rs.RefCell = rs.refCellBorrowMut(parts); const maybe: rs.RefCell = rs.refMutMap(_211, ((p5: Parts.Parts): rs.Place => { return rs.place(() => p5.maybe, (value2) => p5.maybe = value2); })(_211.value)); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(maybe.value, f, rs.u16Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0])]).v)); rs.refMutRelease(maybe); const _227: rs.RefCell = rs.refCellBorrowMut(parts); const bytes2: rs.RefCell = rs.refMutMap(_227, rs.partPlace(((p6: Parts.Parts): rs.ByteVec => { @@ -756,21 +758,21 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { })(_227.value))); const _237: rs.RefCell = rs.refCellBorrowMut(number); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(_237.value, f)]; - const _233: string = rs.fmtFormat([args6[0], " ", args6[1]]); + const _233: rs.String = rs.fmtFormat([args6[0], " ", args6[1]]); rs.refMutRelease(_237); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_233)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_233.v)); rs.refMutRelease(bytes2); const pair: rs.RefCell<[rs.u8, string]> = new rs.RefCell([op, "pair"] as [rs.u8, string]); const _256: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_256.value[0], f), (f: rs.Formatter) => rs.fmtStr(_256.value[1], f)], f)]; - const _252: string = rs.fmtFormat([args8[0], " "]); + const _252: rs.String = rs.fmtFormat([args8[0], " "]); rs.refRelease(_256); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_252)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_252.v)); const _270: rs.RefCell<[rs.u8, string]> = rs.refCellBorrowMut(pair); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_270.value[0], f), (f: rs.Formatter) => rs.fmtStr(_270.value[1], f)], f)]; - const _266: string = rs.fmtFormat([rs.fmtSpec({ alternate: true }, args10[0])]); + const _266: rs.String = rs.fmtFormat([rs.fmtSpec({ alternate: true }, args10[0])]); rs.refMutRelease(_270); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_266)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_266.v)); const _277: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); const tried4: rs.Result, [rs.RefCell<[rs.u8, string]>, rs.u8]> = rs.refTryMap(_277, ((p7: [rs.u8, string]): rs.Result => { if (!((p7[0] & 1) === 0)) { @@ -779,7 +781,7 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.Ok(p7[1]); })(_277.value)); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried4, f, (value: rs.RefCell, f: rs.Formatter) => rs.fmtStr(value.value, f), (value: [rs.RefCell<[rs.u8, string]>, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0].value[0], f), (f: rs.Formatter) => rs.fmtStr(value[0].value[1], f)], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0]]).v)); drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8(tried4); } else { const _291: rs.u8 = op >> 4; @@ -814,7 +816,7 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last2.n & 0xff, option_mapOr$031uhqp(last2.maybe, 253, (m3: rs.u16): rs.u8 => { return m3 & 0xff; })))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text.v)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.bytes)); last2[Symbol.dispose](); flush(log.value, out); @@ -1078,7 +1080,7 @@ export function flush(log: rs.Mutex, out: rs.ByteVec): void { * write the cell they lend; and `Cell`s of `Copy` values and an `UnsafeCell`. */ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; const number: rs.RefCell = new rs.RefCell(0); const nested: rs.RefCell>> = new rs.RefCell(rs.vecFrom([new rs.RefCell(0)])); const pair: rs.Cell<[rs.u8, rs.char]> = new rs.Cell([0, 97] as [rs.u8, rs.char]); @@ -1092,14 +1094,14 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { _30.value = rs.u32Add(_30.value, _27); rs.refMutRelease(_30); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; - const free: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); + const free: rs.String = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); const shared: rs.RefCell = rs.refCellBorrow(number); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; - const read: string = rs.fmtFormat([args4[0]]); + const read: rs.String = rs.fmtFormat([args4[0]]); rs.refRelease(shared); const _held: rs.RefCell = rs.refCellBorrowMut(number); const dynamic: rs.Fmt = (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, read), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free.v), (f: rs.Formatter) => rs.fmtPad(f, read.v), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; text = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", rs.fmtSpec({ alternate: true }, args6[2]), " ", rs.fmtSpec({ align: ">", width: 16 }, args6[2]), " ", args6[3]]); rs.refMutRelease(_held); } else if (_25 === 1) { @@ -1108,11 +1110,11 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { _75.value.items.push(_77); rs.refMutRelease(_75); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; - const free2: string = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0])]); + const free2: rs.String = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0])]); const cells: rs.RefCell>> = rs.refCellBorrow(nested); const _95: rs.Vec> = cells.value; const _inner: rs.RefCell = rs.refCellBorrowMut(_95.items[rs.idx(_95.items, rs.usizeSub(cells.value.items.length, 1))]); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2.v), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; text = rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])]); rs.refMutRelease(_inner); rs.refRelease(cells); @@ -1120,18 +1122,18 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { const outer: rs.RefCell> = new rs.RefCell(new rs.RefCell(v)); const shared2: rs.RefCell> = rs.refCellBorrow(outer); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(shared2.value, f, rs.u8Debug)]; - const free3: string = rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]); + const free3: rs.String = rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]); rs.refRelease(shared2); const exclusive: rs.RefCell> = rs.refCellBorrowMut(outer); const inner: rs.RefCell = rs.refCellBorrowMut(exclusive.value); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(outer, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.u8Debug(inner.value, f)]; - const held: string = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", args14[1], " ", args14[2]]); + const held: rs.String = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", args14[1], " ", args14[2]]); rs.refMutRelease(inner); const _146: rs.RefCell>> = rs.refCellBorrow(nested); const last: rs.RefCell> = rs.refMap(_146, ((n: rs.Vec>): rs.RefCell => { return n.items[rs.idx(n.items, 0)]; })(_146.value)); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free3), (f: rs.Formatter) => rs.fmtPad(f, held), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free3.v), (f: rs.Formatter) => rs.fmtPad(f, held.v), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; text = rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); rs.refRelease(last); rs.refMutRelease(exclusive); @@ -1149,9 +1151,9 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(_204.value, v); rs.refMutRelease(_204); const args20: rs.Fmt[] = [(f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; - const free4: string = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])]); + const free4: rs.String = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])]); const _held2: rs.RefCell = rs.refCellBorrowMut(shown.refcell); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free4), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free4.v), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; text = rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ alternate: true }, args22[1])]); rs.refMutRelease(_held2); } else if (_25 === 5) { @@ -1167,12 +1169,12 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { text = rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0])]); probe[Symbol.dispose](); } else { - const _253: rs.RefCell = new rs.RefCell("s"); + const _253: rs.RefCell = new rs.RefCell(rs.stringFrom("s")); const _256: rs.RefCell = new rs.RefCell(rs.bytes(2).fill(v)); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(_253, f, rs.fmtStr), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(_253, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; text = rs.fmtFormat([args28[0], " ", args28[1]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } } diff --git a/ts/fixtures/lang/borrows/expected/lib.ts b/ts/fixtures/lang/borrows/expected/lib.ts index 54bc53e1b..44b4c6b14 100644 --- a/ts/fixtures/lang/borrows/expected/lib.ts +++ b/ts/fixtures/lang/borrows/expected/lib.ts @@ -173,7 +173,7 @@ export function drop$tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1: [rs.RefCell<[rs.u8 rs.refRelease(_1[0]); } -export function drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32(_1: [rs.RefCell, rs.RefCell, rs.RefCell]): void { +export function drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32(_1: [rs.RefCell, rs.RefCell, rs.RefCell]): void { rs.refRelease(_1[0]); rs.refRelease(_1[1]); rs.refRelease(_1[2]); diff --git a/ts/fixtures/lang/boxes/expected/boxes.Owner.ts b/ts/fixtures/lang/boxes/expected/boxes.Owner.ts index 456b3d3e6..35253a420 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.Owner.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.Owner.ts @@ -5,7 +5,7 @@ import * as rs from "./rs.ts"; /** Boxes of values JS copies, held in a struct a `&mut` reaches. */ export interface Owner { n: rs.u32; - s: string; + s: rs.String; nested: rs.u32; } diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 4e658fad8..0e370cf2f 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -221,7 +221,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceFirst(a), 170)); const _261: rs.ByteSlice = rs.byteSliceFrom(new Uint8Array(0)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_261), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]]).v); } else if (_15 === 2) { const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_24: rs.u8): rs.u16 => { return rs.u16Mul(_24 as rs.u16, 257); @@ -262,7 +262,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.cmpSlice(rs.cmp)(collected2, cloned2) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(collected2)) ? 1 : 0); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected2), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([args4[0]]).v); const v3: rs.Vec = rs.vecFrom(rs.sliceItems(fromVec2)); v3.items.push(5); wides(rs.sliceFrom(v3.items), out); @@ -410,11 +410,12 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_634[1]).reverse()), undefined, true); } } else { - const s: string = text(data2); - const fromRef4: string = s; - const fromString: string = s; - const into2: string = s; - const collected4: string = rs.stringExtendChars("", rs.iterRev(rs.strChars(s))); + const s: rs.String = text(data2); + const fromRef4: string = s.v; + const fromString: string = rs.stringClone(s).v; + const into2: string = rs.stringClone(s).v; + const _655: rs.Iter = rs.iterRev(rs.strChars(s.v)); + const collected4: string = rs.stringExtendChars(rs.stringNew(), _655).v; const empty4: string = ""; put(out, fromRef4); put(out, fromString); @@ -423,13 +424,13 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, empty4); rs.byteVecPush(out, fromRef4 === into2 ? 1 : 0); rs.byteVecPush(out, rs.cmpStr(collected4, fromRef4) & 0xff); - rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s.v)) ? 1 : 0); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, fromRef4), (f: rs.Formatter) => rs.fmtStr(collected4, f)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1]])); - let back2: string = into2; - back2 = back2 + "!"; - put(out, back2); - put(out, collected4); + put(out, rs.fmtFormat([args6[0], "|", args6[1]]).v); + const back2: rs.String = rs.stringFrom(into2); + rs.stringPush(back2, 33); + put(out, back2.v); + put(out, rs.stringFrom(collected4).v); } } @@ -484,7 +485,7 @@ export function reach(b: Owner.Owner, by: rs.u8): void { } else if (_3 === 2) { bump(rs.place(() => b.nested, (value) => b.nested = value), by); } else { - b.s = b.s + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); + rs.stringPush(b.s, rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } } @@ -497,15 +498,15 @@ export function reach(b: Owner.Owner, by: rs.u8): void { export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let n: rs.u32 = 7; const pair: Uint8Array = Uint8Array.of(1, 2); - let s: string = "b"; + const s: rs.String = rs.stringFrom("b"); let t: string = "aBc/D"; let nested: rs.u32 = 3; let maybe: rs.u32 | undefined = undefined as rs.u32 | undefined; - const held: Owner.Owner = { n: 5, s: "", nested: 9 }; + const held: Owner.Owner = { n: 5, s: rs.stringNew(), nested: 9 }; const v: rs.Vec = rs.vecFrom([1, 2]); let o: rs.u32 | undefined = 4; let res: rs.Result = rs.Ok(2); - let said: rs.Result = rs.Ok("r"); + let said: rs.Result = rs.Ok(rs.stringFrom("r")); const words: rs.Slice = rs.sliceFrom([6, 8]); const someWords: rs.Slice | undefined = rs.sliceFrom([3, 5]); let named: string | undefined = "xY/z"; @@ -548,11 +549,11 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } r2.data[r2.start + _76] = r2.data[r2.start + _76] ^ by; } else if (_58 === 8) { - s = s + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); + rs.stringPush(s, rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } else if (_58 === 9) { - s = s + "!?"; + rs.stringPushStr(s, "!?"); } else if (_58 === 10) { - s = rs.stringInsertStr(s, 0, "<"); + rs.stringInsertStr(s, 0, "<"); } else if (_58 === 11) { shout(rs.place(() => t, (value20) => t = value20), by); } else if (_58 === 12) { @@ -562,7 +563,7 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _94: rs.Place = rs.place(() => t, (value17) => t = value17); _94.v = rs.strToAsciiLowercase(_94.v); } else if (_58 === 14) { - t = rs.strSlice(s, 0); + t = rs.strSlice(s.v, 0); } else if (_58 === 15) { bump(rs.place(() => nested, (value16) => nested = value16), by); } else if (_58 === 16) { @@ -615,9 +616,9 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (res.ok) { res = { ok: true, value: rs.u32WrappingMul(res.value, by as rs.u32) }; } - const _165: rs.Place> = rs.place(() => said, (value12) => said = value12); + const _165: rs.Place> = rs.place(() => said, (value12) => said = value12); if (_165.v.ok) { - _165.v = { ok: true, value: _165.v.value + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char) }; + rs.stringPush(_165.v.value, rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } if (rs.usizeRem(i, 5) === 4) { said = rs.Err(by); @@ -680,21 +681,21 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(n).reverse()), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pair)); - put(out, s); + put(out, s.v); put(out, t); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(nested).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(maybe, 238)).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(held.n).reverse()), undefined, true); - put(out, held.s); + put(out, held.s.v); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(held.nested).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v.items), (b: rs.u32): Uint8Array => { return rs.u32ToBeBytes(b).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(option_asDeref$13yyv6y(o), 238)).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(result_unwrapOr$1n4fvf5(copied$1m63478(result_asDeref$1qd1pp0(res)), 238)).reverse()), undefined, true); - const _298: rs.Result = said; + const _298: rs.Result = said; if (_298.ok) { - put(out, _298.value); + put(out, _298.value.v); } else { rs.byteVecPush(out, _298.error); } @@ -854,25 +855,27 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _113[0]); rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_113[1]).reverse()), undefined, true); } - let s: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_222: rs.u8): string => { + let s: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_222: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_222))); }), undefined, 12, true).items); - const t: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_223: rs.u8): string => { + const t: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_223: rs.u8): rs.String => { const x11: rs.u8 = _223; return text(rs.byteSliceFrom(Uint8Array.of(x11, x11))); }), undefined, 12, true).items); - s = rs.boxSliceCloneFrom(s, t); - const _138: rs.Place | undefined = rs.sliceFirstMut(s); + s = rs.boxSliceCloneFrom(s, t, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }, undefined, rs.stringCloneFromFn()); + const _138: rs.String | undefined = rs.sliceFirst(s); if (_138 !== undefined) { - _138.v = _138.v + "!"; + rs.stringPush(_138, 33); } - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(s)), rs.iterSlice(rs.sliceItems(t))); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(s)), rs.iterSlice(rs.sliceItems(t))); while (true) { - const _150: string | rs.Done = iter2.next(); + const _150: rs.String | rs.Done = iter2.next(); if (_150 === rs.DONE) { break; } - put(out, _150); + put(out, _150.v); } let l: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_224: rs.u8): Logged.Logged => { return logged(_224 & 126); @@ -910,7 +913,7 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.dropAll(m); flush(log.value, out); let t2: string = "ab"; - t2 = text(data2); + t2 = text(data2).v; put(out, t2); } else if (_23 === 1) { let a2: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); @@ -942,9 +945,9 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const v3: rs.ByteVec = rs.byteSliceToByteVec(data2); rs.byteVecPush(v3, 102); bytes(rs.byteVecSlice(v3), out); - let s2: string = text(data2); - s2 = s2 + "#"; - put(out, s2); + const s2: rs.String = text(data2); + rs.stringPush(s2, 35); + put(out, s2.v); const w2: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_28: rs.u8): rs.u16 => { return rs.u16Add(_28 as rs.u16, 1); }), undefined, 2, true).items); @@ -1017,7 +1020,7 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged(r2); flush(log.value, out); } else { - const s3: string = text(data2); + const s3: string = text(data2).v; const a6: rs.ByteSlice = rs.stringAsBytes(s3); rs.byteSliceView(a6).reverse(); bytes(a6, out); diff --git a/ts/fixtures/lang/boxes/expected/harness.ts b/ts/fixtures/lang/boxes/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/boxes/expected/harness.ts +++ b/ts/fixtures/lang/boxes/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/capacity/caller.ts b/ts/fixtures/lang/capacity/caller.ts index c62893815..922ae7b2f 100644 --- a/ts/fixtures/lang/capacity/caller.ts +++ b/ts/fixtures/lang/capacity/caller.ts @@ -12,7 +12,9 @@ export { ops, run } from "./lang.ts"; * that a `reserve` gave room past its length, remade from its `Vec` and cleared, which * keeps that room; pushes past pops, a truncate, and a clear of a vector and a heap, * which grow only past the most each held; each way `collects` makes one, of each length - * it tries; and each splice of a vector a run of pushes grew. + * it tries; each splice of a vector a run of pushes grew; and each step of a string, of a + * char and a text of each width, by a few, past what it may hold, and within eight of + * `usize::MAX`, from each way it is made, once pushes grew it. */ const capacityCases = [ ...[["capacity::vecs", 41], ["capacity::deques", 28], ["capacity::heaps", 15]].flatMap(([name, steps]) => @@ -33,6 +35,10 @@ const capacityCases = [ ), ...Array.from({ length: 5 * 2 * 256 }, (_, i) => Uint8Array.of(...op("capacity::vecs"), i % 5, (Math.floor(i / 5) % 2) * 0x11, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 35, Math.floor(i / 10))), ...Array.from({ length: 8 * 6 }, (_, i) => Uint8Array.of(...op("capacity::collects"), i % 8, [0, 1, 2, 5, 9, 23][Math.floor(i / 8)], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), + ...Array.from({ length: 48 * 4 * 4 }, (_, i) => { + const [step, first, arg] = [i % 48, [0, 0x29, 0x0e, 0x0f][Math.floor(i / 48) % 4], [1, 6, 0xc3, 0xe2][Math.floor(i / 192)]]; + return Uint8Array.of(...op("capacity::strings"), first, 1, 3, 0, 2, 1, 1, step, arg, step, arg ^ 3, 0, 1); + }), ]; export const cases: Uint8Array[] = [...capacityCases]; diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 20d5badc3..e2bd454aa 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { copy$array_u64, copy$array_usize, copy$tuple2_u64_u8 } from "./lib.ts"; +import { copy$array_ref_str, copy$array_u64, copy$array_usize, copy$tuple2_u64_u8 } from "./lib.ts"; import * as Holds from "./capacity.Holds.ts"; import { then$1b5wr43, then$0tujtct, then$0svbdod, then$17csa2h, then$0g2g1ls } from "./core/bool.ts"; -import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$1n6i7tn as option_map$1n6i7tn, map$12r4ivp as option_map$12r4ivp, map$03x2fqt as option_map$03x2fqt, map$1o9z3sm as option_map$1o9z3sm, map$1d4d0v7 as option_map$1d4d0v7, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$1n6i7tn as option_map$1n6i7tn, map$12r4ivp as option_map$12r4ivp, map$03x2fqt as option_map$03x2fqt, map$1o9z3sm as option_map$1o9z3sm, map$1d4d0v7 as option_map$1d4d0v7, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; import { unwrapOrElse$128e309 as result_unwrapOrElse$128e309, unwrapOrElse$02f6iwg as result_unwrapOrElse$02f6iwg, unwrapOrElse$05mb9nr as result_unwrapOrElse$05mb9nr, unwrapOrElse$0pqj9wx as result_unwrapOrElse$0pqj9wx, unwrapOrElse$01ys8fc as result_unwrapOrElse$01ys8fc } from "./core/result.ts"; /** A length or capacity, as four bytes. */ @@ -311,7 +311,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d tried = rs.vecTryReserveExact(v, additional2, 1280); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 1280)); } @@ -553,7 +553,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, tried = rs.vecTryReserveExact(v, additional2, 16); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 16)); } @@ -795,7 +795,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n tried = rs.vecTryReserveExact(v, additional2, 2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 2)); } @@ -1035,7 +1035,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu tried = rs.byteVecTryReserveExact(v, additional2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, v.length, v.data.length); } @@ -1286,7 +1286,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: tried = rs.vecTryReserveExact(v, additional2, 0); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 0)); } @@ -2491,7 +2491,7 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, tried = rs.dequeTryReserveExact(q, additional2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2626,7 +2626,7 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number tried = rs.dequeTryReserveExact(q, additional2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2761,7 +2761,7 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: tried = rs.dequeTryReserveExact(q, additional2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2896,7 +2896,7 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: tried = rs.dequeTryReserveExact(q, additional2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -3043,7 +3043,7 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen tried = rs.dequeTryReserveExact(q, additional2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -3150,7 +3150,7 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, tried = rs.vecTryReserveExact(h, additional2, 1280); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 1280)); } @@ -3233,7 +3233,7 @@ export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, tried = rs.vecTryReserveExact(h, additional2, 16); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 16)); } @@ -3316,7 +3316,7 @@ export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: tried = rs.vecTryReserveExact(h, additional2, 2); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 2)); } @@ -3399,7 +3399,7 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n tried = rs.vecTryReserveExact(h, additional2, 1); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 1)); } @@ -3484,7 +3484,7 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: tried = rs.vecTryReserveExact(h, additional2, 0); } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 0)); } @@ -3701,7 +3701,7 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const tried: rs.Result = _180[1][0]; const n: rs.usize = _180[1][1]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); if (!tried.ok) { if (!(i < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i); @@ -3730,4 +3730,247 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } +/** The char boundary at or before byte `arg` of `s`, modulo its length and one. */ +export function boundary(s: string, arg: rs.u8): rs.usize { + let i: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(rs.stringLen(s), 1)); + while (true) { + if (!rs.strIsCharBoundary(s, i)) { + i = rs.usizeSub(i, 1); + } else { + return i; + } + } +} + +/** + * A `String` that `first` makes, by `new`, `with_capacity`, `to_owned`, or `format!`, and + * each pair of `steps` changes, its length and capacity after each, then its bytes: each + * step std's capacity follows, of growth, of shrinking, and of each way std makes one. + */ +export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): void { + let s!: rs.String; + let _302!: rs.String; + let _334!: rs.String; + let _405!: rs.String; + const _4: (a0: rs.u8) => string = (arg2: rs.u8): string => { + const _42: rs.usize = rs.usizeRem(arg2 as rs.usize, rs.sliceFrom(["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]).length); + if (!(_42 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _42); + } + return ["", "ab", "démo", "アリス📷, and more text past sixteen bytes"][_42]; + }; + const _6: rs.u8 = rs.u8Rem(first, 4); + if (_6 === 0) { + s = rs.stringNew(); + } else if (_6 === 1) { + s = rs.stringWithCapacity(first >> 2 as rs.usize); + } else if (_6 === 2) { + s = rs.stringFrom(_4(first >> 2)); + } else { + const _23: string = _4(first >> 2); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtPad(f, _23)]; + s = rs.fmtFormat([args2[0], args2[1]]); + } + put(out, s.cap); + const iter: rs.Iter = rs.byteSliceChunks(steps, 2); + while (true) { + const _40: rs.ByteSlice | rs.Done = iter.next(); + if (_40 === rs.DONE) { + break; + } + rs.idx(_40, 0); + const _46: [rs.u8, rs.u8] = [_40.data[_40.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_40, 1), 0)]; + const op: rs.u8 = _46[0]; + const arg: rs.u8 = _46[1]; + const _56: rs.usize = rs.usizeRem(arg as rs.usize, rs.sliceFrom([97, 233, 20013, 128512]).length); + if (!(_56 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _56); + } + const c: rs.char = [97, 233, 20013, 128512][_56]; + const _64: rs.u8 = rs.u8Rem(op, 48); + if (_64 === 0) { + rs.stringPush(s, c); + } else if (_64 === 1) { + rs.stringPushStr(s, _4(arg)); + } else if (_64 === 2) { + rs.stringReserve(s, amount(arg, s.len, 1)); + } else if (_64 === 3) { + rs.stringReserveExact(s, amount(arg, s.len, 1)); + } else if (_64 === 4) { + put(out, rs.stringTryReserve(s, amount(arg, s.len, 1)).ok ? 1 : 0); + } else if (_64 === 5) { + put(out, rs.stringTryReserveExact(s, amount(arg, s.len, 1)).ok ? 1 : 0); + } else if (_64 === 6) { + rs.stringShrinkTo(s, rs.u8Rem(arg, 40) as rs.usize); + } else if (_64 === 7) { + rs.stringShrinkTo(s, 0); + } else if (_64 === 8) { + rs.stringTruncate(s, boundary(s.v, arg)); + } else if (_64 === 9) { + rs.stringInsertStr(s, boundary(s.v, arg), String.fromCodePoint(c)); + } else if (_64 === 10) { + rs.stringInsertStr(s, boundary(s.v, arg), _4(arg >> 2)); + } else if (_64 === 11) { + rs.stringClear(s); + } else if (_64 === 12) { + const keep: () => boolean = alternate(); + rs.stringRetain(s, (_22: rs.char): boolean => { + return keep(); + }); + } else if (_64 === 13) { + const _126: [rs.usize, rs.usize] = [boundary(s.v, arg), boundary(s.v, arg >> 1)]; + const a: rs.usize = _126[0]; + const b: rs.usize = _126[1]; + rs.stringReplaceRange(s, new rs.Range(rs.min(a, b), rs.max(a, b)), _4(arg >> 2)); + } else if (_64 === 14) { + rs.stringExtendFromWithin(s, { end: boundary(s.v, arg) }); + } else if (_64 === 15) { + put(out, option_mapOr$0yzb10z(rs.stringPop(s), 0, (a0: rs.char): rs.u32 => { + return a0 as rs.u32; + }) as rs.usize); + } else if (_64 === 16) { + if (!(s.len === 0)) { + const _169: rs.Iter = rs.iterRev(new rs.RangeInclusive(0, rs.min(boundary(s.v, arg), rs.usizeSub(s.len, 1)), rs.usizeStep)); + const _172: rs.String = s; + const i2: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(_169, (_2: rs.usize): boolean => { + return rs.strIsCharBoundary(_172.v, _2); + }), 0); + put(out, (rs.stringRemove(s, i2) as rs.u32) as rs.usize); + } + } else if (_64 === 17) { + const rest: rs.String = rs.stringSplitOff(s, boundary(s.v, arg)); + sized(out, rest.len, rest.cap); + } else if (_64 === 18) { + rs.drop(rs.stringDrain(s, { end: boundary(s.v, arg) })); + } else if (_64 === 19) { + s = rs.stringClone(s); + } else if (_64 === 20) { + let over: rs.String = rs.stringWithCapacity(rs.u8Rem(arg, 24) as rs.usize); + const _202: string = _4(arg >> 2); + rs.stringPushStr(over, _202); + over = rs.stringCloneFrom(over, s); + s = over; + } else if (_64 === 21) { + rs.stringExtendChars(s, rs.iterFilter(rs.strChars(_4(arg)), (c3: rs.char): boolean => { + return c3 !== 101; + })); + } else if (_64 === 22) { + rs.stringExtendArray(s, rs.iterSlice(copy$array_ref_str([_4(arg), _4(arg >> 2)]))); + } else if (_64 === 23) { + rs.stringExtend(s, rs.vecIntoIter(rs.vecFrom([_4(arg), _4(arg >> 2)]))); + } else if (_64 === 24) { + s = rs.stringAdd(s, _4(arg)); + } else if (_64 === 25) { + rs.stringPushStr(s, _4(arg)); + } else if (_64 === 26) { + const _252: rs.String = s; + const _256: string = _4(arg >> 2); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, _256)]; + const _253: rs.Arguments = [args4[0], "-", args4[1]]; + rs.resultUnwrap(rs.fmtWriteString(_252, _253), rs.fmtErrorDebug); + } else if (_64 === 27) { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.u8Display(arg, f)]; + s = rs.fmtFormat([args6[0], args6[1]]); + } else if (_64 === 28) { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.u8Display(arg, f)]; + s = rs.fmtFormat([args8[0], " and then some text ", args8[1]]); + } else if (_64 === 29) { + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v)]; + s = rs.fmtFormat(["[", args10[0], "]"]); + } else if (_64 === 30) { + s = rs.fmtFormat(["text alone"]); + } else if (_64 === 31) { + const _303: rs.u8 = rs.u8Rem(arg, 6); + if (_303 === 0) { + const _306: rs.i8 = (arg << 24) >> 24; + _302 = rs.fmtToString((f: rs.Formatter) => rs.i8Display(_306, f), 3); + } else if (_303 === 1) { + const _308: rs.i32 = rs.i32Sub(arg as rs.i32, 128); + _302 = rs.fmtToString((f: rs.Formatter) => rs.i32Display(_308, f), 10); + } else if (_303 === 2) { + _302 = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); + } else if (_303 === 3) { + _302 = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(c, f), 0); + } else if (_303 === 4) { + const _314: boolean = rs.u8Rem(arg, 2) === 0; + _302 = rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_314, f), 0); + } else { + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + _302 = rs.fmtFormat([args12[0]]); + } + s = _302; + } else if (_64 === 32) { + s = rs.strToLowercase(s.v); + } else if (_64 === 33) { + s = rs.strToUppercase(s.v); + } else if (_64 === 34) { + s = rs.stringFrom(rs.strToAsciiUppercase(s.v)); + } else if (_64 === 35) { + const _335: rs.u8 = rs.u8Rem(arg, 5); + if (_335 === 0) { + _334 = rs.strReplace(s.v, "a", "b", true); + } else if (_335 === 1) { + _334 = rs.strReplace(s.v, "a", "xyz", true); + } else if (_335 === 2) { + _334 = rs.strReplace(s.v, String.fromCodePoint(c), "", true); + } else if (_335 === 3) { + _334 = rs.strReplace(s.v, (c2: rs.char): boolean => { + return rs.charIsAlphabetic(c2); + }, "-", false); + } else { + _334 = rs.strReplace(s.v, rs.stringFrom("é").v, "e", true); + } + s = _334; + } else if (_64 === 36) { + s = rs.strReplacen(s.v, "a", "bc", rs.u8Rem(arg, 3) as rs.usize); + } else if (_64 === 37) { + const bytes: rs.ByteVec = rs.stringIntoBytes(s); + sized(out, bytes.length, bytes.data.length); + s = rs.resultUnwrap(rs.stringFromUtf8(bytes), rs.fmtFromUtf8ErrorDebug); + } else if (_64 === 38) { + const bytes2: rs.ByteVec = rs.strToBytes(s.v); + sized(out, bytes2.length, bytes2.data.length); + const bytes3: rs.ByteVec = rs.stringIntoBytes(s); + sized(out, bytes3.length, bytes3.data.length); + s = rs.resultUnwrap(rs.stringFromUtf8(bytes3), rs.fmtFromUtf8ErrorDebug); + } else if (_64 === 39) { + const _388: rs.Iter = rs.iterRev(rs.strChars(s.v)); + s = rs.stringExtendChars(rs.stringNew(), _388); + } else if (_64 === 40) { + s = rs.stringFromStrings(rs.vecIntoIter(rs.vecFrom([s, rs.stringFrom(_4(arg))]))); + } else if (_64 === 41) { + const units: rs.Vec = rs.iterToVec(rs.strEncodeUtf16(s.v), "next", 2); + if (rs.u8Rem(arg, 2) === 0) { + _405 = rs.resultUnwrap(rs.stringFromUtf16(rs.sliceFrom(units.items)), rs.fmtFromUtf16ErrorDebug); + } else { + _405 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); + } + s = _405; + } else if (_64 === 42) { + const bytes4: rs.ByteVec = rs.stringIntoBytes(s); + rs.byteVecPush(bytes4, 255); + s = rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteVecSlice(bytes4))); + } else if (_64 === 43) { + const _422: rs.Slice = rs.sliceFrom([s.v, _4(arg)]); + const _430: string = _4(arg >> 2); + s = rs.strsJoin(rs.sliceItems(_422), _430); + } else if (_64 === 44) { + s = rs.stringFrom(s.v); + } else if (_64 === 45) { + let cow: rs.StrCow = new rs.Borrowed(_4(arg)); + cow = rs.strCowAdd(cow, new rs.Borrowed(s.v)); + const _449: string = _4(arg >> 2); + cow = rs.strCowAdd(cow, new rs.Borrowed(_449)); + s = rs.strCowIntoOwned(cow); + } else if (_64 === 46) { + const _458: string[] = [_4(arg), _4(arg >> 2)]; + s = rs.stringExtendArray(rs.stringNew(), rs.iterSlice(_458)); + } else if (_64 === 47) { + s = rs.stringAdd(rs.replaceIn(s, rs.stringNew()), _4(arg)); + } + sized(out, s.len, s.cap); + } + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); +} + //# sourceMappingURL=capacity.ts.map diff --git a/ts/fixtures/lang/capacity/expected/core/option.ts b/ts/fixtures/lang/capacity/expected/core/option.ts index 781b780a5..4d25274b9 100644 --- a/ts/fixtures/lang/capacity/expected/core/option.ts +++ b/ts/fixtures/lang/capacity/expected/core/option.ts @@ -9,6 +9,13 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } +export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize): rs.usize { + if (self === undefined) { + return default_; + } + return self; +} + export function unwrapOrDefault$0avqj0t(self: rs.ByteSlice | undefined): rs.ByteSlice { if (self === undefined) { return rs.byteSliceFrom(new Uint8Array(0)); @@ -51,6 +58,13 @@ export function map$1d4d0v7(self: rs.Vec[] | undefined, f: (a0: rs.Ve return f(self); } +export function mapOr$0yzb10z(self: rs.char | undefined, default_: rs.u32, _: (a0: rs.char) => rs.u32): rs.u32 { + if (self === undefined) { + return default_; + } + return self as rs.u32; +} + export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/capacity/expected/lib.ts b/ts/fixtures/lang/capacity/expected/lib.ts index 4c151945f..8a874da31 100644 --- a/ts/fixtures/lang/capacity/expected/lib.ts +++ b/ts/fixtures/lang/capacity/expected/lib.ts @@ -1,7 +1,11 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { vecs, cloneFroms, deques, heaps, collects, maps } from "./capacity.ts"; +import { vecs, cloneFroms, deques, heaps, collects, maps, strings } from "./capacity.ts"; + +export function copy$array_ref_str(v: string[]): string[] { + return v.slice(); +} export function copy$array_u64(v: rs.u64[]): rs.u64[] { return v.slice(); @@ -26,7 +30,7 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By deques(a02, a12.data, a12.start, a12.length, a22); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::heaps", (a03: rs.u8, a13: rs.ByteSlice, a23: rs.ByteVec): undefined => { heaps(a03, a13.data, a13.start, a13.length, a23); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::collects", collects as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::maps", maps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::collects", collects as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::maps", maps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::strings", strings as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index 9ed6af89a..b6c682adb 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -646,3 +646,156 @@ pub fn maps(kind: u8, data: &[u8], out: &mut Vec) { put(out, huge.len()); } } + +/// Text of each width a char's UTF-8 takes, and of format's thresholds: none, short, and +/// past 16 bytes. +const TEXTS: [&str; 4] = ["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]; + +/// A char of each UTF-8 width. +const CHARS: [char; 4] = ['a', 'é', '中', '😀']; + +/// The char boundary at or before byte `arg` of `s`, modulo its length and one. +fn boundary(s: &str, arg: u8) -> usize { + let mut i = usize::from(arg) % (s.len() + 1); + while !s.is_char_boundary(i) { + i -= 1; + } + i +} + +/// A `String` that `first` makes, by `new`, `with_capacity`, `to_owned`, or `format!`, and +/// each pair of `steps` changes, its length and capacity after each, then its bytes: each +/// step std's capacity follows, of growth, of shrinking, and of each way std makes one. +pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { + let text = |arg: u8| TEXTS[usize::from(arg) % TEXTS.len()]; + let mut s = match first % 4 { + 0 => String::new(), + 1 => String::with_capacity(usize::from(first >> 2)), + 2 => text(first >> 2).to_owned(), + _ => format!("{}{}", first, text(first >> 2)), + }; + put(out, s.capacity()); + for step in steps.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + let c = CHARS[usize::from(arg) % CHARS.len()]; + match op % 48 { + 0 => s.push(c), + 1 => s.push_str(text(arg)), + 2 => s.reserve(amount(arg, s.len(), 1)), + 3 => s.reserve_exact(amount(arg, s.len(), 1)), + 4 => put(out, usize::from(s.try_reserve(amount(arg, s.len(), 1)).is_ok())), + 5 => put(out, usize::from(s.try_reserve_exact(amount(arg, s.len(), 1)).is_ok())), + 6 => s.shrink_to(usize::from(arg % 40)), + 7 => s.shrink_to_fit(), + 8 => s.truncate(boundary(&s, arg)), + 9 => s.insert(boundary(&s, arg), c), + 10 => s.insert_str(boundary(&s, arg), text(arg >> 2)), + 11 => s.clear(), + 12 => { + let mut keep = alternate(); + s.retain(|_| keep()); + } + 13 => { + let (a, b) = (boundary(&s, arg), boundary(&s, arg >> 1)); + s.replace_range(a.min(b)..a.max(b), text(arg >> 2)); + } + 14 => s.extend_from_within(..boundary(&s, arg)), + 15 => put(out, s.pop().map_or(0, u32::from) as usize), + 16 if !s.is_empty() => { + let i = boundary(&s, arg).min(s.len() - 1); + let i = (0..=i).rev().find(|&i| s.is_char_boundary(i)).unwrap_or(0); + put(out, u32::from(s.remove(i)) as usize); + } + 17 => { + let rest = s.split_off(boundary(&s, arg)); + sized(out, rest.len(), rest.capacity()); + } + 18 => drop(s.drain(..boundary(&s, arg))), + 19 => s = s.clone(), + // Grown from `with_capacity` only where it holds fewer. + 20 => { + let mut over = String::with_capacity(usize::from(arg % 24)); + over.push_str(text(arg >> 2)); + over.clone_from(&s); + s = over; + } + 21 => s.extend(text(arg).chars().filter(|c| *c != 'e')), + 22 => s.extend([text(arg), text(arg >> 2)]), + 23 => s.extend(vec![text(arg), text(arg >> 2)]), + 24 => s = s + text(arg), + 25 => s += text(arg), + 26 => { + use std::fmt::Write; + write!(s, "{arg}-{}", text(arg >> 2)).unwrap(); + } + // Each of `format!`'s estimates: none past a placeholder first, twice its text + // if 16 bytes or more or a placeholder is after it, and its text alone. + 27 => s = format!("{s}{arg}"), + 28 => s = format!("{s} and then some text {arg}"), + 29 => s = format!("[{s}]"), + 30 => s = format!("text alone"), + 31 => { + s = match arg % 6 { + 0 => (arg as i8).to_string(), + 1 => (i32::from(arg) - 128).to_string(), + 2 => arg.to_string(), + 3 => c.to_string(), + 4 => (arg % 2 == 0).to_string(), + _ => format_args!("{arg}").to_string(), + } + } + 32 => s = s.to_lowercase(), + 33 => s = s.to_uppercase(), + 34 => s = s.to_ascii_uppercase(), + 35 => { + s = match arg % 5 { + 0 => s.replace('a', "b"), + 1 => s.replace("a", "xyz"), + 2 => s.replace(c, ""), + 3 => s.replace(|c: char| c.is_alphabetic(), "-"), + _ => s.replace(&String::from("é"), "e"), + } + } + 36 => s = s.replacen('a', "bc", usize::from(arg % 3)), + 37 => { + let bytes = s.into_bytes(); + sized(out, bytes.len(), bytes.capacity()); + s = String::from_utf8(bytes).unwrap(); + } + 38 => { + let bytes = Vec::from(s.as_str()); + sized(out, bytes.len(), bytes.capacity()); + let bytes = Vec::from(s); + sized(out, bytes.len(), bytes.capacity()); + s = String::from_utf8(bytes).unwrap(); + } + 39 => s = s.chars().rev().collect(), + 40 => s = vec![s, text(arg).to_owned()].into_iter().collect(), + 41 => { + let units: Vec = s.encode_utf16().collect(); + s = match arg % 2 { + 0 => String::from_utf16(&units).unwrap(), + _ => String::from_utf16_lossy(&units), + } + } + 42 => { + let mut bytes = s.into_bytes(); + bytes.push(0xff); + s = String::from_utf8_lossy(&bytes).into_owned(); + } + 43 => s = [s.as_str(), text(arg)].join(text(arg >> 2)), + 44 => s = s.into_boxed_str().into_string(), + 45 => { + let mut cow = std::borrow::Cow::Borrowed(text(arg)); + cow += s.as_str(); + cow += text(arg >> 2); + s = cow.into_owned(); + } + 46 => s = String::from_iter([text(arg), text(arg >> 2)]), + 47 => s = mem::take(&mut s) + text(arg), + _ => {} + } + sized(out, s.len(), s.capacity()); + } + out.extend_from_slice(s.as_bytes()); +} diff --git a/ts/fixtures/lang/capacity/src/lib.rs b/ts/fixtures/lang/capacity/src/lib.rs index 1f56103f4..a5278f1a6 100644 --- a/ts/fixtures/lang/capacity/src/lib.rs +++ b/ts/fixtures/lang/capacity/src/lib.rs @@ -22,5 +22,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("capacity::collects", capacity::collects), ("capacity::maps", capacity::maps), ("capacity::clone_froms", capacity::clone_froms), + ("capacity::strings", capacity::strings), ] } diff --git a/ts/fixtures/lang/cells/expected/cells.ts b/ts/fixtures/lang/cells/expected/cells.ts index f192a9337..88cb4a053 100644 --- a/ts/fixtures/lang/cells/expected/cells.ts +++ b/ts/fixtures/lang/cells/expected/cells.ts @@ -4,11 +4,11 @@ import * as rs from "./rs.ts"; import { out$Option_u8, out$u64, out$u8 } from "./lib.ts"; import { thenSome$0quywni } from "./core/bool.ts"; import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; -import { err$1yr5s3w, map$0vjzmou as result_map$0vjzmou, map$0ac8dwe as result_map$0ac8dwe, map$0zkrphe as result_map$0zkrphe, map$0w147c6 as result_map$0w147c6, map$1gelxzx as result_map$1gelxzx, map$0vfooax as result_map$0vfooax } from "./core/result.ts"; +import { err$1yr5s3w, map$0vjzmou as result_map$0vjzmou, map$1kzzqt5 as result_map$1kzzqt5, map$0zkrphe as result_map$0zkrphe, map$0w147c6 as result_map$0w147c6, map$1gelxzx as result_map$1gelxzx, map$0vfooax as result_map$0vfooax } from "./core/result.ts"; /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 | undefined = maybe; const put: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = putMaybe as (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined; @@ -123,7 +123,7 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; @@ -132,13 +132,13 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num }, undefined, rs.None); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell, rs.None); if (_155 === undefined) { @@ -192,15 +192,15 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; - let result!: rs.Result; - const make: (a0: rs.u8) => string = (v3: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f)); + let text!: rs.String; + let result!: rs.Result; + const make: (a0: rs.u8) => rs.String = (v3: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f), 0); }; - const put: (a0: rs.ByteVec, a1: string) => undefined = (out2: rs.ByteVec, t10: string): undefined => { - rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10)); + const put: (a0: rs.ByteVec, a1: rs.String) => undefined = (out2: rs.ByteVec, t10: rs.String): undefined => { + rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10.v)); }; - let cell: rs.OnceCell = new rs.OnceCell(undefined); + let cell: rs.OnceCell = new rs.OnceCell(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; @@ -217,7 +217,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num const v2: rs.u8 = v; const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: string | undefined = cell.v; + const _20: rs.String | undefined = cell.v; if (_20 === undefined) { rs.byteVecPush(out, 0); } else { @@ -225,49 +225,49 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, _20); } } else if (_18 === 1) { - const _26: rs.Result = rs.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { rs.byteVecPush(out, 1); } else { - const t: string = _26.error; + const t: rs.String = _26.error; rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: string = rs.onceGetOrInit(cell, (): string => { + const _34: rs.String = rs.onceGetOrInit(cell, (): rs.String => { return make(v2); }); put(out, _34); } else if (_18 === 3) { let seen: rs.u8 = 2; - const _44: rs.OnceCell = cell; - const t2: string = rs.onceGetOrInit(cell, (): string => { + const _44: rs.OnceCell = cell; + const t2: rs.String = rs.onceGetOrInit(cell, (): rs.String => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: string | undefined = rs.onceTake(cell); + const _50: rs.String | undefined = rs.onceTake(cell); if (_50 === undefined) { rs.byteVecPush(out, 0); } else { - const t3: string = _50; + const t3: rs.String = _50; rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rs.OnceCell = cell; - const _57: string = rs.onceGetOrInit(cell, (): string => { + const _60: rs.OnceCell = cell; + const _57: rs.String = rs.onceGetOrInit(cell, (): rs.String => { rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { const inner: rs.ByteVec = new rs.ByteVec(); - const _69: rs.OnceCell = cell; - const t4: string = rs.onceGetOrInit(cell, (): string => { - put(inner, rs.onceGetOrInit(_69, (): string => { + const _69: rs.OnceCell = cell; + const t4: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + put(inner, rs.onceGetOrInit(_69, (): rs.String => { return make(v2 ^ 1); })); return make(v2); @@ -275,7 +275,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, t4); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: string = rs.onceGetOrInit(cell, (): string => { + const _76: rs.String = rs.onceGetOrInit(cell, (): rs.String => { const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; rs.panicFmt(["init ", args8[0]]); }); @@ -287,23 +287,27 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num cell = new rs.OnceCell(undefined); } } else if (_18 === 9) { - const alias: rs.OnceCell = twin$ref_cell_OnceCell_String(cell); - const copy: rs.OnceCell = rs.onceClone(cell, undefined); - let inner2 = undefined as rs.OnceCell | undefined; - const _95: rs.OnceCell = cell; - const t5: string = rs.onceGetOrInit(cell, (): string => { - inner2 = rs.onceClone(_95, undefined); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_String(cell); + const copy: rs.OnceCell = rs.onceClone(cell, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + inner2 = rs.onceClone(_95, (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); return make(v2); }); put(out, t5); rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rs.OnceCell | rs.Done = iter.next(); + const _112: rs.OnceCell | rs.Done = iter.next(); if (_112 === rs.DONE) { break; } - const _116: string | undefined = _112.v; + const _116: rs.String | undefined = _112.v; if (_116 === undefined) { rs.byteVecPush(out, 238); } else { @@ -311,54 +315,54 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; - const _125: rs.OnceCell = cell; - const t7: string = rs.onceGetOrInit(cell, (): string => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtStr)]; + let inner3: rs.String = rs.stringNew(); + const _125: rs.OnceCell = cell; + const t7: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { - const _155: rs.Place | undefined = rs.optionAsMut(cell); + const _155: rs.String | undefined = cell.v; if (_155 === undefined) { rs.byteVecPush(out, 0); } else { - _155.v = make(v2); + Object.assign(_155, make(v2)); rs.byteVecPush(out, 1); - const _162: string = rs.optionUnwrap(cell.v); + const _162: rs.String = rs.optionUnwrap(cell.v); put(out, _162); } } else { const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$String(make, v2); }); } else if (_166 === 2) { - const _174: rs.OnceCell = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { rs.onceSet(_174, make(v2 ^ 1)); return made$String(make, v2); }); } else { - const _179: rs.OnceCell = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { - return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0ac8dwe(rs.onceGetOrTryInit(_179, (): rs.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$1kzzqt5(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$String(make, v2 ^ 1); - }), (_22: string): undefined => {})), v2)); + }), (_22: rs.String): undefined => {})), v2)); }); } if (result.ok) { - const t8: string = result.value; + const t8: rs.String = result.value; rs.byteVecPush(out, 1); put(out, t8); } else { @@ -366,7 +370,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num } } } - const _190: string | undefined = cell.v; + const _190: rs.String | undefined = cell.v; if (_190 === undefined) { rs.byteVecPush(out, 238); } else { @@ -376,7 +380,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u64 = wide; const put: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, t10: rs.u64): undefined => { @@ -493,7 +497,7 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u64Debug)]; @@ -502,13 +506,13 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -562,7 +566,7 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 = (v3: rs.u8): rs.u8 => { return v3; @@ -681,7 +685,7 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u8Debug)]; @@ -690,13 +694,13 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -750,7 +754,7 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => undefined = (_2: rs.u8): undefined => {}; const put: (a0: rs.ByteVec, a1: undefined) => undefined = (out2: rs.ByteVec, _3: undefined): undefined => { @@ -866,7 +870,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtUnit, rs.None)]; @@ -875,13 +879,13 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe }, undefined, rs.None); put(out, t4); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { if (rs.optionAsMut(cell, rs.None) === undefined) { rs.byteVecPush(out, 0); @@ -930,7 +934,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.ByteVec = (v3: rs.u8): rs.ByteVec => { return rs.byteVecOf(v3, rs.u8Rem(v3, 4) as rs.usize); @@ -1053,7 +1057,7 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; @@ -1062,13 +1066,13 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.ByteVec | undefined = cell.v; if (_155 === undefined) { @@ -1148,7 +1152,7 @@ export function cells(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 | undefined = maybe; const put: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = putMaybe as (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined; @@ -1263,7 +1267,7 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; @@ -1272,13 +1276,13 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num }, undefined, rs.None); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell, rs.None); if (_155 === undefined) { @@ -1332,15 +1336,15 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; - let result!: rs.Result; - const make: (a0: rs.u8) => string = (v3: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f)); + let text!: rs.String; + let result!: rs.Result; + const make: (a0: rs.u8) => rs.String = (v3: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f), 0); }; - const put: (a0: rs.ByteVec, a1: string) => undefined = (out2: rs.ByteVec, t10: string): undefined => { - rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10)); + const put: (a0: rs.ByteVec, a1: rs.String) => undefined = (out2: rs.ByteVec, t10: rs.String): undefined => { + rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10.v)); }; - let cell: rs.OnceLock = new rs.OnceLock(undefined); + let cell: rs.OnceLock = new rs.OnceLock(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; @@ -1357,7 +1361,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num const v2: rs.u8 = v; const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: string | undefined = cell.v; + const _20: rs.String | undefined = cell.v; if (_20 === undefined) { rs.byteVecPush(out, 0); } else { @@ -1365,49 +1369,49 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, _20); } } else if (_18 === 1) { - const _26: rs.Result = rs.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { rs.byteVecPush(out, 1); } else { - const t: string = _26.error; + const t: rs.String = _26.error; rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: string = rs.onceGetOrInit(cell, (): string => { + const _34: rs.String = rs.onceGetOrInit(cell, (): rs.String => { return make(v2); }); put(out, _34); } else if (_18 === 3) { let seen: rs.u8 = 2; - const _44: rs.OnceLock = cell; - const t2: string = rs.onceGetOrInit(cell, (): string => { + const _44: rs.OnceLock = cell; + const t2: rs.String = rs.onceGetOrInit(cell, (): rs.String => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: string | undefined = rs.onceTake(cell); + const _50: rs.String | undefined = rs.onceTake(cell); if (_50 === undefined) { rs.byteVecPush(out, 0); } else { - const t3: string = _50; + const t3: rs.String = _50; rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rs.OnceLock = cell; - const _57: string = rs.onceGetOrInit(cell, (): string => { + const _60: rs.OnceLock = cell; + const _57: rs.String = rs.onceGetOrInit(cell, (): rs.String => { rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { const inner: rs.ByteVec = new rs.ByteVec(); - const _69: rs.OnceLock = cell; - const t4: string = rs.onceGetOrInit(cell, (): string => { - put(inner, rs.onceGetOrInit(_69, (): string => { + const _69: rs.OnceLock = cell; + const t4: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + put(inner, rs.onceGetOrInit(_69, (): rs.String => { return make(v2 ^ 1); })); return make(v2); @@ -1415,7 +1419,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, t4); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: string = rs.onceGetOrInit(cell, (): string => { + const _76: rs.String = rs.onceGetOrInit(cell, (): rs.String => { const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; rs.panicFmt(["init ", args8[0]]); }); @@ -1427,23 +1431,27 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num cell = new rs.OnceLock(undefined); } } else if (_18 === 9) { - const alias: rs.OnceLock = twin$ref_sync_OnceLock_String(cell); - const copy: rs.OnceLock = rs.onceClone(cell, undefined); - let inner2 = undefined as rs.OnceLock | undefined; - const _95: rs.OnceLock = cell; - const t5: string = rs.onceGetOrInit(cell, (): string => { - inner2 = rs.onceClone(_95, undefined); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_String(cell); + const copy: rs.OnceLock = rs.onceClone(cell, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + inner2 = rs.onceClone(_95, (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); return make(v2); }); put(out, t5); rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rs.OnceLock | rs.Done = iter.next(); + const _112: rs.OnceLock | rs.Done = iter.next(); if (_112 === rs.DONE) { break; } - const _116: string | undefined = _112.v; + const _116: rs.String | undefined = _112.v; if (_116 === undefined) { rs.byteVecPush(out, 238); } else { @@ -1451,54 +1459,54 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; - const _125: rs.OnceLock = cell; - const t7: string = rs.onceGetOrInit(cell, (): string => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtStr)]; + let inner3: rs.String = rs.stringNew(); + const _125: rs.OnceLock = cell; + const t7: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { - const _155: rs.Place | undefined = rs.optionAsMut(cell); + const _155: rs.String | undefined = cell.v; if (_155 === undefined) { rs.byteVecPush(out, 0); } else { - _155.v = make(v2); + Object.assign(_155, make(v2)); rs.byteVecPush(out, 1); - const _162: string = rs.optionUnwrap(cell.v); + const _162: rs.String = rs.optionUnwrap(cell.v); put(out, _162); } } else { const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$String(make, v2); }); } else if (_166 === 2) { - const _174: rs.OnceLock = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { rs.onceSet(_174, make(v2 ^ 1)); return made$String(make, v2); }); } else { - const _179: rs.OnceLock = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { - return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0ac8dwe(rs.onceGetOrTryInit(_179, (): rs.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$1kzzqt5(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$String(make, v2 ^ 1); - }), (_22: string): undefined => {})), v2)); + }), (_22: rs.String): undefined => {})), v2)); }); } if (result.ok) { - const t8: string = result.value; + const t8: rs.String = result.value; rs.byteVecPush(out, 1); put(out, t8); } else { @@ -1506,7 +1514,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num } } } - const _190: string | undefined = cell.v; + const _190: rs.String | undefined = cell.v; if (_190 === undefined) { rs.byteVecPush(out, 238); } else { @@ -1516,7 +1524,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u64 = wide; const put: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, t10: rs.u64): undefined => { @@ -1633,7 +1641,7 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u64Debug)]; @@ -1642,13 +1650,13 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -1702,7 +1710,7 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 = (v3: rs.u8): rs.u8 => { return v3; @@ -1821,7 +1829,7 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u8Debug)]; @@ -1830,13 +1838,13 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -1890,7 +1898,7 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => undefined = (_2: rs.u8): undefined => {}; const put: (a0: rs.ByteVec, a1: undefined) => undefined = (out2: rs.ByteVec, _3: undefined): undefined => { @@ -2006,7 +2014,7 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtUnit, rs.None)]; @@ -2015,13 +2023,13 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe }, undefined, rs.None); put(out, t4); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { if (rs.optionAsMut(cell, rs.None) === undefined) { rs.byteVecPush(out, 0); @@ -2070,7 +2078,7 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.ByteVec = (v3: rs.u8): rs.ByteVec => { return rs.byteVecOf(v3, rs.u8Rem(v3, 4) as rs.usize); @@ -2193,7 +2201,7 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; @@ -2202,13 +2210,13 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.ByteVec | undefined = cell.v; if (_155 === undefined) { @@ -2262,7 +2270,7 @@ export function twin$ref_cell_OnceCell_Option_u8(t: rs.OnceCell): rs.OnceCell { +export function twin$ref_cell_OnceCell_String(t: rs.OnceCell): rs.OnceCell { return t; } @@ -2292,7 +2300,7 @@ export function twin$ref_sync_OnceLock_Option_u8(t: rs.OnceLock): rs.OnceLock { +export function twin$ref_sync_OnceLock_String(t: rs.OnceLock): rs.OnceLock { return t; } @@ -2326,7 +2334,7 @@ export function made$Option_u8(make: (a0: rs.u8) => rs.u8 | undefined, v: rs.u8) } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$String(make: (a0: rs.u8) => string, v: rs.u8): rs.Result { +export function made$String(make: (a0: rs.u8) => rs.String, v: rs.u8): rs.Result { if (rs.u8Rem(v, 3) === 0) { return rs.Err(v); } diff --git a/ts/fixtures/lang/cells/expected/core/result.ts b/ts/fixtures/lang/cells/expected/core/result.ts index b4dbe26e3..d09746c0b 100644 --- a/ts/fixtures/lang/cells/expected/core/result.ts +++ b/ts/fixtures/lang/cells/expected/core/result.ts @@ -17,7 +17,7 @@ export function map$0vjzmou(self: rs.Result, op: (a0: return self as rs.Result; } -export function map$0ac8dwe(self: rs.Result, op: (a0: string) => undefined): rs.Result { +export function map$1kzzqt5(self: rs.Result, op: (a0: rs.String) => undefined): rs.Result { if (self.ok) { op(self.value); return rs.OK; diff --git a/ts/fixtures/lang/chars/expected/chars.ts b/ts/fixtures/lang/chars/expected/chars.ts index a6990c3a5..3f39099be 100644 --- a/ts/fixtures/lang/chars/expected/chars.ts +++ b/ts/fixtures/lang/chars/expected/chars.ts @@ -128,7 +128,7 @@ export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _144: rs.char | undefined = rs.charFromU32(_140); if (_144 !== undefined) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(_144, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args2[0])]).v); } } const iter6: rs.Iter = rs.iterSlice([97, 39, 34, 92, 10, 0, 127, 233, 769, 173, 57344, 128512, 65438, 65439, 4447, 4448, 12644, 65440]); @@ -138,7 +138,7 @@ export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { break; } const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(_161, f), (f: rs.Formatter) => rs.fmtCharDisplay(_161, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", args4[1]])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", args4[1]]).v); } } } @@ -196,7 +196,7 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -207,21 +207,22 @@ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): vo const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -232,21 +233,22 @@ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -257,21 +259,22 @@ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -282,21 +285,22 @@ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): vo const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -307,15 +311,16 @@ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): vo const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]]).v); } /** @@ -335,7 +340,8 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _15: rs.u8 = rs.u8Rem(kind, 5); if (_15 === 0) { walk$char_ToLowercase(out, rs.charToLowercase(c)); - put(out, rs.stringExtendChars("", rs.iterRev(rs.charToLowercase(c)))); + const _23: rs.Iter = rs.iterRev(rs.charToLowercase(c)); + put(out, rs.stringExtendChars(rs.stringNew(), _23).v); } else if (_15 === 1) { walk$char_ToUppercase(out, rs.charToUppercase(c)); const up: rs.Iter = rs.charToUppercase(c); @@ -343,7 +349,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _39: rs.char | undefined = rs.iterToOption(up.next()); const _42: rs.usize = up.len(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_36, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtOption(_39, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(up, f), (f: rs.Formatter) => rs.fmtCharsDebug(up, f, "ToUppercase"), (f: rs.Formatter) => rs.usizeDisplay(_42, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4]]).v); } else if (_15 === 2) { walk$char_EscapeUnicode(out, rs.charEscapeUnicode(c)); } else if (_15 === 3) { @@ -375,7 +381,7 @@ export function encodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const s: rs.Place = rs.charEncodeUtf8(c, rs.byteSliceFrom(bytes)); const _34: rs.usize = rs.stringLen(s.v); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.usizeDisplay(_34, f), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]]).v); s.v = rs.strToAsciiUppercase(s.v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); const units: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { @@ -446,7 +452,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else { const e: rs.DecodeUtf16Error = r.error; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtDecodeUtf16ErrorDebug)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2]])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2]]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(e.code))); const _79: rs.DecodeUtf16Error | undefined = last; const _82: rs.DecodeUtf16Error | undefined = e; @@ -457,14 +463,16 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } } - const s: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { + const _94: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r2, 65533); - })); - const lossy: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _94); + const _97: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r3, 63); - })); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, lossy)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1]])); + }); + const lossy: rs.String = rs.stringExtendChars(rs.stringNew(), _97); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.fmtPad(f, lossy.v)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1]]).v); } /** @@ -485,7 +493,7 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } const part3 = rs.charFromDigit(_11, radix); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); } } else if (_6 === 1) { const iter2: rs.Iter = rs.iterSlice([48, 57, 97, 122, 65, 90, 47, 58, 64, 91, 96, 123, 1635, 65345]); @@ -500,11 +508,11 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void for (const n2 of scalars(data).items) { const r: rs.Result = rs.charTryFrom(n2); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([args4[0]]).v); if (!r.ok) { const part = new rs.CharTryFromError(); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(part, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(part, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args6[0]), "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args6[0]), "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1])]).v); const _78: rs.CharTryFromError = new rs.CharTryFromError(); rs.byteVecPush(out, convert_eq$1efmo6b(new rs.CharTryFromError(), _78) ? 1 : 0); } @@ -517,14 +525,14 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _96: rs.u64 = c2 as rs.u64; const _98: rs.u128 = c2 as rs.u128; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(b, f, rs.u8Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.fmtResult(w, f, rs.u16Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.u64Display(_96, f), (f: rs.Formatter) => rs.u128Display(_98, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]]).v); const _109: rs.Result = result_map$1q32zo4(b, (a0: rs.u8): rs.u16 => { return a0 as rs.u16; }); if (!result_and$02o4suw(w, _109).ok) { const part2 = new rs.TryFromCharError(); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(part2, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(part2, f)]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args10[0]), "|", args10[1], "|", rs.fmtSpec({ alternate: true }, args10[1])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args10[0]), "|", args10[1], "|", rs.fmtSpec({ alternate: true }, args10[1])]).v); const _130: rs.TryFromCharError = new rs.TryFromCharError(); rs.byteVecPush(out, char_eq$1g188ap(new rs.TryFromCharError(), _130) ? 1 : 0); } @@ -538,9 +546,9 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * harness's alphabet and the special chars. */ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - let s: string = text(data); - s = rs.stringExtendChars(s, rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); - const s2: string = s; + const s: rs.String = text(data); + rs.stringExtendChars(s, rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); + const s2: string = s.v; const _9: rs.u8 = rs.u8Rem(kind, 3); if (_9 === 0) { const parts: rs.Vec = rs.iterToVec(rs.strSplit(s2, (a011: rs.char): boolean => { @@ -550,17 +558,17 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.charIsNumeric(a012); }); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(parts.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(_21, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1]]).v); const part = rs.strFind(s2, (a013: rs.char): boolean => { return rs.charIsUppercase(a013); }); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([args4[0]]).v); const part2 = rs.strRfind(s2, (a014: rs.char): boolean => { return rs.charIsControl(a014); }); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([args6[0]]).v); } else if (_9 === 1) { const lens: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a07: rs.char): rs.usize => { return rs.charLenUtf8(a07); @@ -568,21 +576,24 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const units: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a08: rs.char): rs.usize => { return rs.charLenUtf16(a08); }), rs.usizeAdd, 0); - const upper: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { + const _61: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { return rs.charToUppercase(a09); - }, undefined, true)); - const lower: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { + }, undefined, true); + const upper: rs.String = rs.stringExtendChars(rs.stringNew(), _61); + const _64: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { return rs.charToLowercase(a010); - }, undefined, true)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper), (f: rs.Formatter) => rs.fmtPad(f, lower)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); + }, undefined, true); + const lower: rs.String = rs.stringExtendChars(rs.stringNew(), _64); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper.v), (f: rs.Formatter) => rs.fmtPad(f, lower.v)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]]).v); } else { - const escaped: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { + const _85: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { return rs.charEscapeDefault(a0); - }, undefined, true)); - const debug: string = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.strChars(s2), (a02: rs.char): rs.Iter => { + }, undefined, true); + const escaped: rs.String = rs.stringExtendChars(rs.stringNew(), _85); + const debug: rs.String = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.strChars(s2), (a02: rs.char): rs.Iter => { return rs.charEscapeDebug(a02); - }), (e: rs.Iter): string => { + }), (e: rs.Iter): rs.String => { return rs.fmtToString((f: rs.Formatter) => rs.fmtCharsDisplay(e, f)); })); const unicode: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.strChars(s2), (a03: rs.char): rs.Iter => { @@ -590,8 +601,8 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), (e2: rs.Iter): rs.usize => { return e2.len(); }), "next", 4); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, escaped), (f: rs.Formatter) => rs.fmtPad(f, debug), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, escaped.v), (f: rs.Formatter) => rs.fmtPad(f, debug.v), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2]]).v); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterAll(rs.strChars(s2), (a04: rs.char): boolean => { return rs.charIsAlphanumeric(a04); }), rs.iterAny(rs.strChars(s2), (a05: rs.char): boolean => { diff --git a/ts/fixtures/lang/chars/expected/harness.ts b/ts/fixtures/lang/chars/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/chars/expected/harness.ts +++ b/ts/fixtures/lang/chars/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/chunks/expected/chunks.ts b/ts/fixtures/lang/chunks/expected/chunks.ts index 2f05fbe8e..9e58840c4 100644 --- a/ts/fixtures/lang/chunks/expected/chunks.ts +++ b/ts/fixtures/lang/chunks/expected/chunks.ts @@ -149,11 +149,11 @@ export function chunks(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, chosen2); rs.byteVecPush(out, chosen2.data[chosen2.start + 1]); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chosen2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(lit), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); if (data.length >= 3) { const chunk2: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, 3); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); } } else if (_4 === 4) { const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { diff --git a/ts/fixtures/lang/clones/expected/clones.Pair.ts b/ts/fixtures/lang/clones/expected/clones.Pair.ts index a87524e42..b7e29d6e3 100644 --- a/ts/fixtures/lang/clones/expected/clones.Pair.ts +++ b/ts/fixtures/lang/clones/expected/clones.Pair.ts @@ -4,15 +4,15 @@ import * as rs from "./rs.ts"; import * as Logged from "./clones.Logged.ts"; export function clone$Clone(self: Pair): Pair { - return new Pair(self.left.map(Logged.clone$Clone), self.tag); + return new Pair(self.left.map(Logged.clone$Clone), rs.stringClone(self.tag)); } /** A derived `Clone`, which clones each field in order. */ export class Pair { left: Logged.Logged[]; - tag: string; + tag: rs.String; - constructor(left: Logged.Logged[], tag: string) { + constructor(left: Logged.Logged[], tag: rs.String) { this.left = left; this.tag = tag; } diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index 68e4a7db6..b33ade272 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -6737,34 +6737,35 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return x67; }, out); } else if (_9 === 3) { - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { + const _111: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { const _518: rs.usize = rs.u8Rem(_273, 4) as rs.usize; if (!(_518 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); } return [97, 233, 20013, 129408][_518]; - })); - turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rs.strChars(text), (it53: rs.Iter): rs.char | undefined => { + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _111); + turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rs.strChars(text.v), (it53: rs.Iter): rs.char | undefined => { return rs.iterToOption(it53.nextBack()); }, plan, (c4: rs.char): rs.u8 => { return rs.u32Rem(c4 as rs.u32, 251) & 0xff; }, out); - turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(rs.strBytes(text), (it54: rs.Iter): rs.u8 | undefined => { + turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(rs.strBytes(text.v), (it54: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it54.nextBack()); }, plan, (b15: rs.u8): rs.u8 => { return b15; }, out); - turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(rs.strSplit(text, "é"), (it55: rs.Iter): string | undefined => { + turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(rs.strSplit(text.v, "é"), (it55: rs.Iter): string | undefined => { return rs.iterToOption(it55.nextBack()); }, plan, (s: string): rs.u8 => { return rs.stringLen(s) & 0xff; }, out); - turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(rs.strSplit(text, "中"), (it56: rs.Iter): string | undefined => { + turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(rs.strSplit(text.v, "中"), (it56: rs.Iter): string | undefined => { return rs.iterToOption(it56.next()); }, plan, (s2: string): rs.u8 => { return rs.stringLen(s2) & 0xff; }, out); - const _135: string = text; + const _135: string = text.v; const make6 = (captured7: rs.u8): (a0: rs.char) => boolean => { return rs.cloning((c5: rs.char): boolean => { captured7 = rs.u8WrappingAdd(captured7, 1); @@ -6779,7 +6780,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }, plan, (s3: string): rs.u8 => { return rs.stringLen(s3) & 0xff; }, out); - turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(rs.strMatchIndices(text, rs.patternChars([97, 129408])), (it58: rs.Iter<[rs.usize, string]>): [rs.usize, string] | undefined => { + turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(rs.strMatchIndices(text.v, rs.patternChars([97, 129408])), (it58: rs.Iter<[rs.usize, string]>): [rs.usize, string] | undefined => { return rs.iterToOption(it58.nextBack()); }, plan, (_283: [rs.usize, string]): rs.u8 => { return (_283[0] & 0xff) ^ (rs.stringLen(_283[1]) & 0xff); @@ -7585,28 +7586,30 @@ export function closures(data: rs.ByteSlice, plan: Plan.Plan, out: rs.ByteVec): flush(log.value, out); rs.drop(copy); flush(log.value, out); - const text: string = "ab"; + const text: rs.String = rs.stringFrom("ab"); const tag2: Logged.Logged = logged(7); - const make6 = (captured9: string, captured10: Logged.Logged): () => [string, Logged.Logged] => { - return rs.closure(rs.cloning((): [string, Logged.Logged] => { - captured9 = captured9 + "c"; - return [captured9, captured10] as [string, Logged.Logged]; - }, () => make6(captured9, Logged.clone$Clone(captured10))), (): void => { + const make6 = (captured9: rs.String, captured10: Logged.Logged): () => [rs.String, Logged.Logged] => { + return rs.closure(rs.cloning((): [rs.String, Logged.Logged] => { + rs.stringPush(captured9, 99); + return [captured9, captured10] as [rs.String, Logged.Logged]; + }, () => make6(((a0: rs.String): rs.String => { + return rs.stringClone(a0); + })(captured9), Logged.clone$Clone(captured10))), (): void => { captured10[Symbol.dispose](); }); }; - const once: () => [string, Logged.Logged] = make6(text, tag2); - const twice: () => [string, Logged.Logged] = rs.closureClone(once); + const once: () => [rs.String, Logged.Logged] = make6(text, tag2); + const twice: () => [rs.String, Logged.Logged] = rs.closureClone(once); flush(log.value, out); - const _127: [string, Logged.Logged] = once(); - const text2: string = _127[0]; + const _127: [rs.String, Logged.Logged] = once(); + const text2: rs.String = _127[0]; const tag3: Logged.Logged = _127[1]; - rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text2), rs.iterSlice(Uint8Array.of(Logged.id(tag3)))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text2.v), rs.iterSlice(Uint8Array.of(Logged.id(tag3)))), undefined, true); tag3[Symbol.dispose](); - const _139: [string, Logged.Logged] = twice(); - const text3: string = _139[0]; + const _139: [rs.String, Logged.Logged] = twice(); + const text3: rs.String = _139[0]; const tag4: Logged.Logged = _139[1]; - rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text3), rs.iterSlice(Uint8Array.of(Logged.id(tag4)))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text3.v), rs.iterSlice(Uint8Array.of(Logged.id(tag4)))), undefined, true); tag4[Symbol.dispose](); flush(log.value, out); const captured11 = data.length & 0xff; @@ -7711,12 +7714,14 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _166: Logged.Logged = logged(part13); const part14 = at(1); const _165: Logged.Logged[] = [_166, logged(part14)]; - const _178: string = "t"; + const _178: rs.String = rs.stringFrom("t"); const part15 = at(2); - const tuple: [Logged.Logged[], string, Logged.Logged] = [_165, _178, logged(part15)]; - const copy: [Logged.Logged[], string, Logged.Logged] = rs.tupleClone(tuple, [(a05: Logged.Logged[]): Logged.Logged[] => { - return a05.map(Logged.clone$Clone); - }, undefined, Logged.clone$Clone]); + const tuple: [Logged.Logged[], rs.String, Logged.Logged] = [_165, _178, logged(part15)]; + const copy: [Logged.Logged[], rs.String, Logged.Logged] = rs.tupleClone(tuple, [(a06: Logged.Logged[]): Logged.Logged[] => { + return a06.map(Logged.clone$Clone); + }, (a07: rs.String): rs.String => { + return rs.stringClone(a07); + }, Logged.clone$Clone]); flush(log.value, out); const part16 = rs.sliceFrom(copy[0]); _13(part16, out); @@ -7733,8 +7738,8 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { flush(log.value, out); const part20 = rs.sliceFrom(other.left); _13(part20, out); - rs.iterExtendBytes(out, rs.strBytes(other.tag), undefined, true); - drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair([copy, pair] as [[Logged.Logged[], string, Logged.Logged], Pair.Pair]); + rs.iterExtendBytes(out, rs.strBytes(other.tag.v), undefined, true); + drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair([copy, pair] as [[Logged.Logged[], rs.String, Logged.Logged], Pair.Pair]); flush(log.value, out); other[Symbol.dispose](); flush(log.value, out); @@ -7756,15 +7761,17 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const part12 = rs.sliceFrom(copy2[1]); _13(part12, out); const _295: rs.u8 = at(4); - const words: string[] = ["a", rs.fmtToString((f: rs.Formatter) => rs.u8Display(_295, f)), ""]; + const words: rs.String[] = [rs.stringFrom("a"), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_295, f), 0), rs.stringNew()]; const vecs: rs.ByteVec[] = [rs.byteSliceToByteVec(data), rs.byteVecFrom(Uint8Array.of(at(5)))]; - const _308: [string[], rs.ByteVec[]] = [words.slice(), vecs.map((a04: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a04)); + const _308: [rs.String[], rs.ByteVec[]] = [words.map((a04: rs.String): rs.String => { + return rs.stringClone(a04); + }), vecs.map((a05: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a05)); })]; - const words2: string[] = _308[0]; + const words2: rs.String[] = _308[0]; const vecs2: rs.ByteVec[] = _308[1]; rs.byteVecPush(vecs2[0], 1); - rs.iterExtendBytes(out, rs.strBytes(rs.strsJoin(words2, "")), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.strsJoin(words2, "").v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterChain(rs.iterSlice(vecs), rs.iterSlice(vecs2)), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); rs.dropAll(copy2, drop$array2_clones_Logged); flush(log.value, out); @@ -8139,8 +8146,8 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return logged(at(rs.usizeAdd(2, i3))); }); rs.iterExtend(row, _43, undefined, 8, true); - const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a04: rs.Vec): rs.Vec => { - return rs.vecFrom(a04.items.map(Logged.clone$Clone)); + const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a05: rs.Vec): rs.Vec => { + return rs.vecFrom(a05.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged); flush(log.value, out); for (const _62 of v2.items) { @@ -8154,8 +8161,8 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part14 = at(0); const _80: Logged.Logged = logged(part14); const part15 = at(1); - const v3: rs.Vec = rs.vecFromElem([_80, logged(part15)], n(2), (a03: Logged.Logged[]): Logged.Logged[] => { - return a03.map(Logged.clone$Clone); + const v3: rs.Vec = rs.vecFromElem([_80, logged(part15)], n(2), (a04: Logged.Logged[]): Logged.Logged[] => { + return a04.map(Logged.clone$Clone); }, drop$array2_clones_Logged); flush(log.value, out); rs.iterForEach(rs.iterSlice(v3.items), (row3: Logged.Logged[]): undefined => { @@ -8193,14 +8200,16 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, none.items.length & 0xff); const part11 = at(3); const _194: rs.u8 = at(4); - const pairs: rs.Vec<[Logged.Logged, string]> = rs.vecFromElem([logged(part11), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_194, f))] as [Logged.Logged, string], n(5), (a02: [Logged.Logged, string]): [Logged.Logged, string] => { - return rs.tupleClone(a02, [Logged.clone$Clone, undefined]); + const pairs: rs.Vec<[Logged.Logged, rs.String]> = rs.vecFromElem([logged(part11), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_194, f), 0)] as [Logged.Logged, rs.String], n(5), (a02: [Logged.Logged, rs.String]): [Logged.Logged, rs.String] => { + return rs.tupleClone(a02, [Logged.clone$Clone, (a03: rs.String): rs.String => { + return rs.stringClone(a03); + }]); }, drop$tuple2_clones_Logged_String); flush(log.value, out); - rs.iterForEach(rs.iterSlice(pairs.items), (_2: [Logged.Logged, string]): undefined => { - rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_2[1]), rs.iterSlice(Uint8Array.of(Logged.id(_2[0])))), undefined, true); + rs.iterForEach(rs.iterSlice(pairs.items), (_2: [Logged.Logged, rs.String]): undefined => { + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_2[1].v), rs.iterSlice(Uint8Array.of(Logged.id(_2[0])))), undefined, true); }); - drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String([some, none, pairs] as [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, string]>]); + drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String([some, none, pairs] as [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, rs.String]>]); flush(log.value, out); } else if (_12 === 5) { const part8 = at(0); diff --git a/ts/fixtures/lang/clones/expected/lib.ts b/ts/fixtures/lang/clones/expected/lib.ts index a72fcbbc4..017f79ec3 100644 --- a/ts/fixtures/lang/clones/expected/lib.ts +++ b/ts/fixtures/lang/clones/expected/lib.ts @@ -54,11 +54,11 @@ export function drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Log rs.dropAll(_1[1], drop$array2_clones_Logged); } -export function drop$tuple2_clones_Logged_String(_1: [Logged.Logged, string]): void { +export function drop$tuple2_clones_Logged_String(_1: [Logged.Logged, rs.String]): void { _1[0][Symbol.dispose](); } -export function drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair(_1: [[Logged.Logged[], string, Logged.Logged], Pair.Pair]): void { +export function drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair(_1: [[Logged.Logged[], rs.String, Logged.Logged], Pair.Pair]): void { drop$tuple3_array2_clones_Logged_String_clones_Logged(_1[0]); _1[1][Symbol.dispose](); } @@ -69,7 +69,7 @@ export function drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Log rs.dropAll(_1[2]); } -export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, string]>]): void { +export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, rs.String]>]): void { rs.dropVec(_1[0]); rs.dropVec(_1[1]); rs.dropVec(_1[2], drop$tuple2_clones_Logged_String); @@ -97,7 +97,7 @@ export function drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clo rs.dropAll(_1[2]); } -export function drop$tuple3_array2_clones_Logged_String_clones_Logged(_1: [Logged.Logged[], string, Logged.Logged]): void { +export function drop$tuple3_array2_clones_Logged_String_clones_Logged(_1: [Logged.Logged[], rs.String, Logged.Logged]): void { rs.dropAll(_1[0]); _1[2][Symbol.dispose](); } diff --git a/ts/fixtures/lang/collections/expected/collections.Cloned.ts b/ts/fixtures/lang/collections/expected/collections.Cloned.ts index 6312a4353..c236b49ee 100644 --- a/ts/fixtures/lang/collections/expected/collections.Cloned.ts +++ b/ts/fixtures/lang/collections/expected/collections.Cloned.ts @@ -8,11 +8,11 @@ import * as rs from "./rs.ts"; */ export interface Cloned { depth: rs.u8; - name: string; + name: rs.String; } export function clone$Clone(self: Cloned): Cloned { - return { depth: rs.u8Add(self.depth, 1), name: self.name }; + return { depth: rs.u8Add(self.depth, 1), name: rs.stringClone(self.name) }; } //# sourceMappingURL=collections.Cloned.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index b85b4194e..75ad4f646 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -26,7 +26,7 @@ import * as Tally from "./collections.Tally.ts"; import * as Window from "./collections.Window.ts"; import * as Wrap from "./collections.Wrap.ts"; import { thenSome$0quywni } from "./core/bool.ts"; -import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$1y26nmr as option_map$1y26nmr, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$0vkblkh as option_mapOr$0vkblkh, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$1wei0sy as option_mapOr$1wei0sy, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$05q90i2 as option_mapOr$05q90i2, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$14nprly as option_clone$14nprly, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$0n6ziv9 as option_map$0n6ziv9, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$0vkblkh as option_mapOr$0vkblkh, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$1wei0sy as option_mapOr$1wei0sy, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$05q90i2 as option_mapOr$05q90i2, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$0dg4ec5 as option_clone$0dg4ec5, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; import { eq$1a91ieh as result_eq$1a91ieh, eq$122baxc as result_eq$122baxc } from "./core/result.ts"; import { put } from "./harness.ts"; @@ -364,35 +364,37 @@ export function hashMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } rs.byteVecPush(out, rs.hashLen(tuples) & 0xff); } else { - const words: rs.HashMap = rs.hashNew() as rs.HashMap; + const words: rs.HashMap = rs.hashNew(rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashMap; for (const b6 of rs.byteSliceView(data)) { const _515: rs.usize = rs.usizeRem(b6 as rs.usize, rs.sliceFrom(["", "a", "ab", "b", "é", "", "￿", "𐀀"]).length); if (!(_515 < 8)) { rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _515); } - rs.byteVecPush(rs.entryOrInsertWith(rs.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_515]), (): rs.ByteVec => { + const word: rs.String = rs.stringFrom(["", "a", "ab", "b", "é", "", "￿", "𐀀"][_515]); + rs.byteVecPush(rs.entryOrInsertWith(rs.entry(words, word), (): rs.ByteVec => { return new rs.ByteVec(); }), b6); } - const lens: rs.BTreeMap = rs.btreeNew(rs.cmpStr) as rs.BTreeMap; - const iter16: rs.Iter<[string, rs.ByteVec]> = rs.hashIter(words); + const lens: rs.BTreeMap = rs.btreeNew(rs.cmpStr) as rs.BTreeMap; + const iter16: rs.Iter<[rs.String, rs.ByteVec]> = rs.hashIter(words); while (true) { - const _530: [string, rs.ByteVec] | rs.Done = iter16.next(); + const _530: [rs.String, rs.ByteVec] | rs.Done = iter16.next(); if (_530 === rs.DONE) { break; } - rs.btreeInsert(lens, _530[0], _530[1].length); + const _537: rs.String = rs.stringClone(_530[0]); + rs.btreeInsert(lens, _537, _530[1].length); } - const iter17: rs.Iter<[string, rs.usize]> = rs.btreeIter(lens); + const iter17: rs.Iter<[rs.String, rs.usize]> = rs.btreeIter(lens); while (true) { - const _542: [string, rs.usize] | rs.Done = iter17.next(); + const _542: [rs.String, rs.usize] | rs.Done = iter17.next(); if (_542 === rs.DONE) { break; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_542[0])); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_542[0].v)); rs.byteVecPush(out, _542[1] & 0xff); } - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.hashDrain(words), (_2: [string, rs.ByteVec]): rs.usize => { + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.hashDrain(words), (_2: [rs.String, rs.ByteVec]): rs.usize => { return _2[1].length; }), rs.usizeAdd, 0) & 0xff); rs.byteVecPush(out, rs.hashLen(words) === 0 ? 1 : 0); @@ -1107,7 +1109,7 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v } rs.byteVecPush(out, it.len() & 0xff); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); let i2: rs.i32 = 0; while (true) { if ((rs.u8Shr(kind, rs.i32Add(5, rs.i32Rem(i2, 3))) & 1) === 1) { @@ -1118,7 +1120,7 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v if (item !== undefined) { rs.byteVecPush(out, item); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]).v)); if (i2 === 1) { rs.iterExtendBytes(out, rs.iterRev(it.clone()), undefined, true); } @@ -1134,15 +1136,15 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v /** `vec![a, b]` and `vec![x; n]`, of bytes, numbers, `Copy` tuples, and types that clone. */ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { - let name!: string; + let name!: rs.String; const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); const n: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 2), 0) as rs.usize, 5); - const _16: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); + const _16: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_16.ok) { name = _16.value; } else { - name = "?"; + name = rs.stringFrom("?"); } const bytes: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(a, b, 66)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); @@ -1153,9 +1155,9 @@ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { for (const _39 of pairs.items) { rs.byteVecPush(out, _39[0] ^ (_39[1] & 0xff)); } - const names: rs.Vec = rs.vecFrom([name, "x", name]); + const names: rs.Vec = rs.vecFrom([rs.stringClone(name), rs.stringFrom("x"), rs.stringClone(name)]); rs.byteVecPush(out, names.items.length & 0xff); - const one: rs.Vec = rs.vecFrom([{ depth: a, name: name }]); + const one: rs.Vec = rs.vecFrom([{ depth: a, name: rs.stringClone(name) }]); rs.byteVecPush(out, one.items[rs.idx(one.items, 0)].depth); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteVecOf(b, n))); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecFromElem(rs.u16Mul(a as rs.u16, 257), n, undefined).items), (w: rs.u16): rs.u8 => { @@ -1168,13 +1170,15 @@ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(tuples.items), (t: [rs.u8, rs.u8]): rs.u8 => { return t[0] ^ t[1]; }), undefined, true); - rs.byteVecPush(out, rs.vecFromElem(name, n, undefined).items.length & 0xff); + rs.byteVecPush(out, rs.vecFromElem(rs.stringClone(name), n, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }).items.length & 0xff); const cloned: rs.Vec = rs.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(cloned.items), (c: Cloned.Cloned): rs.u8 => { return c.depth; }), undefined, true); rs.byteVecPush(out, rs.iterAll(rs.iterSlice(cloned.items), (c2: Cloned.Cloned): boolean => { - return rs.stringLen(c2.name) === data.length; + return c2.name.len === data.length; }) ? 1 : 0); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecFromElem({ _0: b }, n, Bumped.clone$Clone).items), (o: Bumped.Bumped): rs.u8 => { return o._0; @@ -1221,8 +1225,8 @@ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(wrapped.items), (w2: Wrap.Wrap): rs.u8 => { return w2.value ^ w2.count; }), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(names.items), (s2: string): rs.u8 => { - return rs.stringLen(s2) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(names.items), (s2: rs.String): rs.u8 => { + return s2.len & 0xff; }), undefined, true); } @@ -1348,7 +1352,7 @@ export function stores(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); } -export function get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): string | undefined | rs.None { +export function get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.String | undefined | rs.None { return rs.hashGet(self, k, rs.None); } @@ -1360,7 +1364,7 @@ export function get$collections_OptionMap_unit_collections_HashMap_u8_unit(self: return rs.hashGet(self, k, rs.None); } -export function insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8, v: string | undefined): string | undefined | rs.None { +export function insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8, v: rs.String | undefined): rs.String | undefined | rs.None { return rs.hashInsert(self, k, v, undefined, rs.None); } @@ -1372,7 +1376,7 @@ export function insert$collections_OptionMap_unit_collections_HashMap_u8_unit(se return rs.hashInsert(self, k, undefined, undefined, rs.None); } -export function remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): string | undefined | rs.None { +export function remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.String | undefined | rs.None { return rs.hashRemove(self, k, undefined, rs.None); } @@ -1384,7 +1388,7 @@ export function remove$collections_OptionMap_unit_collections_HashMap_u8_unit(se return rs.hashRemove(self, k, undefined, rs.None); } -export function getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.Place | undefined { +export function getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.Place | undefined { return rs.hashGetMut(self, k); } @@ -1396,11 +1400,11 @@ export function getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(se return rs.hashGetMut(self, k); } -export function sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap): rs.Vec<[rs.u8, string | undefined]> { - const all: rs.Vec<[rs.u8, string | undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, string | undefined]): [rs.u8, string | undefined] => { - return [_2[0], option_clone$14nprly(_2[1])] as [rs.u8, string | undefined]; +export function sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap): rs.Vec<[rs.u8, rs.String | undefined]> { + const all: rs.Vec<[rs.u8, rs.String | undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, rs.String | undefined]): [rs.u8, rs.String | undefined] => { + return [_2[0], option_clone$0dg4ec5(_2[1])] as [rs.u8, rs.String | undefined]; }), "next", 16); - rs.sliceSort(rs.sliceFrom(all.items), rs.keyLt((_22: [rs.u8, string | undefined]): rs.u8 => { + rs.sliceSort(rs.sliceFrom(all.items), rs.keyLt((_22: [rs.u8, rs.String | undefined]): rs.u8 => { return _22[0]; }, rs.lt), 16, true); return all; @@ -1478,41 +1482,41 @@ export function sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(s * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_String_collections_HashMap_u8_Option_String(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => string | undefined, out: rs.ByteVec): void { - let read!: string; +export function optional$Option_String_collections_HashMap_u8_Option_String(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.String | undefined, out: rs.ByteVec): void { + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { - const _24: string | undefined = value(b); + const _24: rs.String | undefined = value(b); const part3 = insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k, _24); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.String | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), rs.None)]; read = rs.fmtFormat([args2[0], " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.String | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), rs.None)]; read = rs.fmtFormat([args4[0], " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.String | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), rs.None)]; read = rs.fmtFormat([args6[0], " "]); } else { - const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { - const v: rs.Place = _49; - const _53: string | undefined = value(rs.u8Div(b, 2)); + const v: rs.Place = _49; + const _53: rs.String | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.fmtStr)]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; read = rs.fmtFormat(["=", args8[0], " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, string | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.fmtStr)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.String | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]).v)); } /** @@ -1520,7 +1524,7 @@ export function optional$Option_String_collections_HashMap_u8_Option_String(map: * `value` making what `insert` and `get_mut` put. */ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.u8 | undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1540,7 +1544,7 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); @@ -1549,11 +1553,11 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr read = rs.fmtFormat(["=", args8[0], " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]).v)); } /** @@ -1561,7 +1565,7 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr * `value` making what `insert` and `get_mut` put. */ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.u8 | undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1581,7 +1585,7 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); @@ -1590,11 +1594,11 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash read = rs.fmtFormat(["=", args8[0], " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]).v)); } /** @@ -1602,7 +1606,7 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash * `value` making what `insert` and `get_mut` put. */ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1622,7 +1626,7 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap | undefined = getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; value(rs.u8Div(b, 2)); @@ -1631,11 +1635,11 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]).v)); } /** @@ -1643,7 +1647,7 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1663,7 +1667,7 @@ export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap | undefined = getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; value(rs.u8Div(b, 2)); @@ -1672,11 +1676,11 @@ export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]).v)); } /** `b`, unless a multiple of 3. */ @@ -1690,8 +1694,8 @@ export function made$collections_BTreeMap_u8_Option_u8(): rs.BTreeMap::default` makes its map. */ -export function made$collections_HashMap_u8_Option_String(): rs.HashMap { - return rs.hashNew() as rs.HashMap; +export function made$collections_HashMap_u8_Option_String(): rs.HashMap { + return rs.hashNew() as rs.HashMap; } /** @@ -1710,9 +1714,9 @@ export function optionals(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else if (_4 === 3) { optional$unit_collections_BTreeMap_u8_unit(rs.btreeNew(rs.cmp) as rs.BTreeMap, data, (_2: rs.u8): undefined => {}, out); } else if (_4 === 4) { - optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rs.u8): string | undefined => { - return option_map$1y26nmr(some(b2), (b3: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b3, f)); + optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rs.u8): rs.String | undefined => { + return option_map$0n6ziv9(some(b2), (b3: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b3, f), 0); }); }, out); } else { @@ -1734,12 +1738,12 @@ export function optionals(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _53: boolean = rs.hashContains(map, k); const _56: rs.u8 | undefined | rs.None = read; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_56, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_53, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]).v)); } const all: rs.Vec<[[rs.u8, boolean], rs.u8 | undefined]> = rs.iterToVec(rs.hashIter(map), "next", 4); rs.sliceSort(rs.sliceFrom(all.items), rs.cmpLt(rs.cmpTuple<[[rs.u8, boolean], rs.u8 | undefined], rs.Ordering | undefined>([rs.cmpTuple<[rs.u8, boolean], rs.Ordering | undefined>([rs.cmp, rs.cmp]), rs.cmpOption(rs.cmp)])), 4, true); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [[rs.u8, boolean], rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0][0], f), (f: rs.Formatter) => rs.fmtBool(value[0][1], f)], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]).v)); } } @@ -4408,11 +4412,11 @@ export function cellEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putCmp(rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob), log, out); const _261: rs.u16 = at(0); const _267: rs.u16 = at(1); - const _257: [rs.RefCell, rs.RefCell] = [new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_261, f))), new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_267, f)))]; - const sa: rs.RefCell = _257[0]; - const sb: rs.RefCell = _257[1]; - putEq(rs.refCellBy(rs.same)(sa, sb), log, out); - putEq(!rs.refCellBy(rs.same)(sa, sb), log, out); + const _257: [rs.RefCell, rs.RefCell] = [new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_261, f), 0)), new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_267, f), 0))]; + const sa: rs.RefCell = _257[0]; + const sb: rs.RefCell = _257[1]; + putEq(rs.refCellBy(rs.eqStr)(sa, sb), log, out); + putEq(!rs.refCellBy(rs.eqStr)(sa, sb), log, out); putEq(rs.refCellBy(rs.cmpStr)(sa, sb) === -1, log, out); const order5 = rs.refCellBy(rs.cmpStr)(sa, sb); putEq(order5 !== undefined && order5 <= 0, log, out); @@ -5864,27 +5868,27 @@ export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): }); const _62: [rs.usize, rs.usize | undefined] = it.sizeHint(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_62[0], f), (f: rs.Formatter) => rs.fmtOption(_62[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1]]).v); const _72: rs.Iter<[rs.u16, rs.u16]> = it; const _74: rs.usize = limit as rs.usize; const taken: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterTake(rs.iterBorrow(_72), _74), "next", 4); const _83: [rs.usize, rs.usize | undefined] = it.sizeHint(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_83[0], f), (f: rs.Formatter) => rs.fmtOption(_83[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]])); + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]).v); if (rs.u8Rem(limit, 2) === 0) { const _104: [rs.u16, rs.u16] | undefined = rs.iterToOption(it.next()); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_104, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug)]; - put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1])])); + put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1])]).v); } const _122: rs.usize = rs.btreeLen(map); const _125: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterStepBy(rs.btreeIter(map), 7), "next", 8); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_122, f), (f: rs.Formatter) => rs.fmtList(_125.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args8[0], " ", args8[1]])); + put(out, rs.fmtFormat([args8[0], " ", args8[1]]).v); const taken2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.btreeExtractIfMut(map, undefined, (_217: rs.u16, v3: rs.Place): boolean => { return rs.u16Rem(v3.v, 3) === 0; }), "next", 4); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken2.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u16Debug, rs.u16Debug)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1]])); + put(out, rs.fmtFormat([args10[0], " ", args10[1]]).v); } else if (_44 === 1) { const _152: rs.Iter = rs.iterMap(new rs.Range(0, n), (k5: rs.u16): rs.u16 => { return rs.u16Rem(rs.u16Mul(k5, 3), rs.u16Add(n, 1)); @@ -5894,26 +5898,26 @@ export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): return rs.u16Rem(k6, every) !== 0; }); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([args12[0]]).v); const _174: rs.Iter = it2; const _176: rs.usize = limit as rs.usize; const taken3: rs.Vec = rs.iterToVec(rs.iterTake(rs.iterBorrow(_174), _176), "next", 2); const _185: [rs.usize, rs.usize | undefined] = it2.sizeHint(); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken3.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_185[0], f), (f: rs.Formatter) => rs.fmtOption(_185[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2]])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2]]).v); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([args16[0]]).v); const part3 = rs.btreeExtractKeysIf(rs.btreeNew(rs.cmp) as rs.BTreeSet, range, (_212: rs.u16): boolean => { return true; }); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(part3, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([args18[0]]).v); rs.btreeClear(set); const part4 = rs.btreeExtractKeysIf(set, undefined, (_216: rs.u16): boolean => { return true; }); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(part4, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([args20[0]]).v); } else { const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); const _243: rs.Iter<[Logged.Logged, Logged.Logged]> = rs.iterMap(new rs.Range(0, rs.u16Div(n, 2)), (k: rs.u16): [Logged.Logged, Logged.Logged] => { diff --git a/ts/fixtures/lang/collections/expected/core/option.ts b/ts/fixtures/lang/collections/expected/core/option.ts index 0210b408c..76724d814 100644 --- a/ts/fixtures/lang/collections/expected/core/option.ts +++ b/ts/fixtures/lang/collections/expected/core/option.ts @@ -52,7 +52,7 @@ export function map$16w3l9s(self: Nibble.Nibble | undefined, f: (a0: Nibble.Nibb return f(self); } -export function map$1y26nmr(self: rs.u8 | undefined, f: (a0: rs.u8) => string): string | undefined { +export function map$0n6ziv9(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } @@ -185,11 +185,11 @@ export function mapOr$1h9hu6n(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, return f(self); } -export function clone$14nprly(self: string | undefined): string | undefined { +export function clone$0dg4ec5(self: rs.String | undefined): rs.String | undefined { if (self === undefined) { return undefined; } - return self; + return rs.stringClone(self); } export function flatten$0ux6gqw(self: rs.u8 | undefined | rs.None): rs.u8 | undefined { diff --git a/ts/fixtures/lang/combinators/expected/combinators.ts b/ts/fixtures/lang/combinators/expected/combinators.ts index c2a3567f0..7d4462274 100644 --- a/ts/fixtures/lang/combinators/expected/combinators.ts +++ b/ts/fixtures/lang/combinators/expected/combinators.ts @@ -2,8 +2,8 @@ import * as rs from "./rs.ts"; import { copy$Result_array2_u32_u16, copy$array_u32 } from "./lib.ts"; -import { isSomeAnd$1s2u5lz, isNoneOr$0xn3i4j, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrElse$1badkpb as option_unwrapOrElse$1badkpb, unwrapOrElse$0wd124z as option_unwrapOrElse$0wd124z, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, unwrapOrDefault$03apme8 as option_unwrapOrDefault$03apme8, map$1y26nmr as option_map$1y26nmr, map$1px2rk4 as option_map$1px2rk4, map$1ek423e as option_map$1ek423e, map$1yjmt5m as option_map$1yjmt5m, inspect$1sa9a1m as option_inspect$1sa9a1m, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOrElse$0moj49b as option_mapOrElse$0moj49b, okOr$12zia2c as option_okOr$12zia2c, okOr$19jxvkb as option_okOr$19jxvkb, okOr$1j8owgb as option_okOr$1j8owgb, okOrElse$1usib9z as option_okOrElse$1usib9z, okOrElse$0cs4x8k as option_okOrElse$0cs4x8k, and$02hlbkj as option_and$02hlbkj, andThen$195hx6l as option_andThen$195hx6l, filter$1855tjj, filter$0hq86nl, or$0ar58vy as option_or$0ar58vy, orElse$05gzawv as option_orElse$05gzawv, orElse$1xazu5k as option_orElse$1xazu5k, xor$0x5qjg4, zip$0p00b0o, clone$14nprly as option_clone$14nprly } from "./core/option.ts"; -import { isOkAnd$1poqzjs, isErrAnd$0ecrrmy, ok$08qo4au, err$0zs6b4d, asRef$0qzh9or, map$0jdlh8o as result_map$0jdlh8o, map$044vsgj as result_map$044vsgj, mapOr$1yz3viz as result_mapOr$1yz3viz, mapOrElse$0eu5k5b as result_mapOrElse$0eu5k5b, mapErr$12sqndm as result_mapErr$12sqndm, mapErr$16o3r40 as result_mapErr$16o3r40, inspect$1lvk7wu as result_inspect$1lvk7wu, inspectErr$0nqm52c, unwrapOrDefault$0ysbycw as result_unwrapOrDefault$0ysbycw, and$1cozx1j as result_and$1cozx1j, andThen$19hld68 as result_andThen$19hld68, or$1sapa01 as result_or$1sapa01, orElse$009jxpk as result_orElse$009jxpk, unwrapOr$137i3aj as result_unwrapOr$137i3aj, unwrapOrElse$1d4fano as result_unwrapOrElse$1d4fano, unwrapOrElse$1iet7cd as result_unwrapOrElse$1iet7cd, copied$10r3llp, clone$1dcpug1 as result_clone$1dcpug1 } from "./core/result.ts"; +import { isSomeAnd$1s2u5lz, isNoneOr$0xn3i4j, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrElse$1va5cjo as option_unwrapOrElse$1va5cjo, unwrapOrElse$0wd124z as option_unwrapOrElse$0wd124z, unwrapOrDefault$1exlfpa as option_unwrapOrDefault$1exlfpa, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, unwrapOrDefault$03apme8 as option_unwrapOrDefault$03apme8, map$0n6ziv9 as option_map$0n6ziv9, map$1px2rk4 as option_map$1px2rk4, map$1ek423e as option_map$1ek423e, map$1yjmt5m as option_map$1yjmt5m, inspect$1sa9a1m as option_inspect$1sa9a1m, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOrElse$0moj49b as option_mapOrElse$0moj49b, okOr$12zia2c as option_okOr$12zia2c, okOr$19jxvkb as option_okOr$19jxvkb, okOr$1j8owgb as option_okOr$1j8owgb, okOrElse$1xtou7y as option_okOrElse$1xtou7y, okOrElse$0cs4x8k as option_okOrElse$0cs4x8k, and$02hlbkj as option_and$02hlbkj, andThen$195hx6l as option_andThen$195hx6l, filter$0hpv4s6, filter$0hq86nl, or$0ar58vy as option_or$0ar58vy, orElse$12s7nhv as option_orElse$12s7nhv, orElse$1xazu5k as option_orElse$1xazu5k, xor$0x5qjg4, zip$0p00b0o, clone$0dg4ec5 as option_clone$0dg4ec5 } from "./core/option.ts"; +import { isOkAnd$1poqzjs, isErrAnd$0ecrrmy, ok$08qo4au, err$0zs6b4d, asRef$0qzh9or, map$022lpi2 as result_map$022lpi2, map$044vsgj as result_map$044vsgj, mapOr$1yz3viz as result_mapOr$1yz3viz, mapOrElse$0eu5k5b as result_mapOrElse$0eu5k5b, mapErr$12sqndm as result_mapErr$12sqndm, mapErr$16o3r40 as result_mapErr$16o3r40, inspect$1lvk7wu as result_inspect$1lvk7wu, inspectErr$0nqm52c, unwrapOrDefault$0ysbycw as result_unwrapOrDefault$0ysbycw, and$1cozx1j as result_and$1cozx1j, andThen$19hld68 as result_andThen$19hld68, or$1sapa01 as result_or$1sapa01, orElse$009jxpk as result_orElse$009jxpk, unwrapOr$137i3aj as result_unwrapOr$137i3aj, unwrapOrElse$1d4fano as result_unwrapOrElse$1d4fano, unwrapOrElse$1iet7cd as result_unwrapOrElse$1iet7cd, copied$10r3llp, clone$1mincpv as result_clone$1mincpv } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ export function combinators(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { @@ -135,45 +135,45 @@ export function results(a: rs.u8 | undefined, b: rs.u8 | undefined, limit: rs.u8 /** Values JS shares where Rust clones or moves them. */ export function owned(a: rs.u8 | undefined, b: rs.u8 | undefined, out: rs.ByteVec): void { let matched!: rs.Result; - const s: string | undefined = option_map$1y26nmr(a, (x2: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(x2, f)); + const s: rs.String | undefined = option_map$0n6ziv9(a, (x2: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(x2, f), 0); }); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$165pyh5(filter$1855tjj(option_clone$14nprly(s), (s2: string): boolean => { - return rs.stringLen(s2) > 1; - })))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$1exlfpa(filter$0hpv4s6(option_clone$0dg4ec5(s), (s2: rs.String): boolean => { + return s2.len > 1; + })).v)); rs.byteVecPush(out, 124); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrElse$1badkpb(option_orElse$05gzawv(s, (): string | undefined => { - return option_map$1y26nmr(b, (y2: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(y2, f)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrElse$1va5cjo(option_orElse$12s7nhv(s, (): rs.String | undefined => { + return option_map$0n6ziv9(b, (y2: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(y2, f), 0); }); - }), (): string => { - return "-"; - }))); + }), (): rs.String => { + return rs.stringFrom("-"); + }).v)); rs.byteVecPush(out, 124); - const v: rs.Result = option_okOrElse$1usib9z(option_map$1px2rk4(a, (x3: rs.u8): rs.ByteVec => { + const v: rs.Result = option_okOrElse$1xtou7y(option_map$1px2rk4(a, (x3: rs.u8): rs.ByteVec => { return rs.byteVecOf(x3, 2); - }), (): string => { - return "none"; + }), (): rs.String => { + return rs.stringFrom("none"); }); - const copy: rs.Result = result_clone$1dcpug1(v); + const copy: rs.Result = result_clone$1mincpv(v); if (copy.ok) { rs.byteVecPush(copy.value, 7); } - const grown: rs.Result = result_map$0jdlh8o(result_clone$1dcpug1(v), (v3: rs.ByteVec): rs.ByteVec => { + const grown: rs.Result = result_map$022lpi2(result_clone$1mincpv(v), (v3: rs.ByteVec): rs.ByteVec => { rs.byteVecPush(v3, 9); return v3; }); - const iter: rs.Iter> = rs.iterSlice([v, copy, grown]); + const iter: rs.Iter> = rs.iterSlice([v, copy, grown]); while (true) { - const _36: rs.Result | rs.Done = iter.next(); + const _36: rs.Result | rs.Done = iter.next(); if (_36 === rs.DONE) { break; } - const r: rs.Result = _36; + const r: rs.Result = _36; if (r.ok) { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(r.value)); } else { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(r.error)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(r.error.v)); } rs.byteVecPush(out, 124); } diff --git a/ts/fixtures/lang/combinators/expected/core/option.ts b/ts/fixtures/lang/combinators/expected/core/option.ts index 70968496d..1348d46c9 100644 --- a/ts/fixtures/lang/combinators/expected/core/option.ts +++ b/ts/fixtures/lang/combinators/expected/core/option.ts @@ -23,7 +23,7 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function unwrapOrElse$1badkpb(self: string | undefined, f: () => string): string { +export function unwrapOrElse$1va5cjo(self: rs.String | undefined, f: () => rs.String): rs.String { if (self === undefined) { return f(); } @@ -37,9 +37,9 @@ export function unwrapOrElse$0wd124z(self: rs.u8 | undefined, f: () => rs.u8): r return self; } -export function unwrapOrDefault$165pyh5(self: string | undefined): string { +export function unwrapOrDefault$1exlfpa(self: rs.String | undefined): rs.String { if (self === undefined) { - return ""; + return rs.stringNew(); } return self; } @@ -58,7 +58,7 @@ export function unwrapOrDefault$03apme8(self: rs.u8 | undefined): rs.u8 { return self; } -export function map$1y26nmr(self: rs.u8 | undefined, f: (a0: rs.u8) => string): string | undefined { +export function map$0n6ziv9(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } @@ -142,7 +142,7 @@ export function okOr$1j8owgb(self: rs.u8 | undefined, err: rs.u8): rs.Result string): rs.Result { +export function okOrElse$1xtou7y(self: rs.ByteVec | undefined, err: () => rs.String): rs.Result { if (self === undefined) { return rs.Err(err()); } @@ -170,9 +170,9 @@ export function andThen$195hx6l(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 return f(self); } -export function filter$1855tjj(self: string | undefined, predicate: (a0: string) => boolean): string | undefined { +export function filter$0hpv4s6(self: rs.String | undefined, predicate: (a0: rs.String) => boolean): rs.String | undefined { if (self !== undefined) { - const x: string = self; + const x: rs.String = self; if (predicate(x)) { return x; } @@ -197,7 +197,7 @@ export function or$0ar58vy(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs return self; } -export function orElse$05gzawv(self: string | undefined, f: () => string | undefined): string | undefined { +export function orElse$12s7nhv(self: rs.String | undefined, f: () => rs.String | undefined): rs.String | undefined { if (self === undefined) { return f(); } @@ -242,11 +242,11 @@ export function zip$0p00b0o(self: rs.u8 | undefined, other: rs.u8 | undefined): return _0; } -export function clone$14nprly(self: string | undefined): string | undefined { +export function clone$0dg4ec5(self: rs.String | undefined): rs.String | undefined { if (self === undefined) { return undefined; } - return self; + return rs.stringClone(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/combinators/expected/core/result.ts b/ts/fixtures/lang/combinators/expected/core/result.ts index e76381103..64c33aae2 100644 --- a/ts/fixtures/lang/combinators/expected/core/result.ts +++ b/ts/fixtures/lang/combinators/expected/core/result.ts @@ -37,7 +37,7 @@ export function asRef$0qzh9or(self: rs.Result): rs.Result, op: (a0: rs.ByteVec) => rs.ByteVec): rs.Result { +export function map$022lpi2(self: rs.Result, op: (a0: rs.ByteVec) => rs.ByteVec): rs.Result { if (self.ok) { return rs.Ok(op(self.value)); } @@ -156,11 +156,11 @@ export function copied$10r3llp(self: rs.Result): rs.Result): rs.Result { +export function clone$1mincpv(self: rs.Result): rs.Result { if (self.ok) { return rs.Ok(rs.byteVecFrom(rs.byteVecView(self.value))); } - return rs.Err(self.error); + return rs.Err(rs.stringClone(self.error)); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/conversions/expected/conversions.Named.ts b/ts/fixtures/lang/conversions/expected/conversions.Named.ts index a4dbbebc1..37bf659d2 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.Named.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.Named.ts @@ -4,7 +4,7 @@ import * as rs from "./rs.ts"; import { byte, make$conversions_Value_String, put$conversions_Value_String as conversions_put$conversions_Value_String } from "./conversions.ts"; export function clone$Clone(self: Named): Named { - return { id: self.id, name: self.name }; + return { id: self.id, name: rs.stringClone(self.name) }; } export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { @@ -22,7 +22,7 @@ export function cmp$cmp_Ord(self: Named, other: Named): rs.Ordering { /** A struct, which JS holds as an object. */ export interface Named { id: rs.u16; - name: string; + name: rs.String; } /** The value `data` makes from `at`. */ diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index 27f4fe6ac..7b6e46d12 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -7,7 +7,7 @@ import * as Kept from "./conversions.Kept.ts"; import * as Logged from "./conversions.Logged.ts"; import * as Named from "./conversions.Named.ts"; import { thenSome$1gvhopg } from "./core/bool.ts"; -import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, clone$0wpatp7 as option_clone$0wpatp7, clone$14nprly as option_clone$14nprly, clone$13oewp0 as option_clone$13oewp0, clone$0xr8mw0 as option_clone$0xr8mw0, clone$17fv6u9 as option_clone$17fv6u9, clone$0fp7wpk as option_clone$0fp7wpk, clone$1lfse5o as option_clone$1lfse5o, clone$08wmfj8 as option_clone$08wmfj8, clone$1aebjgp as option_clone$1aebjgp } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, clone$0wpatp7 as option_clone$0wpatp7, clone$13oewp0 as option_clone$13oewp0, clone$0xr8mw0 as option_clone$0xr8mw0, clone$17fv6u9 as option_clone$17fv6u9, clone$0fp7wpk as option_clone$0fp7wpk, clone$1lfse5o as option_clone$1lfse5o, clone$08wmfj8 as option_clone$08wmfj8, clone$1aebjgp as option_clone$1aebjgp } from "./core/option.ts"; /** The byte at `at`, past `data`'s end its index. */ export function byte(data: rs.ByteSlice, at: rs.usize): rs.u8 { @@ -45,15 +45,15 @@ export function put$conversions_Value_u64(self: rs.u64, out: rs.ByteVec): void { } /** The value `data` makes from `at`. */ -export function make$conversions_Value_String(data: rs.ByteSlice, at: rs.usize): string { +export function make$conversions_Value_String(data: rs.ByteSlice, at: rs.usize): rs.String { const part = rs.u8Rem(byte(data, at), 16); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; return rs.fmtFormat(["s", args2[0]]); } /** Its bytes. */ -export function put$conversions_Value_String(self: string, out: rs.ByteVec): void { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(self))), undefined, true); +export function put$conversions_Value_String(self: rs.String, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(self.v))), undefined, true); rs.byteVecPush(out, 255); } @@ -326,8 +326,8 @@ export function cloneFromParam$Option_u16(to: rs.Place, from } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$String(to: rs.Place, from: string): void { - to.v = from; +export function cloneFromParam$String(to: rs.String, from: rs.String): void { + Object.assign(to, rs.stringCloneFrom(to, from)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ @@ -396,8 +396,8 @@ export function cloneIntoParam$Option_u16(from: rs.u16 | undefined, to: rs.Place } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$String(from: string, to: rs.Place): void { - to.v = from; +export function cloneIntoParam$String(from: rs.String, to: rs.String): void { + Object.assign(to, rs.stringCloneFrom(to, from)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ @@ -474,13 +474,11 @@ export function writeFirst$Option_u16(s: rs.Slice, value: rs } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$String(s: rs.Slice, value: string): string { +export function writeFirst$String(s: rs.Slice, value: rs.String): rs.String { rs.idx(s, 0); - const _8: string = value; - const old2 = s.data[s.start]; - s.data[s.start] = _8; - const old: string = old2; - const _10: string = value; + const _8: rs.String = rs.stringClone(value); + const old: rs.String = rs.sliceReplace(s.data, s.start, _8); + const _10: rs.String = value; rs.idx(s, 0); s.data[s.start] = _10; return old; @@ -633,9 +631,9 @@ export function replaceFirst$Option_u16(s: rs.Slice>, } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$String(s: rs.Slice, value: string[]): string[] { +export function replaceFirst$String(s: rs.Slice, value: rs.String[]): rs.String[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, value); + return rs.sliceReplace(s.data, s.start, value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ @@ -783,31 +781,23 @@ export function lentParam$Option_u16(to: rs.Place, data: rs. * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceOfPlace(to); +export function lentParam$String(to: rs.String, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.Slice = rs.sliceIn(to); put$conversions_Value_String(writeFirst$String(s, make$conversions_Value_String(data, 18)), out); - let other: string = make$conversions_Value_String(data, 19); + let other: rs.String = make$conversions_Value_String(data, 19); rs.idx(s, 0); - const swapped = s.data[s.start]; - s.data[s.start] = other; - other = swapped; + other = rs.sliceReplace(s.data, s.start, other); put$conversions_Value_String(other, out); rs.idx(s, 0); - const swapped2 = other; - other = s.data[s.start]; - s.data[s.start] = swapped2; + other = rs.sliceReplace(s.data, s.start, other); put$conversions_Value_String(other, out); - const t: rs.Slice = rs.sliceFrom(rs.vecFrom([make$conversions_Value_String(data, 20), make$conversions_Value_String(data, 21)]).items); + const t: rs.Slice = rs.sliceFrom(rs.vecFrom([make$conversions_Value_String(data, 20), make$conversions_Value_String(data, 21)]).items); rs.idx(s, 0); rs.idx(t, 1); - const swapped3 = s.data[s.start]; - s.data[s.start] = t.data[t.start + 1]; - t.data[t.start + 1] = swapped3; + rs.sliceSwapAcross(s.data, s.start, t.data, t.start + 1); rs.idx(t, 0); rs.idx(s, 0); - const swapped4 = t.data[t.start]; - t.data[t.start] = s.data[s.start]; - s.data[s.start] = swapped4; + rs.sliceSwapAcross(t.data, t.start, s.data, s.start); rs.idx(t, 0); put$conversions_Value_String(t.data[t.start], out); rs.idx(t, 1); @@ -815,37 +805,34 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: string[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); - const _77: string[] = [make$conversions_Value_String(data, 22)]; - put$conversions_Value_String(rs.replaceIn(a, _77)[0], out); - let by: string = make$conversions_Value_String(data, 23); + const a: rs.String[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const _77: rs.String[] = [make$conversions_Value_String(data, 22)]; + put$conversions_Value_String(rs.replaceIn(a, _77, 1)[0], out); + const by: rs.String = make$conversions_Value_String(data, 23); rs.idx(s, 0); - const borrowed3 = s.start; - let r: rs.Place = rs.place(() => s.data[borrowed3], (value2) => s.data[borrowed3] = value2); - const _89: rs.Place[] = rs.arrayOfPlace(rs.place(() => r, (value3) => r = value3)); - const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; - rs.replaceIn(_89, _91)[0].v = make$conversions_Value_String(data, 24); - put$conversions_Value_String(r.v, out); + let r: rs.String = s.data[s.start]; + const _89: rs.String[] = rs.arrayOfPlace(rs.place(() => r, (value2) => r = value2)); + const _91: rs.String[] = [by]; + Object.assign(rs.replaceIn(_89, _91)[0], make$conversions_Value_String(data, 24)); + put$conversions_Value_String(r, out); rs.idx(s, 0); put$conversions_Value_String(s.data[s.start], out); rs.idx(s, 0); - const borrowed4 = s.data; - const borrowed5 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellOfPlace(rs.place(() => borrowed4[borrowed5], (value5) => borrowed4[borrowed5] = value5)), make$conversions_Value_String(data, 25)), out); + put$conversions_Value_String(rs.cellReplace(rs.cellIn(s.data[s.start]), make$conversions_Value_String(data, 25)), out); rs.idx(s, 0); - const borrowed6 = s.data; - const borrowed7 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6))), [make$conversions_Value_String(data, 26)])[0], out); + const borrowed3 = s.data; + const borrowed4 = s.start; + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3)), 1), [make$conversions_Value_String(data, 26)])[0], out); rs.idx(s, 0); - const borrowed8 = s.data; - const borrowed9 = s.start; - put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7))), [make$conversions_Value_String(data, 27)])[0], out); + const borrowed5 = s.data; + const borrowed6 = s.start; + put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4))), [make$conversions_Value_String(data, 27)])[0], out); rs.idx(s, 0); - const borrowed10 = s.data; - const borrowed11 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); + const borrowed7 = s.data; + const borrowed8 = s.start; + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))), 2), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); - s.data[s.start] = other; + s.data[s.start] = rs.stringCloneFrom(s.data[s.start], other); rs.idx(s, 0); put$conversions_Value_String(s.data[s.start], out); } @@ -1635,16 +1622,14 @@ export function lentThrough$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): voi * read after. */ export function lentThrough$String(data: rs.ByteSlice, out: rs.ByteVec): void { - let a: string = make$conversions_Value_String(data, 0); - const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - lentParam$String(rs.place(() => a, (value) => a = value), data, out); - lentParam$String(rs.place(() => held.value, (value2) => held.value = value2), data, out); - const at = rs.idx(v.items, 1); - lentParam$String(rs.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); - const at2 = rs.idx(v.items, 0); - let _19: rs.Place = rs.place(() => v.items[at2], (value4) => v.items[at2] = value4); - lentNested$String(rs.place(() => _19, (value5) => _19 = value5), data, out); + const a: rs.String = make$conversions_Value_String(data, 0); + const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + lentParam$String(a, data, out); + lentParam$String(held.value, data, out); + lentParam$String(v.items[rs.idx(v.items, 1)], data, out); + let _19: rs.String = v.items[rs.idx(v.items, 0)]; + lentNested$String(rs.place(() => _19, (value) => _19 = value), data, out); put$conversions_Value_String(a, out); put$conversions_Value_String(held.value, out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); @@ -1873,7 +1858,7 @@ export function lentNested$Option_u16(to: rs.Place> } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$String(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { +export function lentNested$String(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$String(to.v, data, out); } @@ -1938,8 +1923,8 @@ export function setThrough$Option_u16(to: rs.Place, value: r } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$String(to: rs.Place, value: string): string { - return rs.cellReplace(rs.cellOfPlace(to), value); +export function setThrough$String(to: rs.String, value: rs.String): rs.String { + return rs.cellReplace(rs.cellIn(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ @@ -2091,80 +2076,83 @@ export function converted$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void /** Each conversion of a `T`, its copies put after a write to what they copied. */ export function converted$String(data: rs.ByteSlice, out: rs.ByteVec): void { - let a: string = make$conversions_Value_String(data, 0); - const b: string = make$conversions_Value_String(data, 3); - const owned: string = a; - a = b; + let a: rs.String = make$conversions_Value_String(data, 0); + const b: rs.String = make$conversions_Value_String(data, 3); + const owned: rs.String = rs.stringClone(a); + a = rs.stringCloneFrom(a, b); put$conversions_Value_String(owned, out); put$conversions_Value_String(a, out); - let c: string = make$conversions_Value_String(data, 6); - c = owned; + let c: rs.String = make$conversions_Value_String(data, 6); + c = rs.stringCloneFrom(c, owned); put$conversions_Value_String(c, out); - cloneFromParam$String(rs.place(() => c, (value) => c = value), b); - cloneIntoParam$String(owned, rs.place(() => a, (value2) => a = value2)); + cloneFromParam$String(c, b); + cloneIntoParam$String(owned, a); put$conversions_Value_String(c, out); put$conversions_Value_String(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - held.value = c; - const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - v.items[rs.idx(v.items, 1)] = held.value; - v.items[rs.idx(v.items, 0)] = b; + const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); + held.value = rs.stringCloneFrom(held.value, c); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + const at = rs.idx(v.items, 1); + v.items[at] = rs.stringCloneFrom(v.items[at], held.value); + const at2 = rs.idx(v.items, 0); + v.items[at2] = rs.stringCloneFrom(v.items[at2], b); put$conversions_Value_String(held.value, out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); - const one: string[] = [b]; + const one: rs.String[] = [b]; rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: string = one[0]; + const copied: rs.String = rs.stringClone(one[0]); put$conversions_Value_String(one[0], out); - a = copied; + a = rs.stringCloneFrom(a, copied); put$conversions_Value_String(copied, out); put$conversions_Value_String(a, out); - const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); - const old: string = rs.cellReplace(cell, make$conversions_Value_String(data, 10)); + const cell: rs.Cell = rs.cellIn(c); + const old: rs.String = rs.cellReplace(cell, make$conversions_Value_String(data, 10)); rs.cellSet(cell, make$conversions_Value_String(data, 11)); put$conversions_Value_String(old, out); put$conversions_Value_String(c, out); const at5 = rs.idx(v.items, 0); - const _91: string = make$conversions_Value_String(data, 12); - put$conversions_Value_String(setThrough$String(rs.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); + const _91: rs.String = make$conversions_Value_String(data, 12); + put$conversions_Value_String(setThrough$String(v.items[at5], _91), out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); - const borrowed = held; - rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_String(data, 17)); + rs.cellSet(rs.cellIn(held.value), make$conversions_Value_String(data, 17)); put$conversions_Value_String(held.value, out); - const array: string[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; + const array: rs.String[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: string = b; - const _116: rs.Slice = rs.sliceFrom(array); + const _114: rs.String = rs.stringClone(b); + const _116: rs.Slice = rs.sliceFrom(array); rs.idx(_116, 0); _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const _124: rs.Slice = rs.sliceFrom(array); rs.idx(_124, 2); - _124.data[_124.start + 2] = c; + _124.data[_124.start + 2] = rs.stringCloneFrom(_124.data[_124.start + 2], c); for (const _134 of array) { put$conversions_Value_String(_134, out); } - const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14)]); - const none: rs.Vec = new rs.Vec(); + const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14)]); + const none: rs.Vec = new rs.Vec(); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(list.items).length, list.items.length, rs.sliceFrom(none.items).length, rs.sliceFrom(none.items).length, rs.sliceFrom(list.items).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: string = b; - const _165: rs.Slice = rs.sliceFrom(list.items); + const _163: rs.String = rs.stringClone(b); + const _165: rs.Slice = rs.sliceFrom(list.items); rs.idx(_165, 0); _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const _173: rs.Slice = rs.sliceFrom(list.items); rs.idx(_173, 1); - _173.data[_173.start + 1] = c; + _173.data[_173.start + 1] = rs.stringCloneFrom(_173.data[_173.start + 1], c); rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); - const _184: rs.Vec = list; - const _186: string = make$conversions_Value_String(data, 15); + const _184: rs.Vec = list; + const _186: rs.String = make$conversions_Value_String(data, 15); _184.items.push(_186); - none.items.push(a); - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); + const _188: rs.Vec = none; + const _190: rs.String = rs.stringClone(a); + _188.items.push(_190); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: string | rs.Done = iter2.next(); + const _199: rs.String | rs.Done = iter2.next(); if (_199 === rs.DONE) { break; } @@ -3398,45 +3386,69 @@ export function boxed$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { * `Option`, and in a slice, and a boxed slice by `clone_into`. */ export function boxed$String(data: rs.ByteSlice, out: rs.ByteVec): void { - let boxed: string = make$conversions_Value_String(data, 19); - boxed = make$conversions_Value_String(data, 3); + let boxed: rs.String = make$conversions_Value_String(data, 19); + const _8: rs.String = make$conversions_Value_String(data, 3); + boxed = rs.stringCloneFrom(boxed, _8); put$conversions_Value_String(boxed, out); - const source: string = make$conversions_Value_String(data, 20); - boxed = source; + const source: rs.String = make$conversions_Value_String(data, 20); + boxed = rs.stringCloneFrom(boxed, source); put$conversions_Value_String(boxed, out); put$conversions_Value_String(source, out); - let nested: string = make$conversions_Value_String(data, 21); - nested = ((a0: string): string => { - return a0; + let nested: rs.String = make$conversions_Value_String(data, 21); + const _27: rs.String = ((a0: rs.String): rs.String => { + return rs.stringClone(a0); })(source); + nested = rs.stringCloneFrom(nested, _27); put$conversions_Value_String(nested, out); - let maybe: string | undefined = make$conversions_Value_String(data, 22); - maybe = option_clone$14nprly(boxed); - maybe = option_clone$14nprly(undefined); + let maybe: rs.String | undefined = make$conversions_Value_String(data, 22); + const _38: rs.String | undefined = ((a02: rs.String): rs.String => { + return rs.stringClone(a02); + })(boxed); + maybe = rs.optionCloneFrom(maybe, _38, (a03: rs.String): rs.String => { + return ((a04: rs.String): rs.String => { + return rs.stringClone(a04); + })(a03); + }, undefined, rs.stringCloneFromFn()); + maybe = rs.optionCloneFrom(maybe, undefined, (a05: rs.String): rs.String => { + return ((a06: rs.String): rs.String => { + return rs.stringClone(a06); + })(a05); + }, undefined, rs.stringCloneFromFn()); rs.byteVecPush(out, maybe === undefined ? 1 : 0); - maybe = option_clone$14nprly(source); - rs.iterForEach(rs.iterOption(maybe), (x: string): undefined => { + const _51: rs.String | undefined = ((a07: rs.String): rs.String => { + return rs.stringClone(a07); + })(source); + maybe = rs.optionCloneFrom(maybe, _51, (a08: rs.String): rs.String => { + return ((a09: rs.String): rs.String => { + return rs.stringClone(a09); + })(a08); + }, undefined, rs.stringCloneFromFn()); + rs.iterForEach(rs.iterOption(maybe), (x: rs.String): undefined => { put$conversions_Value_String(x, out); }); - const slots: string[] = [make$conversions_Value_String(data, 23), make$conversions_Value_String(data, 24)]; - rs.sliceCloneFromSlice(rs.sliceFrom(slots), rs.sliceFrom([source, boxed]), (a02: string): string => { - return a02; - }); + const slots: rs.String[] = [make$conversions_Value_String(data, 23), make$conversions_Value_String(data, 24)]; + rs.sliceCloneFromSlice(rs.sliceFrom(slots), rs.sliceFrom([source, boxed]), (a010: rs.String): rs.String => { + return ((a011: rs.String): rs.String => { + return rs.stringClone(a011); + })(a010); + }, undefined, rs.stringCloneFromFn()); for (const _73 of slots) { put$conversions_Value_String(_73, out); } const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; - const whole: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): string => { + const whole: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.String => { return make$conversions_Value_String(data, rs.usizeAdd(26, i)); }), undefined, 12, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): string => { + let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.String => { return make$conversions_Value_String(data, rs.usizeAdd(29, i2)); }), undefined, 12, true).items); - into = rs.boxSliceCloneFrom(into, whole); + into = rs.boxSliceCloneFrom(into, whole, (a012: rs.String): rs.String => { + return rs.stringClone(a012); + }, undefined, rs.stringCloneFromFn()); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(into)), rs.iterSlice(rs.sliceItems(whole))); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(into)), rs.iterSlice(rs.sliceItems(whole))); while (true) { - const _108: string | rs.Done = iter2.next(); + const _108: rs.String | rs.Done = iter2.next(); if (_108 === rs.DONE) { break; } @@ -4203,19 +4215,17 @@ export function lentOne$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { * a whole, the old value read out, and through std's slice methods. */ export function lentOne$String(data: rs.ByteSlice, out: rs.ByteVec): void { - const _6: [string, string, string] = [make$conversions_Value_String(data, 0), make$conversions_Value_String(data, 3), make$conversions_Value_String(data, 6)]; - let a: string = _6[0]; - const b: string = _6[1]; - let c: string = _6[2]; - const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - const s: rs.Slice = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + const _6: [rs.String, rs.String, rs.String] = [make$conversions_Value_String(data, 0), make$conversions_Value_String(data, 3), make$conversions_Value_String(data, 6)]; + let a: rs.String = _6[0]; + const b: rs.String = _6[1]; + let c: rs.String = _6[2]; + const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + const s: rs.Slice = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); - const _28: string = make$conversions_Value_String(data, 5); - const old4 = s.data[s.start]; - s.data[s.start] = _28; - put$conversions_Value_String(old4, out); + const _28: rs.String = make$conversions_Value_String(data, 5); + put$conversions_Value_String(rs.sliceReplace(s.data, s.start, _28), out); put$conversions_Value_String(a, out); const borrowed = held; put$conversions_Value_String(writeFirst$String(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_String(data, 7)), out); @@ -4225,14 +4235,11 @@ export function lentOne$String(data: rs.ByteSlice, out: rs.ByteVec): void { const borrowed3 = at; put$conversions_Value_String(writeFirst$String(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_String(data, 8)), out); put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); - rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), b, undefined); - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5)))); - while (true) { - const _61: rs.Place | rs.Done = iter.next(); - if (_61 === rs.DONE) { - break; - } - _61.v = make$conversions_Value_String(data, 9); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), rs.stringClone(b), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }, undefined, rs.stringCloneFromFn()); + for (const _61 of rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5))) { + Object.assign(_61, make$conversions_Value_String(data, 9)); } put$conversions_Value_String(c, out); put$conversions_Value_String(a, out); @@ -4710,11 +4717,13 @@ export function searched$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { let _45!: rs.usize; let _75!: [rs.u8, rs.usize]; - const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): string => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.String => { return make$conversions_Value_String(data, i2); }), undefined, 12, true); rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpStr), 12, true); - const tagged: rs.Vec<[string, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(v.items)), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); + const tagged: rs.Vec<[rs.String, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { const _24: rs.usize | rs.Done = iter.next(); @@ -4722,8 +4731,8 @@ export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); - const t: rs.Slice<[string, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); + const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const t: rs.Slice<[rs.String, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; const iterEnd: rs.usize = _40; @@ -4731,14 +4740,14 @@ export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: string = make$conversions_Value_String(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpStr), rs.sliceBinarySearchBy(s, (e: string): rs.Ordering => { + const x: rs.String = make$conversions_Value_String(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpStr), rs.sliceBinarySearchBy(s, (e: rs.String): rs.Ordering => { put$conversions_Value_String(e, out); return rs.cmpStr(e, x); - }), rs.sliceBinarySearchByKey(t, x, (_2: [string, rs.u8]): string => { + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.String, rs.u8]): rs.String => { rs.byteVecPush(out, _2[1]); - return _2[0]; - }, rs.cmpStr), rs.Ok(rs.slicePartitionPoint(s, (e2: string): boolean => { + return rs.stringClone(_2[0]); + }, rs.cmpStr), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.String): boolean => { put$conversions_Value_String(e2, out); return rs.cmpStr(e2, x) === -1; }))]); @@ -5476,9 +5485,10 @@ export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u64 => { return _2 as rs.u64; }), undefined, 8, true); - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { + const _8: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { return _25 as rs.char; - })); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _8); Named.make$conversions_Value(data, 0); const _13: rs.usize = rs.byteSliceRange(data, 0, 0).length; rs.byteSliceRange(data, 0, 0); @@ -5487,7 +5497,7 @@ export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { const _23: rs.usize = rs.sliceFrom(wide.items).length * 8; rs.sliceFrom(wide.items); const _22: [rs.usize, rs.usize] = [_23, 8]; - const _29: [rs.usize, rs.usize] = [rs.stringLen(text), 1]; + const _29: [rs.usize, rs.usize] = [rs.stringLen(text.v), 1]; const _36: [rs.usize, rs.usize] = [4, 4]; const _41: [rs.usize, rs.usize] = [16, 16]; [n & 0xff, n & 0xffff] as [rs.u8, rs.u16]; diff --git a/ts/fixtures/lang/conversions/expected/core/option.ts b/ts/fixtures/lang/conversions/expected/core/option.ts index ef47d15d4..c95a8b373 100644 --- a/ts/fixtures/lang/conversions/expected/core/option.ts +++ b/ts/fixtures/lang/conversions/expected/core/option.ts @@ -19,13 +19,6 @@ export function clone$0wpatp7(self: rs.u16 | undefined | rs.None): rs.u16 | unde return self; } -export function clone$14nprly(self: string | undefined): string | undefined { - if (self === undefined) { - return undefined; - } - return self; -} - export function clone$13oewp0(self: Uint8Array | undefined): Uint8Array | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/lang/cows/expected/core/option.ts b/ts/fixtures/lang/cows/expected/core/option.ts index 5bd9ecef4..51528100b 100644 --- a/ts/fixtures/lang/cows/expected/core/option.ts +++ b/ts/fixtures/lang/cows/expected/core/option.ts @@ -31,11 +31,11 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function map$167hjon(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => string): string | undefined { +export function map$0bka7d0(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } - return rs.strCowStr(self); + return rs.strCowIntoOwned(self); } export function map$1g811lq(self: string | undefined, _: (a0: string) => rs.StrCow): rs.StrCow | undefined { @@ -45,7 +45,7 @@ export function map$1g811lq(self: string | undefined, _: (a0: string) => rs.StrC return new rs.Borrowed(self); } -export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { +export function mapOr$1fzqoua(self: rs.String | undefined, default_: rs.u8, f: (a0: rs.String) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/cows/expected/cows.Named.ts b/ts/fixtures/lang/cows/expected/cows.Named.ts index 666855c14..111a1e340 100644 --- a/ts/fixtures/lang/cows/expected/cows.Named.ts +++ b/ts/fixtures/lang/cows/expected/cows.Named.ts @@ -16,7 +16,7 @@ export function fmt$fmt_Debug(self: Named, f: rs.Formatter): rs.Result): rs.Result { if (r.ok) { - r = { ok: true, value: rs.strCowStr(r.value) }; - return { ok: true, value: r.value + "!" }; + r = { ok: true, value: rs.strCowIntoOwned(r.value) }; + rs.stringPush(r.value as rs.String, 33); + return r; } return r; } @@ -20,54 +21,55 @@ export function cow(s: string, owned: boolean): rs.StrCow { if (!owned) { return new rs.Borrowed(s); } - return s; + return rs.stringFrom(s); } export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let r!: rs.Result; - const s: string = text(data); + const s: rs.String = text(data); const owned: boolean = (kind & 128) !== 0; - const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").next()), ""); + const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, "/").next()), ""); const _14: rs.u8 = rs.u8Rem(kind, 6); if (_14 === 0) { - const c: rs.StrCow = cow(s, owned); + const c: rs.StrCow = cow(s.v, owned); rs.byteVecPush(out, rs.stringLen(rs.strCowStr(c)) & 0xff); rs.byteVecPush(out, rs.strCowStr(c).length === 0 ? 1 : 0); rs.byteVecPush(out, rs.iterCount(rs.strChars(rs.strCowStr(c))) & 0xff); put(out, rs.strCowStr(c)); put(out, rs.strCowStr(c)); put(out, rs.strCowStr(rs.strCowClone(c))); - put(out, rs.strCowStr(c)); - put(out, rs.strCowStr(c)); - put(out, rs.strCowStr("")); + put(out, rs.stringFrom(rs.strCowStr(c)).v); + put(out, rs.strCowIntoOwned(c).v); + put(out, rs.strCowStr(rs.stringNew())); put(out, rs.strCowStr(new rs.Borrowed("fallback"))); - put(out, rs.strCowStr(s)); - const shared: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s))); + put(out, rs.strCowIntoOwned(rs.stringClone(s)).v); + const shared: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s.v))); put(out, shared.value); - put(out, rs.strCowStr(option_unwrapOr$0jw3da9(option_map$1g811lq(rs.iterNth(rs.strSplit(s, "\\"), 1), (a0: string): rs.StrCow => { + put(out, rs.strCowStr(option_unwrapOr$0jw3da9(option_map$1g811lq(rs.iterNth(rs.strSplit(s.v, "\\"), 1), (a0: string): rs.StrCow => { return new rs.Borrowed(a0); }), new rs.Borrowed("fallback")))); - put(out, rs.strCowStr(cow(first, owned))); - put(out, first); + put(out, rs.strCowIntoOwned(cow(first, owned)).v); + put(out, rs.stringFrom(first).v); shared[Symbol.dispose](); } else if (_14 === 1) { - let c2: rs.StrCow = cow(s, owned); - c2 = rs.strCowStr(c2); - c2 = c2 + "!"; - c2 = rs.strCowStr(c2); - c2 = c2 + "?"; - c2 = c2 + "𐀀"; + let c2: rs.StrCow = cow(s.v, owned); + c2 = rs.strCowIntoOwned(c2); + rs.stringPush(c2 as rs.String, 33); + c2 = rs.strCowIntoOwned(c2); + const m: rs.String = c2 as rs.String; + rs.stringPush(m, 63); + rs.stringPush(m, 65536); put(out, rs.strCowStr(c2)); - put(out, s); - const v: rs.Vec = rs.vecFrom([cow(first, owned), cow(s, !owned)]); + put(out, s.v); + const v: rs.Vec = rs.vecFrom([cow(first, owned), cow(s.v, !owned)]); const at = rs.idx(v.items, 1); - v.items[at] = rs.strCowStr(v.items[at]); - v.items[at] = v.items[at] + "v"; + v.items[at] = rs.strCowIntoOwned(v.items[at]); + rs.stringPush(v.items[at] as rs.String, 118); for (const _124 of v.items) { put(out, rs.strCowStr(_124)); } - put(out, rs.strCowStr(c2)); - let joined: rs.StrCow = rs.strCowAdd(rs.strCowAdd(cow("", owned), new rs.Borrowed(first)), cow(s, !owned)); + put(out, rs.strCowIntoOwned(c2).v); + let joined: rs.StrCow = rs.strCowAdd(rs.strCowAdd(cow("", owned), new rs.Borrowed(first)), cow(s.v, !owned)); const _145: rs.StrCow = cow("", !owned); joined = rs.strCowAdd(joined, _145); joined = rs.strCowAdd(joined, new rs.Borrowed("+")); @@ -84,9 +86,9 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _156.error); } } else if (_14 === 2) { - const a: rs.StrCow = cow(s, owned); + const a: rs.StrCow = cow(s.v, owned); const b: rs.StrCow = cow(first, !owned); - const iter2: rs.Iter = rs.iterSlice([rs.strCowStr(a) === first, rs.strCowStr(a) === first, rs.strCowStr(a) === s, first === rs.strCowStr(a), s === rs.strCowStr(a), rs.strCowStr(a) === rs.strCowStr(b), rs.strCowStr(a) !== rs.strCowStr(b), rs.cowBy(rs.cmpStr)(a, b) < 0, rs.cowBy(rs.cmpStr)(a, b) >= 0, rs.cowBy(rs.cmpStr)(a, b) === 1]); + const iter2: rs.Iter = rs.iterSlice([rs.strCowStr(a) === first, rs.strCowStr(a) === first, rs.eqStr(rs.strCowStr(a), s), first === rs.strCowStr(a), rs.eqStr(s, rs.strCowStr(a)), rs.strCowStr(a) === rs.strCowStr(b), rs.strCowStr(a) !== rs.strCowStr(b), rs.cowBy(rs.cmpStr)(a, b) < 0, rs.cowBy(rs.cmpStr)(a, b) >= 0, rs.cowBy(rs.cmpStr)(a, b) === 1]); while (true) { const _205: boolean | rs.Done = iter2.next(); if (_205 === rs.DONE) { @@ -101,7 +103,7 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const m2: Named.Named = Named.clone$Clone(n); Named.tag(n, 120); const args2: rs.Fmt[] = [(f: rs.Formatter) => Named.fmt$fmt_Debug(n, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(m2, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1]]).v); rs.byteVecPush(out, Named.eq$cmp_PartialEq(n, m2) ? 1 : 0); rs.byteVecPush(out, Named.cmp$cmp_Ord(n, m2) > 0 ? 1 : 0); rs.byteVecPush(out, Named.partialCmp$cmp_PartialOrd(n, m2) === -1 ? 1 : 0); @@ -109,10 +111,10 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _270: Named.Named = Named.default$Default(); const _272: Named.Named = Named.new("", kind); const args4: rs.Fmt[] = [(f: rs.Formatter) => Named.fmt$fmt_Debug(_270, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(_272, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1]])); + put(out, rs.fmtFormat([args4[0], " ", args4[1]]).v); } else if (_14 === 4) { const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; - const iter3: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.strSplit(s, "/")); + const iter3: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.strSplit(s.v, "/")); while (true) { const _286: [rs.usize, string] | rs.Done = iter3.next(); if (_286 === rs.DONE) { @@ -131,9 +133,9 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, rs.strCowStr(_303[0])); rs.byteVecPush(out, _303[1]); } - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(counts, first), 255)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(counts, (first as unknown) as rs.StrCow), 255)); const names: rs.HashSet = rs.hashNew(rs.hashing(Named.hash$Hash_hash_DefaultHasher as (a0: Named.Named, a1: rs.Hasher) => undefined, Named.eq$cmp_PartialEq)) as rs.HashSet; - const iter5: rs.Iter = rs.strSplit(s, "/"); + const iter5: rs.Iter = rs.strSplit(s.v, "/"); while (true) { const _323: string | rs.Done = iter5.next(); if (_323 === rs.DONE) { @@ -146,12 +148,12 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _339: Named.Named = Named.new(first, 0); rs.byteVecPush(out, rs.hashContains(names, _339) ? 1 : 0); } else { - const c4: rs.StrCow = cow(s, owned); + const c4: rs.StrCow = cow(s.v, owned); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(c4)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(c4), f)]; - put(out, rs.fmtFormat(["[", args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args6[0]), "|", args6[1], "]"])); + put(out, rs.fmtFormat(["[", args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args6[0]), "|", args6[1], "]"]).v); const part2 = cow(first, owned); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.StrCow, f: rs.Formatter) => rs.fmtStr(rs.strCowStr(value), f))]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([args8[0]]).v); } } @@ -179,32 +181,33 @@ export function cloned$borrow_Cow_str(t: rs.StrCow): rs.StrCow { * held in collections and fields. */ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - let made2!: string; + let made2!: rs.String; let _184!: rs.StrCow; - const s: string = text(data); + const s: rs.String = text(data); const owned: boolean = (kind & 128) !== 0; - const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").next()), ""); - const rest: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").nextBack()), ""); + const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, "/").next()), ""); + const rest: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, "/").nextBack()), ""); const _21: rs.u8 = rs.u8Rem(kind, 3); if (_21 === 0) { - const c: rs.StrCow = cow(s, owned); + const c: rs.StrCow = cow(s.v, owned); const _27: rs.StrCow = rs.strCowClone(c); const _29: rs.StrCow = cloned$borrow_Cow_str(c); const _31: rs.StrCow = new rs.Borrowed(first); - const _32: rs.StrCow = s; - const _35: rs.StrCow = new rs.Borrowed(s); + const _32: rs.StrCow = rs.stringClone(s); + const _35: rs.StrCow = new rs.Borrowed(s.v); const _37: rs.StrCow = new rs.Borrowed(first); - const _38: rs.StrCow = ""; - const _39: rs.StrCow = rs.stringExtendChars("", rs.iterRev(rs.strChars(first))); + const _38: rs.StrCow = rs.stringNew(); + const _40: rs.Iter = rs.iterRev(rs.strChars(first)); + const _39: rs.StrCow = rs.stringExtendChars(rs.stringNew(), _40); const iterS: rs.StrCow[] = [_27, _29, _31, _32, _35, _37, _38, new rs.Borrowed("fallback"), _39]; for (const _45 of iterS) { rs.byteVecPush(out, borrows(_45)); put(out, rs.strCowStr(_45)); } let m: rs.StrCow = cow(first, owned); - m = rs.strCowStr(m); + m = rs.strCowIntoOwned(m); rs.byteVecPush(out, borrows(m)); - put(out, rs.strCowStr(cow(rest, owned))); + put(out, rs.strCowIntoOwned(cow(rest, owned)).v); const iter2: rs.Iter<[string, string]> = rs.iterSlice([["", rest] as [string, string], [first, ""] as [string, string], [first, rest] as [string, string], ["", ""] as [string, string]]); while (true) { const _74: [string, string] | rs.Done = iter2.next(); @@ -229,15 +232,15 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } } } else if (_21 === 1) { - let c2: rs.StrCow = cow(s, owned); + let c2: rs.StrCow = cow(s.v, owned); if (c2 instanceof rs.Borrowed) { put(out, (c2 as rs.Borrowed).slice); } else { rs.byteVecPush(out, 238); - put(out, c2 as string); + put(out, (c2 as rs.String).v); } if (!(c2 instanceof rs.Borrowed)) { - (c2 as string) = (c2 as string) + "!"; + rs.stringPush(c2 as rs.String, 33); } put(out, rs.strCowStr(c2)); const kept: rs.StrCow = rs.strCowClone(c2); @@ -245,13 +248,14 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void (c2 as rs.Borrowed).slice = first; } if (!(c2 instanceof rs.Borrowed)) { - const _137: string = rs.stringExtendChars("", rs.iterRev(rs.strChars(first))); - (c2 as string) = _137; + const _138: rs.Iter = rs.iterRev(rs.strChars(first)); + const _137: rs.String = rs.stringExtendChars(rs.stringNew(), _138); + (c2 as rs.String) = _137; } put(out, rs.strCowStr(c2)); put(out, rs.strCowStr(kept)); rs.byteVecPush(out, borrows(kept)); - let e: rs.StrCow = cow(s, !owned); + const e: rs.StrCow = cow(s.v, !owned); const kept2: rs.StrCow = rs.strCowClone(e); if (e instanceof rs.Borrowed) { const borrowed = e as rs.Borrowed; @@ -259,25 +263,26 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void put(out, borrowed.slice); borrowed.slice = first; } else { - const _162: rs.usize = option_mapOr$1je44uu(rs.iterToOption(rs.strChars(e as string).next()), 0, (a05: rs.char): rs.usize => { + const _162: rs.usize = option_mapOr$1je44uu(rs.iterToOption(rs.strChars((e as rs.String).v).next()), 0, (a05: rs.char): rs.usize => { return rs.charLenUtf8(a05); }); - (e as string) = rs.stringTruncate(e as string, _162); - (e as string) = (e as string) + "?"; + rs.stringTruncate(e as rs.String, _162); + rs.stringPush(e as rs.String, 63); } put(out, rs.strCowStr(e)); put(out, rs.strCowStr(kept2)); if (c2 instanceof rs.Borrowed) { made2 = rs.strToUppercase((c2 as rs.Borrowed).slice); } else { - made2 = c2 as string; + made2 = c2 as rs.String; } - put(out, made2); + put(out, made2.v); let d: rs.StrCow = cow(first, !owned); b18: { if (d instanceof rs.Borrowed) { if (!((d as rs.Borrowed).slice.length === 0)) { - _184 = rs.stringExtendChars("", rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1)); + const _190: rs.Iter = rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1); + _184 = rs.stringExtendChars(rs.stringNew(), _190); break b18; } } @@ -293,30 +298,30 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } } } else { - const parts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.strSplit(s, "/")), (_2: [rs.usize, string]): rs.StrCow => { + const parts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.strSplit(s.v, "/")), (_2: [rs.usize, string]): rs.StrCow => { return cow(_2[1], rs.usizeRem(_2[0], 2) === 1 === owned); }), "next", 12); for (const _216 of parts.items) { rs.byteVecPush(out, borrows(_216)); } - put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "+")); - put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "")); - const collected: string = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.iterRev(rs.iterSlice(parts.items)), (a0: rs.StrCow): rs.StrCow => { + put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "+").v); + put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "").v); + const collected: rs.String = rs.stringFromStrings(rs.iterMap(rs.iterRev(rs.iterSlice(parts.items)), (a0: rs.StrCow): rs.StrCow => { return rs.strCowClone(a0); - }), rs.strCowStr)); - let extended: string = rest; + })); + const extended: rs.String = rs.stringFrom(rest); const _244: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (a02: rs.StrCow): rs.StrCow => { return rs.strCowClone(a02); }); - extended = rs.stringExtend(extended, rs.iterMap(_244, rs.strCowStr)); + rs.stringExtend(extended, _244); const _251: rs.Iter<[rs.StrCow, rs.usize]> = rs.iterMap(rs.iterSlice(parts.items), (p: rs.StrCow): [rs.StrCow, rs.usize] => { return [rs.strCowClone(p), rs.stringLen(rs.strCowStr(p))] as [rs.StrCow, rs.usize]; }); - const _250: [string, rs.Vec] = rs.tupleExtend(["", new rs.Vec()] as [string, rs.Vec], _251, [rs.STRING_COW_PART, rs.vecPart(4)]); - const texts: string = _250[0]; + const _250: [rs.String, rs.Vec] = rs.tupleExtend([rs.stringNew(), new rs.Vec()] as [rs.String, rs.Vec], _251, [rs.STRING_COW_PART, rs.vecPart(4)]); + const texts: rs.String = _250[0]; const lens: rs.Vec = _250[1]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, collected), (f: rs.Formatter) => rs.fmtPad(f, extended), (f: rs.Formatter) => rs.fmtPad(f, texts), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, collected.v), (f: rs.Formatter) => rs.fmtPad(f, extended.v), (f: rs.Formatter) => rs.fmtPad(f, texts.v), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]]).v); const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; const iter5: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); while (true) { @@ -337,7 +342,7 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, borrows(_292[0])); rs.byteVecPush(out, _292[1]); } - const _301: [rs.StrCow, rs.u8] | undefined = rs.btreeGetKeyValue(counts, first); + const _301: [rs.StrCow, rs.u8] | undefined = rs.btreeGetKeyValue(counts, (first as unknown) as rs.StrCow); if (_301 !== undefined) { rs.byteVecPush(out, borrows(_301[0])); } @@ -363,10 +368,10 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeSet, _336, true, undefined, undefined, 12, true), [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rest } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]), borrows), "next"); const _347: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeIter(counts); - const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.cowBy(rs.same), true)) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(hashed, first), 255)); - rs.byteVecPush(out, rs.hashContains(hashed, rest) ? 1 : 0); - const both: rs.HashSet = rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.cowBy(rs.same), true)) as rs.HashSet; + const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.eqStr, true)) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(hashed, (first as unknown) as rs.StrCow), 255)); + rs.byteVecPush(out, rs.hashContains(hashed, (rest as unknown) as rs.StrCow) ? 1 : 0); + const both: rs.HashSet = rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.eqStr, true)) as rs.HashSet; const _361: rs.StrCow = cow(first, owned); rs.hashAdd(both, _361); const _366: rs.StrCow = cow(first, !owned); @@ -378,10 +383,10 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, borrows(named.name)); const o2: rs.StrCow | undefined = rs.iterNth(rs.vecIntoIter(parts), 1); rs.byteVecPush(out, option_mapOr$03q317x(o2, 2, borrows)); - rs.byteVecPush(out, option_mapOr$1nyk1yj(option_map$167hjon(o2, (a04: rs.StrCow): string => { - return rs.strCowStr(a04); - }), 0, (t: string): rs.u8 => { - return rs.stringLen(t) & 0xff; + rs.byteVecPush(out, option_mapOr$1fzqoua(option_map$0bka7d0(o2, (a04: rs.StrCow): rs.String => { + return rs.strCowIntoOwned(a04); + }), 0, (t: rs.String): rs.u8 => { + return t.len & 0xff; })); } } @@ -463,7 +468,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putWords(out, rs.cowSlice(c)); putWords(out, rs.cowSlice(rs.cowClone(c))); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(c)), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); putWords(out, rs.sliceFrom(rs.cowIntoOwned(c).items)); putWords(out, rs.cowSlice(new rs.Vec())); const iter: rs.Iter> = rs.iterSlice([new rs.Borrowed(half), rs.vecFrom(v.items.slice()), new rs.Borrowed(rs.sliceFrom(v.items)), new rs.Borrowed(rs.sliceFrom([3, 1, 4])), rs.iterToVec(rs.iterRev(rs.iterSlice(v.items)), undefined, 2, true)]); @@ -502,7 +507,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const before: Run.Run = Run.clone$Clone(run); Run.bump(run); const args4: rs.Fmt[] = [(f: rs.Formatter) => Run.fmt$fmt_Debug(run, f), (f: rs.Formatter) => Run.fmt$fmt_Debug(before, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1]])); + put(out, rs.fmtFormat([args4[0], " ", args4[1]]).v); putWords(out, half); putWords(out, rs.sliceFrom(rs.cowIntoOwned(c2).items)); } else if (_15 === 2) { @@ -642,7 +647,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(runs, _435) ? 1 : 0); const part4 = Run.default$Default(); const args6: rs.Fmt[] = [(f: rs.Formatter) => Run.fmt$fmt_Debug(part4, f)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([args6[0]]).v); } else { const log: rs.Cell = new rs.Cell(0); const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Tally.Tally => { @@ -728,7 +733,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteCowSlice(c), 0, rs.min(rs.byteCowSlice(c).length, 3))); const _35: rs.ByteCow = made(half, !owned); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(c)), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(_35)), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1]]).v); const _47: rs.ByteCow = made(half, !owned); const _44: boolean = rs.eqBytes(c, _47); const _49: boolean = rs.eqBytes(c, data); @@ -943,11 +948,12 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_167.length & 0xff, _167.data.length & 0xff)), undefined, true); } } else { - const _179: [string, string] = [text(left), text(right)]; - const to: string = _179[0]; - const from4: string = _179[1]; - let c5: rs.StrCow = cow(to, intoOwned); - c5 = rs.strCowClone(cow(from4, fromOwned)); + const _179: [rs.String, rs.String] = [text(left), text(right)]; + const to: rs.String = _179[0]; + const from4: rs.String = _179[1]; + let c5: rs.StrCow = cow(to.v, intoOwned); + const _188: rs.StrCow = cow(from4.v, fromOwned); + c5 = rs.strCowCloneFrom(c5, _188); put(out, rs.strCowStr(c5)); } } diff --git a/ts/fixtures/lang/cows/expected/harness.ts b/ts/fixtures/lang/cows/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/cows/expected/harness.ts +++ b/ts/fixtures/lang/cows/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/defaults/expected/defaults.Made.ts b/ts/fixtures/lang/defaults/expected/defaults.Made.ts index d85d379b0..5997e68ec 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.Made.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.Made.ts @@ -7,18 +7,18 @@ export function fmt$fmt_Debug(self: Made, f: rs.Formatter): rs.Result rs.u64Debug(self.n, f); const _7: string = "tag"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.tag, f); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.tag.v, f); return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A type of the crate's own, whose `Default` impl is no zero value. */ export interface Made { n: rs.u64; - tag: string; + tag: rs.String; } export function default$Default(): Made { - return { n: 3, tag: "made" }; + return { n: 3, tag: rs.stringFrom("made") }; } //# sourceMappingURL=defaults.Made.ts.map diff --git a/ts/fixtures/lang/defaults/expected/defaults.ts b/ts/fixtures/lang/defaults/expected/defaults.ts index e84e8f09b..269395d04 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.ts @@ -42,7 +42,7 @@ export function made$unit(): void { /** Each byte an operation, its value the operand; each puts what it read. */ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { - let s!: string; + let s!: rs.String; for (const op of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(op, 9); if (_10 === 0) { @@ -109,7 +109,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _142: rs.Arc | undefined = rs.weakUpgrade(live); const _140: boolean = _142 !== undefined; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_115, f), (f: rs.Formatter) => rs.usizeDisplay(_120, f), (f: rs.Formatter) => rs.fmtBool(_123, f), (f: rs.Formatter) => rs.fmtBool(_127, f), (f: rs.Formatter) => rs.fmtBool(_131, f), (f: rs.Formatter) => rs.fmtBool(_135, f), (f: rs.Formatter) => rs.fmtBool(_140, f)]; - const _111: string = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4], " ", args12[5], " ", args12[6]]); + const _111: rs.String = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4], " ", args12[5], " ", args12[6]]); rs.drop(_142); rs.drop(_137); rs.drop(_117); @@ -170,10 +170,10 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _218: rs.u64 = rs.u64Add(made2.n, op as rs.u64); const _224: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_218, f); const arg = made2.tag; - const args18: rs.Fmt[] = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + const args18: rs.Fmt[] = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg.v)]; s = rs.fmtFormat([args18[0], " ", args18[1]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); rs.byteVecPush(out, 10); } } diff --git a/ts/fixtures/lang/durations/expected/durations.ts b/ts/fixtures/lang/durations/expected/durations.ts index edc5ffa87..1ead0c93a 100644 --- a/ts/fixtures/lang/durations/expected/durations.ts +++ b/ts/fixtures/lang/durations/expected/durations.ts @@ -154,11 +154,11 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const c: rs.Duration = rs.durationNew(0, rs.durationSubsecNanos(b)); const d2: rs.Duration = rs.durationFromNanos(rs.u32Rem(n, 1000000) as rs.u64); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), (f: rs.Formatter) => rs.fmtOption(b, f, rs.durationDebug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args2[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args2[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", args2[3]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args2[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args2[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", args2[3]]).v); const p: rs.usize = rs.u32Rem(n, 13) as rs.usize; const _234: rs.Duration | undefined = b; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtOption(_234, f, rs.durationDebug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 3 }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[1]), "|", rs.fmtSpec({ precision: 12 }, args4[2]), "|", rs.fmtSpec({ plus: true }, args4[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args4[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[3]) }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 3 }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[1]), "|", rs.fmtSpec({ precision: 12 }, args4[2]), "|", rs.fmtSpec({ plus: true }, args4[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args4[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[3]) }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[4])]).v); const iter4: rs.Iter = rs.iterSlice([1500000000, 2500000000, 1250000, 1350000, 999500, 1999999999]); while (true) { const _250: rs.u64 | rs.Done = iter4.next(); @@ -167,7 +167,7 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } const part = rs.durationFromNanos(_250); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(part, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 2 }, args6[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 2 }, args6[0])]).v); } } else if (_24 === 10) { let c2: rs.Duration = a; @@ -236,7 +236,7 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Window.hash$Hash_hash_DefaultHasher as (a0: Window.Window, a1: rs.Hasher) => undefined, Window.eq$cmp_PartialEq)) as rs.HashSet, _398, undefined, undefined, 29360128)) & 0xff); const _413: Window.Window = Window.default$Default(); const args8: rs.Fmt[] = [(f: rs.Formatter) => Window.fmt$fmt_Debug(w2, f), (f: rs.Formatter) => Window.fmt$fmt_Debug(_413, f)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[1])])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[1])]).v); } } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Named.ts b/ts/fixtures/lang/dyns/expected/dyns.Named.ts index bce537b7b..0999b0c74 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Named.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Named.ts @@ -3,6 +3,6 @@ import * as rs from "./rs.ts"; export type Named = - | { label$Named: () => string; fmt$Debug: (a0: rs.Formatter) => rs.Result; area$Shape: () => rs.u32; grow$Shape: (a0: rs.u8) => void; sides$Shape: () => rs.u8; intoArea$Shape: () => rs.u32; larger$Shape: (a0: rs.u32) => rs.u32; tally$Shape: (a0: rs.Place) => void }; + | { label$Named: () => rs.String; fmt$Debug: (a0: rs.Formatter) => rs.Result; area$Shape: () => rs.u32; grow$Shape: (a0: rs.u8) => void; sides$Shape: () => rs.u8; intoArea$Shape: () => rs.u32; larger$Shape: (a0: rs.u32) => rs.u32; tally$Shape: (a0: rs.Place) => void }; //# sourceMappingURL=dyns.Named.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Over.ts b/ts/fixtures/lang/dyns/expected/dyns.Over.ts index bea23cc06..60a234260 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Over.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Over.ts @@ -20,12 +20,12 @@ export class Over { } } -export function run$String(self: Over): string | undefined { - const _3: string | undefined = self.source.take$Source(); +export function run$String(self: Over): rs.String | undefined { + const _3: rs.String | undefined = self.source.take$Source(); if (_3 !== undefined) { - const next: string = _3; - const other: string = self.scale.scale$Scaled(next); - return self.scale.pick$Scaled(next as rs.Ptr, other as rs.Ptr) as string; + const next: rs.String = _3; + const other: rs.String = self.scale.scale$Scaled(rs.stringClone(next)); + return rs.stringClone(self.scale.pick$Scaled(next as rs.Ptr, other as rs.Ptr) as rs.String); } return undefined; } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Square.ts b/ts/fixtures/lang/dyns/expected/dyns.Square.ts index 1b3ba7e19..3b1d83407 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Square.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Square.ts @@ -42,7 +42,7 @@ export function grow$dyns_Shape(self: Square, by: rs.u8): void { self.side = rs.u16WrappingAdd(self.side, by as rs.u16); } -export function label$dyns_Named(self: Square): string { +export function label$dyns_Named(self: Square): rs.String { const arg = self.side; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; return rs.fmtFormat(["square ", args2[0]]); diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts index 8c2104051..69d0b0f3c 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts @@ -56,7 +56,7 @@ export function intoArea$dyns_Shape(self: Tri): rs.u32 { return rs.u32WrappingMul(area$dyns_Shape(self), 2); } -export function label$dyns_Named(self: Tri): string { +export function label$dyns_Named(self: Tri): rs.String { const args2: rs.Fmt[] = [(f: rs.Formatter) => fmt$fmt_Debug(self, f)]; return rs.fmtFormat(["tri ", args2[0]]); } @@ -73,28 +73,27 @@ export function asAnyMut$dyns_Erased(self: rs.Place): Any.Any { * Provided, taking a function of a reference to the argument, which the trait's type * takes in each form a reference may be. */ -export function apply$dyns_Scaled_String(self: Tri, f: (a0: string) => string, x: string): string { +export function apply$dyns_Scaled_String(self: Tri, f: (a0: rs.String) => rs.String, x: rs.String): rs.String { return f(scale$dyns_Scaled_String(self, x)); } -export function scale$dyns_Scaled_String(self: Tri, by: string): string { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, by), (f: rs.Formatter) => fmt$fmt_Debug(self, f)]; +export function scale$dyns_Scaled_String(self: Tri, by: rs.String): rs.String { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, by.v), (f: rs.Formatter) => fmt$fmt_Debug(self, f)]; return rs.fmtFormat([args2[0], args2[1]]); } /** Writes through a `&mut` to the argument, an `rs.Place` for a number. */ -export function bump$dyns_Scaled_String(self: Tri, at: rs.Place): void { +export function bump$dyns_Scaled_String(self: Tri, at: rs.String): void { const _8: rs.u32 = area$dyns_Shape(self); - const _4: string = rs.fmtToString((f: rs.Formatter) => rs.u32Display(_8, f)); - at.v = at.v + _4; + rs.stringPushStr(at, rs.fmtToString((f: rs.Formatter) => rs.u32Display(_8, f), 0).v); } /** * Takes and returns references to the argument, which the trait's type has in each * form a reference may be. */ -export function pick$dyns_Scaled_String(_self: Tri, a: string, b: string): string { - if (!(rs.stringLen(a) >= rs.stringLen(b))) { +export function pick$dyns_Scaled_String(_self: Tri, a: rs.String, b: rs.String): rs.String { + if (!(a.len >= b.len)) { return b; } return a; diff --git a/ts/fixtures/lang/dyns/expected/dyns.ts b/ts/fixtures/lang/dyns/expected/dyns.ts index 191d003b3..c62f97bb8 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.ts @@ -120,17 +120,17 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o let n: rs.u32 = c as rs.u32; const part = total(rs.sliceFrom([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)])); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - put(out, rs.fmtFormat([args2[0], " "])); + put(out, rs.fmtFormat([args2[0], " "]).v); growTwice(new of$dyns_Square(sq), b); growTwice(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), c); growTwice(new ofPlace$u32(rs.place(() => n, (value2) => n = value2)), a); const arg = sq.side; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(tri, f), (f: rs.Formatter) => rs.u32Display(n, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "])); + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]).v); const _78: rs.u8 = sidesOf$dyn_dyns_Shape(new of$dyns_Tri(tri)); const _82: rs.u8 = sidesOf$dyns_Square(sq); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_78, f), (f: rs.Formatter) => rs.u8Display(_82, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + put(out, rs.fmtFormat([args6[0], " ", args6[1], " "]).v); const shapes: rs.Vec = new rs.Vec(); const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 3, dataLen - 3)))); while (true) { @@ -153,11 +153,11 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o if (rs.usizeRem(i2, 2) === 0) { s.v.grow$Shape(a); } - const _129: string = s.v.label$Named(); + const _129: rs.String = s.v.label$Named(); const _132: rs.u32 = s.v.area$Shape(); const _135: rs.u8 = sidesOf$dyn_dyns_Shape(upcast(s.v)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; - put(out, rs.fmtFormat([args8[0], ":", args8[1], ":", args8[2], ":", args8[3], " "])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129.v), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; + put(out, rs.fmtFormat([args8[0], ":", args8[1], ":", args8[2], ":", args8[3], " "]).v); } let sum: rs.u32 = 0; for (const _150 of shapes.items) { @@ -169,42 +169,42 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o const _169: rs.u32 = shapes.items[at2].larger$Shape(b as rs.u32); const _175: rs.u32 = sum; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_175, f), (f: rs.Formatter) => Shown.fmt$fmt_Debug(_165, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "]).v); for (const s2 of shapes.items) { sum = rs.u32WrappingAdd(sum, s2.intoArea$Shape()); } const _203: rs.u32 = new of$u32(n).intoArea$Shape(); const _204: rs.u32 = sum; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_204, f), (f: rs.Formatter) => rs.u32Display(_203, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + put(out, rs.fmtFormat([args12[0], " ", args12[1]]).v); } } -export function counts$dyn_dyns_Named(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyn_dyns_Named(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } -export function counts$dyn_dyns_Shape(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyn_dyns_Shape(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } -export function counts$dyns_Hits(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyns_Hits(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } -export function counts$dyns_Square(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyns_Square(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } @@ -218,14 +218,14 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const shape: rs.Arc = rs.arcClone(named); const up: rs.Arc = rs.arcClone(again); const part = counts$dyns_Square(rs.sliceFrom([sq])); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args2[0], " "])); - const _49: string = named.value.label$Named(); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part.v)]; + put(out, rs.fmtFormat([args2[0], " "]).v); + const _49: rs.String = named.value.label$Named(); const _53: rs.u32 = shape.value.area$Shape(); const _57: rs.u8 = sidesOf$dyn_dyns_Shape(up.value); const _62: Named.Named = named.value; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _49), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _49.v), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "]).v); const _73: [rs.Weak, rs.Weak] = [new rs.Weak(shape), new rs.Weak(up)]; const weak: rs.Weak = _73[0]; const other: rs.Weak = _73[1]; @@ -233,13 +233,13 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const _90: boolean = rs.arcPtrEq(shape, up); const _94: boolean = rs.arcPtrEq(weak.arc, other.arc); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_86, f), (f: rs.Formatter) => rs.fmtBool(_90, f), (f: rs.Formatter) => rs.fmtBool(_94, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "])); + put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "]).v); sq[Symbol.dispose](); named[Symbol.dispose](); - const _113: string = counts$dyn_dyns_Named(rs.sliceFrom([again])); + const _113: rs.String = counts$dyn_dyns_Named(rs.sliceFrom([again])); const _119: rs.usize = weak.arc.strong; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _113), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " "])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _113.v), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1], " "]).v); const upgraded: rs.u32 | undefined = option_map$1mach0o(rs.weakUpgrade(weak), (s: rs.Arc): rs.u32 => { const _0: rs.u32 = s.value.area$Shape(); s[Symbol.dispose](); @@ -247,24 +247,24 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, }); again[Symbol.dispose](); const part2 = counts$dyn_dyns_Shape(rs.sliceFrom([up])); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2)]; - put(out, rs.fmtFormat([args10[0], " "])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2.v)]; + put(out, rs.fmtFormat([args10[0], " "]).v); up[Symbol.dispose](); - const _156: string = counts$dyn_dyns_Shape(rs.sliceFrom([shape])); + const _156: rs.String = counts$dyn_dyns_Shape(rs.sliceFrom([shape])); const _164: rs.Arc | undefined = rs.weakUpgrade(weak); const _162: boolean = _164 !== undefined; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _156), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; - const _152: string = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _156.v), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; + const _152: rs.String = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]); rs.drop(_164); - put(out, _152); + put(out, _152.v); shape[Symbol.dispose](); const _184: rs.Arc | undefined = rs.weakUpgrade(weak); const _182: boolean = _184 === undefined; const _187: rs.usize = other.arc.strong; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_182, f), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; - const _178: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const _178: rs.String = rs.fmtFormat([args14[0], " ", args14[1], " "]); rs.drop(_184); - put(out, _178); + put(out, _178.v); const hits: rs.Arc = new rs.Arc({ _0: new rs.Atomic(dataData[dataStart + 1] as rs.u32) }); const objects: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (_2: rs.i32): rs.Arc => { const _34: rs.Arc = rs.arcClone(hits); @@ -274,13 +274,13 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, return rs.u32WrappingAdd(sum2, s2.value.area$Shape()); }); const _216: rs.u32 = rs.atomicLoad(hits.value._0, 0); - const _222: string = counts$dyns_Hits(rs.sliceFrom([hits])); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "])); + const _222: rs.String = counts$dyns_Hits(rs.sliceFrom([hits])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222.v)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "]).v); rs.dropVec(objects); const part3 = counts$dyns_Hits(rs.sliceFrom([hits])); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3)]; - put(out, rs.fmtFormat([args18[0], " "])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3.v)]; + put(out, rs.fmtFormat([args18[0], " "]).v); const _253: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); const n: rs.Arc = new rs.ArcDyn(_253, new of$u32(_253.value)); const _257: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); @@ -288,7 +288,7 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const _268: rs.u32 = n.value.area$Shape(); const _272: boolean = rs.arcPtrEq(n, m); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_268, f), (f: rs.Formatter) => rs.fmtBool(_272, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + put(out, rs.fmtFormat([args20[0], " ", args20[1], " "]).v); const tris: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_23: rs.u8): rs.Arc => { const x: rs.u8 = _23; const _43: rs.u8 = rs.u8Rem(x, 3); @@ -307,20 +307,20 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, return rs.arcClone(a0); }), undefined, 8, true); for (const _292 of tris.items) { - const _304: string = _292.value.label$Named(); + const _304: rs.String = _292.value.label$Named(); const _307: rs.u32 = _292.value.area$Shape(); const _310: rs.usize = _292.strong; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _304), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; - put(out, rs.fmtFormat([args22[0], ":", args22[1], ":", args22[2], " "])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _304.v), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; + put(out, rs.fmtFormat([args22[0], ":", args22[1], ":", args22[2], " "]).v); } rs.dropVec(tris); let total: rs.u32 = 0; for (const _322 of kept.items) { _322.value.tally$Shape(rs.place(() => total, (value) => total = value)); } - const _337: string = counts$dyn_dyns_Named(rs.sliceFrom(rs.iterToVec(rs.iterSlice(kept.items), undefined, 4, true).items)); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1]])); + const _337: rs.String = counts$dyn_dyns_Named(rs.sliceFrom(rs.iterToVec(rs.iterSlice(kept.items), undefined, 4, true).items)); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337.v)]; + put(out, rs.fmtFormat([args24[0], " ", args24[1]]).v); rs.dropVec(kept); m[Symbol.dispose](); n[Symbol.dispose](); @@ -343,7 +343,7 @@ export function key$dyns_Keyed_u32(self: rs.u32): rs.u32 { } /** What `a` holds, by the type it downcasts to. */ -export function kind(a: Any.Any): string { +export function kind(a: Any.Any): rs.String { const _2: Square.Square | undefined = a instanceof of$dyns_Square ? a.v : undefined; if (_2 !== undefined) { const arg = _2.side; @@ -361,9 +361,9 @@ export function kind(a: Any.Any): string { return rs.fmtFormat(["tri ", args6[0]]); } if (!(a instanceof of$u8 || a instanceof ofPlace$u8)) { - return "other"; + return rs.stringFrom("other"); } - return "u8"; + return rs.stringFrom("u8"); } /** Bumps the number or enum `a` holds where it is. */ @@ -419,8 +419,8 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o break; } const part = kind(_33); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args2[0], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part.v)]; + put(out, rs.fmtFormat([args2[0], " "]).v); } const _51: boolean = bump(new of$dyns_Square(sq), a); const _54: boolean = bump(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), b); @@ -430,7 +430,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _72: Tri.Tri = tri; const arg = sq.side; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_72, f), (f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(hit[0], f), (f: rs.Formatter) => rs.fmtBool(hit[1], f), (f: rs.Formatter) => rs.fmtBool(hit[2], f), (f: rs.Formatter) => rs.fmtBool(hit[3], f)], f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "]).v); const iter2: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)]); while (true) { const _91: dyns_Erased.Erased | rs.Done = iter2.next(); @@ -439,9 +439,9 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const _103: boolean = isA$dyns_Square(_91); const _105: boolean = isA$u32(_91); - const _107: string = kind(_91.asAny$Erased()); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107)]; - put(out, rs.fmtFormat([args6[0], args6[1], args6[2], " "])); + const _107: rs.String = kind(_91.asAny$Erased()); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107.v)]; + put(out, rs.fmtFormat([args6[0], args6[1], args6[2], " "]).v); } let m: rs.u32 = a as rs.u32; const _119: Any.Any = new ofPlace$u32(rs.place(() => m, (value4) => m = value4)).asAnyMut$Erased(); @@ -450,11 +450,11 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o _118.v = rs.u32WrappingMul(_118.v, 3); } const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(m, f)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([args8[0], " "]).v); const unit: Any.Any = new of$unit(undefined); const part2 = [unit instanceof of$unit ? unit.v : unit instanceof ofPlace$unit ? unit.v.v : rs.None, unit instanceof of$Option_u8 || unit instanceof ofPlace$Option_u8] as [undefined | rs.None, boolean]; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part2[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtBool(part2[1], f)], f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([args10[0], " "]).v); let some: rs.u8 | undefined = a; let none: rs.u8 | undefined = undefined; const iter3: rs.Iter = rs.iterSlice([new ofPlace$Option_u8(rs.place(() => some, (value5) => some = value5)), new ofPlace$Option_u8(rs.place(() => none, (value6) => none = value6)), new ofPlace$u32(rs.place(() => n, (value7) => n = value7))]); @@ -465,7 +465,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const part3 = [_167 instanceof of$unit ? _167.v : _167 instanceof ofPlace$unit ? _167.v.v : rs.None, _167 instanceof of$Option_u8 ? _167.v : _167 instanceof ofPlace$Option_u8 ? _167.v.v : rs.None] as [undefined | rs.None, rs.u8 | undefined | rs.None]; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part3[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(part3[1], f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)], f)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([args12[0]]).v); const _189: rs.Place | undefined = _167 instanceof of$Option_u8 ? _167 : _167 instanceof ofPlace$Option_u8 ? _167.v : undefined; if (_189 !== undefined) { _189.v = option_mapOr$19a4gco(_189.v, b, (_2: rs.u8): rs.u8 | undefined => { @@ -474,10 +474,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const arg2 = (_167 instanceof of$unit ? _167 : _167 instanceof ofPlace$unit ? _167.v : undefined) !== undefined; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg2, f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([args14[0], " "]).v); } const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(some, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " "])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " "]).v); const boxes: rs.Vec = new rs.Vec(); const iter4: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2)))); while (true) { @@ -512,19 +512,19 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o if (_261.ok) { const part5 = _261.value; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - put(out, rs.fmtFormat(["n", args18[0], " "])); + put(out, rs.fmtFormat(["n", args18[0], " "]).v); } else if (!(rs.usizeRem(i2, 2) === 0)) { const other2: Any.Any = _261.error; const _282: rs.Result = other2 instanceof of$u8 ? rs.Ok(other2.v) : rs.Err(other2); if (_282.ok) { const arg3 = _282.value; const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg3, f)]; - put(out, rs.fmtFormat(["u8 ", args20[0], " "])); + put(out, rs.fmtFormat(["u8 ", args20[0], " "]).v); } else { const other3: Any.Any = _282.error; const part4 = kind(other3); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; - put(out, rs.fmtFormat([args22[0], " "])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4.v)]; + put(out, rs.fmtFormat([args22[0], " "]).v); rs.drop(other3); } } else { @@ -538,10 +538,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o if (_316 === rs.DONE) { break; } - const _328: string = kind(_316.v); + const _328: rs.String = kind(_316.v); const _331: boolean = bump(_316.v, a); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _328), (f: rs.Formatter) => rs.fmtBool(_331, f)]; - put(out, rs.fmtFormat([args24[0], ":", args24[1], " "])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _328.v), (f: rs.Formatter) => rs.fmtBool(_331, f)]; + put(out, rs.fmtFormat([args24[0], ":", args24[1], " "]).v); } const _339: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([a, b] as [rs.u8, rs.u8]); const hold: rs.Arc = new rs.ArcDyn(_339, new of$tuple2_u8_u8(_339.value)); @@ -550,11 +550,11 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _354: rs.usize = hold.strong; const _357: [rs.u8, rs.u8] | undefined = _358 instanceof of$tuple2_u8_u8 ? _358.v : undefined; const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_354, f), (f: rs.Formatter) => rs.fmtOption(_357, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " "])); + put(out, rs.fmtFormat([args26[0], " ", args26[1], " "]).v); rs.dropAll(held); const part6 = hold.strong; const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; - put(out, rs.fmtFormat([args28[0], " "])); + put(out, rs.fmtFormat([args28[0], " "]).v); const _381: rs.Result, rs.Arc> = rs.arcDowncast(hold, of$u8, (object) => object.v); if (_381.ok) { rs.panic("internal error: entered unreachable code"); @@ -565,7 +565,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o return _02; })); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([args30[0], " "]).v); let n3: rs.u32 = a as rs.u32; const iter7: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$u32(n3)]); while (true) { @@ -575,21 +575,21 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const any: Any.Any = _407; const _420: rs.u32 = _407.key$Keyed(); - const _422: string = kind(any); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422)]; - put(out, rs.fmtFormat([args32[0], args32[1], " "])); + const _422: rs.String = kind(any); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422.v)]; + put(out, rs.fmtFormat([args32[0], args32[1], " "]).v); } const part8 = bump(new ofPlace$u32(rs.place(() => n3, (value8) => n3 = value8)), b); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; - put(out, rs.fmtFormat([args34[0], " "])); + put(out, rs.fmtFormat([args34[0], " "]).v); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([args36[0], " "]).v); const any3: Any.Any = new of$dyns_Square({ side: b as rs.u16 }); const part9 = ok$1wwd922(result_map$0tx2z7o(any3 instanceof of$dyns_Square ? rs.Ok(any3.v) : rs.Err(any3), (sq2: Square.Square): rs.u16 => { return sq2.side; })); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args38[0], " "])); + put(out, rs.fmtFormat([args38[0], " "]).v); const _477: rs.Arc = new rs.Arc(n3); const shared: rs.Arc = new rs.ArcDyn(_477, new of$u32(_477.value)); const weak2: rs.Weak = new rs.Weak(shared); @@ -603,7 +603,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o }); const _495: rs.u32 | undefined = _496 instanceof of$u32 ? _496.v : _496 instanceof ofPlace$u32 ? _496.v.v : undefined; const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_491, f), (f: rs.Formatter) => rs.fmtOption(_495, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); + put(out, rs.fmtFormat([args40[0], " ", args40[1], " "]).v); const typed2: [rs.usize, rs.u32] | undefined = ok$0y6a1w6(result_map$0njbm3o(rs.arcDowncast(any4, of$u32, (object) => object.v), (n4: rs.Arc): [rs.usize, rs.u32] => { const _05: [rs.usize, rs.u32] = [n4.strong, n4.value]; n4[Symbol.dispose](); @@ -612,9 +612,9 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _516: rs.Arc | undefined = rs.weakUpgrade(weak2); const _514: boolean = _516 !== undefined; const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(typed2, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_514, f)]; - const _510: string = rs.fmtFormat([args42[0], " ", args42[1]]); + const _510: rs.String = rs.fmtFormat([args42[0], " ", args42[1]]); rs.drop(_516); - put(out, _510); + put(out, _510.v); weak2[Symbol.dispose](); rs.dropVec(kept); } @@ -669,12 +669,12 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const _31: rs.u8 = twice(halve, a); const _35: rs.u8 = twice(ptr, a); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_27, f), (f: rs.Formatter) => rs.u8Display(_31, f), (f: rs.Formatter) => rs.u8Display(_35, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]).v); const part = firstWord((s: string): string => { return option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, " ").next()), ""); }, "ab cd"); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - put(out, rs.fmtFormat([args4[0], " "])); + put(out, rs.fmtFormat([args4[0], " "]).v); let sum: rs.u32 = 0; const seen: rs.ByteVec = new rs.ByteVec(); bumpAll((x2: rs.u8): undefined => { @@ -682,7 +682,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(seen, x2); }, rs.byteSliceRange(data, 2)); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + put(out, rs.fmtFormat([args6[0], " ", args6[1], " "]).v); const fs: rs.Vec<(a0: rs.u8) => rs.u8> = rs.vecFrom([adder(a), halve, mul, ptr]); const captured = a; const _94: (a0: rs.u8) => rs.u8 = (x3: rs.u8): rs.u8 => { @@ -706,7 +706,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const y: rs.u8 = _115[1](option_unwrapOr$1fr498u(rs.byteSliceGet(rs.byteSliceRange(data, 2), i), b)); const _133: rs.u32 = hook.f(y); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(y, f), (f: rs.Formatter) => rs.u32Display(_133, f)]; - put(out, rs.fmtFormat([args8[0], ":", args8[1], " "])); + put(out, rs.fmtFormat([args8[0], ":", args8[1], " "]).v); } const _142: (a0: rs.u8) => rs.u32 = (x5: rs.u8): rs.u32 => { return x5 as rs.u32; @@ -715,7 +715,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { hook.f = _142; const part4 = hook.f(a); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([args10[0], " "]).v); const captured3 = rs.byteVecFrom(Uint8Array.of(a)); const part6 = ((x6: rs.u8): rs.ByteVec => { const list2: rs.ByteVec = captured3; @@ -723,10 +723,10 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { return list2; })(b); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part6), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([args12[0], " "]).v); const part7 = rs.once(rs.optionUnwrap(rs.vecPop(fs)))(a); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part7, f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([args14[0], " "]).v); const captured4 = b; const _196: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x7: rs.u8): rs.u8 => { return x7 ^ captured4; @@ -737,7 +737,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const _213: rs.u8 = other.value(b); const _218: rs.usize = other.strong; const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_208, f), (f: rs.Formatter) => rs.u8Display(_213, f), (f: rs.Formatter) => rs.usizeDisplay(_218, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2]])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2]]).v); other[Symbol.dispose](); shared[Symbol.dispose](); hook[Symbol.dispose](); @@ -757,7 +757,7 @@ export function dropped(out: rs.ByteVec): void { return rs.replaceIn(d, new rs.ByteVec()); }); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " "])); + put(out, rs.fmtFormat([args2[0], " "]).v); } /** Each of the vtable's methods, then std's adaptors over the borrow, then by value. */ @@ -770,7 +770,7 @@ export function read(it: rs.Iter, out: rs.ByteVec): void { return a0 as rs.u32; }), rs.u32Add, 0); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0], f), (f: rs.Formatter) => rs.fmtOption(hint[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Display(rest, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "]).v); } /** @@ -793,7 +793,7 @@ export function scan$dyns_iters_closure1(map: rs.BTreeMap, from: } /** The length on either side of an item, and an upcast that reads the rest. */ -export function lens(it: rs.Iter): string { +export function lens(it: rs.Iter): rs.String { const before: rs.usize = rs.iterBorrow(it).len(); const first: rs.u8 | undefined = rs.iterToOption(it.next()); const after: rs.usize = rs.iterBorrow(it).len(); @@ -831,10 +831,10 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return thenSome$0quywni(rs.u8Rem(v2, 2) === 1, v2); }); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_44, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " "])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " "]).v); const part = lens(rs.iterDyn(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2)))))); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args4[0], " "])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part.v)]; + put(out, rs.fmtFormat([args4[0], " "]).v); const _79: rs.usize = rs.usizeRem(a as rs.usize, rs.usizeAdd(rs.byteSliceRange(data, 2).length, 1)); const slice: rs.ByteSlice = rs.byteSliceRange(data, 2); if (_79 > slice.length) { @@ -859,7 +859,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(ends[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtOption(nth, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + put(out, rs.fmtFormat([args6[0], " ", args6[1], " "]).v); rs.drop(boxed); dropped(out); const last: rs.u8 | undefined = option_map$11l9b8r(rs.ownedLast(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(front), rs.drop), rs.vecIntoIter(tagged(back), rs.drop)))), rs.drop), (t4: Tagged.Tagged): rs.u8 => { @@ -869,10 +869,10 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([args8[0], " "]).v); const part2 = rs.ownedCount(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(back), rs.drop), rs.vecIntoIter(tagged(front), rs.drop)))), rs.drop); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([args10[0], " "]).v); dropped(out); const own: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 16)), Countdown.next$iter_Iterator, rs.drop)); let sum: rs.u32 = 0; @@ -886,7 +886,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.drop(iter); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([args12[0], " "]).v); dropped(out); const nested: rs.Iter = rs.iterDyn(rs.iterBox(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop))); const inner: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(b, 8)); @@ -903,7 +903,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _235: rs.usize = rs.ownedCount(rs.iterBox(erased)); const _238: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(doubled, Countdown.next$iter_Iterator, rs.drop))); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_233), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(fourth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(mapped), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_235, f), (f: rs.Formatter) => rs.usizeDisplay(_238, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4], " ", args14[5], " ", args14[6], " ", args14[7], " "])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4], " ", args14[5], " ", args14[6], " ", args14[7], " "]).v); dropped(out); inner[Symbol.dispose](); dropped(out); @@ -920,7 +920,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const sixth: rs.u8 | undefined = rs.iterToOption(Countdown.next$iter_Iterator(layered.v.v)); const _301: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(held, Countdown.next$iter_Iterator, rs.drop))); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(hints, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), (f: rs.Formatter) => rs.fmtOption(fifth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(sixth, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_301, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3], " "])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3], " "]).v); dropped(out); own2[Symbol.dispose](); dropped(out); @@ -937,28 +937,28 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const lent3: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterBorrow(rs.iterBox(rs.iterBorrow(zipped()))), "next", 2); const _339: rs.RefCell = rs.refCellBorrow(seen2); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(owned.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(lent3.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_339.value), f, rs.u8Debug)]; - const _335: string = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); + const _335: rs.String = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); rs.refRelease(_339); - put(out, _335); + put(out, _335.v); const split: Chunks.Chunks = new of$dyns_Lease({ _0: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)), _1: rs.usizeAdd(rs.u8Rem(b, 4) as rs.usize, 1) }); const lens_: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterBox(split.chunks$Chunks()), (a0: rs.ByteSlice): rs.usize => { return a0.length; }), "next", 4); const _369: rs.usize = rs.ownedCount(rs.iterBox(split.chunks$Chunks())); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lens_.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_369, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + put(out, rs.fmtFormat([args20[0], " ", args20[1], " "]).v); const part3 = drain(rs.iterDyn(rs.iterBorrow(rs.iterFuse(rs.iterFrom({ _0: rs.u8Rem(a, 4) }, Resuming.next$iter_Iterator))))); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3)]; - put(out, rs.fmtFormat([args22[0], " "])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3.v)]; + put(out, rs.fmtFormat([args22[0], " "]).v); const resuming: Resuming.Resuming = { _0: rs.u8Rem(b, 4) }; const up: rs.Iter = rs.iterDyn(rs.iterFrom(resuming, Resuming.next$iter_Iterator)); const part4 = [rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next())] as [rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined]; const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[2], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[3], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[4], f, rs.u8Debug)], f)]; - put(out, rs.fmtFormat([args24[0], " "])); + put(out, rs.fmtFormat([args24[0], " "]).v); const boxed3: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop)); const part5 = drain(boxed3); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5)]; - put(out, rs.fmtFormat([args26[0], " "])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5.v)]; + put(out, rs.fmtFormat([args26[0], " "]).v); rs.drop(boxed3); dropped(out); const concrete: rs.Arc> = new rs.Arc(rs.vecIntoIter(tagged(front), rs.drop)); @@ -968,7 +968,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _456: [rs.usize, rs.usize | undefined] = other.value.sizeHint(); const _460: boolean = rs.arcGetMut(shared) === undefined; const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_456[0], f), (f: rs.Formatter) => rs.fmtOption(_456[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_460, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "]).v); other[Symbol.dispose](); weak[Symbol.dispose](); const taken: rs.u8 | undefined = option_map$11l9b8r(option_andThen$1xlvufy(rs.arcGetMut(shared), (it2: rs.Iter): Tagged.Tagged | undefined => { @@ -980,7 +980,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(taken, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([args30[0], " "]).v); shared[Symbol.dispose](); dropped(out); const _492: rs.Arc> = new rs.Arc(rs.byteVecIntoIter(rs.byteSliceToByteVec(back))); @@ -991,20 +991,20 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.iterToOption(it3.next()); }); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_506, f), (f: rs.Formatter) => rs.fmtOption(_510, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1], " "])); + put(out, rs.fmtFormat([args32[0], " ", args32[1], " "]).v); exact[Symbol.dispose](); const next: rs.u8 | undefined = option_andThen$0imujmv(rs.arcGetMut(up2), (it4: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it4.next()); }); const _530: [rs.usize, rs.usize | undefined] = up2.value.sizeHint(); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_530[0], f), (f: rs.Formatter) => rs.fmtOption(_530[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args34[0], " ", args34[1], " "])); + put(out, rs.fmtFormat([args34[0], " ", args34[1], " "]).v); const fromBox: rs.Arc> = new rs.Arc(rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop))); const part6 = option_andThen$0imujmv(rs.arcGetMut(fromBox), (it5: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it5.next()); }); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([args36[0], " "]).v); fromBox[Symbol.dispose](); dropped(out); const counted2: rs.Arc = new rs.Arc(new Countdown.Countdown(rs.u8Rem(a, 8))); @@ -1017,19 +1017,19 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return _018; }); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f))]; - put(out, rs.fmtFormat([args38[0], " "])); + put(out, rs.fmtFormat([args38[0], " "]).v); counted2[Symbol.dispose](); const _596: rs.Arc> | undefined = rs.weakUpgrade(weak3); const part8 = _596 === undefined; const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; - const _590: string = rs.fmtFormat([args40[0], " "]); + const _590: rs.String = rs.fmtFormat([args40[0], " "]); rs.drop(_596); - put(out, _590); + put(out, _590.v); dropped(out); const pinned: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop)); const part9 = rs.iterToOption(pinned.next()); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([args42[0]]).v); rs.drop(pinned); dropped(out); weak3[Symbol.dispose](); @@ -1038,7 +1038,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { } /** What `it` yields up to its end and twice past it. */ -export function drain(it: rs.Iter): string { +export function drain(it: rs.Iter): rs.String { const items: rs.ByteVec = rs.iterToByteVec(rs.iterBorrow(it), "next"); const _7: rs.u8 | undefined = rs.iterToOption(it.next()); const _9: rs.u8 | undefined = rs.iterToOption(it.next()); @@ -1064,14 +1064,14 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const named: rs.Arc = new rs.ArcDyn(_19, new of$dyns_Square(_19.value)); const shape: rs.Arc = rs.arcClone(named); const other: rs.Weak = new rs.Weak(shape); - const _34: string = named.value.label$Named(); + const _34: rs.String = named.value.label$Named(); const _38: rs.u32 = shape.value.area$Shape(); const _42: rs.usize = sq.strong; const _45: rs.usize = weak2.arc.strong; const _48: rs.usize = rs.weakWeakCount(weak2); const _51: boolean = rs.arcPtrEq(weak2.arc, other.arc); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _34), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _34.v), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " "]).v); const again: rs.Weak = rs.weakClone(weak2); sq[Symbol.dispose](); named[Symbol.dispose](); @@ -1082,7 +1082,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe }); const _79: rs.usize = shape.strong; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_75, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " "])); + put(out, rs.fmtFormat([args4[0], " ", args4[1], " "]).v); shape[Symbol.dispose](); const _97: rs.Arc | undefined = rs.weakUpgrade(weak2); const _95: boolean = _97 === undefined; @@ -1090,10 +1090,10 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _100: boolean = _102 === undefined; const _105: rs.usize = weak2.arc.strong; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtBool(_100, f), (f: rs.Formatter) => rs.usizeDisplay(_105, f)]; - const _91: string = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "]); + const _91: rs.String = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "]); rs.drop(_102); rs.drop(_97); - put(out, _91); + put(out, _91.v); const noisy: rs.Arc = new rs.Arc(new Noisy.Noisy(dataData[dataStart + 1], rs.arcClone(log))); const weak4: rs.Weak = rs.weakDyn(new rs.Weak(noisy), (arc2: rs.Arc): rs.Arc => { return new rs.ArcDyn(arc2, new of$dyns_Noisy(arc2.value)); @@ -1104,16 +1104,16 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe return _02; }); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([args8[0], " "]).v); noisy[Symbol.dispose](); const _147: rs.Arc | undefined = rs.weakUpgrade(weak4); const _145: boolean = _147 === undefined; const _150: rs.RefCell = rs.refCellBorrow(log.value); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_145, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_150.value), f, rs.u8Debug)]; - const _141: string = rs.fmtFormat([args10[0], " ", args10[1], " "]); + const _141: rs.String = rs.fmtFormat([args10[0], " ", args10[1], " "]); rs.refRelease(_150); rs.drop(_147); - put(out, _141); + put(out, _141.v); const looped: rs.Arc = rs.arcNewCyclic((me: rs.Weak): Looped.Looped => { return new Looped.Looped(dataData[dataStart], rs.weakDyn(rs.weakClone(me), (arc3: rs.Arc): rs.Arc => { return new rs.ArcDyn(arc3, new of$dyns_Looped(arc3.value)); @@ -1127,7 +1127,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _174: rs.usize = looped.strong; const _177: rs.usize = looped.weak; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_168, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_174, f), (f: rs.Formatter) => rs.usizeDisplay(_177, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "])); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]).v); const pinned: Shape.Shape = new of$dyns_Noisy(new Noisy.Noisy(rs.u8WrappingAdd(dataData[dataStart], 1), rs.arcClone(log))); let n: rs.u32 = dataData[dataStart + 1] as rs.u32; const borrowed2: Shape.Shape = new ofPlace$u32(rs.place(() => n, (value) => n = value)); @@ -1135,13 +1135,13 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _209: rs.u8 = pinned.sides$Shape(); const _213: rs.u32 = borrowed2.area$Shape(); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_205, f), (f: rs.Formatter) => rs.u8Display(_209, f), (f: rs.Formatter) => rs.u32Display(_213, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "]).v); rs.drop(pinned); const _230: rs.RefCell = rs.refCellBorrow(log.value); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_230.value), f, rs.u8Debug)]; - const _226: string = rs.fmtFormat([args16[0], " "]); + const _226: rs.String = rs.fmtFormat([args16[0], " "]); rs.refRelease(_230); - put(out, _226); + put(out, _226.v); const boxes: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): Shape.Shape => { const x2: rs.u8 = _2; const _43: rs.u8 = rs.u8Rem(x2, 3); @@ -1181,28 +1181,28 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe return s5.value.area$Shape(); })), undefined, 4, true); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args18[0], " "])); + put(out, rs.fmtFormat([args18[0], " "]).v); const _291: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_291.value); rs.refMutRelease(_291); rs.dropVec(arcs); const _304: rs.RefCell = rs.refCellBorrow(log.value); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_304.value), f, rs.u8Debug)]; - const _300: string = rs.fmtFormat([args20[0], " "]); + const _300: rs.String = rs.fmtFormat([args20[0], " "]); rs.refRelease(_304); - put(out, _300); + put(out, _300.v); rs.dropVec(rcs); const _321: rs.RefCell = rs.refCellBorrow(log.value); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_321.value), f, rs.u8Debug)]; - const _317: string = rs.fmtFormat([args22[0], " "]); + const _317: rs.String = rs.fmtFormat([args22[0], " "]); rs.refRelease(_321); - put(out, _317); + put(out, _317.v); rs.dropVec(kept); const _337: rs.RefCell = rs.refCellBorrow(log.value); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_337.value), f, rs.u8Debug)]; - const _333: string = rs.fmtFormat([args24[0], " "]); + const _333: rs.String = rs.fmtFormat([args24[0], " "]); rs.refRelease(_337); - put(out, _333); + put(out, _333.v); const _345: rs.Arc = new rs.Arc({ side: dataData[dataStart + 1] as rs.u16 }); const any: rs.Arc = new rs.ArcDyn(_345, new of$dyns_Square(_345.value)); const _351: rs.Result, rs.Arc> = rs.arcDowncast(rs.arcClone(any), of$dyns_Tri, (object) => object.v); @@ -1216,7 +1216,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _372: rs.Fmt = (f: rs.Formatter) => rs.fmtBool(wrong, f); const arg = _365.side; const args26: rs.Fmt[] = [_372, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " "])); + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " "]).v); sq2[Symbol.dispose](); } else { put(out, "none "); @@ -1244,7 +1244,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _424: boolean = rs.arcPtrEq(ex, held); const _428: rs.usize = x.strong; const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_416, f), (f: rs.Formatter) => rs.fmtBool(_420, f), (f: rs.Formatter) => rs.fmtBool(_424, f), (f: rs.Formatter) => rs.usizeDisplay(_428, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " "])); + put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " "]).v); ey[Symbol.dispose](); ex[Symbol.dispose](); y[Symbol.dispose](); @@ -1273,15 +1273,15 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _458: rs.usize = n2.strong; const arg2 = _455._0; const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_458, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); + put(out, rs.fmtFormat([args30[0], " ", args30[1], " "]).v); _595 = false; held[Symbol.dispose](); const _475: rs.usize = n2.strong; const _478: rs.RefCell = rs.refCellBorrow(log.value); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_475, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_478.value), f, rs.u8Debug)]; - const _471: string = rs.fmtFormat([args32[0], " ", args32[1], " "]); + const _471: rs.String = rs.fmtFormat([args32[0], " ", args32[1], " "]); rs.refRelease(_478); - put(out, _471); + put(out, _471.v); n2[Symbol.dispose](); } else { put(out, "none "); @@ -1291,16 +1291,16 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe } const _495: rs.RefCell = rs.refCellBorrow(log.value); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_495.value), f, rs.u8Debug)]; - const _491: string = rs.fmtFormat([args34[0], " "]); + const _491: rs.String = rs.fmtFormat([args34[0], " "]); rs.refRelease(_495); - put(out, _491); + put(out, _491.v); const part3 = option_map$1bn5ufk(ok$1oks8md(rs.arcDowncast(new rs.Arc(new of$u32(dataData[dataStart] as rs.u32)), of$u32, (object) => object.v)), (n3: rs.Arc): rs.u32 => { const _09: rs.u32 = n3.value; n3[Symbol.dispose](); return _09; }); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([args36[0], " "]).v); const _523: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x3: rs.u8): rs.u8 => { return rs.u8WrappingAdd(x3, dataData[dataStart]); }); @@ -1311,7 +1311,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _537: rs.u8 = f.value(dataData[dataStart + 1]); const _543: rs.u8 = g.value(dataData[dataStart]); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_537, f), (f: rs.Formatter) => rs.u8Display(_543, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1]])); + put(out, rs.fmtFormat([args38[0], " ", args38[1]]).v); g[Symbol.dispose](); f[Symbol.dispose](); if (_595) { @@ -1382,19 +1382,19 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const nths: [[rs.u8, rs.u8] | undefined, [rs.u8, rs.u8] | undefined] = [tags(rs.iterNth(rs.iterBox(boxed), 1, drop$tuple2_dyns_Tagged_dyns_Tagged)), tags(rs.iterNthBack(rs.iterBox(boxed), 0, drop$tuple2_dyns_Tagged_dyns_Tagged))]; dropped(out); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0][0], f), (f: rs.Formatter) => rs.fmtOption(hint[0][1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.usizeDebug(hint[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(ends[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(nths[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(nths[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]).v); dropped(out); const part = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args4[0], " "])); + put(out, rs.fmtFormat([args4[0], " "]).v); dropped(out); const part2 = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args6[0], " "])); + put(out, rs.fmtFormat([args6[0], " "]).v); dropped(out); const part3 = rs.ownedCount(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([args8[0], " "]).v); dropped(out); const sum: rs.u32 = rs.iterFold(rs.iterBox(it()), 0, (n3: rs.u32, _3: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x: Tagged.Tagged = _3[0]; @@ -1406,7 +1406,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([args10[0], " "]).v); rs.iterForEach(rs.iterBox(it()), (_24: [Tagged.Tagged, Tagged.Tagged]): undefined => { const x2: Tagged.Tagged = _24[0]; const y2: Tagged.Tagged = _24[1]; @@ -1414,7 +1414,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const _142: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg, f); const arg2 = y2._0; const args44: rs.Fmt[] = [_142, (f: rs.Formatter) => rs.u8Display(arg2, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " "])); + put(out, rs.fmtFormat([args44[0], " ", args44[1], " "]).v); y2[Symbol.dispose](); x2[Symbol.dispose](); }); @@ -1428,7 +1428,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([args12[0], " "]).v); const found2: [rs.u8, rs.u8] | undefined = tags(rs.iterFind(rs.iterBox(it()), (_26: [Tagged.Tagged, Tagged.Tagged]): boolean => { return rs.u8Rem(_26[1]._0, 3) === 0; }, drop$tuple2_dyns_Tagged_dyns_Tagged)); @@ -1441,13 +1441,13 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _05; }); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_148, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " "])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " "]).v); dropped(out); const part4 = tags(rs.iterMaxByKey(rs.iterBox(it()), (p: [Tagged.Tagged, Tagged.Tagged]): rs.u8 => { return p[1]._0; }, rs.lt, undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args16[0], " "])); + put(out, rs.fmtFormat([args16[0], " "]).v); dropped(out); const all: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterMap(rs.vecIntoIter(rs.iterToVec(rs.iterBox(it()), "next", 2), drop$tuple2_dyns_Tagged_dyns_Tagged), (p2: [Tagged.Tagged, Tagged.Tagged]): [rs.u8, rs.u8] => { const _07: [rs.u8, rs.u8] = [p2[0]._0, p2[1]._0]; @@ -1456,7 +1456,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { }), "next", 2, true, 2); dropped(out); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args18[0], " "])); + put(out, rs.fmtFormat([args18[0], " "]).v); const back: rs.u32 = rs.iterFold(rs.iterRev(rs.iterBox(it())), 0, (n4: rs.u32, _33: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x5: Tagged.Tagged = _33[0]; const y3: Tagged.Tagged = _33[1]; @@ -1475,24 +1475,24 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _09; }), rs.u32Add, 0); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(back, f), (f: rs.Formatter) => rs.u32Display(_208, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + put(out, rs.fmtFormat([args20[0], " ", args20[1], " "]).v); dropped(out); const _227: rs.usize = rs.ownedCount(rs.iterSkip(rs.iterBox(it()), 1, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); const _232: rs.usize = rs.ownedCount(rs.iterStepBy(rs.iterBox(it()), 2, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_227, f), (f: rs.Formatter) => rs.usizeDisplay(_232, f)]; - put(out, rs.fmtFormat([args22[0], " ", args22[1], " "])); + put(out, rs.fmtFormat([args22[0], " ", args22[1], " "]).v); dropped(out); const _253: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(it()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part5 = tags(rs.iterNth(_253, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - const _246: string = rs.fmtFormat([args24[0], " "]); + const _246: rs.String = rs.fmtFormat([args24[0], " "]); rs.drop(_253); - put(out, _246); + put(out, _246.v); dropped(out); const last: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it()))), drop$tuple2_dyns_Tagged_dyns_Tagged)); dropped(out); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args26[0], " "])); + put(out, rs.fmtFormat([args26[0], " "]).v); const boxed3: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); const _285: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const nth: [rs.u8, rs.u8] | undefined = tags(rs.iterNth(_285, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); @@ -1501,7 +1501,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.usize = rs.ownedCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), drop$tuple2_dyns_Tagged_dyns_Tagged); dropped(out); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(n, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "]).v); const boxed4: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); const first: [rs.u8, rs.u8] | undefined = tags(rs.iterToOption(boxed4.next())); const sum2: rs.u32 = rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed4))), 0, (n5: rs.u32, _34: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { @@ -1514,7 +1514,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(sum2, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); + put(out, rs.fmtFormat([args30[0], " ", args30[1], " "]).v); dropped(out); const n2: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 0, (n6: rs.u8): rs.u8 => { return rs.u8Rem(n6, 4); @@ -1532,16 +1532,16 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const _351: [rs.u8, rs.u8] | undefined = rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(logged())))); const _354: rs.RefCell = rs.refCellBorrow(seen); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(_351, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; - const _347: string = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); + const _347: rs.String = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); rs.refRelease(_354); - put(out, _347); + put(out, _347.v); const part6 = tags(rs.ownedLast(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged)); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args34[0], " "])); + put(out, rs.fmtFormat([args34[0], " "]).v); dropped(out); const part7 = rs.ownedCount(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([args36[0], " "]).v); dropped(out); const erased: () => rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rs.Iter<[Tagged.Tagged, Tagged.Tagged]> => { return rs.iterDyn(skipped(data)); @@ -1549,22 +1549,22 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const _410: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(erased()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part8 = tags(rs.iterNth(_410, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - const _403: string = rs.fmtFormat([args38[0], " "]); + const _403: rs.String = rs.fmtFormat([args38[0], " "]); rs.drop(_410); - put(out, _403); + put(out, _403.v); dropped(out); const _427: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged)); const _432: rs.usize = rs.ownedCount(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_427, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(_432, f)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); + put(out, rs.fmtFormat([args40[0], " ", args40[1], " "]).v); dropped(out); const boxed6: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = erased(); const _455: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(boxed6), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part9 = tags(rs.iterNth(_455, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - const _448: string = rs.fmtFormat([args42[0], " "]); + const _448: rs.String = rs.fmtFormat([args42[0], " "]); rs.drop(_455); - put(out, _448); + put(out, _448.v); dropped(out); rs.drop(boxed6); dropped(out); @@ -1622,11 +1622,11 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _93: rs.Fmt = (f: rs.Formatter) => rs.fmtList(areas.items, f, rs.u32Debug); const arg = _78.side; const args2: rs.Fmt[] = [_93, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.u32Display(_84.value, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_88.value, f)]; - const _74: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "]); + const _74: rs.String = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "]); rs.refRelease(_88); rs.refRelease(_84); rs.refRelease(_80); - put(out, _74); + put(out, _74.v); const held: rs.RefCell = rs.refCellBorrowMut(n.value); const shared: rs.RefCell = rs.refCellBorrow(shapes.items[rs.idx(shapes.items, 0)].value); const _116: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(shapes.items[rs.idx(shapes.items, 1)].value); @@ -1639,10 +1639,10 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { return _02; }), 0); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_114, f), (f: rs.Formatter) => rs.fmtBool(_121, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - const _110: string = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]); + const _110: rs.String = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]); drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError(_123); drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError(_116); - put(out, _110); + put(out, _110.v); rs.refMutRelease(held); rs.refRelease(shared); const r: rs.RefCell = rs.refCellBorrow(shapes.items[rs.idx(shapes.items, 2)].value); @@ -1650,14 +1650,14 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _153: boolean = !_155.ok; const _159: rs.u8 = r.value.sides$Shape(); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.u8Display(_159, f)]; - const _149: string = rs.fmtFormat([args6[0], " ", args6[1], " "]); + const _149: rs.String = rs.fmtFormat([args6[0], " ", args6[1], " "]); drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError(_155); - put(out, _149); + put(out, _149.v); rs.refRelease(r); const _175: rs.usize = sq.strong; const _178: rs.usize = shapes.items[rs.idx(shapes.items, 1)].strong; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_175, f), (f: rs.Formatter) => rs.usizeDisplay(_178, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " "])); + put(out, rs.fmtFormat([args8[0], " ", args8[1], " "]).v); const _187: rs.Arc> = new rs.Arc(new rs.RefCell({ tag: "Flat" } as Tri.Tri)); const named: rs.Arc> = new rs.ArcDyn(_187, rs.tailDyn(_187.value, { value: (value5: rs.RefCell) => new ofPlace$dyns_Tri(rs.valuePlace(value5)) })); const _193: rs.RefCell = rs.refCellBorrowMut(named.value); @@ -1669,17 +1669,17 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { _202.value.grow$Shape(a); rs.refMutRelease(_202); const _217: rs.RefCell = rs.refCellBorrow(named.value); - const _214: string = _217.value.label$Named(); + const _214: rs.String = _217.value.label$Named(); const _224: rs.RefCell = rs.refCellBorrow(upcast.value); const _221: rs.u32 = _224.value.area$Shape(); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214), (f: rs.Formatter) => rs.u32Display(_221, f)]; - const _209: string = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214.v), (f: rs.Formatter) => rs.u32Display(_221, f)]; + const _209: rs.String = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "]); rs.refRelease(_224); rs.refRelease(_217); - put(out, _209); + put(out, _209.v); const _held: rs.RefCell = rs.refCellBorrowMut(named.value); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f))]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([args12[0], " "]).v); rs.refMutRelease(_held); const noisy: rs.Arc> = new rs.Arc(new rs.RefCell(new Noisy.Noisy(c, rs.arcClone(log)))); const _254: rs.Arc> = rs.arcClone(noisy); @@ -1695,24 +1695,24 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { return _03; }); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_268.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_272, f, rs.u32Debug)]; - const _264: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const _264: rs.String = rs.fmtFormat([args14[0], " ", args14[1], " "]); rs.refRelease(_268); - put(out, _264); + put(out, _264.v); shape[Symbol.dispose](); const _289: rs.RefCell = rs.refCellBorrow(log.value); const _295: rs.Arc> | undefined = rs.weakUpgrade(weak); const _293: boolean = _295 === undefined; const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_289.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_293, f)]; - const _285: string = rs.fmtFormat([args16[0], " ", args16[1], " "]); + const _285: rs.String = rs.fmtFormat([args16[0], " ", args16[1], " "]); rs.drop(_295); rs.refRelease(_289); - put(out, _285); + put(out, _285.v); rs.dropVec(shapes); const _311: rs.RefCell = rs.refCellBorrow(log.value); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug)]; - const _307: string = rs.fmtFormat([args18[0], " "]); + const _307: rs.String = rs.fmtFormat([args18[0], " "]); rs.refRelease(_311); - put(out, _307); + put(out, _307.v); const _321: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_321.value); rs.refMutRelease(_321); @@ -1726,9 +1726,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _351: rs.Result, rs.TryLockError>> = rs.mutexTryLock(locked.value); const part = !_351.ok; const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - const _345: string = rs.fmtFormat([args20[0], " "]); + const _345: rs.String = rs.fmtFormat([args20[0], " "]); drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_351); - put(out, _345); + put(out, _345.v); rs.mutexUnlock(_guard); const weak2: rs.Weak> = new rs.Weak(locked); const area: rs.u32 | undefined = option_map$13cu53u(rs.weakUpgrade(weak2), (l: rs.Arc>): rs.u32 => { @@ -1741,9 +1741,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _372: rs.Mutex = rs.mutexLock(m.value); const _377: rs.usize = m.strong; const args22: rs.Fmt[] = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_372.value, f), (f: rs.Formatter) => rs.fmtOption(area, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_377, f)]; - const _368: string = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " "]); + const _368: rs.String = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " "]); rs.mutexUnlock(_372); - put(out, _368); + put(out, _368.v); const rw: rs.Arc> = new rs.Arc(new rs.RefCell(c as rs.u32)); const _390: rs.Arc> = rs.arcClone(rw); const lock: rs.Arc> = new rs.ArcDyn(_390, rs.tailDyn(_390.value, { value: (value9: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value9)) })); @@ -1756,16 +1756,16 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _420: rs.RefCell = rs.rwLockRead(lock.value); const _417: rs.u32 = _420.value.area$Shape(); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_411, f), (f: rs.Formatter) => rs.u32Display(_417, f)]; - const _407: string = rs.fmtFormat([args24[0], " ", args24[1], " "]); + const _407: rs.String = rs.fmtFormat([args24[0], " ", args24[1], " "]); rs.refRelease(_420); drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_413); - put(out, _407); + put(out, _407.v); rs.refRelease(_read); const _437: rs.RefCell = rs.rwLockRead(rw.value); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_437.value, f)]; - const _433: string = rs.fmtFormat([args26[0], " "]); + const _433: rs.String = rs.fmtFormat([args26[0], " "]); rs.refRelease(_437); - put(out, _433); + put(out, _433.v); const t: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), c as rs.u32); const area2: rs.u32 = bumpTail(rs.tailDyn(t, { value: (value10: Tail.Tail) => new ofPlace$u32(rs.place(() => value10.value, (value11) => value10.value = value11)) }), b); const shared2: Tail.Tail = rs.tailDyn(t, { value: (value12: Tail.Tail) => new ofPlace$u32(rs.place(() => value12.value, (value13) => value12.value = value13)) }); @@ -1778,7 +1778,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _473: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_465, f); const arg4 = t.value; const args28: rs.Fmt[] = [_470, _471, _472, _473, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " "])); + put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " "]).v); const cell: rs.Arc>> = new rs.Arc(new rs.RefCell(new Tail.Tail(b, new Noisy.Noisy(a, rs.arcClone(log)), { side: b as rs.u16 }))); const _486: rs.Arc>> = rs.arcClone(cell); const nested: rs.Arc>> = new rs.ArcDyn(_486, rs.tailDyn(_486.value, { value: (value14: rs.RefCell>) => rs.tailDyn(value14.value, { value: (value15: Tail.Tail) => new of$dyns_Square(value15.value) }) }, rs.drop)); @@ -1794,28 +1794,28 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _516: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg5, f); const arg6 = _508.value.side; const args30: rs.Fmt[] = [_515, _516, (f: rs.Formatter) => rs.u16Display(arg6, f)]; - const _498: string = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); + const _498: rs.String = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); rs.refRelease(_510); rs.refRelease(_504); - put(out, _498); + put(out, _498.v); cell[Symbol.dispose](); t[Symbol.dispose](); const _531: rs.RefCell = rs.refCellBorrow(log.value); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_531.value), f, rs.u8Debug)]; - const _527: string = rs.fmtFormat([args32[0], " "]); + const _527: rs.String = rs.fmtFormat([args32[0], " "]); rs.refRelease(_531); - put(out, _527); + put(out, _527.v); nested[Symbol.dispose](); const boxed: Tail.Tail = rs.tailDyn(new Tail.Tail(c, new Noisy.Noisy(c, rs.arcClone(log)), new Noisy.Noisy(rs.u8WrappingAdd(c, 1), rs.arcClone(log))), { value: (value17: Tail.Tail) => new of$dyns_Noisy(value17.value) }, rs.drop); const part2 = boxed.value.area$Shape(); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - put(out, rs.fmtFormat([args34[0], " "])); + put(out, rs.fmtFormat([args34[0], " "]).v); boxed[Symbol.dispose](); const _572: rs.RefCell = rs.refCellBorrow(log.value); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_572.value), f, rs.u8Debug)]; - const _568: string = rs.fmtFormat([args36[0], " "]); + const _568: rs.String = rs.fmtFormat([args36[0], " "]); rs.refRelease(_572); - put(out, _568); + put(out, _568.v); const pinned: Tail.Tail = rs.tailDyn(new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), { tag: "Tall", _0: b } as Tri.Tri), { value: (value19: Tail.Tail) => new ofPlace$dyns_Tri(rs.place(() => value19.value, (value20) => value19.value = value20)) }, rs.drop); const own: rs.Arc> = new rs.Arc(new rs.RefCell(a as rs.u32)); const weak4: rs.Weak> = rs.weakDyn(new rs.Weak(own), (arc: rs.Arc>): rs.Arc> => { @@ -1835,15 +1835,15 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _622: rs.usize = weak4.arc.strong; const arg7 = _610.count; const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg7, f), (f: rs.Formatter) => rs.u32Display(_613, f), (f: rs.Formatter) => rs.u32Display(_618.value, f), (f: rs.Formatter) => rs.usizeDisplay(_622, f)]; - const _606: string = rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " ", args38[3], " "]); + const _606: rs.String = rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " ", args38[3], " "]); rs.refRelease(_618); - put(out, _606); + put(out, _606.v); pinned[Symbol.dispose](); const _640: rs.RefCell = rs.refCellBorrow(log.value); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_640.value), f, rs.u8Debug)]; - const _636: string = rs.fmtFormat([args40[0], " "]); + const _636: rs.String = rs.fmtFormat([args40[0], " "]); rs.refRelease(_640); - put(out, _636); + put(out, _636.v); const shared3: rs.Arc> = new rs.Arc(rs.tailDyn(new rs.RefCell(new Noisy.Noisy(b, rs.arcClone(log))), { value: (value22: rs.RefCell) => new of$dyns_Noisy(value22.value) }, rs.drop)); const again: rs.Arc> = rs.arcClone(shared3); const _659: rs.RefCell = rs.refCellBorrowMut(again.value); @@ -1854,16 +1854,16 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _671: rs.u32 = _674.value.area$Shape(); const _678: rs.RefCell = rs.refCellBorrow(log.value); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_671, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_678.value), f, rs.u8Debug)]; - const _667: string = rs.fmtFormat([args42[0], " ", args42[1], " "]); + const _667: rs.String = rs.fmtFormat([args42[0], " ", args42[1], " "]); rs.refRelease(_678); rs.refRelease(_674); - put(out, _667); + put(out, _667.v); again[Symbol.dispose](); const _695: rs.RefCell = rs.refCellBorrow(log.value); const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_695.value), f, rs.u8Debug)]; - const _691: string = rs.fmtFormat([args44[0], " "]); + const _691: rs.String = rs.fmtFormat([args44[0], " "]); rs.refRelease(_695); - put(out, _691); + put(out, _691.v); const guarded: rs.Vec> = rs.vecFrom([rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(a, rs.arcClone(log)) } as Held.Held), { value: (value23: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value23.value, (value24) => value23.value = value24)) }, drop$dyns_Guarded_dyns_Held), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), new Noisy.Noisy(b, rs.arcClone(log))), { value: (value25: Guarded.Guarded) => new of$dyns_Noisy(value25.value) }, drop$dyns_Guarded_dyns_Noisy), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Empty" } as Held.Held), { value: (value27: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value27.value, (value28) => value27.value = value28)) }, drop$dyns_Guarded_dyns_Held)]); const _728: rs.Arc>> = new rs.Arc(new rs.RefCell(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(c, rs.arcClone(log)) } as Held.Held))); const cell2: rs.Arc>> = new rs.ArcDyn(_728, rs.tailDyn(_728.value, { value: (value29: rs.RefCell>) => rs.tailDyn(value29.value, { value: (value30: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value30.value, (value31) => value30.value = value31)) }) }, drop$cell_RefCell_dyns_Guarded_dyns_Held)); @@ -1876,24 +1876,24 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _761: rs.RefCell> = rs.refCellBorrow(cell2.value); const _757: rs.u32 = _761.value.value.area$Shape(); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(areas2.items, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_757, f)]; - const _753: string = rs.fmtFormat([args46[0], " ", args46[1], " "]); + const _753: rs.String = rs.fmtFormat([args46[0], " ", args46[1], " "]); rs.refRelease(_761); - put(out, _753); + put(out, _753.v); const _773: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_773.value); rs.refMutRelease(_773); rs.dropVec(guarded, drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape); const _785: rs.RefCell = rs.refCellBorrow(log.value); const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_785.value), f, rs.u8Debug)]; - const _781: string = rs.fmtFormat([args48[0], " "]); + const _781: rs.String = rs.fmtFormat([args48[0], " "]); rs.refRelease(_785); - put(out, _781); + put(out, _781.v); rs.arcDrop(cell2, drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape); const _801: rs.RefCell = rs.refCellBorrow(log.value); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_801.value), f, rs.u8Debug)]; - const _797: string = rs.fmtFormat([args50[0], " "]); + const _797: rs.String = rs.fmtFormat([args50[0], " "]); rs.refRelease(_801); - put(out, _797); + put(out, _797.v); const t2: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), b as rs.u32); const apart: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), b as rs.u32); const _822: Tail.Tail = rs.tailDyn(t2, { value: (value32: Tail.Tail) => new ofPlace$u32(rs.place(() => value32.value, (value33) => value32.value = value33)) }); @@ -1917,7 +1917,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _871: boolean = rs.arcPtrEq(r2, other); const _875: boolean = rs.arcPtrEq(u.arc, v.arc); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_859, f), (f: rs.Formatter) => rs.fmtBool(_863, f), (f: rs.Formatter) => rs.fmtBool(_867, f), (f: rs.Formatter) => rs.fmtBool(_871, f), (f: rs.Formatter) => rs.fmtBool(_875, f)]; - put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " ", args52[4], " "])); + put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " ", args52[4], " "]).v); v[Symbol.dispose](); u[Symbol.dispose](); other[Symbol.dispose](); @@ -1955,9 +1955,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _952: rs.Mutex> = rs.mutexLock(it.value); const _949: rs.u8 | undefined = rs.iterToOption(_952.value.next()); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.refCellDebug(shown, f, (value: rs.Fmt, f: rs.Formatter) => value(f)), (f: rs.Formatter) => rs.fmtOption(_943, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_946, f), (f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_949, f, rs.u8Debug)]; - const _939: string = rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "]); + const _939: rs.String = rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "]); rs.mutexUnlock(_952); - put(out, _939); + put(out, _939.v); const _968: rs.u8 | undefined = option_map$1yjmt5m(rs.byteSliceFirst(rs.byteSliceRange(data, 3)), (x3: rs.u8): rs.u8 => { return rs.u8Rem(x3, 4); }); @@ -1980,9 +1980,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _held2: rs.RefCell = rs.refCellBorrowMut(dynamic2.value); const _997: rs.RefCell = rs.refCellBorrow(n.value); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_997.value, f)]; - const _993: string = rs.fmtFormat([args56[0]]); + const _993: rs.String = rs.fmtFormat([args56[0]]); rs.refRelease(_997); - put(out, _993); + put(out, _993.v); rs.refMutRelease(_held2); dynamic2[Symbol.dispose](); break b6; @@ -1992,18 +1992,18 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _1019: rs.Mutex = rs.mutexLock(locked.value); const part3 = _1019.value.area$Shape(); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _1012: string = rs.fmtFormat([args58[0]]); + const _1012: rs.String = rs.fmtFormat([args58[0]]); rs.mutexUnlock(_1019); - put(out, _1012); + put(out, _1012.v); rs.mutexUnlock(_guard2); break b6; } } const _1034: rs.RefCell = rs.refCellBorrow(n.value); const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1034.value, f)]; - const _1030: string = rs.fmtFormat([args60[0]]); + const _1030: rs.String = rs.fmtFormat([args60[0]]); rs.refRelease(_1034); - put(out, _1030); + put(out, _1030.v); } it[Symbol.dispose](); any[Symbol.dispose](); @@ -2076,7 +2076,7 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _68: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_58, f); const arg = _61.side; const args2: rs.Fmt[] = [_68, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_64, f), (f: rs.Formatter) => rs.u32Display(area, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "]).v); const noisy: rs.Arc> = new rs.Arc(new rs.Cell(new Noisy.Noisy(a, rs.arcClone(log)))); const _80: rs.Arc> = rs.arcClone(noisy); const cell: rs.Arc> = new rs.ArcDyn(_80, rs.tailDyn(_80.value, { v: (value5: rs.Cell) => new of$dyns_Noisy(value5.v) }, rs.drop)); @@ -2084,15 +2084,15 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, noisy[Symbol.dispose](); const _95: rs.RefCell = rs.refCellBorrow(log.value); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(area2, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_95.value), f, rs.u8Debug)]; - const _91: string = rs.fmtFormat([args4[0], " ", args4[1], " "]); + const _91: rs.String = rs.fmtFormat([args4[0], " ", args4[1], " "]); rs.refRelease(_95); - put(out, _91); + put(out, _91.v); cell[Symbol.dispose](); const _113: rs.RefCell = rs.refCellBorrow(log.value); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_113.value), f, rs.u8Debug)]; - const _109: string = rs.fmtFormat([args6[0], " "]); + const _109: rs.String = rs.fmtFormat([args6[0], " "]); rs.refRelease(_113); - put(out, _109); + put(out, _109.v); const _123: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_123.value); rs.refMutRelease(_123); @@ -2106,13 +2106,13 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _158: Tri.Tri = copy$dyns_Tri(u.value.v); const _163: rs.u32 = boxed.v.area$Shape(); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(area3, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_158, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "])); + put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "]).v); boxed[Symbol.dispose](); const _183: rs.RefCell = rs.refCellBorrow(log.value); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_183.value), f, rs.u8Debug)]; - const _179: string = rs.fmtFormat([args10[0], " "]); + const _179: rs.String = rs.fmtFormat([args10[0], " "]); rs.refRelease(_183); - put(out, _179); + put(out, _179.v); const _193: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_193.value); rs.refMutRelease(_193); @@ -2125,25 +2125,25 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _218: rs.u32 = m.area$Shape(); const _222: rs.u32 = t.area$Shape(); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_218, f), (f: rs.Formatter) => rs.u32Display(_222, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " "])); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " "]).v); const _244: rs.u32 = new of$dyns_Noisy(new Noisy.Noisy(b, rs.arcClone(log))).area$Shape(); const _248: Noisy.Noisy = kept; const _250: Tri.Tri = held; const _253: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_244, f); const arg2 = _248._0; const args14: rs.Fmt[] = [_253, (f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_250, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "]).v); const _267: rs.RefCell = rs.refCellBorrow(log.value); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_267.value), f, rs.u8Debug)]; - const _263: string = rs.fmtFormat([args16[0], " "]); + const _263: rs.String = rs.fmtFormat([args16[0], " "]); rs.refRelease(_267); - put(out, _263); + put(out, _263.v); rs.drop(new of$dyns_Noisy(kept)); const _285: rs.RefCell = rs.refCellBorrow(log.value); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_285.value), f, rs.u8Debug)]; - const _281: string = rs.fmtFormat([args18[0], " "]); + const _281: rs.String = rs.fmtFormat([args18[0], " "]); rs.refRelease(_285); - put(out, _281); + put(out, _281.v); const _295: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_295.value); rs.refMutRelease(_295); @@ -2158,15 +2158,15 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, ticks[Symbol.dispose](); const _332: rs.RefCell = rs.refCellBorrow(log.value); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(first[0], f), (f: rs.Formatter) => rs.fmtOption(first[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Display(polls, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(rest[0], f), (f: rs.Formatter) => rs.fmtOption(rest[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_332.value), f, rs.u8Debug)]; - const _328: string = rs.fmtFormat([args20[0], " ", args20[1], " ", args20[2], " ", args20[3], " "]); + const _328: rs.String = rs.fmtFormat([args20[0], " ", args20[1], " ", args20[2], " ", args20[3], " "]); rs.refRelease(_332); - put(out, _328); + put(out, _328.v); future[Symbol.dispose](); const _354: rs.RefCell = rs.refCellBorrow(log.value); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; - const _350: string = rs.fmtFormat([args22[0], " "]); + const _350: rs.String = rs.fmtFormat([args22[0], " "]); rs.refRelease(_354); - put(out, _350); + put(out, _350.v); const _364: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_364.value); rs.refMutRelease(_364); @@ -2186,15 +2186,15 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, block[Symbol.dispose](); const _398: rs.RefCell = rs.refCellBorrow(log.value); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(ready, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_398.value), f, rs.u8Debug)]; - const _394: string = rs.fmtFormat([args24[0], " ", args24[1], " "]); + const _394: rs.String = rs.fmtFormat([args24[0], " ", args24[1], " "]); rs.refRelease(_398); - put(out, _394); + put(out, _394.v); erased[Symbol.dispose](); const _416: rs.RefCell = rs.refCellBorrow(log.value); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_416.value), f, rs.u8Debug)]; - const _412: string = rs.fmtFormat([args26[0], " "]); + const _412: rs.String = rs.fmtFormat([args26[0], " "]); rs.refRelease(_416); - put(out, _412); + put(out, _412.v); const _426: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_426.value); rs.refMutRelease(_426); @@ -2218,13 +2218,13 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _475: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg4, f); const arg5 = t2.value; const args28: rs.Fmt[] = [_471, _472, _473, _474, _475, (f: rs.Formatter) => Tri.fmt$fmt_Debug(arg5, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " ", args28[5], " "])); + put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " ", args28[5], " "]).v); t2[Symbol.dispose](); const _489: rs.RefCell = rs.refCellBorrow(log.value); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_489.value), f, rs.u8Debug)]; - const _485: string = rs.fmtFormat([args30[0], " "]); + const _485: rs.String = rs.fmtFormat([args30[0], " "]); rs.refRelease(_489); - put(out, _485); + put(out, _485.v); let sq2: rs.Cell = new rs.Cell({ side: c as rs.u16 }); let tri2: rs.RefCell = new rs.RefCell({ tag: "Tall", _0: a } as Tri.Tri); const p2: rs.Place> = rs.rawUnsizePlace(rs.place(() => sq2, (value14) => sq2 = value14), (p7) => rs.tailDyn(p7, { v: (value15: rs.Cell) => new of$dyns_Square(value15.v) })); @@ -2242,9 +2242,9 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _538: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(areas2[0], f), (f: rs.Formatter) => rs.u32Debug(areas2[1], f)], f); const arg6 = _531.side; const args32: rs.Fmt[] = [_538, (f: rs.Formatter) => rs.u16Display(arg6, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_534.value, f)]; - const _527: string = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); + const _527: rs.String = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); rs.refRelease(_534); - put(out, _527); + put(out, _527.v); const _546: [Ticks.Ticks, Noisy.Noisy, Tail.Tail] = [new Ticks.Ticks(rs.u8Rem(b, 3), 0, rs.arcClone(log)), new Noisy.Noisy(a, rs.arcClone(log)), new Tail.Tail(b, new Noisy.Noisy(b, rs.arcClone(log)), new Noisy.Noisy(c, rs.arcClone(log)))]; const ticks2: Ticks.Ticks = _546[0]; const noisy2: Noisy.Noisy = _546[1]; @@ -2260,9 +2260,9 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, tail3[Symbol.dispose](); const _599: rs.RefCell = rs.refCellBorrow(log.value); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(polled, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_599.value), f, rs.u8Debug)]; - const _595: string = rs.fmtFormat([args34[0], " ", args34[1], " "]); + const _595: rs.String = rs.fmtFormat([args34[0], " ", args34[1], " "]); rs.refRelease(_599); - put(out, _595); + put(out, _595.v); const _611: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_611.value); rs.refMutRelease(_611); @@ -2274,7 +2274,7 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const second: rs.u8 | undefined = rs.iterToOption(_632.value.next()); rs.mutexUnlock(_632); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args36[0], " ", args36[1], " "])); + put(out, rs.fmtFormat([args36[0], " ", args36[1], " "]).v); cell2[Symbol.dispose](); dropped(out); locked[Symbol.dispose](); @@ -2288,11 +2288,11 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const area5: rs.u32 = wide.v.v.area$Shape(); const _677: rs.u32 = slot.v; const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(null_, f), (f: rs.Formatter) => rs.u32Display(area5, f), (f: rs.Formatter) => rs.u32Display(_677, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "])); + put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "]).v); const shown: rs.Fmt = rs.rawUnsize(side, (p13) => rs.fmtOwned(p13, (value: Square.Square, f: rs.Formatter) => Square.fmt$fmt_Debug(value, f))); const _703: boolean = rs.rawUnsize(rs.NULL, (p14) => new of$dyns_Square(p14)) === rs.NULL; const args40: rs.Fmt[] = [(f: rs.Formatter) => shown(f), (f: rs.Formatter) => rs.fmtBool(_703, f)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1]])); + put(out, rs.fmtFormat([args40[0], " ", args40[1]]).v); owned[Symbol.dispose](); shape[Symbol.dispose](); u[Symbol.dispose](); @@ -2353,7 +2353,7 @@ export function pick$dyns_Scaled_u16_u16(_self: rs.u16, a: rs.u16, b: rs.u16): r return a; } -export function take$dyns_Source_u8(self: rs.Place): string | undefined { +export function take$dyns_Source_u8(self: rs.Place): rs.String | undefined { const _2: rs.u8 | undefined = rs.u8CheckedSub(self.v, 1); if (_2 !== undefined) { self.v = _2; @@ -2367,13 +2367,13 @@ export function left$dyns_Source_u8(self: rs.u8): rs.usize { return self as rs.usize; } -export function taken$String(s: Source.Source): string { - const taken: rs.Vec = new rs.Vec(); +export function taken$String(s: Source.Source): rs.String { + const taken: rs.Vec = new rs.Vec(); while (true) { - const _3: string | undefined = s.take$Source(); + const _3: rs.String | undefined = s.take$Source(); if (_3 !== undefined) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_3, f)]; - const _8: string = rs.fmtFormat([args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_3.v, f)]; + const _8: rs.String = rs.fmtFormat([args2[0]]); taken.items.push(_8); } else { break; @@ -2382,13 +2382,13 @@ export function taken$String(s: Source.Source): string { return rs.strsJoin(taken.items, ","); } -export function taken$u32(s: Source.Source): string { - const taken: rs.Vec = new rs.Vec(); +export function taken$u32(s: Source.Source): rs.String { + const taken: rs.Vec = new rs.Vec(); while (true) { const _3: rs.u32 | undefined = s.take$Source(); if (_3 !== undefined) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(_3, f)]; - const _8: string = rs.fmtFormat([args2[0]]); + const _8: rs.String = rs.fmtFormat([args2[0]]); taken.items.push(_8); } else { break; @@ -2412,31 +2412,31 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { } else { tri = { tag: "Flat" } as Tri.Tri; } - const named: Scaled.Scaled = new of$dyns_Tri(tri); + const named: Scaled.Scaled = new of$dyns_Tri(tri); const _37: rs.u16 = ((c as rs.u16) << 8) & 0xffff; - const _41: string = "s"; + const _41: rs.String = rs.stringFrom("s"); let n: rs.u8 = b; let w: rs.u16 = _37; - let s: string = _41; + const s: rs.String = _41; narrow.bump$Scaled(rs.place(() => n, (value) => n = value) as rs.Ptr); wide.bump$Scaled(rs.place(() => w, (value2) => w = value2) as rs.Ptr); - named.bump$Scaled(rs.place(() => s, (value3) => s = value3) as rs.Ptr); + named.bump$Scaled(s as rs.Ptr); const _57: rs.u8 = narrow.scale$Scaled(b); const _59: rs.u16 = wide.scale$Scaled(rs.u16Mul(c as rs.u16, 300)); const args3: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f)]; - const _65: string = named.scale$Scaled(rs.fmtFormat([args3[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => rs.u16Display(_59, f), (f: rs.Formatter) => rs.fmtPad(f, _65), (f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u16Display(w, f), (f: rs.Formatter) => rs.fmtPad(f, s)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " "])); - const _90: string = "ab"; + const _65: rs.String = named.scale$Scaled(rs.fmtFormat([args3[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => rs.u16Display(_59, f), (f: rs.Formatter) => rs.fmtPad(f, _65.v), (f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u16Display(w, f), (f: rs.Formatter) => rs.fmtPad(f, s.v)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " "]).v); + const _90: rs.String = rs.stringFrom("ab"); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(c, f)]; - const _89: [string, string] = [_90, rs.fmtFormat([args6[0]])]; - const x: string = _90; - const y: string = _89[1]; + const _89: [rs.String, rs.String] = [_90, rs.fmtFormat([args6[0]])]; + const x: rs.String = _90; + const y: rs.String = _89[1]; const _108: rs.u8 = narrow.pick$Scaled(b as rs.Ptr, c as rs.Ptr) as rs.u8; const _112: rs.u16 = wide.pick$Scaled((a as rs.u16) as rs.Ptr, w as rs.Ptr) as rs.u16; - const _118: string = named.pick$Scaled(x as rs.Ptr, y as rs.Ptr) as string; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_108, f), (f: rs.Formatter) => rs.u16Display(_112, f), (f: rs.Formatter) => rs.fmtPad(f, _118)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "])); + const _118: rs.String = named.pick$Scaled(x as rs.Ptr, y as rs.Ptr) as rs.String; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_108, f), (f: rs.Formatter) => rs.u16Display(_112, f), (f: rs.Formatter) => rs.fmtPad(f, _118.v)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "]).v); const paired: Paired.Paired = new of$dyns_Many({ _0: b }); const up: Scaled.Scaled = paired as Scaled.Scaled; const v: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 3)); @@ -2446,7 +2446,7 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _150: [rs.u8, rs.u8] = paired.pair$Paired(c); const _152: rs.ByteVec = up.scale$Scaled(rs.byteSliceToByteVec(rs.byteSliceRange(data, 3))); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_150[0], f), (f: rs.Formatter) => rs.u8Debug(_150[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_152), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(picked), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " "])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " "]).v); const _164: rs.Arc = new rs.Arc({ _0: c }); const shared: rs.Arc> = new rs.ArcDyn(_164, new of$dyns_Many(_164.value)); const up2: rs.Arc> = rs.arcClone(shared) as rs.Arc>; @@ -2455,7 +2455,7 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _183: [rs.u8, rs.u8] = shared.value.pair$Paired(b); const _187: rs.usize = up2.strong; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_183[0], f), (f: rs.Formatter) => rs.u8Debug(_183[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v2), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "])); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]).v); const weak2: rs.Weak> = new rs.Weak(shared) as rs.Weak>; up2[Symbol.dispose](); const scaled: rs.ByteVec | undefined = option_map$00ac22d(rs.weakUpgrade(weak2), (s2: rs.Arc>): rs.ByteVec => { @@ -2467,15 +2467,15 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _217: rs.Arc> | undefined = rs.weakUpgrade(weak2); const _215: boolean = _217 === undefined; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(scaled, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtBool(_215, f)]; - const _211: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const _211: rs.String = rs.fmtFormat([args14[0], " ", args14[1], " "]); rs.drop(_217); - put(out, _211); + put(out, _211.v); const nest: Nest.Nest = new of$dyns_Leaf({ _0: c }); const _236: boolean = (nest.next$Nest() as Nest.Nest | undefined) === undefined; const _240: rs.u8 = nest.depth$Nest(); const _242: rs.u8 = narrow.apply$Scaled(doubled as (a0: rs.Ptr) => rs.u8, c); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_236, f), (f: rs.Formatter) => rs.u8Display(_240, f), (f: rs.Formatter) => rs.u8Display(_242, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "]).v); const owned: Source.Source = new of$dyns_Drained(new Drained.Drained(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_2: rs.u8): Noisy.Noisy => { return new Noisy.Noisy(_2, rs.arcClone(log)); }), undefined, 8, true))); @@ -2483,40 +2483,40 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _268: rs.usize = owned.left$Source(); const _271: rs.RefCell = rs.refCellBorrow(log.value); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_268, f), (f: rs.Formatter) => rs.fmtOption(first, f, (value: Noisy.Noisy, f: rs.Formatter) => Noisy.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_271.value), f, rs.u8Debug)]; - const _264: string = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); + const _264: rs.String = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); rs.refRelease(_271); - put(out, _264); + put(out, _264.v); rs.drop(first); const _290: rs.RefCell = rs.refCellBorrow(log.value); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_290.value), f, rs.u8Debug)]; - const _286: string = rs.fmtFormat([args20[0], " "]); + const _286: rs.String = rs.fmtFormat([args20[0], " "]); rs.refRelease(_290); - put(out, _286); + put(out, _286.v); if (rs.u8Rem(a, 2) === 0) { rs.drop(owned.take$Source()); } rs.drop(owned); const _311: rs.RefCell = rs.refCellBorrow(log.value); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug)]; - const _307: string = rs.fmtFormat([args22[0], " "]); + const _307: rs.String = rs.fmtFormat([args22[0], " "]); rs.refRelease(_311); - put(out, _307); + put(out, _307.v); const steps: Steps.Steps = { _0: rs.u8Rem(a, 6) as rs.u32, _1: b as rs.u32 }; const counted: Counted.Counted = new of$dyns_Steps(steps); const next: rs.u32 | undefined = counted.take$Source(); const _334: rs.usize = counted.left$Source(); const _337: rs.u32 = counted.total$Counted(); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2], " "])); - const _354: string = taken$u32(counted as Source.Source); - const _358: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, _354); + put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2], " "]).v); + const _354: rs.String = taken$u32(counted as Source.Source); + const _358: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, _354.v); const arg = steps._1; const args26: rs.Fmt[] = [_358, (f: rs.Formatter) => rs.u32Display(arg, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " "])); + put(out, rs.fmtFormat([args26[0], " ", args26[1], " "]).v); let left: rs.u8 = rs.u8Rem(c, 5); - const _372: string = taken$String(new ofPlace$u8(rs.place(() => left, (value4) => left = value4))); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _372), (f: rs.Formatter) => rs.u8Display(left, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + const _372: rs.String = taken$String(new ofPlace$u8(rs.place(() => left, (value3) => left = value3))); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _372.v), (f: rs.Formatter) => rs.u8Display(left, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "]).v); const tasks: rs.Vec> = rs.vecFrom([new of$dyns_Steps({ _0: 1, _1: a as rs.u32 })]); const square: Task.Task = new of$dyns_Square({ side: c as rs.u16 }); tasks.items[rs.idx(tasks.items, 0)].run$Task(); @@ -2525,11 +2525,11 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { })); const _408: rs.u32 = square.run$Task(); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(ran, f), (f: rs.Formatter) => rs.u32Display(_408, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); - const over: Over.Over = new Over.Over(new of$dyns_Tri(copy$dyns_Tri(tri)), new of$u8(rs.u8Rem(a, 4))); - const runs: rs.Vec = new rs.Vec(); + put(out, rs.fmtFormat([args30[0], " ", args30[1], " "]).v); + const over: Over.Over = new Over.Over(new of$dyns_Tri(copy$dyns_Tri(tri)), new of$u8(rs.u8Rem(a, 4))); + const runs: rs.Vec = new rs.Vec(); while (true) { - const _425: string | undefined = Over.run$String(over); + const _425: rs.String | undefined = Over.run$String(over); if (_425 !== undefined) { runs.items.push(_425); } else { @@ -2537,8 +2537,8 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { } } const _439: rs.usize = over.source.left$Source(); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(runs.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(_439, f)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1]])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(runs.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.usizeDisplay(_439, f)]; + put(out, rs.fmtFormat([args32[0], " ", args32[1]]).v); over[Symbol.dispose](); rs.drop(square); rs.dropVec(tasks); diff --git a/ts/fixtures/lang/dyns/expected/lib.ts b/ts/fixtures/lang/dyns/expected/lib.ts index 62a9c5b58..9c6e2ec2c 100644 --- a/ts/fixtures/lang/dyns/expected/lib.ts +++ b/ts/fixtures/lang/dyns/expected/lib.ts @@ -332,6 +332,28 @@ export class of$Option_u8 { } } +export class of$String { + v: rs.String; + + constructor(v: rs.String) { + this.v = v; + } + + writeChar$Write(a: rs.char): rs.Result { + rs.stringPush(this.v, a); + return rs.OK; + } + + writeFmt$Write(a: rs.Arguments): rs.Result { + return rs.fmtWriteString(this.v, a); + } + + writeStr$Write(a: string): rs.Result { + rs.stringPushStr(this.v, a); + return rs.OK; + } +} + export class of$dyns_By { v: By.By; @@ -571,7 +593,7 @@ export class of$dyns_Square { return Square.key$dyns_Keyed(this.v); } - label$Named(): string { + label$Named(): rs.String { return Square.label$dyns_Named(this.v); } @@ -623,8 +645,8 @@ export class of$dyns_Tri { this.v = v; } - apply$Scaled(a: (a0: rs.Ptr) => string, a2: string): string { - return Tri.apply$dyns_Scaled_String(this.v, a as (a0: string) => string, a2); + apply$Scaled(a: (a0: rs.Ptr) => rs.String, a2: rs.String): rs.String { + return Tri.apply$dyns_Scaled_String(this.v, a as (a0: rs.String) => rs.String, a2); } area$Shape(): rs.u32 { @@ -639,8 +661,8 @@ export class of$dyns_Tri { return Tri.asAnyMut$dyns_Erased(this); } - bump$Scaled(a: rs.Ptr): void { - return Tri.bump$dyns_Scaled_String(this.v, a as rs.Place); + bump$Scaled(a: rs.Ptr): void { + return Tri.bump$dyns_Scaled_String(this.v, a as rs.String); } fmt$Debug(a: rs.Formatter): rs.Result { @@ -655,7 +677,7 @@ export class of$dyns_Tri { return Tri.intoArea$dyns_Shape(this.v); } - label$Named(): string { + label$Named(): rs.String { return Tri.label$dyns_Named(this.v); } @@ -663,11 +685,11 @@ export class of$dyns_Tri { return Tri.larger$dyns_Shape(this.v, a); } - pick$Scaled(a: rs.Ptr, a2: rs.Ptr): rs.Ptr { - return Tri.pick$dyns_Scaled_String(this.v, a as string, a2 as string) as rs.Ptr; + pick$Scaled(a: rs.Ptr, a2: rs.Ptr): rs.Ptr { + return Tri.pick$dyns_Scaled_String(this.v, a as rs.String, a2 as rs.String) as rs.Ptr; } - scale$Scaled(a: string): string { + scale$Scaled(a: rs.String): rs.String { return Tri.scale$dyns_Scaled_String(this.v, a); } @@ -1105,7 +1127,7 @@ export class of$u8 { return left$dyns_Source_u8(this.v); } - take$Source(): string | undefined { + take$Source(): rs.String | undefined { return dyns_take$dyns_Source_u8(this); } } @@ -1126,30 +1148,6 @@ export class ofPlace$Option_u8 { } } -export class ofPlace$String { - v: rs.Place; - - constructor(v: rs.Place) { - this.v = v; - } - - writeChar$Write(a: rs.char): rs.Result { - this.v.v = this.v.v + String.fromCodePoint(a); - return rs.OK; - } - - writeFmt$Write(a: rs.Arguments): rs.Result { - const written = rs.fmtWriteString(this.v.v, a); - this.v.v = written.s; - return written.result; - } - - writeStr$Write(a: string): rs.Result { - this.v.v = this.v.v + a; - return rs.OK; - } -} - export class ofPlace$dyns_Held { v: rs.Place; @@ -1209,7 +1207,7 @@ export class ofPlace$dyns_Tri { return Tri.intoArea$dyns_Shape(this.v.v); } - label$Named(): string { + label$Named(): rs.String { return Tri.label$dyns_Named(this.v.v); } @@ -1227,25 +1225,23 @@ export class ofPlace$dyns_Tri { } export class ofPlace$mut_String { - v: rs.Place>; + v: rs.Place; - constructor(v: rs.Place>) { + constructor(v: rs.Place) { this.v = v; } writeChar$Write(a: rs.char): rs.Result { - this.v.v.v = this.v.v.v + String.fromCodePoint(a); + rs.stringPush(this.v.v, a); return rs.OK; } writeFmt$Write(a: rs.Arguments): rs.Result { - const written = rs.fmtWriteString(this.v.v.v, a); - this.v.v.v = written.s; - return written.result; + return rs.fmtWriteString(this.v.v, a); } writeStr$Write(a: string): rs.Result { - this.v.v.v = this.v.v.v + a; + rs.stringPushStr(this.v.v, a); return rs.OK; } } @@ -1305,7 +1301,7 @@ export class ofPlace$u8 { return left$dyns_Source_u8(this.v.v); } - take$Source(): string | undefined { + take$Source(): rs.String | undefined { return dyns_take$dyns_Source_u8(this.v); } } diff --git a/ts/fixtures/lang/dyns/expected/stds.Key.ts b/ts/fixtures/lang/dyns/expected/stds.Key.ts index f1be7faf5..10accdfab 100644 --- a/ts/fixtures/lang/dyns/expected/stds.Key.ts +++ b/ts/fixtures/lang/dyns/expected/stds.Key.ts @@ -26,7 +26,7 @@ export function hash$Hash_mut_stds_Sum(self: Key, state: rs.Place) /** A key of the crate's own, which hashes its fields into whichever hasher it is given. */ export interface Key { id: rs.u16; - name: string; + name: rs.String; tags: rs.ByteVec; } diff --git a/ts/fixtures/lang/dyns/expected/stds.Upper.ts b/ts/fixtures/lang/dyns/expected/stds.Upper.ts index 40a473101..3e315459b 100644 --- a/ts/fixtures/lang/dyns/expected/stds.Upper.ts +++ b/ts/fixtures/lang/dyns/expected/stds.Upper.ts @@ -7,11 +7,11 @@ import * as rs from "./rs.ts"; * `limit` bytes, logs each char `write_char` writes itself, and logs as it drops. */ export class Upper { - s: string; + s: rs.String; limit: rs.usize; log: rs.Arc>; - constructor(s: string, limit: rs.usize, log: rs.Arc>) { + constructor(s: rs.String, limit: rs.usize, log: rs.Arc>) { this.s = s; this.limit = limit; this.log = log; @@ -24,9 +24,9 @@ export class Upper { } export function writeStr$fmt_Write(self: Upper, s: string): rs.Result { - if (!(rs.usizeAdd(rs.stringLen(self.s), rs.stringLen(s)) > self.limit)) { - const _12: string = rs.strToUppercase(s); - self.s = self.s + _12; + if (!(rs.usizeAdd(self.s.len, rs.stringLen(s)) > self.limit)) { + const _12: string = rs.strToUppercase(s).v; + rs.stringPushStr(self.s, _12); return rs.OK; } return rs.Err(new rs.FmtError()); diff --git a/ts/fixtures/lang/dyns/expected/stds.ts b/ts/fixtures/lang/dyns/expected/stds.ts index c07a26e5b..eef90d8e9 100644 --- a/ts/fixtures/lang/dyns/expected/stds.ts +++ b/ts/fixtures/lang/dyns/expected/stds.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { hasher$mut_dyn_hash_Hasher, hasher$mut_hash_DefaultHasher, of$hash_DefaultHasher, of$ref_str, of$stds_Counter, of$stds_Fnv, of$stds_Key, of$stds_Sum, of$stds_Upper, of$u8, ofPlace$String, ofPlace$mut_String } from "./lib.ts"; +import { hasher$mut_dyn_hash_Hasher, hasher$mut_hash_DefaultHasher, of$String, of$hash_DefaultHasher, of$ref_str, of$stds_Counter, of$stds_Fnv, of$stds_Key, of$stds_Sum, of$stds_Upper, of$u8, ofPlace$mut_String } from "./lib.ts"; import type * as fmt_Write from "./core/fmt.Write.ts"; import type * as Hasher from "./core/hash.Hasher.ts"; import { and$0302lm8 as result_and$0302lm8 } from "./core/result.ts"; @@ -87,7 +87,7 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u8 = _10[0]; const b: rs.u8 = _10[1]; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); - const key: Key.Key = { id: (((a as rs.u16) << 8) & 0xffff) | b as rs.u16, name: rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))), tags: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)) }; + const key: Key.Key = { id: (((a as rs.u16) << 8) & 0xffff) | b as rs.u16, name: rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))), tags: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)) }; const keys: DynHash.DynHash[] = [new of$stds_Key(key), new of$u8(a), new of$ref_str("k")]; const std: rs.Hasher = rs.hasher(); const fnv: Fnv.Fnv = new Fnv.Fnv({ hi: 0xcbf29ce4, lo: 0x84222325 } as rs.u64, rs.arcClone(log)); @@ -107,9 +107,9 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _72: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_59, f); const arg = sum._0; const args2: rs.Fmt[] = [_70, _71, _72, (f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_66.value), f, rs.u8Debug)]; - const _43: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "]); + const _43: rs.String = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "]); rs.refRelease(_66); - put(out, _43); + put(out, _43.v); const _79: rs.u8 = rs.u8Rem(a, 3); if (_79 === 0) { _78 = new of$hash_DefaultHasher(rs.hasher()); @@ -122,7 +122,7 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { boxed.writeU8$Hasher(b); const native: rs.Hasher = rs.hasher(); Key.dynHash$stds_DynHash(key, new of$hash_DefaultHasher(native)); - const _100: [rs.u8, string] = [a, key.name]; + const _100: [rs.u8, rs.String] = [a, key.name]; let _103: rs.Hasher = native; rs.hashTuple([rs.hash8, rs.hashStr])(_100, new rs.OwnHasher(rs.place(() => _103, (value2) => _103 = value2), hasher$mut_hash_DefaultHasher)); Key.hash$Hash_boxed_Box_dyn_hash_Hasher(key, rs.place(() => boxed, (value18) => boxed = value18)); @@ -135,66 +135,66 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _129: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_124, f); const arg2 = sum2._0; const args4: rs.Fmt[] = [_128, _129, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "])); + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]).v); rs.drop(boxed); const _143: rs.RefCell = rs.refCellBorrow(log.value); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_143.value), f, rs.u8Debug)]; - const _139: string = rs.fmtFormat([args6[0], " "]); + const _139: rs.String = rs.fmtFormat([args6[0], " "]); rs.refRelease(_143); - put(out, _139); + put(out, _139.v); fnv[Symbol.dispose](); const _160: rs.RefCell = rs.refCellBorrow(log.value); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_160.value), f, rs.u8Debug)]; - const _156: string = rs.fmtFormat([args8[0], " "]); + const _156: rs.String = rs.fmtFormat([args8[0], " "]); rs.refRelease(_160); - put(out, _156); + put(out, _156.v); const _170: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_170.value); rs.refMutRelease(_170); - const text: string = rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))); - let s: string = "s:"; - const written: rs.Result = render(new ofPlace$String(rs.place(() => s, (value20) => s = value20)), a, text); - const upper: Upper.Upper = new Upper.Upper("", rs.u8Rem(b, 32) as rs.usize, rs.arcClone(log)); - const failed: rs.Result = render(new of$stds_Upper(upper), a, text); + const text: rs.String = rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))); + const s: rs.String = rs.stringFrom("s:"); + const written: rs.Result = render(new of$String(s), a, text.v); + const upper: Upper.Upper = new Upper.Upper(rs.stringNew(), rs.u8Rem(b, 32) as rs.usize, rs.arcClone(log)); + const failed: rs.Result = render(new of$stds_Upper(upper), a, text.v); const counter: Counter.Counter = { _0: 0 }; - const counted: rs.Result = render(new of$stds_Counter(counter), b, text); - const again: rs.Result = twice$dyn_fmt_Write(new ofPlace$String(rs.place(() => s, (value21) => s = value21)), "+"); - let inner: rs.Place = rs.place(() => s, (value22) => s = value22); - const again2: rs.Result = result_and$0302lm8(again, render(new ofPlace$mut_String(rs.place(() => inner, (value23) => inner = value23)), b, "&")); + const counted: rs.Result = render(new of$stds_Counter(counter), b, text.v); + const again: rs.Result = twice$dyn_fmt_Write(new of$String(s), "+"); + let inner: rs.String = s; + const again2: rs.Result = result_and$0302lm8(again, render(new ofPlace$mut_String(rs.place(() => inner, (value20) => inner = value20)), b, "&")); const _219: rs.RefCell = rs.refCellBorrow(log.value); - const _228: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s); + const _228: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s.v); const _229: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(written, f, rs.fmtUnit, rs.fmtErrorDebug); const arg3 = upper.s; - const _230: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, arg3); + const _230: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, arg3.v); const _231: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(failed, f, rs.fmtUnit, rs.fmtErrorDebug); const arg4 = counter._0; const args10: rs.Fmt[] = [_228, _229, _230, _231, (f: rs.Formatter) => rs.usizeDisplay(arg4, f), (f: rs.Formatter) => rs.fmtResult(counted, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtResult(again2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_219.value), f, rs.u8Debug)]; - const _213: string = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4], " ", args10[5], " ", args10[6], " ", args10[7], " "]); + const _213: rs.String = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4], " ", args10[5], " ", args10[6], " ", args10[7], " "]); rs.refRelease(_219); - put(out, _213); + put(out, _213.v); const _246: Rendered.Rendered = { _0: a }; const _248: Rendered.Rendered = { _0: b }; const args12: rs.Fmt[] = [(f: rs.Formatter) => Rendered.fmt$fmt_Display(_246, f), (f: rs.Formatter) => Rendered.fmt$fmt_Display(_248, f)]; - put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ align: ">", width: 12 }, args12[1]), " "])); + put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ align: ">", width: 12 }, args12[1]), " "]).v); if (rs.u8Rem(b, 2) === 0) { _255 = new of$stds_Counter({ _0: a as rs.usize }); } else { - _255 = new of$stds_Upper(new Upper.Upper("x", 64, rs.arcClone(log))); + _255 = new of$stds_Upper(new Upper.Upper(rs.stringFrom("x"), 64, rs.arcClone(log))); } const boxed2: fmt_Write.Write = _255; const written2: rs.Result = render(boxed2, b, "b"); rs.drop(boxed2); const _278: rs.RefCell = rs.refCellBorrow(log.value); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(written2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_278.value), f, rs.u8Debug)]; - const _274: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const _274: rs.String = rs.fmtFormat([args14[0], " ", args14[1], " "]); rs.refRelease(_278); - put(out, _274); + put(out, _274.v); upper[Symbol.dispose](); const _297: rs.RefCell = rs.refCellBorrow(log.value); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_297.value), f, rs.u8Debug)]; - const _293: string = rs.fmtFormat([args16[0]]); + const _293: rs.String = rs.fmtFormat([args16[0]]); rs.refRelease(_297); - put(out, _293); + put(out, _293.v); log[Symbol.dispose](); } } diff --git a/ts/fixtures/lang/edits/expected/edits.Named.ts b/ts/fixtures/lang/edits/expected/edits.Named.ts index d989f5ebf..8559291f0 100644 --- a/ts/fixtures/lang/edits/expected/edits.Named.ts +++ b/ts/fixtures/lang/edits/expected/edits.Named.ts @@ -3,14 +3,14 @@ import * as rs from "./rs.ts"; export function clone$Clone(self: Named): Named { - return { id: self.id, name: self.name }; + return { id: self.id, name: rs.stringClone(self.name) }; } export function eq$cmp_PartialEq(self: Named, other: Named): boolean { if (!(self.id === other.id)) { return false; } - return self.name === other.name; + return rs.eqStr(self.name, other.name); } export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { @@ -26,7 +26,7 @@ export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Orderin /** An element that is not `Copy`, cloned and compared field by field. */ export interface Named { id: rs.u16; - name: string; + name: rs.String; } //# sourceMappingURL=edits.Named.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Tally.ts b/ts/fixtures/lang/edits/expected/edits.Tally.ts index 28df292eb..651b3e923 100644 --- a/ts/fixtures/lang/edits/expected/edits.Tally.ts +++ b/ts/fixtures/lang/edits/expected/edits.Tally.ts @@ -5,11 +5,11 @@ import * as rs from "./rs.ts"; /** What `mem::take` leaves its own `Default` in place of. */ export interface Tally { n: rs.u8; - names: rs.Vec; + names: rs.Vec; } export function default$Default(): Tally { - return { n: 7, names: rs.vecFrom(["fresh"]) }; + return { n: 7, names: rs.vecFrom([rs.stringFrom("fresh")]) }; } //# sourceMappingURL=edits.Tally.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index d708e7eea..a1fc25ad7 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -72,11 +72,11 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _33 of pairs.items) { putU16s(out, rs.sliceFrom([_33[0], _33[1]])); } - const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_233: rs.u8): string => { + const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_233: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_233))); }), undefined, 12, true); - rs.vecRetain(names, (s3: string): boolean => { - return rs.stringLen(s3) > 1; + rs.vecRetain(names, (s3: rs.String): boolean => { + return s3.len > 1; }); rs.byteVecPush(out, names.items.length & 0xff); const v2: rs.Vec = rs.vecFrom(words.items.slice()); @@ -93,18 +93,18 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putU16s(out, rs.sliceFrom(v2.items)); while (true) { - const _66: string | undefined = rs.vecPopIfMut(names, (s4: rs.Place): boolean => { - s4.v = s4.v + "."; - return rs.usizeRem(rs.stringLen(s4.v), 3) !== 0; + const _66: rs.String | undefined = rs.vecPopIf(names, (s4: rs.String): boolean => { + rs.stringPush(s4, 46); + return rs.usizeRem(s4.len, 3) !== 0; }); if (_66 !== undefined) { - put(out, _66); + put(out, _66.v); } else { break; } } for (const _76 of names.items) { - put(out, _76); + put(out, _76.v); } const part8 = rs.usizeSaturatingSub(data.length, 1); const stop: rs.u16 = rs.u16Mul(at(part8) as rs.u16, 3); @@ -140,16 +140,16 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.vecDedupBy(tested, (a3: Named.Named, b10: Named.Named): boolean => { seen2.items.push(a3.id); seen2.items.push(b10.id); - return a3.name === b10.name; + return rs.eqStr(a3.name, b10.name); }); putU16s(out, rs.sliceFrom(seen2.items)); for (const _144 of tested.items) { - put(out, _144.name); + put(out, _144.name.v); } - const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_226: rs.u8): string => { + const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_226: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_226, 3)))); }), undefined, 12, true); - rs.vecDedupBy(names2, rs.same); + rs.vecDedupBy(names2, rs.eqStr); rs.byteVecPush(out, names2.items.length & 0xff); } else if (_8 === 2) { const v4: rs.Vec = rs.vecFrom(words.items.slice()); @@ -196,13 +196,13 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return o; })])); } - const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_221: rs.u8): string => { + const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_221: rs.u8): rs.String => { const b8: rs.u8 = _221; return text(rs.byteSliceFrom(Uint8Array.of(b8, rs.u8Div(b8, 16)))); }), undefined, 12, true); rs.sliceSort(rs.sliceFrom(names3.items), rs.cmpLt(rs.cmpStr), 12, true); for (const _263 of names3.items) { - put(out, _263); + put(out, _263.v); } } else if (_8 === 3) { const v6: rs.Vec = rs.vecFrom(words.items.slice()); @@ -250,7 +250,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const changed: rs.Vec = rs.vecFrom(named2.items.map(Named.clone$Clone)); const _411: Named.Named | undefined = rs.sliceFirst(rs.sliceFrom(changed.items)); if (_411 !== undefined) { - _411.name = _411.name + "!"; + rs.stringPush(_411.name, 33); } rs.byteVecPush(out, rs.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); rs.byteVecPush(out, !rs.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); @@ -269,12 +269,14 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.vecFrom(a02.items.slice()); })); rs.byteVecPush(out, rs.eqSlice(rs.eqSlice(rs.same))(_453, nested) ? 1 : 0); - const pair: [string, rs.u8] = [text(data), at(0)]; - const copy: [string, rs.u8] = rs.tupleClone(pair, [undefined, undefined]); - put(out, copy[0]); - const _470: [rs.u8, string] = [copy[1], copy[0]]; - const _474: [rs.u8, string] = [at(1), pair[0]]; - rs.byteVecPush(out, rs.cmpTuple<[rs.u8, string], rs.Ordering | undefined>([rs.cmp, rs.cmpStr])(_470, _474) === 1 ? 1 : 0); + const pair: [rs.String, rs.u8] = [text(data), at(0)]; + const copy: [rs.String, rs.u8] = rs.tupleClone(pair, [(a03: rs.String): rs.String => { + return rs.stringClone(a03); + }, undefined]); + put(out, copy[0].v); + const _470: [rs.u8, rs.String] = [copy[1], copy[0]]; + const _474: [rs.u8, rs.String] = [at(1), pair[0]]; + rs.byteVecPush(out, rs.cmpTuple<[rs.u8, rs.String], rs.Ordering | undefined>([rs.cmp, rs.cmpStr])(_470, _474) === 1 ? 1 : 0); const _483: [rs.u8, rs.u8] = [at(0), at(1)]; const _491: [rs.u8, rs.u8] = [at(1), at(0)]; rs.byteVecPush(out, rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])(_483, _491) === -1 ? 1 : 0); @@ -289,7 +291,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { tally = default_; rs.byteVecPush(out, taken3.n); rs.byteVecPush(out, tally.n); - put(out, tally.names.items[rs.idx(tally.names.items, 0)]); + put(out, tally.names.items[rs.idx(tally.names.items, 0)].v); let queue: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(words.items), undefined, 2, true), 2) as rs.VecDeque; const default_2 = rs.dequeNew(2) as rs.VecDeque; const taken4 = queue; @@ -338,9 +340,9 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, v7.items.length === 0 ? 1 : 0); const boxed: Named.Named = removed; const copy2: Named.Named = Named.clone$Clone(boxed); - copy2.name = copy2.name + "!"; - put(out, boxed.name); - put(out, copy2.name); + rs.stringPush(copy2.name, 33); + put(out, boxed.name.v); + put(out, copy2.name.v); const held: Named.Named | undefined = filter$184yuq2(boxed, (_27: Named.Named): boolean => { return rs.u8Rem(at(3), 2) === 0; }); @@ -371,51 +373,51 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _764: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(at(5))); rs.idx(_764, 0); rs.byteVecPush(out, _764.data[_764.start]); - const part6 = rs.fromUtf8ErrorClone(rs.resultUnwrapErr(rs.stringFromUtf8(rs.byteVecFrom(Uint8Array.of(97, 255, at(6)))), rs.fmtStr)); + const part6 = rs.fromUtf8ErrorClone(rs.resultUnwrapErr(rs.stringFromUtf8(rs.byteVecFrom(Uint8Array.of(97, 255, at(6)))), (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(part6, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); rs.byteVecPush(out, 16 & 0xff); rs.byteVecPush(out, 16 & 0xff); rs.byteVecPush(out, 4 & 0xff); rs.byteVecPush(out, 6 & 0xff); rs.byteVecPush(out, rs.u8Mul(4 & 0xff, 1 & 0xff)); } else { - const s2: string = text(data); + const s2: rs.String = text(data); const sep: rs.char[] = [47, 97]; - rs.byteVecPush(out, rs.strContains(s2, rs.patternChars(sep)) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s2, rs.patternChars(sep)) ? 1 : 0); - rs.byteVecPush(out, rs.iterCount(rs.strSplit(s2, rs.patternChars(sep))) & 0xff); - rs.byteVecPush(out, rs.strEndsWith(s2, "/") ? 1 : 0); - rs.byteVecPush(out, rs.strEndsWith(s2, "😀") ? 1 : 0); - rs.byteVecPush(out, rs.strEndsWith(s2, (c: rs.char): boolean => { + rs.byteVecPush(out, rs.strContains(s2.v, rs.patternChars(sep)) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s2.v, rs.patternChars(sep)) ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.strSplit(s2.v, rs.patternChars(sep))) & 0xff); + rs.byteVecPush(out, rs.strEndsWith(s2.v, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strEndsWith(s2.v, "😀") ? 1 : 0); + rs.byteVecPush(out, rs.strEndsWith(s2.v, (c: rs.char): boolean => { return rs.isAsciiDigit(c); }) ? 1 : 0); - const _848: [string, string] | undefined = rs.strSplitOnce(s2, "/"); + const _848: [string, string] | undefined = rs.strSplitOnce(s2.v, "/"); if (_848 === undefined) { rs.byteVecPush(out, 253); } else { put(out, _848[0]); put(out, _848[1]); } - const _857: [string, string] | undefined = rs.strSplitOnce(s2, "a0"); + const _857: [string, string] | undefined = rs.strSplitOnce(s2.v, "a0"); if (_857 === undefined) { rs.byteVecPush(out, 253); } else { put(out, _857[0]); put(out, _857[1]); } - const iter11: rs.RangeInclusive = new rs.RangeInclusive(0, rs.usizeAdd(rs.stringLen(s2), 1), rs.usizeStep); + const iter11: rs.RangeInclusive = new rs.RangeInclusive(0, rs.usizeAdd(s2.len, 1), rs.usizeStep); while (true) { const _872: rs.usize | rs.Done = iter11.next(); if (_872 === rs.DONE) { break; } - rs.byteVecPush(out, rs.strIsCharBoundary(s2, _872) ? 1 : 0); + rs.byteVecPush(out, rs.strIsCharBoundary(s2.v, _872) ? 1 : 0); } - rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); - rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.strBytes(s2)), 3), undefined, true); - rs.byteVecPush(out, rs.strBytes(s2).len() & 0xff); - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.strBytes(s2), (_22: rs.u8): boolean => { + rs.iterExtendBytes(out, rs.strBytes(s2.v), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.strBytes(s2.v)), 3), undefined, true); + rs.byteVecPush(out, rs.strBytes(s2.v).len() & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.strBytes(s2.v), (_22: rs.u8): boolean => { return _22 >= 128; })) & 0xff); } @@ -612,41 +614,37 @@ export function apply$Option_u8_u8_Option_u8_Option_T_replace_u8(_: (a0: rs.Plac } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_String_String_mem_replace_String(_: (a0: rs.Place, a1: string) => string, place: rs.Place, value: string): string { - return ((a0: rs.Place, a1: string): string => { - const old = a0.v; - a0.v = a1; - return old; +export function apply$String_String_String_mem_replace_String(_: (a0: rs.String, a1: rs.String) => rs.String, place: rs.String, value: rs.String): rs.String { + return ((a0: rs.String, a1: rs.String): rs.String => { + return rs.replaceIn(a0, a1); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_char_unit_String_push(_: (a0: rs.Place, a1: rs.char) => undefined, place: rs.Place, value: rs.char): void { - ((a0: rs.Place, a1: rs.char): undefined => { - a0.v = a0.v + String.fromCodePoint(a1); +export function apply$String_char_unit_String_push(_: (a0: rs.String, a1: rs.char) => undefined, place: rs.String, value: rs.char): void { + ((a0: rs.String, a1: rs.char): undefined => { + rs.stringPush(a0, a1); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rs.Place, a1: rs.Place) => undefined, place: rs.Place, value: rs.Place): void { - ((a0: rs.Place, a1: rs.Place): undefined => { - const swapped = a0.v; - a0.v = a1.v; - a1.v = swapped; +export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rs.String, a1: rs.String) => undefined, place: rs.String, value: rs.String): void { + ((a0: rs.String, a1: rs.String): undefined => { + Object.assign(a0, rs.replaceIn(a1, a0)); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_ref_String_unit_Clone_clone_from_String(_: (a0: rs.Place, a1: string) => undefined, place: rs.Place, value: string): void { - ((a0: rs.Place, a1: string): undefined => { - a0.v = a1; +export function apply$String_ref_String_unit_Clone_clone_from_String(_: (a0: rs.String, a1: rs.String) => undefined, place: rs.String, value: rs.String): void { + ((a0: rs.String, a1: rs.String): undefined => { + Object.assign(a0, rs.stringCloneFrom(a0, a1)); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_ref_str_unit_String_push_str(_: (a0: rs.Place, a1: string) => undefined, place: rs.Place, value: string): void { - ((a0: rs.Place, a1: string): undefined => { - a0.v = a0.v + a1; +export function apply$String_ref_str_unit_String_push_str(_: (a0: rs.String, a1: string) => undefined, place: rs.String, value: string): void { + ((a0: rs.String, a1: string): undefined => { + rs.stringPushStr(a0, a1); })(place, value); } @@ -716,15 +714,13 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), (n3: rs.usize): rs.u8 => { return n3 & 0xff; }), undefined, true); - const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): string => { + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_210))); }), undefined, 12, true); - put(out, rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSliceMut(rs.sliceFrom(texts.items))), (a024: rs.Place): string => { - const taken9 = a024.v; - a024.v = ""; - return taken9; - }), undefined, 12, true).items, "")); - put(out, rs.strsJoin(texts.items, "")); + put(out, rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(texts.items)), (a024: rs.String): rs.String => { + return rs.replaceIn(a024, rs.stringNew()); + }), undefined, 12, true).items, "").v); + put(out, rs.strsJoin(texts.items, "").v); } else if (_5 === 1) { let n: rs.u8 = at(0); const _66: rs.u8 = at(1); @@ -742,14 +738,12 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _75: rs.u8 = at(2); rs.byteVecPush(out, replace(rs.place(() => n, (value4) => n = value4), _75)); rs.byteVecPush(out, n); - let s: string = text(data); - const _83: string = text(rs.byteSliceFrom(Uint8Array.of(at(0)))); - put(out, apply$String_String_String_mem_replace_String((a010: rs.Place, a19: string): string => { - const old8 = a010.v; - a010.v = a19; - return old8; - }, rs.place(() => s, (value5) => s = value5), _83)); - put(out, s); + const s: rs.String = text(data); + const _83: rs.String = text(rs.byteSliceFrom(Uint8Array.of(at(0)))); + put(out, apply$String_String_String_mem_replace_String((a010: rs.String, a19: rs.String): rs.String => { + return rs.replaceIn(a010, a19); + }, s, _83).v); + put(out, s.v); const v: rs.ByteVec = rs.byteSliceToByteVec(data); const old2: rs.ByteVec = ((a011: rs.ByteVec): rs.ByteVec => { return rs.replaceIn(a011, new rs.ByteVec()); @@ -762,20 +756,20 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const old9 = a012.v; a012.v = a110; return old9; - }, rs.place(() => held2, (value6) => held2 = value6), _121)), undefined, true); + }, rs.place(() => held2, (value5) => held2 = value5), _121)), undefined, true); rs.iterExtendBytes(out, rs.iterOption(held2), undefined, true); - apply$String_ref_str_unit_String_push_str((a013: rs.Place, a111: string): undefined => { - a013.v = a013.v + a111; - }, rs.place(() => s, (value7) => s = value7), "+"); - apply$String_char_unit_String_push((a014: rs.Place, a112: rs.char): undefined => { - a014.v = a014.v + String.fromCodePoint(a112); - }, rs.place(() => s, (value8) => s = value8), 33); + apply$String_ref_str_unit_String_push_str((a013: rs.String, a111: string): undefined => { + rs.stringPushStr(a013, a111); + }, s, "+"); + apply$String_char_unit_String_push((a014: rs.String, a112: rs.char): undefined => { + rs.stringPush(a014, a112); + }, s, 33); const _136: rs.usize = old2.length; - const _134: string = rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_136, f)); - apply$String_ref_String_unit_Clone_clone_from_String((a015: rs.Place, a113: string): undefined => { - a015.v = a113; - }, rs.place(() => s, (value9) => s = value9), _134); - put(out, s); + const _134: rs.String = rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_136, f), 0); + apply$String_ref_String_unit_Clone_clone_from_String((a015: rs.String, a113: rs.String): undefined => { + Object.assign(a015, rs.stringCloneFrom(a015, a113)); + }, s, _134); + put(out, s.v); const bytes2: rs.ByteVec = rs.byteSliceToByteVec(data); rs.iterForEach(rs.iterSliceMut(rs.byteVecSlice(bytes2)), (a016: rs.Place): undefined => { a016.v = rs.toAsciiUppercase(a016.v); @@ -825,22 +819,20 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })(x, y); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(x)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(y)); - const texts2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): string => { + const texts2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_22))); }), undefined, 12, true); - const others: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_26: rs.u8): string => { + const others: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_26: rs.u8): rs.String => { const b6: rs.u8 = _26; return text(rs.byteSliceFrom(Uint8Array.of(b6, b6))); }), undefined, 12, true); - rs.iterForEach(rs.iterZip(rs.iterSliceMut(rs.sliceFrom(texts2.items)), rs.iterSliceMut(rs.sliceFrom(others.items)), [false, false]), (_27: [rs.Place, rs.Place]): undefined => { - apply$String_mut_String_unit_mem_swap_String((a07: rs.Place, a16: rs.Place): undefined => { - const swapped4 = a07.v; - a07.v = a16.v; - a16.v = swapped4; + rs.iterForEach(rs.iterZip(rs.iterSlice(texts2.items), rs.iterSlice(others.items), [false, false]), (_27: [rs.String, rs.String]): undefined => { + apply$String_mut_String_unit_mem_swap_String((a07: rs.String, a16: rs.String): undefined => { + Object.assign(a07, rs.replaceIn(a16, a07)); }, _27[0], _27[1]); }); - put(out, rs.strsJoin(texts2.items, "")); - put(out, rs.strsJoin(others.items, "")); + put(out, rs.strsJoin(texts2.items, "").v); + put(out, rs.strsJoin(others.items, "").v); } else { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { @@ -1078,11 +1070,11 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } const i: rs.usize = _224[0]; - _224[1].name = _224[1].name + "!"; + rs.stringPush(_224[1].name, 33); _224[1].id = rs.u16Add(_224[1].id, i & 0xffff); } for (const _236 of v3.items) { - put(out, _236.name); + put(out, _236.name.v); rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_236.id)), undefined, true); } const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_226: rs.u8): rs.u16[] => { @@ -1303,7 +1295,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_715 === rs.DONE) { break; } - _715.name = _715.name + "+"; + rs.stringPush(_715.name, 43); } const iter13: rs.Iter = rs.dequeIter(named); while (true) { @@ -1311,7 +1303,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_724 === rs.DONE) { break; } - put(out, _724.name); + put(out, _724.name.v); } const bytes2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), 1, true) as rs.VecDeque; const _735: rs.Place | rs.Done = rs.dequeRangeMut(bytes2, undefined).next(); @@ -1598,7 +1590,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const iterEnd2: rs.i32 = 3; while (iterStart2++ < iterEnd2) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecExtractIf(it2, f, rs.u16Debug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0]]).v))), undefined, true); it2.next(); } rs.drop(it2); @@ -1610,7 +1602,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return { id: b12 as rs.u16, name: text(rs.byteSliceFrom(Uint8Array.of(b12))) }; }), undefined, 16, true); const taken: rs.Vec = rs.iterToVec(rs.vecExtractIf(named2, undefined, (n9: Named.Named): boolean => { - n9.name = n9.name + "+"; + rs.stringPush(n9.name, 43); return rs.u16Rem(n9.id, 2) === 0; }), "next", 16); const iter4: rs.Iter = rs.iterChain(rs.iterSlice(named2.items), rs.iterSlice(taken.items)); @@ -1619,7 +1611,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_130 === rs.DONE) { break; } - put(out, _130.name); + put(out, _130.name.v); } const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const _140: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(data.length, 1)), rs.usizeStep); @@ -1629,7 +1621,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); const first: rs.u8 | undefined = rs.iterToOption(it3.next()); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecExtractIf(it3, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]]).v))), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(it3, "next"))); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); rs.vecExtractIfMut(w, undefined, (x2: rs.Place): boolean => { @@ -1717,7 +1709,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const s: rs.Iter = rs.spliceFrom(rs.vecSplice(pairs, r4, 4), _337, true); const first3: rs.u16[] | undefined = rs.iterToOption(s.next()); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))), (f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args6[0], args6[1]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args6[0], args6[1]]).v))), undefined, true); const removed: rs.Vec = rs.iterToVec(rs.iterChain(rs.iterOption(copy$Option_array2_u16(first3)), s), "next", 4); const iter5: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterSlice(pairs.items)); while (true) { @@ -1748,7 +1740,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const s2: rs.Iter = rs.spliceFrom(rs.byteVecSplice(bytes2, r5), _409); const back: rs.u8 | undefined = rs.iterToOption(s2.nextBack()); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s2, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtCounted(value, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args8[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args8[0]]).v))), undefined, true); rs.drop(s2); rs.iterExtendBytes(out, rs.iterOption(back), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes2)); @@ -1757,7 +1749,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _454: Uint8Array = Uint8Array.of(170, 187); const s3: rs.Iter = rs.spliceFrom(rs.byteVecSplice(tail, _453), rs.iterSlice(_454), true); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s3, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"]))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args10[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args10[0]]).v))), undefined, true); rs.iterExtendBytes(out, rs.iterRev(s3), "next"); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tail)); const hints: rs.RefCell = new rs.RefCell(new rs.ByteVec()); @@ -1825,10 +1817,10 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_607 === rs.DONE) { break; } - _607.name = _607.name + "!"; + rs.stringPush(_607.name, 33); } for (const _616 of flat3.items) { - put(out, _616.name); + put(out, _616.name.v); } const flat4: rs.ByteVec = rs.byteVecIntoFlattened(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c3: rs.ByteSlice): Uint8Array => { rs.idx(c3, 0); @@ -1873,10 +1865,10 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }, Tracked.cmp$cmp_Ord, rs.drop); mark(240); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(found, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args12[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args12[0]]).v))), undefined, true); const part3 = rs.dequeBinarySearch(q, probe, Tracked.cmp$cmp_Ord); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part3, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args14[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args14[0]]).v))), undefined, true); rs.byteVecPush(out, rs.dequePartitionPoint(q, (t4: Tracked.Tracked): boolean => { return t4.id < probe.id; }) & 0xff); @@ -1975,13 +1967,13 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return rs.cmp(n5.id, probe2); }); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args16[0]])))), undefined, true); - const _947: string = text(rs.byteSliceFrom(Uint8Array.of(at(3)))); - const found4: rs.Result = rs.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): string => { - return n6.name; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args16[0]]).v))), undefined, true); + const _947: rs.String = text(rs.byteSliceFrom(Uint8Array.of(at(3)))); + const found4: rs.Result = rs.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): rs.String => { + return rs.stringClone(n6.name); }, rs.cmpStr); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(found4, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args18[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args18[0]]).v))), undefined, true); rs.byteVecPush(out, rs.dequePartitionPoint(named4, (n7: Named.Named): boolean => { return n7.id <= probe2; }) & 0xff); @@ -1992,7 +1984,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } const _974: Named.Named | undefined = rs.dequeGet(named4, i4); if (_974 !== undefined) { - _974.name = _974.name + "?"; + rs.stringPush(_974.name, 63); } const iter15: rs.Iter = rs.dequeIter(named4); while (true) { @@ -2000,7 +1992,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_984 === rs.DONE) { break; } - put(out, _984.name); + put(out, _984.name.v); } } } diff --git a/ts/fixtures/lang/edits/expected/harness.ts b/ts/fixtures/lang/edits/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/edits/expected/harness.ts +++ b/ts/fixtures/lang/edits/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/errors/expected/core/result.ts b/ts/fixtures/lang/errors/expected/core/result.ts index cb538e3b5..8d434615d 100644 --- a/ts/fixtures/lang/errors/expected/core/result.ts +++ b/ts/fixtures/lang/errors/expected/core/result.ts @@ -31,12 +31,12 @@ export function eq$1amzj8d(self: rs.Result return str_error_eq$1lr55px(self.error, (other as { ok: false; error: rs.ParseBoolError }).error); } -export function eq$1357wj0(self: rs.Result, other: rs.Result): boolean { +export function eq$1h622n4(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: string }).value; + return rs.eqStr(self.value, (other as { ok: true; value: rs.String }).value); } return string_eq$1enuhj8(self.error, (other as { ok: false; error: rs.FromUtf8Error }).error); } @@ -240,9 +240,9 @@ export function map$07r5pce(self: rs.Result, op: (a0: r return self as rs.Result; } -export function mapErr$1scmdah(self: rs.Result>, op: (a0: rs.Result) => rs.Result): rs.Result> { +export function mapErr$1102tun(self: rs.Result>, op: (a0: rs.Result) => rs.Result): rs.Result> { if (self.ok) { - return self as rs.Result>; + return self as rs.Result>; } return rs.Err(op(self.error)); } @@ -254,9 +254,9 @@ export function mapErr$0ka0di9(self: rs.Result, op: (a0: Err return rs.Err(op(self.error)); } -export function mapErr$1a5uolr(self: rs.Result, op: (a0: Error.Error) => string): rs.Result { +export function mapErr$1lqaapp(self: rs.Result, op: (a0: Error.Error) => rs.String): rs.Result { if (self.ok) { - return self as rs.Result; + return self as rs.Result; } return rs.Err(op(self.error)); } diff --git a/ts/fixtures/lang/errors/expected/errors.ts b/ts/fixtures/lang/errors/expected/errors.ts index ff1e038e3..05a036d38 100644 --- a/ts/fixtures/lang/errors/expected/errors.ts +++ b/ts/fixtures/lang/errors/expected/errors.ts @@ -8,7 +8,7 @@ import type * as Error from "./core/error.Error.ts"; import { fromStr$1t58fis as num_fromStr$1t58fis } from "./core/num.ts"; import { eq$1uroq6x as num_error_eq$1uroq6x } from "./core/num/error.ts"; import { map$1hw1osb as option_map$1hw1osb, map$0jqf1o0 as option_map$0jqf1o0, map$0p4jgzx as option_map$0p4jgzx } from "./core/option.ts"; -import { eq$0ypn0py as result_eq$0ypn0py, eq$1amzj8d as result_eq$1amzj8d, eq$1357wj0 as result_eq$1357wj0, eq$0q0qbov as result_eq$0q0qbov, eq$1w4olsu as result_eq$1w4olsu, eq$1nt6phd as result_eq$1nt6phd, eq$0y6o605 as result_eq$0y6o605, eq$1ow2tmy as result_eq$1ow2tmy, eq$17fo3dq as result_eq$17fo3dq, eq$0trkzzw as result_eq$0trkzzw, eq$1fss0tv as result_eq$1fss0tv, eq$0rz6big as result_eq$0rz6big, eq$06v73px as result_eq$06v73px, eq$096f56j as result_eq$096f56j, eq$031vf96 as result_eq$031vf96, eq$1qyqhny as result_eq$1qyqhny, eq$0hvarbg as result_eq$0hvarbg, eq$03c8d7v as result_eq$03c8d7v, err$11tr79p, err$0bvotqj, err$1tv7qwu, err$069ojhs, map$1w6ihbb as result_map$1w6ihbb, map$18dk705 as result_map$18dk705, map$07r5pce as result_map$07r5pce, mapErr$1scmdah as result_mapErr$1scmdah, mapErr$0ka0di9 as result_mapErr$0ka0di9, mapErr$1a5uolr as result_mapErr$1a5uolr, mapErr$09oysgi as result_mapErr$09oysgi, mapErr$1xpyw31 as result_mapErr$1xpyw31, clone$0688qis as result_clone$0688qis } from "./core/result.ts"; +import { eq$0ypn0py as result_eq$0ypn0py, eq$1amzj8d as result_eq$1amzj8d, eq$1h622n4 as result_eq$1h622n4, eq$0q0qbov as result_eq$0q0qbov, eq$1w4olsu as result_eq$1w4olsu, eq$1nt6phd as result_eq$1nt6phd, eq$0y6o605 as result_eq$0y6o605, eq$1ow2tmy as result_eq$1ow2tmy, eq$17fo3dq as result_eq$17fo3dq, eq$0trkzzw as result_eq$0trkzzw, eq$1fss0tv as result_eq$1fss0tv, eq$0rz6big as result_eq$0rz6big, eq$06v73px as result_eq$06v73px, eq$096f56j as result_eq$096f56j, eq$031vf96 as result_eq$031vf96, eq$1qyqhny as result_eq$1qyqhny, eq$0hvarbg as result_eq$0hvarbg, eq$03c8d7v as result_eq$03c8d7v, err$11tr79p, err$0bvotqj, err$1tv7qwu, err$069ojhs, map$1w6ihbb as result_map$1w6ihbb, map$18dk705 as result_map$18dk705, map$07r5pce as result_map$07r5pce, mapErr$1102tun as result_mapErr$1102tun, mapErr$0ka0di9 as result_mapErr$0ka0di9, mapErr$1lqaapp as result_mapErr$1lqaapp, mapErr$09oysgi as result_mapErr$09oysgi, mapErr$1xpyw31 as result_mapErr$1xpyw31, clone$0688qis as result_clone$0688qis } from "./core/result.ts"; import { parse$1yfzdza, parse$1kyj9pm, parse$02m1946, parse$04z9euf, parse$092epd5, parse$1brosjp } from "./core/str.ts"; import { eq$1lr55px as str_error_eq$1lr55px } from "./core/str/error.ts"; import type * as Coded from "./errors.Coded.ts"; @@ -67,17 +67,17 @@ export function pairs$Result_Result_char_char_ParseCharError_str_ParseBoolError( } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_String_string_FromUtf8Error(values: rs.Slice>, out: rs.ByteVec): void { +export function pairs$Result_String_string_FromUtf8Error(values: rs.Slice>, out: rs.ByteVec): void { l1: for (const a of rs.sliceItems(values)) { - const iterS2: rs.Result[] = rs.sliceItems(values); + const iterS2: rs.Result[] = rs.sliceItems(values); let iterI2: number = 0; while (true) { - const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; if (_11 === rs.DONE) { continue l1; } - const b: rs.Result = _11; - rs.byteVecPush(out, (result_eq$1357wj0(a, b) ? 1 : 0) | (((!result_eq$1357wj0(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1h622n4(a, b) ? 1 : 0) | (((!result_eq$1h622n4(a, b) ? 1 : 0) << 1) & 0xff)); } } } @@ -471,15 +471,15 @@ export function parsed$u8(all: rs.Slice): rs.Vec = rs.sliceFrom([48, 49, 50, 53, 57, 43, 45, 46, 101, 97, 98, 78, 116, 102, 233]); const _15: rs.usize = rs.usizeRem(b as rs.usize, rs.sliceFrom([48, 49, 50, 53, 57, 43, 45, 46, 101, 97, 98, 78, 116, 102, 233]).length); rs.idx(_14, _15); - input = input + String.fromCodePoint(_14.data[_14.start + _15]); + rs.stringPush(input, _14.data[_14.start + _15]); } const all: rs.Vec = rs.vecFrom(["", "0", "-0", "1", "-1", "+", "a", "ab", "😀", "true", "false", "127", "128", "-128", "-129", "256", "18446744073709551615", "18446744073709551616", "-170141183460469231731687303715884105729", "1.5", "1e400", "NaN", "inf"].slice()); - all.items.push(input); + all.items.push(input.v); const bytes: rs.Vec = rs.vecFrom([rs.byteSliceFrom(Uint8Array.of()), rs.byteSliceFrom(Uint8Array.of(97)), rs.byteSliceFrom(Uint8Array.of(255)), rs.byteSliceFrom(Uint8Array.of(97, 255)), rs.byteSliceFrom(Uint8Array.of(195)), rs.byteSliceFrom(Uint8Array.of(97, 195)), rs.byteSliceFrom(Uint8Array.of(224, 128)), rs.byteSliceFrom(Uint8Array.of(240, 159, 152)), rs.byteSliceFrom(Uint8Array.of(240, 159, 152, 128)), rs.byteSliceFrom(Uint8Array.of(237, 160, 128))].slice()); bytes.items.push(data); const _32: rs.u8 = rs.u8Rem(kind, 16); @@ -513,7 +513,7 @@ export function eqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.strFromUtf8(b7); }), undefined, 12, true).items), out); } else if (_32 === 10) { - pairs$Result_String_string_FromUtf8Error(rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(bytes.items), (b6: rs.ByteSlice): rs.Result => { + pairs$Result_String_string_FromUtf8Error(rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(bytes.items), (b6: rs.ByteSlice): rs.Result => { return rs.stringFromUtf8(rs.byteSliceToByteVec(b6)); }), undefined, 20, true).items), out); } else if (_32 === 11) { @@ -561,8 +561,8 @@ export function eqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { n = b2 as rs.usize; } - const text: string = rs.strSlice("ab", 0, rs.u8Rem(b2, 3) as rs.usize); - return [rs.byteVecTryReserve(new rs.ByteVec(), n), rs.stringTryReserve(text, n), rs.dequeTryReserve(rs.dequeNew(2) as rs.VecDeque, n), rs.hashTryReserve(rs.hashNew() as rs.HashSet, n, 469762048)]; + const text: rs.String = rs.stringFrom(rs.strSlice("ab", 0, rs.u8Rem(b2, 3) as rs.usize)); + return [rs.byteVecTryReserve(new rs.ByteVec(), n), rs.stringTryReserveExact(text, n), rs.dequeTryReserve(rs.dequeNew(2) as rs.VecDeque, n), rs.hashTryReserve(rs.hashNew() as rs.HashSet, n, 469762048)]; }, (value: rs.Result[]) => rs.iterSlice(value), true, 4), undefined, 8, true); pairs$collections_TryReserveError(rs.sliceFrom(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(v7.items), (r: rs.Result): rs.TryReserveError | undefined => { return err$069ojhs(result_clone$0688qis(r)); @@ -598,16 +598,16 @@ export function DROPPED$init(): rs.Cell { } /** Each error in the chain, by `Display` and `Debug`. */ -export function chain(e: Error.Error): string { +export function chain(e: Error.Error): rs.String { const args2: rs.Fmt[] = [(f: rs.Formatter) => e.fmt$Display(f), (f: rs.Formatter) => e.fmt$Debug(f)]; - let s: string = rs.fmtFormat([args2[0], " ", args2[1]]); + const s: rs.String = rs.fmtFormat([args2[0], " ", args2[1]]); let cur: Error.Error | undefined = e.source$Error(); while (true) { if (cur !== undefined) { const c: Error.Error = cur; const args4: rs.Fmt[] = [(f: rs.Formatter) => c.fmt$Display(f), (f: rs.Formatter) => c.fmt$Debug(f)]; - const _17: string = rs.fmtFormat([" <- ", args4[0], " ", args4[1]]); - s = s + _17; + const _17: string = rs.fmtFormat([" <- ", args4[0], " ", args4[1]]).v; + rs.stringPushStr(s, _17); cur = c.source$Error(); } else { return s; @@ -634,7 +634,7 @@ export function failure(kind: rs.u8, n: rs.u8): Failure.Failure { export function checked(kind: rs.u8, n: rs.u8): rs.Result { if (!(rs.u8Rem(n, 4) === 0)) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args2[0], args2[0]])), (a0: rs.ParseIntError): Failure.Failure => { + const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args2[0], args2[0]]).v), (a0: rs.ParseIntError): Failure.Failure => { return { tag: "Parse", _0: a0 }; }); if (_8.ok) { @@ -661,37 +661,37 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const a: rs.u8 = _10[0]; const b: rs.u8 = _10[1]; const _24: Failure.Failure = failure(a, b); - const _21: string = chain(new of$errors_Failure(_24)); + const _21: rs.String = chain(new of$errors_Failure(_24)); const _29: Leaf.Leaf = new Leaf.Leaf(a); - const _26: string = chain(new of$errors_Leaf(_29)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _21), (f: rs.Formatter) => rs.fmtPad(f, _26)]; - const _17: string = rs.fmtFormat([args2[0], " | ", args2[1], " | "]); + const _26: rs.String = chain(new of$errors_Leaf(_29)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _21.v), (f: rs.Formatter) => rs.fmtPad(f, _26.v)]; + const _17: rs.String = rs.fmtFormat([args2[0], " | ", args2[1], " | "]); _29[Symbol.dispose](); drop$errors_Failure(_24); - put(out, _17); + put(out, _17.v); const part = chain(new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args4[0], " | "])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part.v)]; + put(out, rs.fmtFormat([args4[0], " | "]).v); const reserved: Error.Error = rs.resultUnwrapErr(reserve(a), rs.fmtUnit); - const _63: string = chain(reserved); + const _63: rs.String = chain(reserved); const _66: boolean = reserved instanceof of$collections_TryReserveError || reserved instanceof ofPlace$collections_TryReserveError; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _63), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; - put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1]), " ", args6[2], " | "])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _63.v), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; + put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1]), " ", args6[2], " | "]).v); const held: Failure.Failure = failure(a, b); - const _86: string = chain(new of$boxed_Box_errors_Failure(held)); - const _90: string = chain(new of$ref_errors_Failure(held)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _86), (f: rs.Formatter) => rs.fmtPad(f, _90)]; - put(out, rs.fmtFormat([args8[0], " | ", args8[1], " | "])); + const _86: rs.String = chain(new of$boxed_Box_errors_Failure(held)); + const _90: rs.String = chain(new of$ref_errors_Failure(held)); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _86.v), (f: rs.Formatter) => rs.fmtPad(f, _90.v)]; + put(out, rs.fmtFormat([args8[0], " | ", args8[1], " | "]).v); const coded: Coded.Coded = new of$errors_Failure(failure(b, a)); const up: Error.Error = coded; const _111: rs.u8 = coded.code$Coded(); - const _114: string = chain(up); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " | "])); + const _114: rs.String = chain(up); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114.v)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " | "]).v); const boxed: Transported.Transported = new Transported.Transported(coded); - const _129: string = chain(new of$errors_Transported(boxed)); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; - put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[1]), " | "])); + const _129: rs.String = chain(new of$errors_Transported(boxed)); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129.v), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; + put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[1]), " | "]).v); set$1ljkjlf(DROPPED, 0); const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): rs.Result => { const n: rs.u8 = _2; @@ -701,40 +701,40 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number if (_149.ok) { const arg = _149.value; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([args14[0], " "]).v); } else { const part2 = chain(_149.error); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2)]; - put(out, rs.fmtFormat([args16[0], " "])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2.v)]; + put(out, rs.fmtFormat([args16[0], " "]).v); } } rs.dropVec(results, drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send); const part3 = get$0q7640n(DROPPED); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - put(out, rs.fmtFormat(["| ", args18[0], " "])); + put(out, rs.fmtFormat(["| ", args18[0], " "]).v); set$1ljkjlf(DROPPED, 0); const leaf: Leaf.Leaf = new Leaf.Leaf(b); const borrowed: Error.Error = new of$ref_errors_Leaf(leaf); const part4 = chain(borrowed); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; - put(out, rs.fmtFormat([args20[0], " "])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4.v)]; + put(out, rs.fmtFormat([args20[0], " "]).v); rs.drop(borrowed); const part5 = get$0q7640n(DROPPED); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - put(out, rs.fmtFormat([args22[0], " "])); + put(out, rs.fmtFormat([args22[0], " "]).v); leaf[Symbol.dispose](); const part6 = get$0q7640n(DROPPED); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - put(out, rs.fmtFormat([args24[0], " | "])); + put(out, rs.fmtFormat([args24[0], " | "]).v); const coded2: Coded.Coded = new of$errors_Failure(failure(a, b)); const part7 = downcast(coded2); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part7)]; - put(out, rs.fmtFormat([args26[0], " "])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part7.v)]; + put(out, rs.fmtFormat([args26[0], " "]).v); const errors: rs.Vec = rs.vecFrom([coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))]); for (const _277 of errors.items) { const part8 = downcast(_277); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part8)]; - put(out, rs.fmtFormat([args28[0], " "])); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part8.v)]; + put(out, rs.fmtFormat([args28[0], " "]).v); } const leaf2: Leaf.Leaf = new Leaf.Leaf(a); const e: Error.Error = new of$errors_Leaf(leaf2); @@ -744,7 +744,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number } const arg2 = leaf2.code; const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f)]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([args30[0], " "]).v); set$1ljkjlf(DROPPED, 0); for (const e2 of errors.items) { const _324: rs.Result = e2 instanceof of$errors_Failure ? rs.Ok(e2.v) : rs.Err(e2); @@ -753,7 +753,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const _334: rs.u8 = Failure.code$errors_Coded(f); const _337: rs.u32 = get$0q7640n(DROPPED); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; - put(out, rs.fmtFormat(["failure ", args32[0], " ", args32[1], " "])); + put(out, rs.fmtFormat(["failure ", args32[0], " ", args32[1], " "]).v); drop$errors_Failure(f); } else { const e3: Error.Error = _324.error; @@ -763,34 +763,34 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const _356: rs.u32 = get$0q7640n(DROPPED); const arg3 = l.code; const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg3, f), (f: rs.Formatter) => rs.u32Display(_356, f)]; - put(out, rs.fmtFormat(["leaf ", args34[0], " ", args34[1], " "])); + put(out, rs.fmtFormat(["leaf ", args34[0], " ", args34[1], " "]).v); l[Symbol.dispose](); } else { const e4: Error.Error = _345.error; const args36: rs.Fmt[] = [(f: rs.Formatter) => e4.fmt$Display(f)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([args36[0], " "]).v); rs.drop(e4); } } } const part9 = get$0q7640n(DROPPED); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; - put(out, rs.fmtFormat([args38[0], " "])); - const part10 = result_mapErr$1scmdah(result_mapErr$0ka0di9(checked(b, rs.u8WrappingMul(a, 4)), (e5: Error.Error): rs.Result => { + put(out, rs.fmtFormat([args38[0], " "]).v); + const part10 = result_mapErr$1102tun(result_mapErr$0ka0di9(checked(b, rs.u8WrappingMul(a, 4)), (e5: Error.Error): rs.Result => { return result_map$18dk705(e5 instanceof of$errors_Failure ? rs.Ok(e5.v) : rs.Err(e5), (f2: Failure.Failure): rs.u8 => { const _03: rs.u8 = Failure.code$errors_Coded(f2); drop$errors_Failure(f2); return _03; }); - }), (e6: rs.Result): rs.Result => { - return result_mapErr$1a5uolr(e6, (e7: Error.Error): string => { - const _05: string = rs.fmtToString((f: rs.Formatter) => e7.fmt$Display(f)); + }), (e6: rs.Result): rs.Result => { + return result_mapErr$1lqaapp(e6, (e7: Error.Error): rs.String => { + const _05: rs.String = rs.fmtToString((f: rs.Formatter) => e7.fmt$Display(f)); rs.drop(e7); return _05; }); }); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; - put(out, rs.fmtFormat([args40[0]])); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]; + put(out, rs.fmtFormat([args40[0]]).v); leaf2[Symbol.dispose](); boxed[Symbol.dispose](); drop$errors_Failure(held); @@ -799,7 +799,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number } /** Which of the crate's errors and std's `e` and its source are, and the `Failure` it holds. */ -export function downcast(e: Error.Error): string { +export function downcast(e: Error.Error): rs.String { const is: [boolean, boolean, boolean] = [e instanceof of$errors_Failure || e instanceof ofPlace$errors_Failure, e instanceof of$errors_Leaf, e instanceof of$num_ParseIntError || e instanceof ofPlace$num_ParseIntError]; const source: [boolean, rs.IntErrorKind | undefined] | undefined = option_map$1hw1osb(e.source$Error(), (s: Error.Error): [boolean, rs.IntErrorKind | undefined] => { return [s instanceof of$errors_Leaf, option_map$0p4jgzx(s instanceof of$num_ParseIntError ? s.v : s instanceof ofPlace$num_ParseIntError ? s.v.v : undefined, (p: rs.ParseIntError): rs.IntErrorKind => { diff --git a/ts/fixtures/lang/fields/expected/fields.ts b/ts/fixtures/lang/fields/expected/fields.ts index 99bb6eaad..e61e99db9 100644 --- a/ts/fixtures/lang/fields/expected/fields.ts +++ b/ts/fixtures/lang/fields/expected/fields.ts @@ -96,12 +96,12 @@ export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(p.headLen & 0xff, q.headLen & 0xff, Couple.eq$cmp_PartialEq(p, q) ? 1 : 0))); rs.byteVecExtendFromSlice(out, new rs.ByteSlice(q.wordData, q.wordStart, q.wordLen)); const args2: rs.Fmt[] = [(f: rs.Formatter) => Couple.fmt$fmt_Debug(p, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } const _148: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 3)); const open: Exposed.Exposed = { buf: _148, at: kind }; const args4: rs.Fmt[] = [(f: rs.Formatter) => Exposed.fmt$fmt_Debug(open, f), (f: rs.Formatter) => Scanner.fmt$fmt_Debug(r2, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]]).v)); rs.byteVecPush(out, kind ^ (_148.length & 0xff)); if (!(rs.u8Rem(kind, 2) === 0)) { const _175: Glued.Glued = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; @@ -110,7 +110,7 @@ export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { two = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; } const args6: rs.Fmt[] = [(f: rs.Formatter) => Glued.fmt$fmt_Debug(two, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0]]).v)); rs.byteVecPush(out, rs.usizeAdd(two._0Len, two._1Len) & 0xff); const _195: Scanner.Scanner = SCANNER; rs.byteVecExtendFromSlice(out, new rs.ByteSlice(_195.bufData, _195.bufStart, _195.bufLen)); diff --git a/ts/fixtures/lang/floats/expected/floats.ts b/ts/fixtures/lang/floats/expected/floats.ts index 3344cb76f..1b0220168 100644 --- a/ts/fixtures/lang/floats/expected/floats.ts +++ b/ts/fixtures/lang/floats/expected/floats.ts @@ -43,7 +43,7 @@ export function putSecs(out: rs.ByteVec, d: rs.Result rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); } } @@ -389,13 +389,13 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args4[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args4[4]) }, args4[2])])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f))); + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args4[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args4[4]) }, args4[2])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f)).v); } else if (_13 === 1) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args6[0]), " ", rs.fmtSpec({ precision: 800 }, args6[1]), " ", rs.fmtSpec({ precision: 1100 }, args6[2]), " ", rs.fmtSpec({ precision: 65535 }, args6[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args6[0]), " ", rs.fmtSpec({ precision: 800 }, args6[1]), " ", rs.fmtSpec({ precision: 1100 }, args6[2]), " ", rs.fmtSpec({ precision: 65535 }, args6[0])]).v); } else if (_13 === 2) { const _72: [rs.f64, rs.ByteSlice] = take(_6[1]); const b: rs.f64 = _72[0]; @@ -406,7 +406,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _80: rs.Vec = rs.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); const part = { level: a, peak: _78, history: _80 }; const args8: rs.Fmt[] = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])]).v); } else { let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); let iterStart: rs.i32 = 0; @@ -414,7 +414,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void while (iterStart++ < iterEnd) { const x: rs.f64 = rs.f64FromBits(step(rs.place(() => state, (value) => state = value))); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]]).v); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 64; @@ -425,7 +425,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const r2: rs.u64 = step(rs.place(() => state, (value2) => state = value2)); const x2: rs.f64 = rs.u64ToF64(rs.u64Shr(r2, 11)) / rs.u64ToF64(rs.u64Shl(1, rs.u64Add(rs.u64Rem(r2, 24), 1))); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + put(out, rs.fmtFormat([args12[0], " ", args12[1]]).v); } } } @@ -445,14 +445,14 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { one(_6.value, out); } } else if (_4 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(data)) { const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); rs.idx(_21, _22); - s = s + String.fromCodePoint(_21.data[_21.start + _22] as rs.char); + rs.stringPush(s, _21.data[_21.start + _22] as rs.char); } - one(s, out); + one(s.v, out); } else { let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); let iterStart: rs.i32 = 0; @@ -464,19 +464,19 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); const len: rs.usize = rs.u64Low(rs.u64Add(rs.u64Rem(r, 40), 1)); const point: rs.usize = rs.usizeRem(rs.u64Low(rs.u64Shr(r, 8)), rs.usizeAdd(len, 1)); - let s2: string = ""; + const s2: rs.String = rs.stringNew(); let iterStart2: rs.usize = 0; const iterEnd2: rs.usize = len; while ((_60 = iterStart2++) < iterEnd2) { if (_60 === point) { - s2 = s2 + "."; + rs.stringPush(s2, 46); } const _69: rs.char = rs.u8Add(48, rs.u64Low(rs.u64Rem(step(rs.place(() => state, (value2) => state = value2)), 10)) & 0xff) as rs.char; - s2 = s2 + String.fromCodePoint(_69); + rs.stringPush(s2, _69); } const _85: rs.i64 = rs.i64Sub(rs.i64Cast(rs.u64Rem(rs.u64Shr(r, 16), 700)), 350); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_85, f)]; - one(rs.fmtFormat([args2[0], "e", args2[1]]), out); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_85, f)]; + one(rs.fmtFormat([args2[0], "e", args2[1]]).v, out); } } } @@ -489,11 +489,11 @@ export function one(s: string, out: rs.ByteVec): void { const v: rs.f64 = _4.value; putF64(out, v); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Debug(v, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); } else { const e: rs.ParseFloatError = _4.error; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|", rs.fmtSpec({ precision: 7 }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|", rs.fmtSpec({ precision: 7 }, args4[0])]).v); } rs.byteVecPush(out, rs.f64FromStr(s).ok ? 1 : 0); } diff --git a/ts/fixtures/lang/folds/expected/folds.ts b/ts/fixtures/lang/folds/expected/folds.ts index 000d41739..549f73393 100644 --- a/ts/fixtures/lang/folds/expected/folds.ts +++ b/ts/fixtures/lang/folds/expected/folds.ts @@ -12,7 +12,7 @@ export function state$i64_Option_i64(out: rs.ByteVec, v: rs.i64 | undefined, r: const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.i64Debug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -21,7 +21,7 @@ export function state$i64_Option_tuple2_i64_usize(out: rs.ByteVec, v: [rs.i64, r const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.i64, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -30,7 +30,7 @@ export function state$i64_Option_tuple2_usize_i64(out: rs.ByteVec, v: [rs.usize, const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.i64], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.i64Debug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -39,7 +39,7 @@ export function state$i64_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -48,7 +48,7 @@ export function state$i64_Result_usize_unit(out: rs.ByteVec, v: rs.Result rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -57,7 +57,7 @@ export function state$i64_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -66,7 +66,7 @@ export function state$i64_tuple2_Option_i64_Option_i64(out: rs.ByteVec, v: [rs.i const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.i64Debug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -75,7 +75,7 @@ export function state$i64_tuple2_Option_i64_Option_usize(out: rs.ByteVec, v: [rs const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -84,7 +84,7 @@ export function state$i64_tuple2_Option_i64_usize(out: rs.ByteVec, v: [rs.i64 | const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -93,7 +93,7 @@ export function state$i64_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusi const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -102,7 +102,7 @@ export function state$i64_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusi const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -111,7 +111,7 @@ export function state$u8_Option_tuple2_u8_usize(out: rs.ByteVec, v: [rs.u8, rs.u const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.u8, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -120,7 +120,7 @@ export function state$u8_Option_tuple2_usize_u8(out: rs.ByteVec, v: [rs.usize, r const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -129,7 +129,7 @@ export function state$u8_Option_u8(out: rs.ByteVec, v: rs.u8 | undefined, r: rs. const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -138,7 +138,7 @@ export function state$u8_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -147,7 +147,7 @@ export function state$u8_Result_usize_unit(out: rs.ByteVec, v: rs.Result rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -156,7 +156,7 @@ export function state$u8_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive< const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -165,7 +165,7 @@ export function state$u8_tuple2_Option_u8_Option_u8(out: rs.ByteVec, v: [rs.u8 | const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -174,7 +174,7 @@ export function state$u8_tuple2_Option_u8_Option_usize(out: rs.ByteVec, v: [rs.u const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -183,7 +183,7 @@ export function state$u8_tuple2_Option_u8_usize(out: rs.ByteVec, v: [rs.u8 | und const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -192,7 +192,7 @@ export function state$u8_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusiv const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -201,7 +201,7 @@ export function state$u8_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusiv const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v); } /** diff --git a/ts/fixtures/lang/futures/expected/futures.ts b/ts/fixtures/lang/futures/expected/futures.ts index 9ab2c274a..dc444608a 100644 --- a/ts/fixtures/lang/futures/expected/futures.ts +++ b/ts/fixtures/lang/futures/expected/futures.ts @@ -48,7 +48,7 @@ export function pollOnce$future_Pending_u8(f: rs.Future): rs.Poll } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Ready_String(f: rs.Ready): rs.Poll { +export function pollOnce$future_Ready_String(f: rs.Ready): rs.Poll { return f.poll(rs.NOOP_WAKER); } @@ -80,113 +80,113 @@ export function pollOnce$futures_readies_closure0(f: rs.Future): rs.Poll< /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Pending_futures_Logged(out: rs.ByteVec, _value: rs.Future): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_PollFn_futures_pendings_closure0(out: rs.ByteVec, _value: rs.Future): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_Option_Option_u8(out: rs.ByteVec, value: rs.Ready): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_Option_u8(out: rs.ByteVec, value: rs.Ready): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_String(out: rs.ByteVec, value: rs.Ready): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtStr)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtStr)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Ready_String(out: rs.ByteVec, value: rs.Ready): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([args2[0]]).v); + const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_u8(out: rs.ByteVec, value: rs.Ready): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_unit(out: rs.ByteVec, value: rs.Ready): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_Option_u8(out: rs.ByteVec, value: rs.Poll): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_Result_u8_String(out: rs.ByteVec, value: rs.Poll>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_Result_u8_String(out: rs.ByteVec, value: rs.Poll>): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]; + put(out, rs.fmtFormat([args2[0]]).v); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_String(out: rs.ByteVec, value: rs.Poll): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_String(out: rs.ByteVec, value: rs.Poll): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([args2[0]]).v); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_array2_u8(out: rs.ByteVec, value: rs.Poll): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_task_Poll_u8(out: rs.ByteVec, value: rs.Poll | rs.OuterPending): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_u8(out: rs.ByteVec, value: rs.Poll): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_unit(out: rs.ByteVec, value: rs.Poll): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); } /** @@ -219,11 +219,11 @@ export function readies(data: rs.ByteSlice, out: rs.ByteVec): void { debug$future_Ready_unit(out, new rs.Ready(undefined)); debug$future_Ready_Option_u8(out, new rs.Ready(rs.byteSliceFirst(data))); debug$future_Ready_Option_Option_u8(out, new rs.Ready(rs.None as rs.u8 | undefined | rs.None)); - const text_: rs.Ready = new rs.Ready(text(data)); + const text_: rs.Ready = new rs.Ready(text(data)); debug$future_Ready_String(out, text_); - const _52: rs.Poll = pollOnce$future_Ready_String(text_); + const _52: rs.Poll = pollOnce$future_Ready_String(text_); if (_52 !== rs.Pending) { - rs.iterExtendBytes(out, rs.strBytes(_52), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(_52.v), undefined, true); } debug$future_Ready_String(out, text_); const boxed: rs.Future = new rs.Ready(data.length); @@ -465,7 +465,7 @@ export function pendings(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { let q!: rs.Poll; - let r!: rs.Poll>; + let r!: rs.Poll>; for (const b of rs.byteSliceView(data)) { const p: rs.Poll = b; if (!(rs.u8Rem(b, 3) === 0)) { @@ -476,7 +476,7 @@ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { debug$task_Poll_u8(out, p); debug$task_Poll_u8(out, q); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(q, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtPoll(p, f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[1])])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[1])]).v); debug$task_Poll_Option_u8(out, poll_map$1jzbsum(b as rs.Poll, (o: rs.u8 | undefined): rs.u8 | undefined => { return filter$0hq86nl(o, (v: rs.u8): boolean => { return rs.u8Rem(v, 2) === 0; @@ -488,7 +488,7 @@ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_38 === 1) { r = rs.Ok(b); } else { - r = rs.Err(rs.fmtToString((f: rs.Formatter) => rs.u8Display(b, f))); + r = rs.Err(rs.fmtToString((f: rs.Formatter) => rs.u8Display(b, f), 0)); } debug$task_Poll_Result_u8_String(out, r); debug$task_Poll_task_Poll_u8(out, nested(b)); diff --git a/ts/fixtures/lang/futures/expected/harness.ts b/ts/fixtures/lang/futures/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/futures/expected/harness.ts +++ b/ts/fixtures/lang/futures/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/hashes/expected/harness.ts b/ts/fixtures/lang/hashes/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/hashes/expected/harness.ts +++ b/ts/fixtures/lang/hashes/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Index.ts b/ts/fixtures/lang/hashes/expected/hashes.Index.ts index 3f63782f4..df8d22b57 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Index.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Index.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Index, other: Index): boolean { - if (!rs.hashEq(rs.same)(self.names, other.names)) { + if (!rs.hashEq(rs.eqStr)(self.names, other.names)) { return false; } return rs.hashEq()(self.seen, other.seen); @@ -11,7 +11,7 @@ export function eq$cmp_PartialEq(self: Index, other: Index): boolean { /** A type whose derived `PartialEq` compares the maps it holds. */ export interface Index { - names: rs.HashMap; + names: rs.HashMap; seen: rs.HashSet<[rs.u8, boolean]>; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Key.ts b/ts/fixtures/lang/hashes/expected/hashes.Key.ts index 8679e175e..5c9182424 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Key.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Key.ts @@ -5,14 +5,14 @@ import * as Fnv from "./hashes.Fnv.ts"; import * as Tally from "./hashes.Tally.ts"; export function clone$Clone(self: Key): Key { - return { _0: self._0, _1: self._1 }; + return { _0: self._0, _1: rs.stringClone(self._1) }; } export function eq$cmp_PartialEq(self: Key, other: Key): boolean { if (!(self._0 === other._0)) { return false; } - return self._1 === other._1; + return rs.eqStr(self._1, other._1); } export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void { @@ -45,7 +45,7 @@ export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { /** A key that is a JS object. */ export interface Key { _0: rs.u16; - _1: string; + _1: rs.String; } //# sourceMappingURL=hashes.Key.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Packet.ts b/ts/fixtures/lang/hashes/expected/hashes.Packet.ts index 7471a87ff..4c2572bdc 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Packet.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Packet.ts @@ -49,7 +49,7 @@ export function hash$Hash_hashes_Switch(self: Packet, state: rs.Place; next: rs.i32 | undefined; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.ts b/ts/fixtures/lang/hashes/expected/hashes.ts index 5b69e73ef..0e4a21012 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.ts @@ -67,7 +67,7 @@ export function digest$Option_u32(value: rs.u32 | undefined, out: rs.ByteVec): v } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$String(value: string, out: rs.ByteVec): void { +export function digest$String(value: rs.String, out: rs.ByteVec): void { const h: rs.Hasher = rs.hasher(); rs.hashStr(value, h); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); @@ -392,7 +392,7 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_5 === 1) { const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); digest$str(text, out); - digest$String(text, out); + digest$String(rs.stringFrom(text), out); digest$str("", out); digest$tuple2_ref_str_usize([text, rs.stringLen(text)] as [string, rs.usize], out); const arc: rs.Arc = new rs.Arc(text); @@ -417,7 +417,7 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { digest$Option_num_NonZero_u32(rs.nonZero((n | 1) >>> 0), out); } else if (_5 === 3) { const n2: rs.u64 = rs.u64Cast(w(0, 8)); - digest$hashes_Packet({ id: n2, flags: option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), name: result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "?"), tags: rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + digest$hashes_Packet({ id: n2, flags: option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), name: rs.stringFrom(result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "?")), tags: rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { return _2 as rs.u16; }), undefined, 2, true), next: thenSome$05ku0zn(rs.u64Rem(n2, 3) !== 0, rs.u64Low(n2) | 0) }, out); const _188: rs.u64 = rs.u64Rem(n2, 3); @@ -502,7 +502,9 @@ export function random(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashFinish(built)) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashOne(rs.buildHasher(copy), n, rs.hash64)) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashOne(rs.buildHasher(s), n, rs.hash64)) ? 1 : 0); - rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr), rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr)) ? 1 : 0); + const _53: rs.u64 = rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr); + const _57: rs.String = rs.stringFrom(text); + rs.byteVecPush(out, rs.u64Eq(_53, rs.hashOne(rs.buildHasher(other.state), _57, rs.hashStr)) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), [b, text] as [rs.u8, string], rs.hashTuple([rs.hash8, rs.hashStr])), rs.hashOne(rs.buildHasher(copy), [b, text] as [rs.u8, string], rs.hashTuple([rs.hash8, rs.hashStr]))) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), { _0: b }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined), rs.hashOne(rs.buildHasher(s), { _0: b ^ 240 }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined)) ? 1 : 0); const arc: rs.Arc = new rs.Arc(text); @@ -632,7 +634,7 @@ export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); @@ -673,7 +675,7 @@ export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Bare({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Bare({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -712,7 +714,7 @@ export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); @@ -753,7 +755,7 @@ export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Full({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Full({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -792,7 +794,7 @@ export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); @@ -833,7 +835,7 @@ export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Partial({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Partial({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -872,7 +874,7 @@ export function hashInto$hashes_Switch(h: rs.Place, data: rs.Byte rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); @@ -913,7 +915,7 @@ export function hashInto$hashes_Switch(h: rs.Place, data: rs.Byte const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Switch({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Switch({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -1069,7 +1071,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.sliceSort(rs.sliceFrom(held.items), rs.cmpLt(rs.cmpTuple<[Key.Key, rs.u8], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 8, true); for (const _63 of held.items) { rs.byteVecPush(out, _63[0]._0 & 0xff); - put(out, _63[0]._1); + put(out, _63[0]._1.v); rs.byteVecPush(out, _63[1]); } const probe: Key.Key = { _0: first as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(first))) }; @@ -1243,18 +1245,18 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { _113.v = rs.u16Add(_113.v, _102); } }; - const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes3: rs.ByteSlice): rs.HashSet => { - const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): string => { + const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes3: rs.ByteSlice): rs.HashSet => { + const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_2, 4)))); }); - return rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _3, undefined, undefined, 117440512); + return rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashSet, _3, undefined, undefined, 117440512); }; const _175: (a0: rs.ByteSlice) => hashes_Index.Index = (bytes4: rs.ByteSlice): hashes_Index.Index => { - const _46: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, string] => { + const _46: rs.Iter<[rs.u8, rs.String]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, rs.String] => { const b4: rs.u8 = _22; - return [rs.u8Rem(b4, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b4, 3))))] as [rs.u8, string]; + return [rs.u8Rem(b4, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b4, 3))))] as [rs.u8, rs.String]; }); - const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); + const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); const _75: rs.Iter<[rs.u8, boolean]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_23: rs.u8): [rs.u8, boolean] => { const b5: rs.u8 = _23; return [rs.u8Rem(b5, 5), rs.u8Rem(b5, 2) === 0] as [rs.u8, boolean]; @@ -1332,20 +1334,20 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { const part7 = rs.byteVecSlice(flipped); const _118: rs.HashMap = _96(part7); rs.byteVecPush(out, !rs.hashEq(rs.same)(_114, _118) ? 1 : 0); - const _128: rs.HashSet = _123(data); + const _128: rs.HashSet = _123(data); const part8 = rs.byteVecSlice(reversed); - const _132: rs.HashSet = _123(part8); + const _132: rs.HashSet = _123(part8); rs.byteVecPush(out, rs.hashEq()(_128, _132) ? 1 : 0); - const _141: rs.HashSet = _123(data); - const _145: rs.HashSet = _123(shorter); + const _141: rs.HashSet = _123(data); + const _145: rs.HashSet = _123(shorter); rs.byteVecPush(out, rs.hashEq()(_141, _145) ? 1 : 0); - const _154: rs.HashSet = _123(data); + const _154: rs.HashSet = _123(data); const part9 = rs.byteVecSlice(flipped); - const _152: rs.Vec> = rs.vecFrom([_154, _123(part9)]); + const _152: rs.Vec> = rs.vecFrom([_154, _123(part9)]); const part10 = rs.byteVecSlice(reversed); - const _165: rs.HashSet = _123(part10); + const _165: rs.HashSet = _123(part10); const part11 = rs.byteVecSlice(flipped); - const _163: rs.Vec> = rs.vecFrom([_165, _123(part11)]); + const _163: rs.Vec> = rs.vecFrom([_165, _123(part11)]); rs.byteVecPush(out, rs.eqSeq(rs.hashEq())(_152, _163) ? 1 : 0); const _180: hashes_Index.Index = _175(data); const part12 = rs.byteVecSlice(reversed); @@ -1377,7 +1379,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _36: Tallied.Tallied = Tallied.default$Default(); rs.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, _36) ? 1 : 0); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), (f: rs.Formatter) => rs.fmtOption(undefined, f, (_value: undefined, f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), rs.None), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(cloned, f), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(held, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3])])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3])]).v); const word: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "✓"); const n: rs.u16 = rs.u128Low(wide(data, 0, 2)) & 0xffff; const built: Tally.Tally = Tally.default$Default(); @@ -1387,7 +1389,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _70: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), word, rs.hashStr, undefined, rs.drop); const _74: [rs.u8, string] = [n & 0xff, word]; const _72: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _74, rs.hashTuple([rs.hash8, rs.hashStr]), undefined, rs.drop); - const _79: Key.Key = { _0: n, _1: word }; + const _80: rs.String = rs.stringFrom(word); + const _79: Key.Key = { _0: n, _1: _80 }; const hashes: rs.u64[] = [_66, _68, _70, _72, rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _79, rs.hashOwn(Key.hash$Hash_hashes_Tally as (a0: Key.Key, a1: Tally.Tally) => undefined), undefined, rs.drop)]; built[Symbol.dispose](); const iter: rs.Iter = rs.iterSlice(hashes); @@ -1423,7 +1426,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { rs.sliceSort(rs.sliceFrom(entries.items), rs.cmpLt(rs.cmpTuple<[Key.Key, rs.u8], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 8, true); for (const _147 of entries.items) { rs.byteVecPush(out, _147[0]._0 & 0xff); - put(out, _147[0]._1); + put(out, _147[0]._1.v); rs.byteVecPush(out, _147[1]); } const probe: Key.Key = { _0: first as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(first))) }; @@ -1438,7 +1441,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { }); rs.byteVecPush(out, rs.hashEq(rs.same)(keyed, _195) ? 1 : 0); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([args4[0]]).v); const _212: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.u8 => { return rs.u8Rem(b2, 4); }); diff --git a/ts/fixtures/lang/heap/expected/heap.ts b/ts/fixtures/lang/heap/expected/heap.ts index 5eb04c223..6ebb8c03e 100644 --- a/ts/fixtures/lang/heap/expected/heap.ts +++ b/ts/fixtures/lang/heap/expected/heap.ts @@ -167,24 +167,24 @@ export function layouts(data: rs.ByteSlice, out: rs.ByteVec): void { } const made: rs.Result = rs.layoutFromSizeAlign(size, align); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); if (!made.ok) { - rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f))), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f)).v), undefined, true); } const part3 = rs.layoutArray(rs.usizeShr(size, rs.u8Rem(b, 8)), 8, 8); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); const unit: rs.Layout = rs.resultUnwrap(rs.layoutArray(size, 0, 1), rs.fmtLayoutErrorDebug); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(unit.size & 0xff, unit.align & 0xff)), undefined, true); } const _92: Fault.Fault = { tag: "Alloc", layout: { size: 16, align: 8 } }; const _94: rs.Layout = { size: 4, align: 4 }; const args6: rs.Fmt[] = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(_92, f), (f: rs.Formatter) => rs.fmtLayoutDebug(_94, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); rs.byteVecPush(out, 8 & 0xff); const arg = { tag: "Overflow" } as Fault.Fault; const args8: rs.Fmt[] = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(arg, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0]]).v), undefined, true); } //# sourceMappingURL=heap.ts.map diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index cbfef7d04..c034a9d04 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -2001,22 +2001,23 @@ export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, it2.sizeHint()); } } else if (_37 === 16) { - const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { + const _353: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { const _5: rs.usize = rs.u8Rem(_29, 4) as rs.usize; if (!(_5 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _5); } return [97, 233, 128512, 2048][_5]; - })); + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _353); const _355: rs.u8 = rs.u8Rem(arm, 4); if (_355 === 0) { - walk$str_Chars(rs.strChars(s), steps, out); + walk$str_Chars(rs.strChars(s.v), steps, out); } else if (_355 === 1) { - walkFront$str_Split_char(rs.strSplit(s, "é"), steps, out); + walkFront$str_Split_char(rs.strSplit(s.v, "é"), steps, out); } else if (_355 === 2) { - walk$str_Bytes(rs.strBytes(s), steps, out); + walk$str_Bytes(rs.strBytes(s.v), steps, out); } else { - let t: string = s; + const t: rs.String = rs.stringClone(s); const _379: rs.RangeFrom = new rs.RangeFrom(rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.usizeDiv(bytes.length, 2)))), (_231: rs.u8): rs.usize => { const _512: rs.usize = rs.u8Rem(_231, 4) as rs.usize; if (!(_512 < 4)) { @@ -2024,7 +2025,7 @@ export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } return [1, 2, 4, 3][_512]; }), rs.usizeAdd, 0), rs.usizeStep); - walk$string_Drain(rs.stringDrain(rs.place(() => t, (value) => t = value), _379), steps, out); + walk$string_Drain(rs.stringDrain(t, _379), steps, out); } } else if (_37 === 17) { const size: rs.usize = rs.usizeAdd(rs.usizeRem(at(1) as rs.usize, 4), 1); diff --git a/ts/fixtures/lang/ints/expected/ints.ts b/ts/fixtures/lang/ints/expected/ints.ts index be74894f5..7b4b0ebae 100644 --- a/ts/fixtures/lang/ints/expected/ints.ts +++ b/ts/fixtures/lang/ints/expected/ints.ts @@ -2025,51 +2025,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_25 === 0) { const v2: rs.u8 = v; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v2))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v2, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v2, f), 0).v)); } else if (_25 === 1) { const v3: rs.u16 = v as rs.u16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v3))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v3, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v3, f), 0).v)); } else if (_25 === 2) { const v4: rs.u32 = v as rs.u32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v4))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v4, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v4, f), 0).v)); } else if (_25 === 3) { const v5: rs.u64 = v as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v5))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v5, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v5, f), 0).v)); } else if (_25 === 4) { const v6: rs.u128 = v as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v6))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v6, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v6, f), 0).v)); } else if (_25 === 5) { const v7: rs.usize = v as rs.usize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v7))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v7, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v7, f), 0).v)); } else if (_25 === 6) { const v8: rs.i8 = (v << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v8))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v8, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v8, f), 3).v)); } else if (_25 === 7) { const v9: rs.i16 = v as rs.i16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v9))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v9, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v9, f), 5).v)); } else if (_25 === 8) { const v10: rs.i32 = v as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v10))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v10, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v10, f), 10).v)); } else if (_25 === 9) { const v11: rs.i64 = v as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v11))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v11, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v11, f), 19).v)); } else if (_25 === 10) { const v12: rs.i128 = v as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v12))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v12, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v12, f), 39).v)); } else { const v13: rs.isize = v as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v13))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v13, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v13, f), 10).v)); } } else if (_5 === 1) { const buf2: Uint8Array = rs.bytes(2); @@ -2080,51 +2080,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_165 === 0) { const v15: rs.u8 = v14 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v15))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v15, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v15, f), 0).v)); } else if (_165 === 1) { const v16: rs.u16 = v14; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v16))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v16, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v16, f), 0).v)); } else if (_165 === 2) { const v17: rs.u32 = v14 as rs.u32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v17))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v17, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v17, f), 0).v)); } else if (_165 === 3) { const v18: rs.u64 = v14 as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v18))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v18, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v18, f), 0).v)); } else if (_165 === 4) { const v19: rs.u128 = v14 as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v19))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v19, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v19, f), 0).v)); } else if (_165 === 5) { const v20: rs.usize = v14 as rs.usize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v20))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v20, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v20, f), 0).v)); } else if (_165 === 6) { const v21: rs.i8 = (v14 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v21))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v21, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v21, f), 3).v)); } else if (_165 === 7) { const v22: rs.i16 = (v14 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v22))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v22, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v22, f), 5).v)); } else if (_165 === 8) { const v23: rs.i32 = v14 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v23))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v23, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v23, f), 10).v)); } else if (_165 === 9) { const v24: rs.i64 = v14 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v24))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v24, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v24, f), 19).v)); } else if (_165 === 10) { const v25: rs.i128 = v14 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v25))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v25, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v25, f), 39).v)); } else { const v26: rs.isize = v14 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v26))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v26, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v26, f), 10).v)); } } else if (_5 === 2) { const buf3: Uint8Array = rs.bytes(4); @@ -2135,51 +2135,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_305 === 0) { const v28: rs.u8 = v27 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v28))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v28, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v28, f), 0).v)); } else if (_305 === 1) { const v29: rs.u16 = v27 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v29))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v29, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v29, f), 0).v)); } else if (_305 === 2) { const v30: rs.u32 = v27; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v30))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v30, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v30, f), 0).v)); } else if (_305 === 3) { const v31: rs.u64 = v27 as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v31))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v31, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v31, f), 0).v)); } else if (_305 === 4) { const v32: rs.u128 = v27 as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v32))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v32, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v32, f), 0).v)); } else if (_305 === 5) { const v33: rs.usize = v27 as rs.usize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v33))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v33, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v33, f), 0).v)); } else if (_305 === 6) { const v34: rs.i8 = (v27 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v34))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v34, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v34, f), 3).v)); } else if (_305 === 7) { const v35: rs.i16 = (v27 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v35))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v35, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v35, f), 5).v)); } else if (_305 === 8) { const v36: rs.i32 = v27 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v36))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v36, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v36, f), 10).v)); } else if (_305 === 9) { const v37: rs.i64 = v27 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v37))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v37, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v37, f), 19).v)); } else if (_305 === 10) { const v38: rs.i128 = v27 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v38))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v38, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v38, f), 39).v)); } else { const v39: rs.isize = v27 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v39))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v39, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v39, f), 10).v)); } } else if (_5 === 3) { const buf4: Uint8Array = rs.bytes(8); @@ -2190,51 +2190,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_445 === 0) { const v41: rs.u8 = rs.u64Low(v40) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v41))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v41, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v41, f), 0).v)); } else if (_445 === 1) { const v42: rs.u16 = rs.u64Low(v40) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v42))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v42, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v42, f), 0).v)); } else if (_445 === 2) { const v43: rs.u32 = rs.u64Low(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v43))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v43, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v43, f), 0).v)); } else if (_445 === 3) { const v44: rs.u64 = v40; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v44))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v44, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v44, f), 0).v)); } else if (_445 === 4) { const v45: rs.u128 = rs.u128Cast(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v45))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v45, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v45, f), 0).v)); } else if (_445 === 5) { const v46: rs.usize = rs.u64Low(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v46))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v46, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v46, f), 0).v)); } else if (_445 === 6) { const v47: rs.i8 = (rs.u64Low(v40) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v47))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v47, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v47, f), 3).v)); } else if (_445 === 7) { const v48: rs.i16 = (rs.u64Low(v40) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v48))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v48, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v48, f), 5).v)); } else if (_445 === 8) { const v49: rs.i32 = rs.u64Low(v40) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v49))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v49, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v49, f), 10).v)); } else if (_445 === 9) { const v50: rs.i64 = rs.i64Cast(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v50))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v50, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v50, f), 19).v)); } else if (_445 === 10) { const v51: rs.i128 = rs.i128Cast(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v51))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v51, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v51, f), 39).v)); } else { const v52: rs.isize = rs.u64Low(v40) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v52))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v52, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v52, f), 10).v)); } } else if (_5 === 4) { const buf5: Uint8Array = rs.bytes(16); @@ -2245,51 +2245,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_585 === 0) { const v54: rs.u8 = rs.u128Low(v53) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v54))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v54, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v54, f), 0).v)); } else if (_585 === 1) { const v55: rs.u16 = rs.u128Low(v53) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v55))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v55, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v55, f), 0).v)); } else if (_585 === 2) { const v56: rs.u32 = rs.u128Low(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v56))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v56, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v56, f), 0).v)); } else if (_585 === 3) { const v57: rs.u64 = rs.u64Cast(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v57))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v57, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v57, f), 0).v)); } else if (_585 === 4) { const v58: rs.u128 = v53; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v58))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v58, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v58, f), 0).v)); } else if (_585 === 5) { const v59: rs.usize = rs.u128Low(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v59))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v59, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v59, f), 0).v)); } else if (_585 === 6) { const v60: rs.i8 = (rs.u128Low(v53) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v60))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v60, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v60, f), 3).v)); } else if (_585 === 7) { const v61: rs.i16 = (rs.u128Low(v53) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v61))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v61, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v61, f), 5).v)); } else if (_585 === 8) { const v62: rs.i32 = rs.u128Low(v53) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v62))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v62, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v62, f), 10).v)); } else if (_585 === 9) { const v63: rs.i64 = rs.i64Cast(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v63))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v63, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v63, f), 19).v)); } else if (_585 === 10) { const v64: rs.i128 = rs.i128Cast(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v64))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v64, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v64, f), 39).v)); } else { const v65: rs.isize = rs.u128Low(v53) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v65))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v65, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v65, f), 10).v)); } } else if (_5 === 5) { const buf6: Uint8Array = rs.bytes(4); @@ -2300,51 +2300,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_725 === 0) { const v67: rs.u8 = v66 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v67))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v67, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v67, f), 0).v)); } else if (_725 === 1) { const v68: rs.u16 = v66 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v68))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v68, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v68, f), 0).v)); } else if (_725 === 2) { const v69: rs.u32 = v66 as rs.u32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v69))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v69, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v69, f), 0).v)); } else if (_725 === 3) { const v70: rs.u64 = v66 as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v70))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v70, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v70, f), 0).v)); } else if (_725 === 4) { const v71: rs.u128 = v66 as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v71))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v71, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v71, f), 0).v)); } else if (_725 === 5) { const v72: rs.usize = v66; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v72))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v72, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v72, f), 0).v)); } else if (_725 === 6) { const v73: rs.i8 = (v66 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v73))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v73, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v73, f), 3).v)); } else if (_725 === 7) { const v74: rs.i16 = (v66 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v74))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v74, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v74, f), 5).v)); } else if (_725 === 8) { const v75: rs.i32 = v66 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v75))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v75, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v75, f), 10).v)); } else if (_725 === 9) { const v76: rs.i64 = v66 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v76))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v76, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v76, f), 19).v)); } else if (_725 === 10) { const v77: rs.i128 = v66 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v77))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v77, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v77, f), 39).v)); } else { const v78: rs.isize = v66 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v78))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v78, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v78, f), 10).v)); } } else if (_5 === 6) { const buf7: Uint8Array = Uint8Array.of(0); @@ -2355,51 +2355,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_865 === 0) { const v80: rs.u8 = v79 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v80))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v80, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v80, f), 0).v)); } else if (_865 === 1) { const v81: rs.u16 = v79 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v81))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v81, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v81, f), 0).v)); } else if (_865 === 2) { const v82: rs.u32 = v79 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v82))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v82, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v82, f), 0).v)); } else if (_865 === 3) { const v83: rs.u64 = rs.u64Cast(v79); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v83))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v83, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v83, f), 0).v)); } else if (_865 === 4) { const v84: rs.u128 = rs.u128Cast(v79); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v84))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v84, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v84, f), 0).v)); } else if (_865 === 5) { const v85: rs.usize = v79 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v85))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v85, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v85, f), 0).v)); } else if (_865 === 6) { const v86: rs.i8 = v79; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v86))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v86, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v86, f), 3).v)); } else if (_865 === 7) { const v87: rs.i16 = v79 as rs.i16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v87))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v87, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v87, f), 5).v)); } else if (_865 === 8) { const v88: rs.i32 = v79 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v88))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v88, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v88, f), 10).v)); } else if (_865 === 9) { const v89: rs.i64 = v79 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v89))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v89, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v89, f), 19).v)); } else if (_865 === 10) { const v90: rs.i128 = v79 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v90))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v90, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v90, f), 39).v)); } else { const v91: rs.isize = v79 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v91))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v91, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v91, f), 10).v)); } } else if (_5 === 7) { const buf8: Uint8Array = rs.bytes(2); @@ -2410,51 +2410,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1005 === 0) { const v93: rs.u8 = v92 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v93))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v93, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v93, f), 0).v)); } else if (_1005 === 1) { const v94: rs.u16 = v92 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v94))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v94, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v94, f), 0).v)); } else if (_1005 === 2) { const v95: rs.u32 = v92 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v95))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v95, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v95, f), 0).v)); } else if (_1005 === 3) { const v96: rs.u64 = rs.u64Cast(v92); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v96))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v96, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v96, f), 0).v)); } else if (_1005 === 4) { const v97: rs.u128 = rs.u128Cast(v92); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v97))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v97, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v97, f), 0).v)); } else if (_1005 === 5) { const v98: rs.usize = v92 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v98))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v98, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v98, f), 0).v)); } else if (_1005 === 6) { const v99: rs.i8 = (v92 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v99))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v99, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v99, f), 3).v)); } else if (_1005 === 7) { const v100: rs.i16 = v92; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v100))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v100, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v100, f), 5).v)); } else if (_1005 === 8) { const v101: rs.i32 = v92 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v101))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v101, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v101, f), 10).v)); } else if (_1005 === 9) { const v102: rs.i64 = v92 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v102))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v102, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v102, f), 19).v)); } else if (_1005 === 10) { const v103: rs.i128 = v92 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v103))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v103, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v103, f), 39).v)); } else { const v104: rs.isize = v92 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v104))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v104, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v104, f), 10).v)); } } else if (_5 === 8) { const buf9: Uint8Array = rs.bytes(4); @@ -2465,51 +2465,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1145 === 0) { const v106: rs.u8 = v105 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v106))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v106, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v106, f), 0).v)); } else if (_1145 === 1) { const v107: rs.u16 = v105 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v107))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v107, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v107, f), 0).v)); } else if (_1145 === 2) { const v108: rs.u32 = v105 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v108))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v108, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v108, f), 0).v)); } else if (_1145 === 3) { const v109: rs.u64 = rs.u64Cast(v105); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v109))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v109, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v109, f), 0).v)); } else if (_1145 === 4) { const v110: rs.u128 = rs.u128Cast(v105); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v110))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v110, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v110, f), 0).v)); } else if (_1145 === 5) { const v111: rs.usize = v105 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v111))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v111, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v111, f), 0).v)); } else if (_1145 === 6) { const v112: rs.i8 = (v105 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v112))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v112, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v112, f), 3).v)); } else if (_1145 === 7) { const v113: rs.i16 = (v105 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v113))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v113, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v113, f), 5).v)); } else if (_1145 === 8) { const v114: rs.i32 = v105; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v114))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v114, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v114, f), 10).v)); } else if (_1145 === 9) { const v115: rs.i64 = v105 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v115))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v115, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v115, f), 19).v)); } else if (_1145 === 10) { const v116: rs.i128 = v105 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v116))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v116, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v116, f), 39).v)); } else { const v117: rs.isize = v105 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v117))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v117, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v117, f), 10).v)); } } else if (_5 === 9) { const buf10: Uint8Array = rs.bytes(8); @@ -2520,51 +2520,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1285 === 0) { const v119: rs.u8 = rs.i64Low(v118) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v119))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v119, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v119, f), 0).v)); } else if (_1285 === 1) { const v120: rs.u16 = rs.i64Low(v118) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v120))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v120, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v120, f), 0).v)); } else if (_1285 === 2) { const v121: rs.u32 = rs.i64Low(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v121))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v121, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v121, f), 0).v)); } else if (_1285 === 3) { const v122: rs.u64 = rs.u64Cast(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v122))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v122, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v122, f), 0).v)); } else if (_1285 === 4) { const v123: rs.u128 = rs.u128Cast(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v123))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v123, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v123, f), 0).v)); } else if (_1285 === 5) { const v124: rs.usize = rs.i64Low(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v124))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v124, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v124, f), 0).v)); } else if (_1285 === 6) { const v125: rs.i8 = (rs.i64Low(v118) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v125))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v125, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v125, f), 3).v)); } else if (_1285 === 7) { const v126: rs.i16 = (rs.i64Low(v118) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v126))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v126, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v126, f), 5).v)); } else if (_1285 === 8) { const v127: rs.i32 = rs.i64Low(v118) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v127))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v127, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v127, f), 10).v)); } else if (_1285 === 9) { const v128: rs.i64 = v118; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v128))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v128, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v128, f), 19).v)); } else if (_1285 === 10) { const v129: rs.i128 = rs.i128Cast(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v129))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v129, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v129, f), 39).v)); } else { const v130: rs.isize = rs.i64Low(v118) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v130))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v130, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v130, f), 10).v)); } } else if (_5 === 10) { const buf11: Uint8Array = rs.bytes(16); @@ -2575,51 +2575,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1425 === 0) { const v132: rs.u8 = rs.i128Low(v131) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v132))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v132, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v132, f), 0).v)); } else if (_1425 === 1) { const v133: rs.u16 = rs.i128Low(v131) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v133))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v133, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v133, f), 0).v)); } else if (_1425 === 2) { const v134: rs.u32 = rs.i128Low(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v134))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v134, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v134, f), 0).v)); } else if (_1425 === 3) { const v135: rs.u64 = rs.u64Cast(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v135))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v135, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v135, f), 0).v)); } else if (_1425 === 4) { const v136: rs.u128 = rs.u128Cast(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v136))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v136, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v136, f), 0).v)); } else if (_1425 === 5) { const v137: rs.usize = rs.i128Low(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v137))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v137, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v137, f), 0).v)); } else if (_1425 === 6) { const v138: rs.i8 = (rs.i128Low(v131) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v138))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v138, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v138, f), 3).v)); } else if (_1425 === 7) { const v139: rs.i16 = (rs.i128Low(v131) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v139))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v139, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v139, f), 5).v)); } else if (_1425 === 8) { const v140: rs.i32 = rs.i128Low(v131) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v140))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v140, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v140, f), 10).v)); } else if (_1425 === 9) { const v141: rs.i64 = rs.i64Cast(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v141))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v141, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v141, f), 19).v)); } else if (_1425 === 10) { const v142: rs.i128 = v131; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v142))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v142, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v142, f), 39).v)); } else { const v143: rs.isize = rs.i128Low(v131) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v143))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v143, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v143, f), 10).v)); } } else { const buf12: Uint8Array = rs.bytes(4); @@ -2630,51 +2630,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1565 === 0) { const v145: rs.u8 = v144 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v145))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v145, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v145, f), 0).v)); } else if (_1565 === 1) { const v146: rs.u16 = v144 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v146))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v146, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v146, f), 0).v)); } else if (_1565 === 2) { const v147: rs.u32 = v144 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v147))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v147, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v147, f), 0).v)); } else if (_1565 === 3) { const v148: rs.u64 = rs.u64Cast(v144); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v148))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v148, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v148, f), 0).v)); } else if (_1565 === 4) { const v149: rs.u128 = rs.u128Cast(v144); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v149))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v149, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v149, f), 0).v)); } else if (_1565 === 5) { const v150: rs.usize = v144 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v150))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v150, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v150, f), 0).v)); } else if (_1565 === 6) { const v151: rs.i8 = (v144 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v151))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v151, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v151, f), 3).v)); } else if (_1565 === 7) { const v152: rs.i16 = (v144 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v152))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v152, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v152, f), 5).v)); } else if (_1565 === 8) { const v153: rs.i32 = v144 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v153))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v153, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v153, f), 10).v)); } else if (_1565 === 9) { const v154: rs.i64 = v144 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v154))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v154, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v154, f), 19).v)); } else if (_1565 === 10) { const v155: rs.i128 = v144 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v155))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v155, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v155, f), 39).v)); } else { const v156: rs.isize = v144; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v156))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v156, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v156, f), 10).v)); } } } @@ -2744,7 +2744,7 @@ export function fromHalves(hi: rs.u32, lo: rs.u32): rs.u64 { } /** `n` in `radix`, without a sign. */ -export function digits(n: rs.u128, radix: rs.u32): string { +export function digits(n: rs.u128, radix: rs.u32): rs.String { const out: rs.ByteVec = new rs.ByteVec(); while (true) { const _8: rs.usize = rs.u128Low(rs.u128Rem(n, radix as rs.u128)); @@ -2763,7 +2763,7 @@ export function digits(n: rs.u128, radix: rs.u32): string { } /** The digits of one more than `s`, in `radix`. */ -export function succ(s: string, radix: rs.u32): string { +export function succ(s: string, radix: rs.u32): rs.String { const out: rs.ByteVec = rs.byteSliceToByteVec(rs.stringAsBytes(s)); const iter: rs.Iter> = rs.iterRev(rs.iterSliceMut(rs.byteVecSlice(out))); while (true) { @@ -2795,41 +2795,41 @@ export function succ(s: string, radix: rs.u32): string { * its bounds and one past them, with signs and leading zeros, at and past the length * below which std skips its overflow checks, malformed signs, and stray characters. */ -export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32): rs.Vec { - const _7: [string, string] = [digits(max, radix), succ(digits(max, radix), radix)]; - const top: string = _7[0]; - const past: string = _7[1]; - const _15: string = top; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; - const _17: string = rs.fmtFormat(["+", args2[0]]); - const _26: string = past; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past)]; - const _28: string = rs.fmtFormat(["+", args4[0]]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; - const all: rs.Vec = rs.vecFrom([_15, _17, _26, _28, rs.fmtFormat(["000", args6[0]])]); - const upper: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.strBytes(top), (b: rs.u8): rs.u8 => { +export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32): rs.Vec { + const _7: [rs.String, rs.String] = [digits(max, radix), succ(digits(max, radix).v, radix)]; + const top: rs.String = _7[0]; + const past: rs.String = _7[1]; + const _15: rs.String = rs.stringClone(top); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top.v)]; + const _17: rs.String = rs.fmtFormat(["+", args2[0]]); + const _26: rs.String = rs.stringClone(past); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past.v)]; + const _28: rs.String = rs.fmtFormat(["+", args4[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top.v)]; + const all: rs.Vec = rs.vecFrom([_15, _17, _26, _28, rs.fmtFormat(["000", args6[0]])]); + const upper: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.strBytes(top.v), (b: rs.u8): rs.u8 => { if (!(b > 57)) { return b; } return rs.u8Sub(b, 32); }), undefined, true); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; - const _54: string = rs.fmtFormat(["-", args8[0]]); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past)]; - const _53: string[] = [_54, rs.fmtFormat(["000", args10[0]]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top.v)]; + const _54: rs.String = rs.fmtFormat(["-", args8[0]]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past.v)]; + const _53: rs.String[] = [_54, rs.fmtFormat(["000", args10[0]]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; rs.iterExtend(all, rs.iterSlice(_53), undefined, 12, true); if (rs.u128Gt(min, 0)) { - const _77: [string, string] = [digits(min, radix), succ(digits(min, radix), radix)]; - const bottom: string = _77[0]; - const below: string = _77[1]; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom)]; - const _86: string = rs.fmtFormat(["-", args12[0]]); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below)]; - const _95: string = rs.fmtFormat(["-", args14[0]]); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom)]; - const _104: string = rs.fmtFormat(["-000", args16[0]]); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below)]; - const _85: string[] = [_86, _95, _104, rs.fmtFormat(["-00", args18[0]])]; + const _77: [rs.String, rs.String] = [digits(min, radix), succ(digits(min, radix).v, radix)]; + const bottom: rs.String = _77[0]; + const below: rs.String = _77[1]; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom.v)]; + const _86: rs.String = rs.fmtFormat(["-", args12[0]]); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below.v)]; + const _95: rs.String = rs.fmtFormat(["-", args14[0]]); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom.v)]; + const _104: rs.String = rs.fmtFormat(["-000", args16[0]]); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below.v)]; + const _85: rs.String[] = [_86, _95, _104, rs.fmtFormat(["-00", args18[0]])]; rs.iterExtend(all, rs.iterSlice(_85), undefined, 12, true); } const unchecked: rs.usize = rs.usizeSub(rs.usizeDiv(bits, 4), rs.u128Gt(min, 0) ? 1 : 0); @@ -2846,15 +2846,15 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) break; } const len: rs.usize = _142; - let run: string = ""; + const run: rs.String = rs.stringNew(); const _149: rs.usize = rs.max(len, 1); let iterStart: rs.usize = 0; const iterEnd: rs.usize = _149; while (iterStart++ < iterEnd) { - run = run + String.fromCodePoint(high); + rs.stringPush(run, high); } - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, run)]; - const _158: string[] = [rs.fmtFormat(["-", args20[0]]), run]; + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, run.v)]; + const _158: rs.String[] = [rs.fmtFormat(["-", args20[0]]), run]; rs.iterExtend(all, rs.iterSlice(_158), undefined, 12, true); } const _172: rs.usize = rs.usizeRem(radix as rs.usize, 36); @@ -2869,12 +2869,13 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) if (_193 === rs.DONE) { break; } - all.items.push(_193); + const _199: rs.String = rs.stringFrom(_193); + all.items.push(_199); } const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]; - const _203: string = rs.fmtFormat(["1", args22[0]]); + const _203: rs.String = rs.fmtFormat(["1", args22[0]]); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]; - const _202: string[] = [_203, rs.fmtFormat([args24[0]])]; + const _202: rs.String[] = [_203, rs.fmtFormat([args24[0]])]; rs.iterExtend(all, rs.iterSlice(_202), undefined, 12, true); return all; } @@ -3065,7 +3066,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_40.ok) { const arg48 = _40.value; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg48, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); } else { const e: rs.ParseIntError = _40.error; const _56: rs.IntErrorKind = e.kind; @@ -3087,7 +3088,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _76: rs.IntErrorKind = e.kind; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]]).v); } if (radix2 === 10) { const parsed: rs.Result = parse$1brosjp(_19.value); @@ -3101,20 +3102,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_15 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(rest)) { const _116: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _117: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_116, _117); - s = s + String.fromCodePoint(_116.data[_116.start + _117] as rs.char); + rs.stringPush(s, _116.data[_116.start + _117] as rs.char); } - const _128: string = s; + const _128: string = s.v; const radix3: rs.u32 = radix; const _131: rs.Result = num_fromStrRadix$1osjin2(_128, radix3); if (_131.ok) { const arg47 = _131.value; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg47, f)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([args6[0]]).v); } else { const e2: rs.ParseIntError = _131.error; const _147: rs.IntErrorKind = e2.kind; @@ -3136,7 +3137,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _167: rs.IntErrorKind = e2.kind; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]]).v); } if (radix3 === 10) { const parsed2: rs.Result = parse$1brosjp(_128); @@ -3158,12 +3159,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix4: rs.u32 = _199; for (const _207 of edges(255, 0, 8, radix4).items) { + const _215: string = _207.v; const radix5: rs.u32 = radix4; - const _218: rs.Result = num_fromStrRadix$1osjin2(_207, radix5); + const _218: rs.Result = num_fromStrRadix$1osjin2(_215, radix5); if (_218.ok) { const arg46 = _218.value; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg46, f)]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([args10[0]]).v); } else { const e3: rs.ParseIntError = _218.error; const _234: rs.IntErrorKind = e3.kind; @@ -3185,11 +3187,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _254: rs.IntErrorKind = e3.kind; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]]).v); } if (radix5 === 10) { - const parsed3: rs.Result = parse$1brosjp(_207); - const from3: rs.Result = num_fromStr$1t58fis(_207); + const parsed3: rs.Result = parse$1brosjp(_215); + const from3: rs.Result = num_fromStr$1t58fis(_215); if (from3.ok) { max3 = rs.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { @@ -3217,7 +3219,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_315.ok) { const arg45 = _315.value; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg45, f)]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([args14[0]]).v); } else { const e4: rs.ParseIntError = _315.error; const _331: rs.IntErrorKind = e4.kind; @@ -3239,7 +3241,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _351: rs.IntErrorKind = e4.kind; const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; - put(out, rs.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); + put(out, rs.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]]).v); } if (radix7 === 10) { const parsed4: rs.Result = parse$1brosjp(_310); @@ -3275,7 +3277,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_414.ok) { const arg44 = _414.value; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg44, f)]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([args18[0]]).v); } else { const e5: rs.ParseIntError = _414.error; const _430: rs.IntErrorKind = e5.kind; @@ -3297,7 +3299,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _450: rs.IntErrorKind = e5.kind; const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; - put(out, rs.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); + put(out, rs.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]]).v); } if (radix9 === 10) { const parsed5: rs.Result = parse$0un0sth(_393.value); @@ -3311,20 +3313,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_389 === 1) { - let s3: string = ""; + const s3: rs.String = rs.stringNew(); for (const b2 of rs.byteSliceView(rest2)) { const _490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _491: rs.usize = rs.usizeRem(b2 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_490, _491); - s3 = s3 + String.fromCodePoint(_490.data[_490.start + _491] as rs.char); + rs.stringPush(s3, _490.data[_490.start + _491] as rs.char); } - const _502: string = s3; + const _502: string = s3.v; const radix10: rs.u32 = radix8; const _505: rs.Result = num_fromStrRadix$1wu02v6(_502, radix10); if (_505.ok) { const arg43 = _505.value; const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg43, f)]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([args22[0]]).v); } else { const e6: rs.ParseIntError = _505.error; const _521: rs.IntErrorKind = e6.kind; @@ -3346,7 +3348,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _541: rs.IntErrorKind = e6.kind; const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; - put(out, rs.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); + put(out, rs.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]]).v); } if (radix10 === 10) { const parsed6: rs.Result = parse$0un0sth(_502); @@ -3368,12 +3370,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix11: rs.u32 = _573; for (const _581 of edges(65535, 0, 16, radix11).items) { + const _589: string = _581.v; const radix12: rs.u32 = radix11; - const _592: rs.Result = num_fromStrRadix$1wu02v6(_581, radix12); + const _592: rs.Result = num_fromStrRadix$1wu02v6(_589, radix12); if (_592.ok) { const arg42 = _592.value; const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg42, f)]; - put(out, rs.fmtFormat([args26[0]])); + put(out, rs.fmtFormat([args26[0]]).v); } else { const e7: rs.ParseIntError = _592.error; const _608: rs.IntErrorKind = e7.kind; @@ -3395,11 +3398,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _628: rs.IntErrorKind = e7.kind; const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; - put(out, rs.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); + put(out, rs.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]]).v); } if (radix12 === 10) { - const parsed7: rs.Result = parse$0un0sth(_581); - const from7: rs.Result = num_fromStr$1gvvety(_581); + const parsed7: rs.Result = parse$0un0sth(_589); + const from7: rs.Result = num_fromStr$1gvvety(_589); if (from7.ok) { max7 = rs.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { @@ -3427,7 +3430,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_689.ok) { const arg41 = _689.value; const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg41, f)]; - put(out, rs.fmtFormat([args30[0]])); + put(out, rs.fmtFormat([args30[0]]).v); } else { const e8: rs.ParseIntError = _689.error; const _705: rs.IntErrorKind = e8.kind; @@ -3449,7 +3452,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _725: rs.IntErrorKind = e8.kind; const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; - put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); + put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]]).v); } if (radix14 === 10) { const parsed8: rs.Result = parse$0un0sth(_684); @@ -3485,7 +3488,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_788.ok) { const arg40 = _788.value; const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg40, f)]; - put(out, rs.fmtFormat([args34[0]])); + put(out, rs.fmtFormat([args34[0]]).v); } else { const e9: rs.ParseIntError = _788.error; const _804: rs.IntErrorKind = e9.kind; @@ -3507,7 +3510,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _824: rs.IntErrorKind = e9.kind; const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; - put(out, rs.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); + put(out, rs.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]]).v); } if (radix16 === 10) { const parsed9: rs.Result = parse$069xxen(_767.value); @@ -3521,20 +3524,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_763 === 1) { - let s5: string = ""; + const s5: rs.String = rs.stringNew(); for (const b3 of rs.byteSliceView(rest3)) { const _864: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _865: rs.usize = rs.usizeRem(b3 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_864, _865); - s5 = s5 + String.fromCodePoint(_864.data[_864.start + _865] as rs.char); + rs.stringPush(s5, _864.data[_864.start + _865] as rs.char); } - const _876: string = s5; + const _876: string = s5.v; const radix17: rs.u32 = radix15; const _879: rs.Result = num_fromStrRadix$1ftrr55(_876, radix17); if (_879.ok) { const arg39 = _879.value; const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg39, f)]; - put(out, rs.fmtFormat([args38[0]])); + put(out, rs.fmtFormat([args38[0]]).v); } else { const e10: rs.ParseIntError = _879.error; const _895: rs.IntErrorKind = e10.kind; @@ -3556,7 +3559,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _915: rs.IntErrorKind = e10.kind; const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; - put(out, rs.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); + put(out, rs.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]]).v); } if (radix17 === 10) { const parsed10: rs.Result = parse$069xxen(_876); @@ -3578,12 +3581,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix18: rs.u32 = _947; for (const _955 of edges(4294967295, 0, 32, radix18).items) { + const _963: string = _955.v; const radix19: rs.u32 = radix18; - const _966: rs.Result = num_fromStrRadix$1ftrr55(_955, radix19); + const _966: rs.Result = num_fromStrRadix$1ftrr55(_963, radix19); if (_966.ok) { const arg38 = _966.value; const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg38, f)]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([args42[0]]).v); } else { const e11: rs.ParseIntError = _966.error; const _982: rs.IntErrorKind = e11.kind; @@ -3605,11 +3609,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1002: rs.IntErrorKind = e11.kind; const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; - put(out, rs.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); + put(out, rs.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]]).v); } if (radix19 === 10) { - const parsed11: rs.Result = parse$069xxen(_955); - const from11: rs.Result = num_fromStr$1rjp7t4(_955); + const parsed11: rs.Result = parse$069xxen(_963); + const from11: rs.Result = num_fromStr$1rjp7t4(_963); if (from11.ok) { max11 = rs.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { @@ -3637,7 +3641,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_1063.ok) { const arg37 = _1063.value; const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg37, f)]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([args46[0]]).v); } else { const e12: rs.ParseIntError = _1063.error; const _1079: rs.IntErrorKind = e12.kind; @@ -3659,7 +3663,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1099: rs.IntErrorKind = e12.kind; const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; - put(out, rs.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); + put(out, rs.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]]).v); } if (radix21 === 10) { const parsed12: rs.Result = parse$069xxen(_1058); @@ -3695,7 +3699,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_1162.ok) { const arg36 = _1162.value; const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg36, f)]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([args50[0]]).v); } else { const e13: rs.ParseIntError = _1162.error; const _1178: rs.IntErrorKind = e13.kind; @@ -3717,7 +3721,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1198: rs.IntErrorKind = e13.kind; const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; - put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]])); + put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]]).v); } if (radix23 === 10) { const parsed13: rs.Result = parse$092epd5(_1141.value); @@ -3731,20 +3735,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_1137 === 1) { - let s7: string = ""; + const s7: rs.String = rs.stringNew(); for (const b4 of rs.byteSliceView(rest4)) { const _1238: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _1239: rs.usize = rs.usizeRem(b4 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_1238, _1239); - s7 = s7 + String.fromCodePoint(_1238.data[_1238.start + _1239] as rs.char); + rs.stringPush(s7, _1238.data[_1238.start + _1239] as rs.char); } - const _1250: string = s7; + const _1250: string = s7.v; const radix24: rs.u32 = radix22; const _1253: rs.Result = num_fromStrRadix$0al5jri(_1250, radix24); if (_1253.ok) { const arg35 = _1253.value; const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg35, f)]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([args54[0]]).v); } else { const e14: rs.ParseIntError = _1253.error; const _1269: rs.IntErrorKind = e14.kind; @@ -3766,7 +3770,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1289: rs.IntErrorKind = e14.kind; const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; - put(out, rs.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]])); + put(out, rs.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]]).v); } if (radix24 === 10) { const parsed14: rs.Result = parse$092epd5(_1250); @@ -3788,12 +3792,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix25: rs.u32 = _1321; for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 64, radix25).items) { + const _1337: string = _1329.v; const radix26: rs.u32 = radix25; - const _1340: rs.Result = num_fromStrRadix$0al5jri(_1329, radix26); + const _1340: rs.Result = num_fromStrRadix$0al5jri(_1337, radix26); if (_1340.ok) { const arg34 = _1340.value; const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg34, f)]; - put(out, rs.fmtFormat([args58[0]])); + put(out, rs.fmtFormat([args58[0]]).v); } else { const e15: rs.ParseIntError = _1340.error; const _1356: rs.IntErrorKind = e15.kind; @@ -3815,11 +3820,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1376: rs.IntErrorKind = e15.kind; const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; - put(out, rs.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]])); + put(out, rs.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]]).v); } if (radix26 === 10) { - const parsed15: rs.Result = parse$092epd5(_1329); - const from15: rs.Result = num_fromStr$0bkyuqf(_1329); + const parsed15: rs.Result = parse$092epd5(_1337); + const from15: rs.Result = num_fromStr$0bkyuqf(_1337); if (from15.ok) { max15 = rs.u8Mul(rs.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { @@ -3847,7 +3852,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_1437.ok) { const arg33 = _1437.value; const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg33, f)]; - put(out, rs.fmtFormat([args62[0]])); + put(out, rs.fmtFormat([args62[0]]).v); } else { const e16: rs.ParseIntError = _1437.error; const _1453: rs.IntErrorKind = e16.kind; @@ -3869,7 +3874,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1473: rs.IntErrorKind = e16.kind; const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; - put(out, rs.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]])); + put(out, rs.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]]).v); } if (radix28 === 10) { const parsed16: rs.Result = parse$092epd5(_1432); @@ -3905,7 +3910,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_1536.ok) { const arg32 = _1536.value; const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg32, f)]; - put(out, rs.fmtFormat([args66[0]])); + put(out, rs.fmtFormat([args66[0]]).v); } else { const e17: rs.ParseIntError = _1536.error; const _1552: rs.IntErrorKind = e17.kind; @@ -3927,7 +3932,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1572: rs.IntErrorKind = e17.kind; const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; - put(out, rs.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]])); + put(out, rs.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]]).v); } if (radix30 === 10) { const parsed17: rs.Result = parse$11owssr(_1515.value); @@ -3941,20 +3946,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_1511 === 1) { - let s9: string = ""; + const s9: rs.String = rs.stringNew(); for (const b5 of rs.byteSliceView(rest5)) { const _1612: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _1613: rs.usize = rs.usizeRem(b5 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_1612, _1613); - s9 = s9 + String.fromCodePoint(_1612.data[_1612.start + _1613] as rs.char); + rs.stringPush(s9, _1612.data[_1612.start + _1613] as rs.char); } - const _1624: string = s9; + const _1624: string = s9.v; const radix31: rs.u32 = radix29; const _1627: rs.Result = num_fromStrRadix$09i2k2a(_1624, radix31); if (_1627.ok) { const arg31 = _1627.value; const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg31, f)]; - put(out, rs.fmtFormat([args70[0]])); + put(out, rs.fmtFormat([args70[0]]).v); } else { const e18: rs.ParseIntError = _1627.error; const _1643: rs.IntErrorKind = e18.kind; @@ -3976,7 +3981,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1663: rs.IntErrorKind = e18.kind; const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; - put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]])); + put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]]).v); } if (radix31 === 10) { const parsed18: rs.Result = parse$11owssr(_1624); @@ -3998,12 +4003,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix32: rs.u32 = _1695; for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 128, radix32).items) { + const _1710: string = _1702.v; const radix33: rs.u32 = radix32; - const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1702, radix33); + const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1710, radix33); if (_1713.ok) { const arg30 = _1713.value; const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg30, f)]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([args74[0]]).v); } else { const e19: rs.ParseIntError = _1713.error; const _1729: rs.IntErrorKind = e19.kind; @@ -4025,11 +4031,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1749: rs.IntErrorKind = e19.kind; const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; - put(out, rs.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]])); + put(out, rs.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]]).v); } if (radix33 === 10) { - const parsed19: rs.Result = parse$11owssr(_1702); - const from19: rs.Result = num_fromStr$0ihvy10(_1702); + const parsed19: rs.Result = parse$11owssr(_1710); + const from19: rs.Result = num_fromStr$0ihvy10(_1710); if (from19.ok) { max19 = rs.u8Mul(rs.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { @@ -4057,7 +4063,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_1810.ok) { const arg29 = _1810.value; const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg29, f)]; - put(out, rs.fmtFormat([args78[0]])); + put(out, rs.fmtFormat([args78[0]]).v); } else { const e20: rs.ParseIntError = _1810.error; const _1826: rs.IntErrorKind = e20.kind; @@ -4079,7 +4085,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1846: rs.IntErrorKind = e20.kind; const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; - put(out, rs.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]])); + put(out, rs.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]]).v); } if (radix35 === 10) { const parsed20: rs.Result = parse$11owssr(_1805); @@ -4115,7 +4121,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_1909.ok) { const arg28 = _1909.value; const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg28, f)]; - put(out, rs.fmtFormat([args82[0]])); + put(out, rs.fmtFormat([args82[0]]).v); } else { const e21: rs.ParseIntError = _1909.error; const _1925: rs.IntErrorKind = e21.kind; @@ -4137,7 +4143,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1945: rs.IntErrorKind = e21.kind; const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; - put(out, rs.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); + put(out, rs.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]]).v); } if (radix37 === 10) { const parsed21: rs.Result = parse$07zoymb(_1888.value); @@ -4151,20 +4157,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_1884 === 1) { - let s11: string = ""; + const s11: rs.String = rs.stringNew(); for (const b6 of rs.byteSliceView(rest6)) { const _1985: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _1986: rs.usize = rs.usizeRem(b6 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_1985, _1986); - s11 = s11 + String.fromCodePoint(_1985.data[_1985.start + _1986] as rs.char); + rs.stringPush(s11, _1985.data[_1985.start + _1986] as rs.char); } - const _1997: string = s11; + const _1997: string = s11.v; const radix38: rs.u32 = radix36; const _2000: rs.Result = num_fromStrRadix$1479ec4(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg27, f)]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([args86[0]]).v); } else { const e22: rs.ParseIntError = _2000.error; const _2016: rs.IntErrorKind = e22.kind; @@ -4186,7 +4192,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2036: rs.IntErrorKind = e22.kind; const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; - put(out, rs.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); + put(out, rs.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]]).v); } if (radix38 === 10) { const parsed22: rs.Result = parse$07zoymb(_1997); @@ -4208,12 +4214,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix39: rs.u32 = _2068; for (const _2076 of edges(4294967295, 0, 32, radix39).items) { + const _2084: string = _2076.v; const radix40: rs.u32 = radix39; - const _2087: rs.Result = num_fromStrRadix$1479ec4(_2076, radix40); + const _2087: rs.Result = num_fromStrRadix$1479ec4(_2084, radix40); if (_2087.ok) { const arg26 = _2087.value; const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg26, f)]; - put(out, rs.fmtFormat([args90[0]])); + put(out, rs.fmtFormat([args90[0]]).v); } else { const e23: rs.ParseIntError = _2087.error; const _2103: rs.IntErrorKind = e23.kind; @@ -4235,11 +4242,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2123: rs.IntErrorKind = e23.kind; const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; - put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); + put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]]).v); } if (radix40 === 10) { - const parsed23: rs.Result = parse$07zoymb(_2076); - const from23: rs.Result = num_fromStr$1jgkxdq(_2076); + const parsed23: rs.Result = parse$07zoymb(_2084); + const from23: rs.Result = num_fromStr$1jgkxdq(_2084); if (from23.ok) { max23 = rs.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { @@ -4267,7 +4274,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_2184.ok) { const arg25 = _2184.value; const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg25, f)]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([args94[0]]).v); } else { const e24: rs.ParseIntError = _2184.error; const _2200: rs.IntErrorKind = e24.kind; @@ -4289,7 +4296,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2220: rs.IntErrorKind = e24.kind; const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; - put(out, rs.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); + put(out, rs.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]]).v); } if (radix42 === 10) { const parsed24: rs.Result = parse$07zoymb(_2179); @@ -4325,7 +4332,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_2283.ok) { const arg24 = _2283.value; const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg24, f)]; - put(out, rs.fmtFormat([args98[0]])); + put(out, rs.fmtFormat([args98[0]]).v); } else { const e25: rs.ParseIntError = _2283.error; const _2299: rs.IntErrorKind = e25.kind; @@ -4347,7 +4354,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2319: rs.IntErrorKind = e25.kind; const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; - put(out, rs.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); + put(out, rs.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]]).v); } if (radix44 === 10) { const parsed25: rs.Result = parse$02m1946(_2262.value); @@ -4361,20 +4368,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_2258 === 1) { - let s13: string = ""; + const s13: rs.String = rs.stringNew(); for (const b7 of rs.byteSliceView(rest7)) { const _2359: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _2360: rs.usize = rs.usizeRem(b7 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_2359, _2360); - s13 = s13 + String.fromCodePoint(_2359.data[_2359.start + _2360] as rs.char); + rs.stringPush(s13, _2359.data[_2359.start + _2360] as rs.char); } - const _2371: string = s13; + const _2371: string = s13.v; const radix45: rs.u32 = radix43; const _2374: rs.Result = num_fromStrRadix$0qyezqs(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg23, f)]; - put(out, rs.fmtFormat([args102[0]])); + put(out, rs.fmtFormat([args102[0]]).v); } else { const e26: rs.ParseIntError = _2374.error; const _2390: rs.IntErrorKind = e26.kind; @@ -4396,7 +4403,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2410: rs.IntErrorKind = e26.kind; const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; - put(out, rs.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); + put(out, rs.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]]).v); } if (radix45 === 10) { const parsed26: rs.Result = parse$02m1946(_2371); @@ -4418,12 +4425,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix46: rs.u32 = _2442; for (const _2453 of edges(127, rs.u128Add(127, 1), 8, radix46).items) { + const _2461: string = _2453.v; const radix47: rs.u32 = radix46; - const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2453, radix47); + const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2461, radix47); if (_2464.ok) { const arg22 = _2464.value; const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg22, f)]; - put(out, rs.fmtFormat([args106[0]])); + put(out, rs.fmtFormat([args106[0]]).v); } else { const e27: rs.ParseIntError = _2464.error; const _2480: rs.IntErrorKind = e27.kind; @@ -4445,11 +4453,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2500: rs.IntErrorKind = e27.kind; const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; - put(out, rs.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); + put(out, rs.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]]).v); } if (radix47 === 10) { - const parsed27: rs.Result = parse$02m1946(_2453); - const from27: rs.Result = num_fromStr$1amqoj7(_2453); + const parsed27: rs.Result = parse$02m1946(_2461); + const from27: rs.Result = num_fromStr$1amqoj7(_2461); if (from27.ok) { max27 = rs.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { @@ -4477,7 +4485,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_2561.ok) { const arg21 = _2561.value; const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg21, f)]; - put(out, rs.fmtFormat([args110[0]])); + put(out, rs.fmtFormat([args110[0]]).v); } else { const e28: rs.ParseIntError = _2561.error; const _2577: rs.IntErrorKind = e28.kind; @@ -4499,7 +4507,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2597: rs.IntErrorKind = e28.kind; const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; - put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); + put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]]).v); } if (radix49 === 10) { const parsed28: rs.Result = parse$02m1946(_2556); @@ -4535,7 +4543,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_2660.ok) { const arg20 = _2660.value; const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg20, f)]; - put(out, rs.fmtFormat([args114[0]])); + put(out, rs.fmtFormat([args114[0]]).v); } else { const e29: rs.ParseIntError = _2660.error; const _2676: rs.IntErrorKind = e29.kind; @@ -4557,7 +4565,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2696: rs.IntErrorKind = e29.kind; const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; - put(out, rs.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); + put(out, rs.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]]).v); } if (radix51 === 10) { const parsed29: rs.Result = parse$00ajhlu(_2639.value); @@ -4571,20 +4579,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_2635 === 1) { - let s15: string = ""; + const s15: rs.String = rs.stringNew(); for (const b8 of rs.byteSliceView(rest8)) { const _2736: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _2737: rs.usize = rs.usizeRem(b8 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_2736, _2737); - s15 = s15 + String.fromCodePoint(_2736.data[_2736.start + _2737] as rs.char); + rs.stringPush(s15, _2736.data[_2736.start + _2737] as rs.char); } - const _2748: string = s15; + const _2748: string = s15.v; const radix52: rs.u32 = radix50; const _2751: rs.Result = num_fromStrRadix$19vdb8q(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg19, f)]; - put(out, rs.fmtFormat([args118[0]])); + put(out, rs.fmtFormat([args118[0]]).v); } else { const e30: rs.ParseIntError = _2751.error; const _2767: rs.IntErrorKind = e30.kind; @@ -4606,7 +4614,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2787: rs.IntErrorKind = e30.kind; const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; - put(out, rs.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); + put(out, rs.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]]).v); } if (radix52 === 10) { const parsed30: rs.Result = parse$00ajhlu(_2748); @@ -4628,12 +4636,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix53: rs.u32 = _2819; for (const _2830 of edges(32767, rs.u128Add(32767, 1), 16, radix53).items) { + const _2838: string = _2830.v; const radix54: rs.u32 = radix53; - const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2830, radix54); + const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2838, radix54); if (_2841.ok) { const arg18 = _2841.value; const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg18, f)]; - put(out, rs.fmtFormat([args122[0]])); + put(out, rs.fmtFormat([args122[0]]).v); } else { const e31: rs.ParseIntError = _2841.error; const _2857: rs.IntErrorKind = e31.kind; @@ -4655,11 +4664,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2877: rs.IntErrorKind = e31.kind; const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; - put(out, rs.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); + put(out, rs.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]]).v); } if (radix54 === 10) { - const parsed31: rs.Result = parse$00ajhlu(_2830); - const from31: rs.Result = num_fromStr$0ehcbzz(_2830); + const parsed31: rs.Result = parse$00ajhlu(_2838); + const from31: rs.Result = num_fromStr$0ehcbzz(_2838); if (from31.ok) { max31 = rs.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { @@ -4687,7 +4696,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_2938.ok) { const arg17 = _2938.value; const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg17, f)]; - put(out, rs.fmtFormat([args126[0]])); + put(out, rs.fmtFormat([args126[0]]).v); } else { const e32: rs.ParseIntError = _2938.error; const _2954: rs.IntErrorKind = e32.kind; @@ -4709,7 +4718,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2974: rs.IntErrorKind = e32.kind; const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; - put(out, rs.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); + put(out, rs.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]]).v); } if (radix56 === 10) { const parsed32: rs.Result = parse$00ajhlu(_2933); @@ -4745,7 +4754,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_3037.ok) { const arg16 = _3037.value; const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg16, f)]; - put(out, rs.fmtFormat([args130[0]])); + put(out, rs.fmtFormat([args130[0]]).v); } else { const e33: rs.ParseIntError = _3037.error; const _3053: rs.IntErrorKind = e33.kind; @@ -4767,7 +4776,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3073: rs.IntErrorKind = e33.kind; const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; - put(out, rs.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); + put(out, rs.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]]).v); } if (radix58 === 10) { const parsed33: rs.Result = parse$14v13am(_3016.value); @@ -4781,20 +4790,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_3012 === 1) { - let s17: string = ""; + const s17: rs.String = rs.stringNew(); for (const b9 of rs.byteSliceView(rest9)) { const _3113: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _3114: rs.usize = rs.usizeRem(b9 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_3113, _3114); - s17 = s17 + String.fromCodePoint(_3113.data[_3113.start + _3114] as rs.char); + rs.stringPush(s17, _3113.data[_3113.start + _3114] as rs.char); } - const _3125: string = s17; + const _3125: string = s17.v; const radix59: rs.u32 = radix57; const _3128: rs.Result = num_fromStrRadix$1ct8u92(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg15, f)]; - put(out, rs.fmtFormat([args134[0]])); + put(out, rs.fmtFormat([args134[0]]).v); } else { const e34: rs.ParseIntError = _3128.error; const _3144: rs.IntErrorKind = e34.kind; @@ -4816,7 +4825,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3164: rs.IntErrorKind = e34.kind; const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; - put(out, rs.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); + put(out, rs.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]]).v); } if (radix59 === 10) { const parsed34: rs.Result = parse$14v13am(_3125); @@ -4838,12 +4847,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix60: rs.u32 = _3196; for (const _3207 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix60).items) { + const _3215: string = _3207.v; const radix61: rs.u32 = radix60; - const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3207, radix61); + const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3215, radix61); if (_3218.ok) { const arg14 = _3218.value; const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg14, f)]; - put(out, rs.fmtFormat([args138[0]])); + put(out, rs.fmtFormat([args138[0]]).v); } else { const e35: rs.ParseIntError = _3218.error; const _3234: rs.IntErrorKind = e35.kind; @@ -4865,11 +4875,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3254: rs.IntErrorKind = e35.kind; const args140: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; - put(out, rs.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); + put(out, rs.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]]).v); } if (radix61 === 10) { - const parsed35: rs.Result = parse$14v13am(_3207); - const from35: rs.Result = num_fromStr$1ckv470(_3207); + const parsed35: rs.Result = parse$14v13am(_3215); + const from35: rs.Result = num_fromStr$1ckv470(_3215); if (from35.ok) { max35 = rs.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { @@ -4897,7 +4907,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_3315.ok) { const arg13 = _3315.value; const args142: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg13, f)]; - put(out, rs.fmtFormat([args142[0]])); + put(out, rs.fmtFormat([args142[0]]).v); } else { const e36: rs.ParseIntError = _3315.error; const _3331: rs.IntErrorKind = e36.kind; @@ -4919,7 +4929,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3351: rs.IntErrorKind = e36.kind; const args144: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; - put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); + put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]]).v); } if (radix63 === 10) { const parsed36: rs.Result = parse$14v13am(_3310); @@ -4955,7 +4965,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_3414.ok) { const arg12 = _3414.value; const args146: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg12, f)]; - put(out, rs.fmtFormat([args146[0]])); + put(out, rs.fmtFormat([args146[0]]).v); } else { const e37: rs.ParseIntError = _3414.error; const _3430: rs.IntErrorKind = e37.kind; @@ -4977,7 +4987,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3450: rs.IntErrorKind = e37.kind; const args148: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; - put(out, rs.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]])); + put(out, rs.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]]).v); } if (radix65 === 10) { const parsed37: rs.Result = parse$0px1msj(_3393.value); @@ -4991,20 +5001,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_3389 === 1) { - let s19: string = ""; + const s19: rs.String = rs.stringNew(); for (const b10 of rs.byteSliceView(rest10)) { const _3490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _3491: rs.usize = rs.usizeRem(b10 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_3490, _3491); - s19 = s19 + String.fromCodePoint(_3490.data[_3490.start + _3491] as rs.char); + rs.stringPush(s19, _3490.data[_3490.start + _3491] as rs.char); } - const _3502: string = s19; + const _3502: string = s19.v; const radix66: rs.u32 = radix64; const _3505: rs.Result = num_fromStrRadix$04fc4zz(_3502, radix66); if (_3505.ok) { const arg11 = _3505.value; const args150: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg11, f)]; - put(out, rs.fmtFormat([args150[0]])); + put(out, rs.fmtFormat([args150[0]]).v); } else { const e38: rs.ParseIntError = _3505.error; const _3521: rs.IntErrorKind = e38.kind; @@ -5026,7 +5036,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3541: rs.IntErrorKind = e38.kind; const args152: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; - put(out, rs.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]])); + put(out, rs.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]]).v); } if (radix66 === 10) { const parsed38: rs.Result = parse$0px1msj(_3502); @@ -5048,12 +5058,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix67: rs.u32 = _3573; for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, 1), 64, radix67).items) { + const _3592: string = _3584.v; const radix68: rs.u32 = radix67; - const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3584, radix68); + const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3592, radix68); if (_3595.ok) { const arg10 = _3595.value; const args154: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg10, f)]; - put(out, rs.fmtFormat([args154[0]])); + put(out, rs.fmtFormat([args154[0]]).v); } else { const e39: rs.ParseIntError = _3595.error; const _3611: rs.IntErrorKind = e39.kind; @@ -5075,11 +5086,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3631: rs.IntErrorKind = e39.kind; const args156: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; - put(out, rs.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]])); + put(out, rs.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]]).v); } if (radix68 === 10) { - const parsed39: rs.Result = parse$0px1msj(_3584); - const from39: rs.Result = num_fromStr$00n8jbp(_3584); + const parsed39: rs.Result = parse$0px1msj(_3592); + const from39: rs.Result = num_fromStr$00n8jbp(_3592); if (from39.ok) { max39 = rs.u8Mul(rs.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { @@ -5107,7 +5118,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_3692.ok) { const arg9 = _3692.value; const args158: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg9, f)]; - put(out, rs.fmtFormat([args158[0]])); + put(out, rs.fmtFormat([args158[0]]).v); } else { const e40: rs.ParseIntError = _3692.error; const _3708: rs.IntErrorKind = e40.kind; @@ -5129,7 +5140,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3728: rs.IntErrorKind = e40.kind; const args160: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; - put(out, rs.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]])); + put(out, rs.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]]).v); } if (radix70 === 10) { const parsed40: rs.Result = parse$0px1msj(_3687); @@ -5165,7 +5176,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_3791.ok) { const arg8 = _3791.value; const args162: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg8, f)]; - put(out, rs.fmtFormat([args162[0]])); + put(out, rs.fmtFormat([args162[0]]).v); } else { const e41: rs.ParseIntError = _3791.error; const _3807: rs.IntErrorKind = e41.kind; @@ -5187,7 +5198,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3827: rs.IntErrorKind = e41.kind; const args164: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; - put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]])); + put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]]).v); } if (radix72 === 10) { const parsed41: rs.Result = parse$1kyj9pm(_3770.value); @@ -5201,20 +5212,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_3766 === 1) { - let s21: string = ""; + const s21: rs.String = rs.stringNew(); for (const b11 of rs.byteSliceView(rest11)) { const _3867: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _3868: rs.usize = rs.usizeRem(b11 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_3867, _3868); - s21 = s21 + String.fromCodePoint(_3867.data[_3867.start + _3868] as rs.char); + rs.stringPush(s21, _3867.data[_3867.start + _3868] as rs.char); } - const _3879: string = s21; + const _3879: string = s21.v; const radix73: rs.u32 = radix71; const _3882: rs.Result = num_fromStrRadix$0cysu2u(_3879, radix73); if (_3882.ok) { const arg7 = _3882.value; const args166: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg7, f)]; - put(out, rs.fmtFormat([args166[0]])); + put(out, rs.fmtFormat([args166[0]]).v); } else { const e42: rs.ParseIntError = _3882.error; const _3898: rs.IntErrorKind = e42.kind; @@ -5236,7 +5247,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3918: rs.IntErrorKind = e42.kind; const args168: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; - put(out, rs.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]])); + put(out, rs.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]]).v); } if (radix73 === 10) { const parsed42: rs.Result = parse$1kyj9pm(_3879); @@ -5258,12 +5269,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix74: rs.u32 = _3950; for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 1), 128, radix74).items) { + const _3969: string = _3961.v; const radix75: rs.u32 = radix74; - const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3961, radix75); + const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3969, radix75); if (_3972.ok) { const arg6 = _3972.value; const args170: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg6, f)]; - put(out, rs.fmtFormat([args170[0]])); + put(out, rs.fmtFormat([args170[0]]).v); } else { const e43: rs.ParseIntError = _3972.error; const _3988: rs.IntErrorKind = e43.kind; @@ -5285,11 +5297,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4008: rs.IntErrorKind = e43.kind; const args172: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; - put(out, rs.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]])); + put(out, rs.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]]).v); } if (radix75 === 10) { - const parsed43: rs.Result = parse$1kyj9pm(_3961); - const from43: rs.Result = num_fromStr$1el0yvy(_3961); + const parsed43: rs.Result = parse$1kyj9pm(_3969); + const from43: rs.Result = num_fromStr$1el0yvy(_3969); if (from43.ok) { max43 = rs.u8Mul(rs.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { @@ -5317,7 +5329,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_4069.ok) { const arg5 = _4069.value; const args174: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg5, f)]; - put(out, rs.fmtFormat([args174[0]])); + put(out, rs.fmtFormat([args174[0]]).v); } else { const e44: rs.ParseIntError = _4069.error; const _4085: rs.IntErrorKind = e44.kind; @@ -5339,7 +5351,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4105: rs.IntErrorKind = e44.kind; const args176: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; - put(out, rs.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]])); + put(out, rs.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]]).v); } if (radix77 === 10) { const parsed44: rs.Result = parse$1kyj9pm(_4064); @@ -5375,7 +5387,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_4168.ok) { const arg4 = _4168.value; const args178: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg4, f)]; - put(out, rs.fmtFormat([args178[0]])); + put(out, rs.fmtFormat([args178[0]]).v); } else { const e45: rs.ParseIntError = _4168.error; const _4184: rs.IntErrorKind = e45.kind; @@ -5397,7 +5409,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4204: rs.IntErrorKind = e45.kind; const args180: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; - put(out, rs.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); + put(out, rs.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]]).v); } if (radix79 === 10) { const parsed45: rs.Result = parse$1g90yxu(_4147.value); @@ -5411,20 +5423,20 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_4143 === 1) { - let s23: string = ""; + const s23: rs.String = rs.stringNew(); for (const b12 of rs.byteSliceView(rest12)) { const _4244: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _4245: rs.usize = rs.usizeRem(b12 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_4244, _4245); - s23 = s23 + String.fromCodePoint(_4244.data[_4244.start + _4245] as rs.char); + rs.stringPush(s23, _4244.data[_4244.start + _4245] as rs.char); } - const _4256: string = s23; + const _4256: string = s23.v; const radix80: rs.u32 = radix78; const _4259: rs.Result = num_fromStrRadix$1nys6eo(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; const args182: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg3, f)]; - put(out, rs.fmtFormat([args182[0]])); + put(out, rs.fmtFormat([args182[0]]).v); } else { const e46: rs.ParseIntError = _4259.error; const _4275: rs.IntErrorKind = e46.kind; @@ -5446,7 +5458,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4295: rs.IntErrorKind = e46.kind; const args184: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; - put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); + put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]]).v); } if (radix80 === 10) { const parsed46: rs.Result = parse$1g90yxu(_4256); @@ -5468,12 +5480,13 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix81: rs.u32 = _4327; for (const _4338 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix81).items) { + const _4346: string = _4338.v; const radix82: rs.u32 = radix81; - const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4338, radix82); + const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4346, radix82); if (_4349.ok) { const arg2 = _4349.value; const args186: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]; - put(out, rs.fmtFormat([args186[0]])); + put(out, rs.fmtFormat([args186[0]]).v); } else { const e47: rs.ParseIntError = _4349.error; const _4365: rs.IntErrorKind = e47.kind; @@ -5495,11 +5508,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4385: rs.IntErrorKind = e47.kind; const args188: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; - put(out, rs.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); + put(out, rs.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]]).v); } if (radix82 === 10) { - const parsed47: rs.Result = parse$1g90yxu(_4338); - const from47: rs.Result = num_fromStr$0ytcpik(_4338); + const parsed47: rs.Result = parse$1g90yxu(_4346); + const from47: rs.Result = num_fromStr$0ytcpik(_4346); if (from47.ok) { max47 = rs.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); } else { @@ -5527,7 +5540,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat if (_4446.ok) { const arg = _4446.value; const args190: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg, f)]; - put(out, rs.fmtFormat([args190[0]])); + put(out, rs.fmtFormat([args190[0]]).v); } else { const e48: rs.ParseIntError = _4446.error; const _4462: rs.IntErrorKind = e48.kind; @@ -5549,7 +5562,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4482: rs.IntErrorKind = e48.kind; const args192: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; - put(out, rs.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); + put(out, rs.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]]).v); } if (radix84 === 10) { const parsed48: rs.Result = parse$1g90yxu(_4441); diff --git a/ts/fixtures/lang/iters/expected/core/option.ts b/ts/fixtures/lang/iters/expected/core/option.ts index 9038bc655..cd060fb03 100644 --- a/ts/fixtures/lang/iters/expected/core/option.ts +++ b/ts/fixtures/lang/iters/expected/core/option.ts @@ -40,9 +40,9 @@ export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs return self; } -export function unwrapOrDefault$165pyh5(self: string | undefined): string { +export function unwrapOrDefault$1exlfpa(self: rs.String | undefined): rs.String { if (self === undefined) { - return ""; + return rs.stringNew(); } return self; } @@ -54,14 +54,14 @@ export function unwrapOrDefault$0w012ed(self: rs.ByteVec | undefined): rs.ByteVe return self; } -export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string): string | undefined { +export function map$06og5bz(self: rs.String | undefined, _: (a0: rs.String) => string): string | undefined { if (self === undefined) { return undefined; } - return self; + return self.v; } -export function map$1bpbukm(self: rs.Vec | undefined, f: (a0: rs.Vec) => string): string | undefined { +export function map$1wdw03s(self: rs.Vec | undefined, f: (a0: rs.Vec) => string): string | undefined { if (self === undefined) { return undefined; } @@ -111,7 +111,7 @@ export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs. return f(self); } -export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { +export function mapOr$1fzqoua(self: rs.String | undefined, default_: rs.u8, f: (a0: rs.String) => rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -181,6 +181,13 @@ export function mapOr$02sqh24(self: rs.Place | undefined, default_: rs.u8 return f(self); } +export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; @@ -258,9 +265,9 @@ export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a return f(self); } -export function asDeref$0w8at8i(self: string | undefined): string | undefined { - return map$1uo1d4o(self, (a0: string): string => { - return a0; +export function asDeref$0wpj87j(self: rs.String | undefined): string | undefined { + return map$06og5bz(self, (a0: rs.String): string => { + return a0.v; }); } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index b37962345..da7ef6484 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { drop$iters_Ticks, of$u8 } from "./lib.ts"; import { thenSome$1ctlqen, thenSome$1gvhopg, thenSome$0quywni, thenSome$1n1oy1h } from "./core/bool.ts"; -import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$1uo1d4o as option_map$1uo1d4o, map$1bpbukm as option_map$1bpbukm, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$1exlfpa as option_unwrapOrDefault$1exlfpa, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$06og5bz as option_map$06og5bz, map$1wdw03s as option_map$1wdw03s, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1fzqoua as option_mapOr$1fzqoua, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0wpj87j as option_asDeref$0wpj87j, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; import { unwrapOr$0a3q6xs as result_unwrapOr$0a3q6xs } from "./core/result.ts"; import type * as Badge from "./iters.Badge.ts"; import * as Bag from "./iters.Bag.ts"; @@ -399,9 +399,9 @@ export function eq$cmp_PartialEq_iters_Quarter_array2_u8(self: rs.ByteSlice, oth return rs.iterSum(rs.iterSlice(rs.byteSliceView(self)), rs.u8Add, 0) === other._0; } -export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quarter.Quarter): boolean { +export function eq$cmp_PartialEq_iters_Quarter_String(self: rs.String, other: Quarter.Quarter): boolean { rs.cellSet(other._1, rs.u8WrappingAdd(other._1.v, 4)); - return rs.stringLen(self) === other._0 as rs.usize; + return self.len === other._0 as rs.usize; } /** @@ -410,9 +410,9 @@ export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quart * first item, and a mismatch keeps the item for the next `next`. */ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { - const _3: (a0: rs.u8) => string = (b: rs.u8): string => { + const _3: (a0: rs.u8) => rs.String = (b: rs.u8): rs.String => { const _42: rs.char = rs.u8Add(97, rs.u8Rem(b, 3)) as rs.char; - return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_42, f), 0); }; const _4: (a0: string | undefined) => rs.u8 = (w: string | undefined): rs.u8 => { return option_mapOr$1nyk1yj(w, 170, (w2: string): rs.u8 => { @@ -429,91 +429,97 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const _159: (a0: rs.u8) => rs.Vec = (b2: rs.u8): rs.Vec => { return rs.vecFromElem(((rs.u8Rem(b2, 2) as rs.u16) << 9) & 0xffff, rs.u8Rem(b2, 3) as rs.usize, undefined); }; - const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): string => { + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.String => { return _3(_2); }), undefined, 12, true); - const _12: string | undefined = rs.sliceFirst(rs.sliceFrom(words.items)); - const first: string = option_unwrapOrDefault$165pyh5(_12 === undefined ? undefined : _12); - const it: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.slice()))); - const part = option_asDeref$0w8at8i(rs.peekableNextIfEq(it, "a", (a0: string, a1: string): boolean => { - return a0 === a1; + const _12: rs.String | undefined = rs.sliceFirst(rs.sliceFrom(words.items)); + const first: rs.String = option_unwrapOrDefault$1exlfpa(_12 === undefined ? undefined : rs.stringClone(_12)); + const it: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.map((a0: rs.String): rs.String => { + return rs.stringClone(a0); + })))); + const part = option_asDeref$0wpj87j(rs.peekableNextIfEq(it, "a", (a02: rs.String, a1: string): boolean => { + return rs.eqStr(a02, a1); })); rs.byteVecPush(out, _4(part)); - const part2 = option_asDeref$0w8at8i(rs.peekableNextIfEq(it, "b", (a02: string, a12: string): boolean => { - return a02 === a12; + const part2 = option_asDeref$0wpj87j(rs.peekableNextIfEq(it, "b", (a03: rs.String, a12: string): boolean => { + return rs.eqStr(a03, a12); })); rs.byteVecPush(out, _4(part2)); - const part3 = option_asDeref$0w8at8i(rs.iterToOption(it.next())); + const part3 = option_asDeref$0wpj87j(rs.iterToOption(it.next())); rs.byteVecPush(out, _4(part3)); - const it2: rs.Peekable = rs.iterPeekable(rs.iterSlice(words.items)); - const part4 = option_map$1uo1d4o(rs.peekableNextIfEq(it2, first, (a03: string, a13: string): boolean => { - return a03 === a13; - }), (a04: string): string => { - return a04; + const it2: rs.Peekable = rs.iterPeekable(rs.iterSlice(words.items)); + const part4 = option_map$06og5bz(rs.peekableNextIfEq(it2, first.v, (a04: rs.String, a13: string): boolean => { + return rs.eqStr(a04, a13); + }), (a05: rs.String): string => { + return a05.v; }); rs.byteVecPush(out, _4(part4)); - const part5 = option_map$1uo1d4o(rs.peekableNextIfEq(it2, "c", (a05: string, a14: string): boolean => { - return a05 === a14; - }), (a06: string): string => { - return a06; + const part5 = option_map$06og5bz(rs.peekableNextIfEq(it2, "c", (a06: rs.String, a14: string): boolean => { + return rs.eqStr(a06, a14); + }), (a07: rs.String): string => { + return a07.v; }); rs.byteVecPush(out, _4(part5)); - const part6 = option_map$1uo1d4o(rs.iterToOption(it2.next()), (a07: string): string => { - return a07; + const part6 = option_map$06og5bz(rs.iterToOption(it2.next()), (a08: rs.String): string => { + return a08.v; }); rs.byteVecPush(out, _4(part6)); - const it3: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (a08: string): string => { - return a08; + const it3: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (a09: rs.String): string => { + return a09.v; })); - const part7 = rs.peekableNextIfEq(it3, first, (a09: string, a15: string): boolean => { - return a09 === a15; + const part7 = rs.peekableNextIfEq(it3, first, (a010: string, a15: rs.String): boolean => { + return rs.eqStr(a010, a15); }); rs.byteVecPush(out, _4(part7)); const part8 = rs.iterToOption(it3.next()); rs.byteVecPush(out, _4(part8)); - const it4: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.Vec => { + const it4: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.Vec => { return rs.vecFrom([_3(_24)]); })); - const _107: rs.Vec = rs.vecFrom([first]); - const part9 = option_map$1bpbukm(rs.peekableNextIfEq(it4, _107, (a010: rs.Vec, a16: rs.Vec): boolean => { - return rs.eqSlice(rs.same)(a010, a16); - }), (v3: rs.Vec): string => { - return v3.items[rs.idx(v3.items, 0)]; + const _107: rs.Vec = rs.vecFrom([first.v]); + const part9 = option_map$1wdw03s(rs.peekableNextIfEq(it4, _107, (a011: rs.Vec, a16: rs.Vec): boolean => { + return rs.eqSlice(rs.eqStr)(a011, a16); + }), (v3: rs.Vec): string => { + return v3.items[rs.idx(v3.items, 0)].v; }); rs.byteVecPush(out, _4(part9)); - const part10 = option_map$1bpbukm(rs.iterToOption(it4.next()), (v4: rs.Vec): string => { - return v4.items[rs.idx(v4.items, 0)]; + const part10 = option_map$1wdw03s(rs.iterToOption(it4.next()), (v4: rs.Vec): string => { + return v4.items[rs.idx(v4.items, 0)].v; }); rs.byteVecPush(out, _4(part10)); - const it5: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (w3: string): rs.StrCow => { - return new rs.Borrowed(w3); + const it5: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (w3: rs.String): rs.StrCow => { + return new rs.Borrowed(w3.v); })); - const part11 = option_asDeref$0pg0e8a(rs.peekableNextIfEq(it5, "b", (a011: rs.StrCow, a17: string): boolean => { - return rs.strCowStr(a011) === a17; + const part11 = option_asDeref$0pg0e8a(rs.peekableNextIfEq(it5, "b", (a012: rs.StrCow, a17: string): boolean => { + return rs.strCowStr(a012) === a17; })); rs.byteVecPush(out, _4(part11)); const part12 = option_asDeref$0pg0e8a(rs.iterToOption(it5.next())); rs.byteVecPush(out, _4(part12)); - const part13 = option_asDeref$0w8at8i(rs.peekableNextIfEq(rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.slice()))), first, (a012: string, a18: rs.StrCow): boolean => { - return a012 === rs.strCowStr(a18); + const it6: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.map((a013: rs.String): rs.String => { + return rs.stringClone(a013); + })))); + const _155: rs.StrCow = rs.stringClone(first); + const part13 = option_asDeref$0wpj87j(rs.peekableNextIfEq(it6, _155, (a014: rs.String, a18: rs.StrCow): boolean => { + return rs.eqStr(a014, rs.strCowStr(a18)); })); rs.byteVecPush(out, _4(part13)); const it7: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): rs.Vec => { return _159(_26); })); const _171: rs.Slice = rs.sliceFrom([0]); - const part14 = rs.peekableNextIfEq(it7, _171, (a013: rs.Vec, a19: rs.Slice): boolean => { - return rs.eqSlice(rs.same)(a013, a19); + const part14 = rs.peekableNextIfEq(it7, _171, (a015: rs.Vec, a19: rs.Slice): boolean => { + return rs.eqSlice(rs.same)(a015, a19); }); rs.byteVecPush(out, _158(part14)); - const part15 = rs.peekableNextIfEq(it7, [512, 512], (a014: rs.Vec, a110: rs.u16[]): boolean => { - return rs.eqSlice(rs.same)(a014, a110); + const part15 = rs.peekableNextIfEq(it7, [512, 512], (a016: rs.Vec, a110: rs.u16[]): boolean => { + return rs.eqSlice(rs.same)(a016, a110); }); rs.byteVecPush(out, _158(part15)); const _189: rs.u16[] = []; const _188: rs.Slice = rs.sliceFrom(_189); - const part16 = rs.peekableNextIfEq(it7, _188, (a015: rs.Vec, a111: rs.Slice): boolean => { - return rs.eqSlice(rs.same)(a015, a111); + const part16 = rs.peekableNextIfEq(it7, _188, (a017: rs.Vec, a111: rs.Slice): boolean => { + return rs.eqSlice(rs.same)(a017, a111); }); rs.byteVecPush(out, _158(part16)); const part17 = rs.iterToOption(it7.next()); @@ -523,8 +529,8 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.byteVecOf(rs.u8Rem(b6, 2), rs.u8Rem(b6, 3) as rs.usize); })); const _203: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(1)), 0); - rs.byteVecPush(out, option_mapOr$0g5x999(rs.peekableNextIfEq(it8, _203, (a016: rs.ByteVec, a112: rs.ByteSlice): boolean => { - return rs.eqBytes(a016, a112); + rs.byteVecPush(out, option_mapOr$0g5x999(rs.peekableNextIfEq(it8, _203, (a018: rs.ByteVec, a112: rs.ByteSlice): boolean => { + return rs.eqBytes(a018, a112); }), 170, (v5: rs.ByteVec): rs.u8 => { return v5.length & 0xff; })); @@ -540,8 +546,8 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { })); const _217: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(0, 1)), 0); rs.byteVecPush(out, option_mapOr$1i4rvy8(rs.peekableNextIfEq(it9, _217, (a: Uint8Array, b7: rs.ByteSlice): boolean => { - return ((a017: rs.ByteSlice, a113: rs.ByteSlice): boolean => { - return rs.eqBytes(a017, a113); + return ((a019: rs.ByteSlice, a113: rs.ByteSlice): boolean => { + return rs.eqBytes(a019, a113); })(rs.byteSliceFrom(a), b7); }), 170, (p: Uint8Array): rs.u8 => { return p[1]; @@ -560,14 +566,14 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const it10: rs.Peekable> = rs.iterPeekable(rs.iterSliceMut(rs.byteVecSlice(bytes))); const _242: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); - const _239: rs.Place | undefined = rs.peekableNextIfEq(it10, _242, (a018: rs.Place, a114: rs.u8): boolean => { - return a018.v === a114; + const _239: rs.Place | undefined = rs.peekableNextIfEq(it10, _242, (a020: rs.Place, a114: rs.u8): boolean => { + return a020.v === a114; }); if (_239 !== undefined) { _239.v = _239.v ^ 64; } - rs.byteVecPush(out, option_mapOr$02sqh24(rs.peekableNextIfEq(it10, 3, (a019: rs.Place, a115: rs.u8): boolean => { - return a019.v === a115; + rs.byteVecPush(out, option_mapOr$02sqh24(rs.peekableNextIfEq(it10, 3, (a021: rs.Place, a115: rs.u8): boolean => { + return a021.v === a115; }), 170, (b9: rs.Place): rs.u8 => { return b9.v; })); @@ -590,16 +596,16 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const it12: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it12, { _0: want ^ 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it12, { _0: want, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); - const it13: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): string => { - return rs.strSlice("ab", 0, rs.u8Rem(_213, 3) as rs.usize); + const it13: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): rs.String => { + return rs.stringFrom(rs.strSlice("ab", 0, rs.u8Rem(_213, 3) as rs.usize)); })); - rs.byteVecPush(out, option_mapOr$1nyk1yj(rs.peekableNextIfEq(it13, { _0: 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_String), 170, (w4: string): rs.u8 => { - return rs.stringLen(w4) & 0xff; + rs.byteVecPush(out, option_mapOr$1fzqoua(rs.peekableNextIfEq(it13, { _0: 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_String), 170, (w4: rs.String): rs.u8 => { + return w4.len & 0xff; })); - rs.byteVecPush(out, option_mapOr$1nyk1yj(rs.iterToOption(it13.next()), 170, (w5: string): rs.u8 => { - return rs.stringLen(w5) & 0xff; + rs.byteVecPush(out, option_mapOr$1fzqoua(rs.iterToOption(it13.next()), 170, (w5: rs.String): rs.u8 => { + return w5.len & 0xff; })); - rs.byteVecPush(out, eq$cmp_PartialEq_iters_Quarter_String("ab", { _0: want, _1: calls }) ? 1 : 0); + rs.byteVecPush(out, eq$cmp_PartialEq_iters_Quarter_String(rs.stringFrom("ab"), { _0: want, _1: calls }) ? 1 : 0); rs.byteVecPush(out, calls.v); } @@ -1738,7 +1744,7 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { const _31: Doubled.Doubled = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; const _33: Doubled.Doubled = { _0Data: _34.data, _0Start: _34.start, _0Len: _34.length }; const args2: rs.Fmt[] = [(f: rs.Formatter) => Doubled.fmt$fmt_Debug(_31, f), (f: rs.Formatter) => Doubled.fmt$fmt_Debug(_33, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1])]).v)); const tags: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tag.Tag => { const b3: rs.u8 = _2; return { bytes: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; @@ -6557,7 +6563,8 @@ export function adapted(a: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterTake(rs.iterStepBy(new rs.RangeFrom(lo, rs.u8Step), 3), 4), "next")), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(rs.stringExtendChars("", rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6)))), undefined, true); + const _71: rs.Iter = rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6)); + rs.iterExtendBytes(out, rs.strBytes(rs.stringExtendChars(rs.stringNew(), _71).v), undefined, true); const _77: [rs.usize, rs.usize | undefined] = rs.iterZip(it(), new rs.RangeFrom(lo, rs.u8Step), "len").sizeHint(); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$188iunt(_77[1], 238, (h: rs.usize): rs.u8 => { return h & 0xff; @@ -6756,14 +6763,14 @@ export function bounded$char(table: rs.Slice, at: rs.usize[], out: rs.B const _111: [rs.char, rs.char] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_111[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_113[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.char }, { end: rs.char; inclusive: true }] = [new rs.RangeFrom(a, rs.charStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.char } = _137[1]; const through: { end: rs.char; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.fmtCharDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.char, rs.char]; } @@ -6826,14 +6833,14 @@ export function bounded$f32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.f32, rs.f32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_111[0], f), (f: rs.Formatter) => rs.f32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_113[0], f), (f: rs.Formatter) => rs.f32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.f32 }, { end: rs.f32; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.f32 } = _137[1]; const through: { end: rs.f32; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f32Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.f32, rs.f32]; } @@ -6896,14 +6903,14 @@ export function bounded$f64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.f64, rs.f64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_111[0], f), (f: rs.Formatter) => rs.f64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_113[0], f), (f: rs.Formatter) => rs.f64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.f64 }, { end: rs.f64; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.f64 } = _137[1]; const through: { end: rs.f64; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.f64, rs.f64]; } @@ -6966,14 +6973,14 @@ export function bounded$i128(table: rs.Slice, at: rs.usize[], out: rs.B const _111: [rs.i128, rs.i128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_111[0], f), (f: rs.Formatter) => rs.i128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_113[0], f), (f: rs.Formatter) => rs.i128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i128 }, { end: rs.i128; inclusive: true }] = [new rs.RangeFrom(a, rs.i128Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i128 } = _137[1]; const through: { end: rs.i128; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i128Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.i128, rs.i128]; } @@ -7036,14 +7043,14 @@ export function bounded$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.i16, rs.i16] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_111[0], f), (f: rs.Formatter) => rs.i16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_113[0], f), (f: rs.Formatter) => rs.i16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i16 }, { end: rs.i16; inclusive: true }] = [new rs.RangeFrom(a, rs.i16Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i16 } = _137[1]; const through: { end: rs.i16; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i16Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.i16, rs.i16]; } @@ -7106,14 +7113,14 @@ export function bounded$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.i32, rs.i32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_111[0], f), (f: rs.Formatter) => rs.i32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_113[0], f), (f: rs.Formatter) => rs.i32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i32 }, { end: rs.i32; inclusive: true }] = [new rs.RangeFrom(a, rs.i32Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i32 } = _137[1]; const through: { end: rs.i32; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i32Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.i32, rs.i32]; } @@ -7176,14 +7183,14 @@ export function bounded$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.i64, rs.i64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_111[0], f), (f: rs.Formatter) => rs.i64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_113[0], f), (f: rs.Formatter) => rs.i64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i64 }, { end: rs.i64; inclusive: true }] = [new rs.RangeFrom(a, rs.i64Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i64 } = _137[1]; const through: { end: rs.i64; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.i64, rs.i64]; } @@ -7246,14 +7253,14 @@ export function bounded$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const _111: [rs.i8, rs.i8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_111[0], f), (f: rs.Formatter) => rs.i8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_113[0], f), (f: rs.Formatter) => rs.i8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i8 }, { end: rs.i8; inclusive: true }] = [new rs.RangeFrom(a, rs.i8Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i8 } = _137[1]; const through: { end: rs.i8; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i8Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.i8, rs.i8]; } @@ -7316,14 +7323,14 @@ export function bounded$isize(table: rs.Slice, at: rs.usize[], out: rs const _111: [rs.isize, rs.isize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_111[0], f), (f: rs.Formatter) => rs.isizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_113[0], f), (f: rs.Formatter) => rs.isizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.isize }, { end: rs.isize; inclusive: true }] = [new rs.RangeFrom(a, rs.isizeStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.isize } = _137[1]; const through: { end: rs.isize; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.isizeDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.isize, rs.isize]; } @@ -7386,14 +7393,14 @@ export function bounded$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const _111: [rs.u128, rs.u128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u128 } = _137[1]; const through: { end: rs.u128; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u128, rs.u128]; } @@ -7456,14 +7463,14 @@ export function bounded$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const _111: [rs.u64, rs.u64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u64 } = _137[1]; const through: { end: rs.u64; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u64, rs.u64]; } @@ -7526,14 +7533,14 @@ export function bounded$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const _111: [rs.u8, rs.u8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u8 } = _137[1]; const through: { end: rs.u8; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u8, rs.u8]; } @@ -7596,14 +7603,14 @@ export function bounded$num_NonZero_usize(table: rs.Slice, at: rs.usiz const _111: [rs.usize, rs.usize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.usize } = _137[1]; const through: { end: rs.usize; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.usize, rs.usize]; } @@ -7666,14 +7673,14 @@ export function bounded$u128(table: rs.Slice, at: rs.usize[], out: rs.B const _111: [rs.u128, rs.u128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.u128Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u128 } = _137[1]; const through: { end: rs.u128; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u128, rs.u128]; } @@ -7736,14 +7743,14 @@ export function bounded$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.u16, rs.u16] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_111[0], f), (f: rs.Formatter) => rs.u16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_113[0], f), (f: rs.Formatter) => rs.u16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u16 }, { end: rs.u16; inclusive: true }] = [new rs.RangeFrom(a, rs.u16Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u16 } = _137[1]; const through: { end: rs.u16; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u16Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u16, rs.u16]; } @@ -7806,14 +7813,14 @@ export function bounded$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.u32, rs.u32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_111[0], f), (f: rs.Formatter) => rs.u32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_113[0], f), (f: rs.Formatter) => rs.u32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u32 }, { end: rs.u32; inclusive: true }] = [new rs.RangeFrom(a, rs.u32Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u32 } = _137[1]; const through: { end: rs.u32; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u32Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u32, rs.u32]; } @@ -7876,14 +7883,14 @@ export function bounded$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.u64, rs.u64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.u64Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u64 } = _137[1]; const through: { end: rs.u64; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u64, rs.u64]; } @@ -7946,14 +7953,14 @@ export function bounded$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const _111: [rs.u8, rs.u8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.u8Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u8 } = _137[1]; const through: { end: rs.u8; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.u8, rs.u8]; } @@ -8016,14 +8023,14 @@ export function bounded$usize(table: rs.Slice, at: rs.usize[], out: rs const _111: [rs.usize, rs.usize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.usizeStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.usize } = _137[1]; const through: { end: rs.usize; inclusive: true } = _137[2]; const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]]).v), undefined, true); return [a, b] as [rs.usize, rs.usize]; } @@ -8662,11 +8669,11 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.fmtCharDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8687,7 +8694,7 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B const start2: rs.char = _140[0]; const end2: rs.char = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(start2, f), (f: rs.Formatter) => rs.fmtCharDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -8756,11 +8763,11 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI128), rs.rangeEq(rs.i128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); const _111: boolean = rs.rangeEq(rs.i128Eq)(r, _114); @@ -8781,7 +8788,7 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B const start2: rs.i128 = _140[0]; const end2: rs.i128 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Debug(start2, f), (f: rs.Formatter) => rs.i128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -8850,11 +8857,11 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i16Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8875,7 +8882,7 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.i16 = _140[0]; const end2: rs.i16 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Debug(start2, f), (f: rs.Formatter) => rs.i16Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -8944,11 +8951,11 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i32Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8969,7 +8976,7 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.i32 = _140[0]; const end2: rs.i32 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Debug(start2, f), (f: rs.Formatter) => rs.i32Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9038,11 +9045,11 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI64), rs.rangeEq(rs.i64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); const _111: boolean = rs.rangeEq(rs.i64Eq)(r, _114); @@ -9063,7 +9070,7 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.i64 = _140[0]; const end2: rs.i64 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Debug(start2, f), (f: rs.Formatter) => rs.i64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9132,11 +9139,11 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9157,7 +9164,7 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const start2: rs.i8 = _140[0]; const end2: rs.i8 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Debug(start2, f), (f: rs.Formatter) => rs.i8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9226,11 +9233,11 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashIsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.isizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.isizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9251,7 +9258,7 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs const start2: rs.isize = _140[0]; const end2: rs.isize = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDebug(start2, f), (f: rs.Formatter) => rs.isizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9320,11 +9327,11 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); @@ -9345,7 +9352,7 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const start2: rs.u128 = _140[0]; const end2: rs.u128 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9414,11 +9421,11 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); @@ -9439,7 +9446,7 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const start2: rs.u64 = _140[0]; const end2: rs.u64 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9508,11 +9515,11 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9533,7 +9540,7 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const start2: rs.u8 = _140[0]; const end2: rs.u8 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9602,11 +9609,11 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9627,7 +9634,7 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz const start2: rs.usize = _140[0]; const end2: rs.usize = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9696,11 +9703,11 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); @@ -9721,7 +9728,7 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B const start2: rs.u128 = _140[0]; const end2: rs.u128 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9790,11 +9797,11 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u16Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9815,7 +9822,7 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.u16 = _140[0]; const end2: rs.u16 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Debug(start2, f), (f: rs.Formatter) => rs.u16Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9884,11 +9891,11 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u32Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9909,7 +9916,7 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.u32 = _140[0]; const end2: rs.u32 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(start2, f), (f: rs.Formatter) => rs.u32Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -9978,11 +9985,11 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); @@ -10003,7 +10010,7 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.u64 = _140[0]; const end2: rs.u64 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -10072,11 +10079,11 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -10097,7 +10104,7 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const start2: rs.u8 = _140[0]; const end2: rs.u8 = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } @@ -10166,11 +10173,11 @@ export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -10191,7 +10198,7 @@ export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs const start2: rs.usize = _140[0]; const end2: rs.usize = _140[1]; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } } diff --git a/ts/fixtures/lang/joins/expected/harness.ts b/ts/fixtures/lang/joins/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/joins/expected/harness.ts +++ b/ts/fixtures/lang/joins/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index 658173157..8ea3c671d 100644 --- a/ts/fixtures/lang/joins/expected/joins.ts +++ b/ts/fixtures/lang/joins/expected/joins.ts @@ -181,25 +181,25 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { flush(log.value, out); log[Symbol.dispose](); } else if (_26 === 4) { - const owned2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p3: rs.ByteSlice): string => { + const owned2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p3: rs.ByteSlice): rs.String => { return text(p3); }), undefined, 12, true); - const sep4: string = text(seps); - put(out, rs.strsJoin(owned2.items, "")); - const _409: rs.Slice = rs.sliceFrom(owned2.items); - const _411: string = sep4; - put(out, rs.strsJoin(rs.sliceItems(_409), _411)); - const borrowed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(owned2.items), (a0: string): string => { - return a0; + const sep4: rs.String = text(seps); + put(out, rs.strsJoin(owned2.items, "").v); + const _409: rs.Slice = rs.sliceFrom(owned2.items); + const _411: string = sep4.v; + put(out, rs.strsJoin(rs.sliceItems(_409), _411).v); + const borrowed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(owned2.items), (a0: rs.String): string => { + return a0.v; }), undefined, 8, true); - put(out, rs.strsJoin(borrowed.items, "")); + put(out, rs.strsJoin(borrowed.items, "").v); const _428: rs.Slice = rs.sliceFrom(borrowed.items); - const _430: string = sep4; - put(out, rs.strsJoin(rs.sliceItems(_428), _430)); - put(out, rs.strsJoin([], "")); - const _443: rs.Slice = rs.sliceFrom([]); - const _445: string = sep4; - put(out, rs.strsJoin(rs.sliceItems(_443), _445)); + const _430: string = sep4.v; + put(out, rs.strsJoin(rs.sliceItems(_428), _430).v); + put(out, rs.strsJoin([], "").v); + const _443: rs.Slice = rs.sliceFrom([]); + const _445: string = sep4.v; + put(out, rs.strsJoin(rs.sliceItems(_443), _445).v); } else if (_26 === 5) { const cows: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.sliceItems(parts))), (_22: [rs.usize, rs.ByteSlice]): rs.ByteCow => { const i2: rs.usize = _22[0]; @@ -230,12 +230,12 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } return text(_214[1]); }), undefined, 12, true); - put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "")); - put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "--")); + put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "").v); + put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "--").v); } else { const big: rs.ByteVec = rs.byteVecOf(1, 1 << 16); const wide4: rs.Vec = rs.vecFromElem(1, 1 << 16, undefined); - const text_: string = text(rs.byteVecSlice(big)); + const text_: rs.String = text(rs.byteVecSlice(big)); const refs: (a0: rs.usize) => rs.Vec = (n: rs.usize): rs.Vec => { return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0), n, undefined); }; @@ -249,9 +249,9 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_512 === 3) { wides(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(wide4.items), rs.usizeAdd(1 << 14, 1), undefined).items), 2), out); } else if (_512 === 4) { - put(out, rs.strsJoin(rs.vecFromElem(text_, rs.usizeAdd(1 << 15, 1), undefined).items, "")); + put(out, rs.strsJoin(rs.vecFromElem(text_.v, rs.usizeAdd(1 << 15, 1), undefined).items, "").v); } else if (_512 === 5) { - put(out, rs.strsJoin(rs.vecFromElem(text_, rs.usizeAdd(1 << 16, 1), undefined).items, "")); + put(out, rs.strsJoin(rs.vecFromElem(text_.v, rs.usizeAdd(1 << 16, 1), undefined).items, "").v); } else { const sep5: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 1 << 16), (i: rs.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index 99f668b18..e667af459 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -73,7 +73,7 @@ export function name(b: rs.u8): Name.Name { if (rs.u8Rem(b, 2) === 0) { text = new rs.Arc(_3[_4]); } else { - text = new rs.Arc(_3[_4]); + text = new rs.Arc(rs.stringFrom(_3[_4]).v); } return new Name.Name(text, small(rs.u8Div(b, 64))); } @@ -129,15 +129,15 @@ export function partial(o: rs.Ordering | undefined): rs.u8 { } /** The index of the first of `keys` that borrows as `q`. */ -export function find$String_str(keys: rs.Slice, q: string): rs.u8 { - const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(keys))); +export function find$String_str(keys: rs.Slice, q: string): rs.u8 { + const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(keys))); while (true) { - const _7: [rs.usize, string] | rs.Done = iter.next(); + const _7: [rs.usize, rs.String] | rs.Done = iter.next(); if (_7 === rs.DONE) { break; } const i: rs.usize = _7[0]; - if (_7[1] === q) { + if (_7[1].v === q) { return i & 0xff; } } @@ -676,7 +676,7 @@ export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); } const _105: string[] = ["", "a", "ab", "", "￿", "𐀀"]; - rs.byteVecPush(out, find$String_str(rs.sliceFrom([text, _105[_106]]), _105[_106])); + rs.byteVecPush(out, find$String_str(rs.sliceFrom([rs.stringFrom(text), rs.stringFrom(_105[_106])]), _105[_106])); const _127: rs.Arc[] = [a.text, b.text]; rs.byteVecPush(out, find$sync_Arc_str_str(rs.sliceFrom(_127), _105[_106])); rs.dropAll(_127); diff --git a/ts/fixtures/lang/lists/expected/lists.ts b/ts/fixtures/lang/lists/expected/lists.ts index 57172ba0c..10fb95c83 100644 --- a/ts/fixtures/lang/lists/expected/lists.ts +++ b/ts/fixtures/lang/lists/expected/lists.ts @@ -234,7 +234,7 @@ export function edges(data: rs.ByteSlice, out: rs.ByteVec): void { /** `Debug` of the lists and of their iterators part read, plain, pretty, and in hex. */ export function printed(l: rs.LinkedList, m: rs.LinkedList, out: rs.ByteVec): void { - let text: string = ""; + const text: rs.String = rs.stringNew(); const it: rs.Iter = rs.listIter(l); it.next(); const owned: rs.Iter = rs.listIter(rs.listClone(m, undefined)); @@ -242,8 +242,9 @@ export function printed(l: rs.LinkedList, m: rs.LinkedList, out: r const lent: rs.Iter> = rs.listIterMut(rs.listClone(m, undefined)); lent.next(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.listIter(l), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.listIter(m), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtListIter(it, f, rs.u8Debug, rs.usizeDebug, "Iter"), (f: rs.Formatter) => rs.fmtIter(owned, f, rs.u8Debug, ["IntoIter"]), (f: rs.Formatter) => rs.fmtListIter(lent, f, rs.u8Debug, rs.usizeDebug, "IterMut")]; - text = rs.fmtWriteString(text, [args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ debugHex: "x" }, args2[2]), "|", rs.fmtSpec({ alternate: true }, args2[2]), "|", args2[3], "|", args2[4]]).s; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); + const _19: rs.Arguments = [args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ debugHex: "x" }, args2[2]), "|", rs.fmtSpec({ alternate: true }, args2[2]), "|", args2[3], "|", args2[4]]; + rs.fmtWriteString(text, _19); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); } /** A list of `Tally`s, which JS changes in place rather than through places. */ @@ -294,13 +295,15 @@ export function tallies(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.listContains(l, { n: 120 }, Tally.eq$cmp_PartialEq) ? 1 : 0); rs.byteVecPush(out, rs.cmpList(Tally.cmp$cmp_Ord)(l, copy) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashOf$collections_LinkedList_lists_Tally(taken), hashOf$collections_LinkedList_lists_Tally(rest)) ? 1 : 0); - let text: string = ""; + const text: rs.String = rs.stringNew(); const part = rs.iterToVec(rs.iterTake(rs.iterRev(rs.listIter(rest)), 2), undefined, 4, true); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part.items, f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rs.fmtWriteString(text, [args2[0]]).s; + const _83: rs.Arguments = [args2[0]]; + rs.fmtWriteString(text, _83); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.listIter(taken), f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rs.fmtWriteString(text, [rs.fmtSpec({ alternate: true }, args4[0])]).s; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); + const _97: rs.Arguments = [rs.fmtSpec({ alternate: true }, args4[0])]; + rs.fmtWriteString(text, _97); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); } //# sourceMappingURL=lists.ts.map diff --git a/ts/fixtures/lang/locks/expected/locks.Held.ts b/ts/fixtures/lang/locks/expected/locks.Held.ts index d4e2dc66b..114884856 100644 --- a/ts/fixtures/lang/locks/expected/locks.Held.ts +++ b/ts/fixtures/lang/locks/expected/locks.Held.ts @@ -19,7 +19,7 @@ export function deref$ops_Deref_Option_u8(self: Held): rs.u8 return self._0.value; } -export function deref$ops_Deref_String(self: Held): string { +export function deref$ops_Deref_String(self: Held): rs.String { return self._0.value; } @@ -35,8 +35,8 @@ export function derefMut$ops_DerefMut_Option_u8(self: Held): return rs.place(() => self._0.value, (value) => self._0.value = value); } -export function derefMut$ops_DerefMut_String(self: Held): rs.Place { - return rs.place(() => self._0.value, (value) => self._0.value = value); +export function derefMut$ops_DerefMut_String(self: Held): rs.String { + return self._0.value; } export function derefMut$ops_DerefMut_Vec_u8(self: Held): rs.ByteVec { diff --git a/ts/fixtures/lang/locks/expected/locks.Shared.ts b/ts/fixtures/lang/locks/expected/locks.Shared.ts index b16b84883..ce404354e 100644 --- a/ts/fixtures/lang/locks/expected/locks.Shared.ts +++ b/ts/fixtures/lang/locks/expected/locks.Shared.ts @@ -23,7 +23,7 @@ export function new$Option_u8(value: rs.u8 | undefined): Shared { +export function new$String(value: rs.String): Shared { return new Shared(new rs.Arc(new rs.Mutex(value))); } @@ -39,7 +39,7 @@ export function lock$Option_u8(self: Shared): Held.Held): Held.Held { +export function lock$String(self: Shared): Held.Held { return new Held.Held(rs.mutexLock(self._0.value)); } diff --git a/ts/fixtures/lang/locks/expected/locks.ts b/ts/fixtures/lang/locks/expected/locks.ts index dff9664af..f2a09ea88 100644 --- a/ts/fixtures/lang/locks/expected/locks.ts +++ b/ts/fixtures/lang/locks/expected/locks.ts @@ -76,13 +76,13 @@ export function locks(data: rs.ByteSlice, out: rs.ByteVec): void { _107.value = rs.u32Add(_107.value, _104); rs.mutexUnlock(_107); const args2: rs.Fmt[] = [(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; - const free: string = rs.fmtFormat([args2[0]]); + const free: rs.String = rs.fmtFormat([args2[0]]); const guard: rs.Result, rs.TryLockError>> = rs.mutexTryLock(lock._0); const args4: rs.Fmt[] = [(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; - const held3: string = rs.fmtFormat([args4[0]]); + const held3: rs.String = rs.fmtFormat([args4[0]]); const _139: boolean = guard.ok; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, held3), (f: rs.Formatter) => rs.fmtBool(_139, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free.v), (f: rs.Formatter) => rs.fmtPad(f, held3.v), (f: rs.Formatter) => rs.fmtBool(_139, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]).v)); drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(guard); } else if (_18 === 6) { rs.byteVecPush(out, false ? 1 : 0); @@ -614,66 +614,67 @@ export function mutexMapped(data: rs.ByteSlice, out: rs.ByteVec): void { * as std writes what each lends. */ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { + const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { return rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; - })); - const mutex: rs.Mutex<[rs.u8, string]> = new rs.Mutex([data.length & 0xff, text] as [rs.u8, string]); - const lock: rs.RefCell<[rs.ByteVec, string]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, string]); - const guard: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])]))); - const n: rs.Mutex = rs.mutexMap(guard, ((t: [rs.u8, string]): rs.Place => { + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _4); + const mutex: rs.Mutex<[rs.u8, rs.String]> = new rs.Mutex([data.length & 0xff, rs.stringClone(text)] as [rs.u8, rs.String]); + const lock: rs.RefCell<[rs.ByteVec, rs.String]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, rs.String]); + const guard: rs.Mutex<[rs.u8, rs.String]> = rs.mutexLock(mutex); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1].v, f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])]).v)); + const n: rs.Mutex = rs.mutexMap(guard, ((t: [rs.u8, rs.String]): rs.Place => { return rs.place(() => t[0], (value) => t[0] = value); })(guard.value)); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n.value, f), (f: rs.Formatter) => rs.u8Debug(n.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args4[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args4[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args4[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args4[0])]).v)); const n2: rs.Mutex = rs.mutexMap(n, ((n3: rs.Place): rs.Place => { return n3; })(rs.valuePlace(n))); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, args6[0]), "]"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, args6[0]), "]"]).v)); rs.mutexUnlock(n2); - const _58: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); - const text2: rs.Mutex = rs.mutexMap(_58, ((t2: [rs.u8, string]): rs.Place => { - return rs.place(() => t2[1], (value2) => t2[1] = value2); - })(_58.value)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text2.value), (f: rs.Formatter) => rs.fmtStr(text2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args8[0]), "]"]))); + const _58: rs.Mutex<[rs.u8, rs.String]> = rs.mutexLock(mutex); + const text2: rs.Mutex = rs.mutexMap(_58, rs.partPlace(((t2: [rs.u8, rs.String]): rs.String => { + return t2[1]; + })(_58.value))); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text2.value.v), (f: rs.Formatter) => rs.fmtStr(text2.value.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args8[0]), "]"]).v)); rs.mutexUnlock(text2); - const read: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); - const bytes: rs.RefCell = rs.refMap(read, ((t3: [rs.ByteVec, string]): rs.ByteVec => { + const read: rs.RefCell<[rs.ByteVec, rs.String]> = rs.rwLockRead(lock); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1].v, f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]).v)); + const bytes: rs.RefCell = rs.refMap(read, ((t3: [rs.ByteVec, rs.String]): rs.ByteVec => { return t3[0]; })(read.value)); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes.value), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]))); - const _104: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); - const text3: rs.RefCell = rs.refMap(_104, ((t4: [rs.ByteVec, string]): string => { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]).v)); + const _104: rs.RefCell<[rs.ByteVec, rs.String]> = rs.rwLockRead(lock); + const text3: rs.RefCell = rs.refMap(_104, ((t4: [rs.ByteVec, rs.String]): rs.String => { return t4[1]; })(_104.value)); - const first: rs.RefCell = rs.refMap(text3, ((t5: string): string => { - return option_unwrapOr$1iemzn8(rs.strGet(t5, 0, 1), "-"); + const first: rs.RefCell = rs.refMap(text3, ((t5: rs.String): string => { + return option_unwrapOr$1iemzn8(rs.strGet(t5.v, 0, 1), "-"); })(text3.value)); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, first.value), (f: rs.Formatter) => rs.fmtStr(first.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args14[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args14[0])]).v)); rs.refRelease(first); rs.refRelease(bytes); - const write: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockWrite(lock); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args16[0]]))); - const text4: rs.RefCell = rs.refMutMap(write, ((t6: [rs.ByteVec, string]): rs.Place => { - return rs.place(() => t6[1], (value3) => t6[1] = value3); - })(write.value)); - text4.value = text4.value + "!"; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text4.value), (f: rs.Formatter) => rs.fmtStr(text4.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args18[0], " ", args18[1]]))); - const _154: rs.RefCell = text4; - const text5: rs.RefCell = rs.refMutMap(_154, ((t7: rs.Place): rs.Place => { + const write: rs.RefCell<[rs.ByteVec, rs.String]> = rs.rwLockWrite(lock); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1].v, f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args16[0]]).v)); + const text4: rs.RefCell = rs.refMutMap(write, rs.partPlace(((t6: [rs.ByteVec, rs.String]): rs.String => { + return t6[1]; + })(write.value))); + rs.stringPush(text4.value, 33); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text4.value.v), (f: rs.Formatter) => rs.fmtStr(text4.value.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args18[0], " ", args18[1]]).v)); + const _154: rs.RefCell = text4; + const text5: rs.RefCell = rs.refMutMap(_154, rs.partPlace(((t7: rs.String): rs.String => { return t7; - })(rs.valuePlace(_154))); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text5.value)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, args20[0])]))); + })(_154.value))); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text5.value.v)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, args20[0])]).v)); rs.refMutRelease(text5); } @@ -867,7 +868,7 @@ export function held$u32(lock: rs.RefCell): rs.u8 { * and locked while each writes what it holds. */ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; const mutex: rs.Arc> = new rs.Arc(new rs.Mutex(0)); const lock: rs.RefCell>> = new rs.RefCell(rs.vecFrom([new rs.Mutex(97)])); for (const op of rs.byteSliceView(data)) { @@ -878,9 +879,9 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { _22.value = v; rs.mutexUnlock(_22); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; - const free: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); + const free: rs.String = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); const _held: rs.Mutex = rs.mutexLock(mutex.value); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free.v), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; text = rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ alternate: true }, args4[1]), " ", rs.fmtSpec({ align: ">", width: 12 }, args4[1])]); rs.mutexUnlock(_held); } else if (_18 === 1) { @@ -889,13 +890,13 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { _52.value.items.push(_55); rs.refMutRelease(_52); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - const free2: string = rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0])]); + const free2: rs.String = rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0])]); const read: rs.RefCell>> = rs.rwLockRead(lock); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - const shared: string = rs.fmtFormat([args8[0]]); + const shared: rs.String = rs.fmtFormat([args8[0]]); const _85: rs.Vec> = read.value; const _held2: rs.Mutex = rs.mutexLock(_85.items[rs.idx(_85.items, 0)]); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.fmtPad(f, shared), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2.v), (f: rs.Formatter) => rs.fmtPad(f, shared.v), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; text = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2])]); rs.mutexUnlock(_held2); rs.refRelease(read); @@ -921,11 +922,11 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { mutex2[Symbol.dispose](); } } else { - const part = new rs.RefCell(new rs.Mutex("s")); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtStr))]; + const part = new rs.RefCell(new rs.Mutex(rs.stringFrom("s"))); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]; text = rs.fmtFormat([args18[0]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } mutex[Symbol.dispose](); } @@ -939,7 +940,7 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { export function guarded(data: rs.ByteSlice, out: rs.ByteVec): void { const slot: Shared.Shared = Shared.new$Option_u8(undefined); const number: Shared.Shared = Shared.new$u32(0); - const text: Shared.Shared = Shared.new$String(""); + const text: Shared.Shared = Shared.new$String(rs.stringNew()); const seen: Shared.Shared = Shared.new$Vec_u8(new rs.ByteVec()); const tally: [rs.u8, rs.u8 | undefined] = [0, undefined]; for (const op of rs.byteSliceView(data)) { @@ -982,14 +983,13 @@ export function guarded(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, option_unwrapOr$1fr498u(Held.deref$ops_Deref_Option_u8(_67), 254)); _67[Symbol.dispose](); } else if (_18 === 4) { - const _72: Held.Held = Shared.lock$String(text); - const _70: rs.Place = Held.derefMut$ops_DerefMut_String(_72); - _70.v = _70.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + const _72: Held.Held = Shared.lock$String(text); + rs.stringPush(Held.derefMut$ops_DerefMut_String(_72), rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); _72[Symbol.dispose](); - const held2: Held.Held = Shared.lock$String(text); - if (rs.stringLen(Held.deref$ops_Deref_String(held2)) > 3) { - const _85: string = rs.strToUppercase(Held.deref$ops_Deref_String(held2)); - Held.derefMut$ops_DerefMut_String(held2).v = _85; + const held2: Held.Held = Shared.lock$String(text); + if (Held.deref$ops_Deref_String(held2).len > 3) { + const _85: rs.String = rs.strToUppercase(Held.deref$ops_Deref_String(held2).v); + Object.assign(Held.derefMut$ops_DerefMut_String(held2), _85); } const _94: Held.Held = Shared.lock$Vec_u8(seen); rs.byteVecPush(Held.derefMut$ops_DerefMut_Vec_u8(_94), op); @@ -1010,8 +1010,8 @@ export function guarded(data: rs.ByteSlice, out: rs.ByteVec): void { const _119: Held.Held = Shared.lock$u32(number); rs.byteVecPush(out, Held.deref$ops_Deref_u32(_119) & 0xff); _119[Symbol.dispose](); - const _125: Held.Held = Shared.lock$String(text); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(Held.deref$ops_Deref_String(_125))); + const _125: Held.Held = Shared.lock$String(text); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(Held.deref$ops_Deref_String(_125).v)); _125[Symbol.dispose](); const _131: Held.Held = Shared.lock$Vec_u8(seen); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(Held.deref$ops_Deref_Vec_u8(_131))); diff --git a/ts/fixtures/lang/manual/expected/manual.ts b/ts/fixtures/lang/manual/expected/manual.ts index 25daf5502..068d69729 100644 --- a/ts/fixtures/lang/manual/expected/manual.ts +++ b/ts/fixtures/lang/manual/expected/manual.ts @@ -104,11 +104,12 @@ export function needs$unit(): boolean { * generic body that branches on it does, as std's collections do; and types' names. */ export function needsDrops(data: rs.ByteSlice, out: rs.ByteVec): void { - const captured = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { return _2 as rs.char; - })); + }); + const captured = rs.stringExtendChars(rs.stringNew(), _4); const named: () => rs.usize = (): rs.usize => { - return rs.stringLen(captured); + return captured.len; }; const copied: () => rs.usize = (): rs.usize => { return data.length; @@ -117,8 +118,8 @@ export function needsDrops(data: rs.ByteSlice, out: rs.ByteVec): void { return a0 ? 1 : 0; })), undefined, true); rs.byteVecPush(out, (named() & 0xff) ^ (copied() & 0xff)); - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$String(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b2, f)); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$String(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b2, f), 0); }), undefined, 12, true))).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$u8(rs.byteSliceToByteVec(data))).reverse()), undefined, true); const iter: rs.Iter = rs.iterSlice(["lang_manual_fixture::manual::ByHand", "core::option::Option<&[alloc::string::String]>", "lang_manual_fixture::manual::needs_drops::{{closure}}", "[u8]", nameOf$u8(), nameOf$String()]); @@ -155,7 +156,7 @@ export function nameOf$u8(): string { * How many items a generic body drops one by one, as std's collections do only of a type * that needs dropping, and forgets the rest. */ -export function droppedByHand$String(items: rs.Vec): rs.u32 { +export function droppedByHand$String(items: rs.Vec): rs.u32 { if (false) { return 0; } diff --git a/ts/fixtures/lang/nested/expected/nested.ts b/ts/fixtures/lang/nested/expected/nested.ts index 25a450bcf..478d5eb09 100644 --- a/ts/fixtures/lang/nested/expected/nested.ts +++ b/ts/fixtures/lang/nested/expected/nested.ts @@ -123,7 +123,7 @@ export function made(data: rs.ByteSlice, out: rs.ByteVec): void { const tagged: Tagged.Tagged = new Tagged.Tagged(u, _106); rs.byteVecPush(out, (tagged.value !== rs.None ? 1 : 0) | ((order(tagged.order) << 1) & 0xff)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(o, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(u, f, rs.fmtUnit, rs.None)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v)); } } @@ -451,7 +451,7 @@ export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { if (240 <= data.data[data.start]) { if (data.data[data.start] <= 255) { const b: rs.u8 = data.data[data.start]; - let s: string = ""; + const s: rs.String = rs.stringNew(); const rest3: rs.Iter = rs.iterMap(new rs.Range(0, 2147483647), (_224: rs.usize): rs.char => { rs.panicFmt(["read"]); }); @@ -461,14 +461,14 @@ export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { }, undefined, rs.None), (_30: undefined): rs.char => { return 97; }), rest3); - s = rs.stringExtendChars(s, _137); + rs.stringExtendChars(s, _137); } else { const _142: rs.Iter = rs.iterChain(rs.iterMap(rs.iterSuccessors(undefined as rs.u8 | undefined | rs.None, (_225: rs.u8 | undefined): rs.u8 | undefined | rs.None => { return rs.None; }, undefined, rs.None), (_226: rs.u8 | undefined): rs.char => { return 97; }), rest3); - s = rs.stringExtendChars(s, _142); + rs.stringExtendChars(s, _142); } } } @@ -780,7 +780,7 @@ export function units(data: rs.ByteSlice, out: rs.ByteVec): void { const e: rs.Result = result_mapErr$136pgpq(option_okOr$06f2ml7(rs.byteSliceFirst(data), undefined), (_: undefined): undefined => {}); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(o !== rs.None ? 1 : 0, none !== rs.None ? 1 : 0, r.ok ? 1 : 0, !e.ok ? 1 : 0)), undefined, true); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtOption(o, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtUnit, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(e, f, rs.u8Debug, rs.fmtUnit)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]]).v))), undefined, true); } //# sourceMappingURL=nested.ts.map diff --git a/ts/fixtures/lang/orders/expected/core/cmp.ts b/ts/fixtures/lang/orders/expected/core/cmp.ts index 67e100148..e82809bf4 100644 --- a/ts/fixtures/lang/orders/expected/core/cmp.ts +++ b/ts/fixtures/lang/orders/expected/core/cmp.ts @@ -3,7 +3,7 @@ import * as rs from "../rs.ts"; import * as Item from "../orders.Item.ts"; -export function min$0tf7r1u(v1: string, v2: string): string { +export function min$10ohimp(v1: rs.String, v2: rs.String): rs.String { return rs.ordMin(v1, v2, rs.cmpLt(rs.cmpStr)); } @@ -74,7 +74,7 @@ export function minByKey$1qsvvgc(v1: Item.Item, v2: Item.Item, f: (a0: Item.Item return _0; } -export function max$0mrbrbr(v1: string, v2: string): string { +export function max$16nac37(v1: rs.String, v2: rs.String): rs.String { return rs.ordMax(v1, v2, rs.cmpLt(rs.cmpStr)); } diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index be86b3a23..fbd01a2cf 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { copy$tuple2_u8_u8 } from "./lib.ts"; import { thenSome$1qfl7tz } from "./core/bool.ts"; -import { min$0tf7r1u, min$0hz2v7s, min$1akgklh, min$094dtzd, minBy$18ytev0, minBy$0p6yz91, minByKey$1qsvvgc, max$0mrbrbr, max$0vq2d0c, max$0n458i1, max$1nu2xoq, max$12ifqlw, max$0we2ghu, maxBy$1ghjx71, maxBy$1gr65n2, maxByKey$1a9sf4b } from "./core/cmp.ts"; +import { min$10ohimp, min$0hz2v7s, min$1akgklh, min$094dtzd, minBy$18ytev0, minBy$0p6yz91, minByKey$1qsvvgc, max$16nac37, max$0vq2d0c, max$0n458i1, max$1nu2xoq, max$12ifqlw, max$0we2ghu, maxBy$1ghjx71, maxBy$1gr65n2, maxByKey$1a9sf4b } from "./core/cmp.ts"; import { unwrapOr$18rai12 as option_unwrapOr$18rai12, map$0adj75b as option_map$0adj75b, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$13h3wxw as option_mapOr$13h3wxw, mapOr$172961h as option_mapOr$172961h, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$0i0fno7 as option_mapOr$0i0fno7 } from "./core/option.ts"; import { eq$1wvyxyw as result_eq$1wvyxyw, eq$0p2ygx3 as result_eq$0p2ygx3, partialCmp$1frpo9k as result_partialCmp$1frpo9k, partialCmp$1ks7sga as result_partialCmp$1ks7sga, partialCmp$0rzsy3r as result_partialCmp$0rzsy3r, partialCmp$0wss1z6 as result_partialCmp$0wss1z6, cmp$0lhhufb as result_cmp$0lhhufb, cmp$13u97s2 as result_cmp$13u97s2, cmp$0h35u3j as result_cmp$0h35u3j, cmp$18cbpvu as result_cmp$18cbpvu } from "./core/result.ts"; import { eq$1qrb1lw as poll_eq$1qrb1lw, cmp$17et0iz as poll_cmp$17et0iz, partialCmp$1gaal0x as poll_partialCmp$1gaal0x, partialCmp$12m7vp8 as poll_partialCmp$12m7vp8 } from "./core/task/poll.ts"; @@ -75,10 +75,10 @@ export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, o const b: rs.u8 = _13[1]; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max$0we2ghu(a, b), min$094dtzd(a, b), max$0n458i1((a << 24) >> 24, (b << 24) >> 24) & 0xff)), undefined, true); const _37: rs.u8 = rs.u8Div(b, 2); - const _32: [string, string] = [rs.fmtToString((f: rs.Formatter) => rs.u8Display(a, f)), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_37, f))]; - const s: string = _32[0]; - const t: string = _32[1]; - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.stringLen(max$0mrbrbr(s, t)) & 0xff, rs.stringLen(min$0tf7r1u(s, t)) & 0xff)), undefined, true); + const _32: [rs.String, rs.String] = [rs.fmtToString((f: rs.Formatter) => rs.u8Display(a, f), 0), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_37, f), 0)]; + const s: rs.String = _32[0]; + const t: rs.String = _32[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max$16nac37(rs.stringClone(s), rs.stringClone(t)).len & 0xff, min$10ohimp(s, t).len & 0xff)), undefined, true); const _55: [Item.Item, Item.Item] = [item(rs.usizeMul(2, i), a), item(rs.usizeAdd(rs.usizeMul(2, i), 1), b)]; const x: Item.Item = _55[0]; const y: Item.Item = _55[1]; @@ -216,16 +216,16 @@ export function sorted(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), rs.lent(key)), rs.le, true) ? 1 : 0); rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), rs.lent(key)), rs.le, true) ? 1 : 0); flush(out); - const strings: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (b7: rs.u8): string => { + const strings: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (b7: rs.u8): rs.String => { const _415: rs.u8 = rs.u8Rem(b7, 16); - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_415, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_415, f), 0); }), undefined, 12, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceIsSorted(_12, rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), (a5: rs.u8, b8: rs.u8): boolean => { return rs.u8Div(a5, 4) <= rs.u8Div(b8, 4); }) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (_25: rs.u8): rs.u8 => { return rs.u8Rem(_25, 8); - }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), rs.le) ? 1 : 0, rs.sliceIsSorted(rs.sliceFrom(strings.items), rs.cmpLe(rs.cmpStr)) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(strings.items), (a0: string): rs.usize => { - return rs.stringLen(a0); + }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), rs.le) ? 1 : 0, rs.sliceIsSorted(rs.sliceFrom(strings.items), rs.cmpLe(rs.cmpStr)) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(strings.items), (a0: rs.String): rs.usize => { + return a0.len; }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (_29: rs.u8): rs.f64 => { return (_29 as rs.f64) / 3.0; }), rs.cmpLe(rs.f64PartialCmp)) ? 1 : 0)), undefined, true); @@ -384,7 +384,7 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.from(bytes.items)))), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapIntoSortedVec(rs.heapClone(bytes, undefined), rs.le, rs.ge, rs.lt))), undefined, true); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(bytes.items, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]]).v), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(bytes)), undefined, true); const least: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2; @@ -402,24 +402,26 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { } } const _51: rs.usize = data.length; - const strings: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(["pear", "apple", rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_51, f))]), undefined, 12, true), rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); - const copy: rs.BinaryHeap = rs.heapClone(strings, undefined); - const _56: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): string => { + const strings: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice([rs.stringFrom("pear"), rs.stringFrom("apple"), rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_51, f), 0)]), undefined, 12, true), rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); + const copy: rs.BinaryHeap = rs.heapClone(strings, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }); + const _56: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): rs.String => { const _43: rs.u8 = rs.u8Rem(b4, 10); - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_43, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_43, f), 0); }); rs.heapExtend(copy, _56, rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr), undefined, 12, true); - rs.heapRetain(copy, (s: string): boolean => { - if (!(rs.stringLen(s) > 1)) { - return rs.cmpStr(s, "5") === -1; + rs.heapRetain(copy, (s: rs.String): boolean => { + if (!(s.len > 1)) { + return rs.cmpStr(s.v, "5") === -1; } return true; }, rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); - rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(copy.items), (s2: string): rs.Iter => { - return rs.strBytes(s2); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(copy.items), (s2: rs.String): rs.Iter => { + return rs.strBytes(s2.v); }, undefined, true), "next"); - rs.iterExtendBytes(out, rs.iterMap(rs.heapIter(strings), (s3: string): rs.u8 => { - return rs.stringLen(s3) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.heapIter(strings), (s3: rs.String): rs.u8 => { + return s3.len & 0xff; }), "next"); const pairs: rs.BinaryHeap<[rs.u8, rs.u8]> = rs.heapNew() as rs.BinaryHeap<[rs.u8, rs.u8]>; const _73: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, rs.u8] => { diff --git a/ts/fixtures/lang/panics/caller.ts b/ts/fixtures/lang/panics/caller.ts index 953b7fe88..09caea6c5 100644 --- a/ts/fixtures/lang/panics/caller.ts +++ b/ts/fixtures/lang/panics/caller.ts @@ -1,4 +1,8 @@ // What `panics`' hooks wrote, which `differential.ts` compares after each case. +import { note as noted } from "./lib.ts"; + export { ops, run } from "./lang.ts"; -export { note } from "./lib.ts"; + +/** What the hooks wrote since the last call, as a JS string. */ +export const note = (): string => noted().v; diff --git a/ts/fixtures/lang/panics/expected/harness.ts b/ts/fixtures/lang/panics/expected/harness.ts index adfa38b8e..8dda179a3 100644 --- a/ts/fixtures/lang/panics/expected/harness.ts +++ b/ts/fixtures/lang/panics/expected/harness.ts @@ -38,8 +38,8 @@ export function op(name: string): rs.u16 { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -51,7 +51,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/panics/expected/lib.ts b/ts/fixtures/lang/panics/expected/lib.ts index 303963f04..7d3cffef5 100644 --- a/ts/fixtures/lang/panics/expected/lib.ts +++ b/ts/fixtures/lang/panics/expected/lib.ts @@ -19,9 +19,9 @@ export function drop$Result_u8_boxed_Box_dyn_Any_marker_Send(_1: rs.Result undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::called", panics_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::raised", raised as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::called", located_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::read", read as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::panicked", panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } -export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); +export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); -export function NOTE$init(): rs.RefCell { - return new rs.RefCell(""); +export function NOTE$init(): rs.RefCell { + return new rs.RefCell(rs.stringNew()); } /** Take what the hooks wrote since the last call. */ -export function note(): string { - return rs.localKeyWithBorrowMutPlace(NOTE, (a0: rs.Place): string => { - const taken = a0.v; - a0.v = ""; - return taken; +export function note(): rs.String { + return rs.localKeyWithBorrowMut(NOTE, (a0: rs.String): rs.String => { + return rs.replaceIn(a0, rs.stringNew()); }); } diff --git a/ts/fixtures/lang/panics/expected/located.ts b/ts/fixtures/lang/panics/expected/located.ts index 2ff7e7c61..3fcf377ee 100644 --- a/ts/fixtures/lang/panics/expected/located.ts +++ b/ts/fixtures/lang/panics/expected/located.ts @@ -73,7 +73,7 @@ export function generic$u8(t: rs.u8): rs.Location { export function lines(out: rs.ByteVec, at: rs.Slice): void { for (const _5 of rs.sliceItems(at)) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]).v)); } } @@ -131,7 +131,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]).v)); } } @@ -144,19 +144,17 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); const _9: rs.u8 = rs.u8Rem(kind, 4); if (_9 === 0) { - let s: string = ""; + const s: rs.String = rs.stringNew(); const _18: string = a.file; const _20: rs.u32 = a.line; const _22: rs.u32 = a.col; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; - const written = rs.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); - s = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug); + const _15: rs.Arguments = [args2[0], "|", args2[1], "|", args2[2], "|"]; + rs.resultUnwrap(rs.fmtWriteString(s, _15), rs.fmtErrorDebug); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; - const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]); - s = written2.s; - rs.resultUnwrap(written2.result, rs.fmtErrorDebug); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + const _32: rs.Arguments = [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]; + rs.resultUnwrap(rs.fmtWriteString(s, _32), rs.fmtErrorDebug); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } else if (_9 === 1) { const copy: rs.Location = a; const same: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); @@ -191,7 +189,7 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const held: Held$read.Held = { at: a, maybe: _117 }; const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; const args6: rs.Fmt[] = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]).v)); } } diff --git a/ts/fixtures/lang/panics/expected/panics.ts b/ts/fixtures/lang/panics/expected/panics.ts index 4cfc59f49..8e5ce36ae 100644 --- a/ts/fixtures/lang/panics/expected/panics.ts +++ b/ts/fixtures/lang/panics/expected/panics.ts @@ -16,8 +16,8 @@ export function seven(): rs.u8 { } /** What `f` returns, through `catch_unwind`. */ -export function caught$String_panics_called_closure6(f: () => string): string { - const _2: rs.Result = rs.Ok(f()); +export function caught$String_panics_called_closure6(f: () => rs.String): rs.String { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } @@ -131,20 +131,20 @@ export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_7 === 3) { const _132: rs.u8 = first; const _134: rs.u8 = first; - const _136: string = text(data); + const _136: rs.String = text(data); const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; const _144: [rs.u8, string] = [first, "a"]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136.v, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]).v)); } else if (_7 === 4) { const d: rs.u8 = 0; - const s2: string = ""; + const s2: rs.String = rs.stringNew(); const p2: Point.Point = Point.default$Default(); const v3: rs.ByteVec = new rs.ByteVec(); const e: rs.u8 = first; f = rs.byteSliceToByteVec(data); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, rs.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, s2.len & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); } else { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(1, log); @@ -230,10 +230,10 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rs.ByteVec => { return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): rs.String => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f)]; return rs.fmtFormat([args6[0]]); - }))); + }).v)); } else if (_10 === 3) { rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { return rs.u8WrappingMul(first, 2); @@ -285,7 +285,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return n2; }); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v)); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); @@ -499,7 +499,7 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_9 === 0) { rs.panic("a payload of text"); } else if (_9 === 1) { - rs.panic(text(data)); + rs.panic(text(data).v); } else if (_9 === 2) { rs.panic("Box"); } else if (_9 === 3) { @@ -523,9 +523,9 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { const boxed: Any.Any = new of$u8(first); new of$u8(first); - const synced: Any.Any = new of$String(""); + const synced: Any.Any = new of$String(rs.stringNew()); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]).v)); rs.drop(synced); rs.drop(boxed); } diff --git a/ts/fixtures/lang/panics/hook/expected/harness.ts b/ts/fixtures/lang/panics/hook/expected/harness.ts index ba815243a..56b848daa 100644 --- a/ts/fixtures/lang/panics/hook/expected/harness.ts +++ b/ts/fixtures/lang/panics/hook/expected/harness.ts @@ -38,8 +38,8 @@ export function op(name: string): rs.u16 { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -51,7 +51,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13, { file: "fixtures/lang/panics/src/../../harness.rs", line: 62, col: 16 }, true); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index 2bc072f77..1ba331c7b 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -14,9 +14,9 @@ export interface Shown { export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result { const part = rs.panicking(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - const line: string = rs.fmtFormat(["shown ", args2[0], "\n"]); - rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { - note.v = note.v + line; + const line: rs.String = rs.fmtFormat(["shown ", args2[0], "\n"]); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); if (!self.again) { return rs.fmtWriteStr(f, "shown"); diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.ts b/ts/fixtures/lang/panics/hook/expected/hooked.ts index b255c77d8..84784632a 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8, drop$bytes_buf_Take_bytes_Bytes, of$String, of$ref_str, of$u32, ofPlace$String, ofPlace$ref_str, ofPlace$u32, NOTE } from "./lib.ts"; +import { drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8, drop$bytes_buf_Take_bytes_Bytes, of$String, of$ref_str, of$u32, ofPlace$ref_str, ofPlace$u32, NOTE } from "./lib.ts"; import { take$bytes_Buf_bytes_Bytes as buf_impl_take$bytes_Buf_bytes_Bytes } from "./bytes/buf/buf_impl.ts"; import * as Take from "./bytes/buf/take.Take.ts"; import * as UninitSlice from "./bytes/buf/uninit_slice.UninitSlice.ts"; @@ -17,34 +17,34 @@ import { withBorrow$097wfl1 } from "./std/thread/local.ts"; * parts, and whether the thread is panicking. */ export function record(info: rs.PanicHookInfo): void { - let kind!: string; + let kind!: rs.String; const payload: Any.Any = rs.hookPayload(info, of$ref_str, of$String); if (!(payload instanceof of$ref_str || payload instanceof ofPlace$ref_str)) { - if (!(payload instanceof of$String || payload instanceof ofPlace$String)) { + if (!(payload instanceof of$String)) { const _8: rs.u32 | undefined = payload instanceof of$u32 ? payload.v : payload instanceof ofPlace$u32 ? payload.v.v : undefined; if (_8 !== undefined) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_8, f)]; kind = rs.fmtFormat(["u32 ", args2[0]]); } else { - kind = "other"; + kind = rs.stringFrom("other"); } } else { - kind = "String"; + kind = rs.stringFrom("String"); } } else { - kind = "&str"; + kind = rs.stringFrom("&str"); } const at: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 39, col: 30 }); - const _27: string = rs.strReplace(rs.fmtToString((f: rs.Formatter) => rs.fmtPanicHookInfoDisplay(info, f)), at.file, stdNamed(at.file)); + const _27: rs.String = rs.strReplace(rs.fmtToString((f: rs.Formatter) => rs.fmtPanicHookInfoDisplay(info, f)).v, at.file, stdNamed(at.file).v, true); const _37: string | undefined = info.text; - const _39: string = stdNamed(at.file); + const _39: rs.String = stdNamed(at.file); const _42: rs.u32 = at.line; const _44: rs.u32 = at.col; const _46: boolean = rs.panicking(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _27), (f: rs.Formatter) => rs.fmtPad(f, kind), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; - const line: string = rs.fmtFormat([args4[0], "\n", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], "\n"]); - rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { - note.v = note.v + line; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _27.v), (f: rs.Formatter) => rs.fmtPad(f, kind.v), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39.v), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; + const line: rs.String = rs.fmtFormat([args4[0], "\n", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], "\n"]); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); } @@ -54,7 +54,7 @@ export function record(info: rs.PanicHookInfo): void { * generic or inlined function, and by `/rustc//library/` where std's own build * did, as the translation always does. */ -export function stdNamed(file: string): string { +export function stdNamed(file: string): rs.String { const _2: [string, string] | undefined = rs.strSplitOnce(file, "/library/"); b1: { if (_2 !== undefined) { @@ -68,7 +68,7 @@ export function stdNamed(file: string): string { return rs.fmtFormat(["/library/", args2[0]]); } } - return file; + return rs.stringFrom(file); } /** Replace the hook with one that records each panic, then passes it on. */ @@ -138,7 +138,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 15 }); } else if (_10 === 16) { const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panic(rs.fmtFormat(["any ", args4[0]]), { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); + rs.panic(rs.fmtFormat(["any ", args4[0]]).v, { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); } else if (_10 === 17) { const _104: rs.u8 = rs.u8WrappingAdd(n, 1); if (!(n === _104)) { @@ -575,9 +575,9 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _126: rs.u32 = at2.line; const _14: rs.u32 = at2.col; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _10), (f: rs.Formatter) => rs.u32Display(_126, f), (f: rs.Formatter) => rs.u32Display(_14, f)]; - const line: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]); - rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { - note.v = note.v + line; + const line: rs.String = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 383, col: 13 }); }, { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); diff --git a/ts/fixtures/lang/panics/hook/expected/lib.ts b/ts/fixtures/lang/panics/hook/expected/lib.ts index 59068410d..48cec75db 100644 --- a/ts/fixtures/lang/panics/hook/expected/lib.ts +++ b/ts/fixtures/lang/panics/hook/expected/lib.ts @@ -33,9 +33,9 @@ export function drop$bytes_buf_Take_bytes_Bytes(_1: Take.Take): vo } export class of$String { - v: string; + v: rs.String; - constructor(v: string) { + constructor(v: rs.String) { this.v = v; } } @@ -108,14 +108,6 @@ export class of$u8 { } } -export class ofPlace$String { - v: rs.Place; - - constructor(v: rs.Place) { - this.v = v; - } -} - export class ofPlace$ref_str { v: rs.Place; @@ -140,18 +132,16 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By return rs.iterToVec(rs.iterChain(rs.vecIntoIter(rs.vecFrom([["panics::wrapped", wrapped as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::called", panics_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::raised", raised as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::called", located_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::read", read as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::panicked", located_panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]])), rs.iterSlice([["hooked::panicked", hooked_panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::aborted", aborted as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::sited", sited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::stock", stock as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]])), undefined, 12, true); } -export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); +export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); -export function NOTE$init(): rs.RefCell { - return new rs.RefCell(""); +export function NOTE$init(): rs.RefCell { + return new rs.RefCell(rs.stringNew()); } /** Take what the hooks wrote since the last call. */ -export function note(): string { - return rs.localKeyWithBorrowMutPlace(NOTE, (a0: rs.Place): string => { - const taken = a0.v; - a0.v = ""; - return taken; +export function note(): rs.String { + return rs.localKeyWithBorrowMut(NOTE, (a0: rs.String): rs.String => { + return rs.replaceIn(a0, rs.stringNew()); }, { file: "fixtures/lang/panics/src/lib.rs", line: 51, col: 5 }); } diff --git a/ts/fixtures/lang/panics/hook/expected/located.ts b/ts/fixtures/lang/panics/hook/expected/located.ts index 153d6277d..3a0fae6c9 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.ts @@ -73,7 +73,7 @@ export function generic$u8(t: rs.u8): rs.Location { export function lines(out: rs.ByteVec, at: rs.Slice): void { for (const _5 of rs.sliceItems(at)) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]).v)); } } @@ -131,7 +131,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]).v)); } } @@ -144,19 +144,17 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); const _9: rs.u8 = rs.u8Rem(kind, 4, { file: "fixtures/lang/panics/src/located.rs", line: 199, col: 11 }); if (_9 === 0) { - let s: string = ""; + const s: rs.String = rs.stringNew(); const _18: string = a.file; const _20: rs.u32 = a.line; const _22: rs.u32 = a.col; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; - const written = rs.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); - s = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); + const _15: rs.Arguments = [args2[0], "|", args2[1], "|", args2[2], "|"]; + rs.resultUnwrap(rs.fmtWriteString(s, _15), rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; - const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]); - s = written2.s; - rs.resultUnwrap(written2.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + const _32: rs.Arguments = [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]; + rs.resultUnwrap(rs.fmtWriteString(s, _32), rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } else if (_9 === 1) { const copy: rs.Location = a; const same: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); @@ -191,7 +189,7 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const held: Held$read.Held = { at: a, maybe: _117 }; const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; const args6: rs.Fmt[] = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]).v)); } } diff --git a/ts/fixtures/lang/panics/hook/expected/panics.ts b/ts/fixtures/lang/panics/hook/expected/panics.ts index 0086a8cf1..2522791c9 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.ts @@ -16,8 +16,8 @@ export function seven(): rs.u8 { } /** What `f` returns, through `catch_unwind`. */ -export function caught$String_panics_called_closure6(f: () => string): string { - const _2: rs.Result = rs.Ok(f()); +export function caught$String_panics_called_closure6(f: () => rs.String): rs.String { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } @@ -131,20 +131,20 @@ export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_7 === 3) { const _132: rs.u8 = first; const _134: rs.u8 = first; - const _136: string = text(data); + const _136: rs.String = text(data); const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; const _144: [rs.u8, string] = [first, "a"]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136.v, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]).v)); } else if (_7 === 4) { const d: rs.u8 = 0; - const s2: string = ""; + const s2: rs.String = rs.stringNew(); const p2: Point.Point = Point.default$Default(); const v3: rs.ByteVec = new rs.ByteVec(); const e: rs.u8 = first; f = rs.byteSliceToByteVec(data); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, rs.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, s2.len & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); } else { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(1, log); @@ -230,10 +230,10 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rs.ByteVec => { return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): rs.String => { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f)]; return rs.fmtFormat([args6[0]]); - }))); + }).v)); } else if (_10 === 3) { rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { return rs.u8WrappingMul(first, 2); @@ -285,7 +285,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return n2; }); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v)); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); @@ -499,7 +499,7 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_9 === 0) { rs.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }, false); } else if (_9 === 1) { - rs.panic(text(data), { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, true); + rs.panic(text(data).v, { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, true); } else if (_9 === 2) { rs.panicAny(new of$u8(first), { file: "fixtures/lang/panics/src/panics.rs", line: 291, col: 14 }); } else if (_9 === 3) { @@ -522,9 +522,9 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { const boxed: Any.Any = new of$u8(first); new of$u8(first); - const synced: Any.Any = new of$String(""); + const synced: Any.Any = new of$String(rs.stringNew()); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]).v)); rs.drop(synced); rs.drop(boxed); } diff --git a/ts/fixtures/lang/pointers/expected/lib.ts b/ts/fixtures/lang/pointers/expected/lib.ts index 7c169c6d1..f81ec1d8c 100644 --- a/ts/fixtures/lang/pointers/expected/lib.ts +++ b/ts/fixtures/lang/pointers/expected/lib.ts @@ -176,7 +176,7 @@ export function copy$tuple2_u32_u32(v: [rs.u32, rs.u32]): [rs.u32, rs.u32] { return [v[0], v[1]]; } -export function copy$tuple2_u8_String(v: [rs.u8, string]): [rs.u8, string] { +export function copy$tuple2_u8_String(v: [rs.u8, rs.String]): [rs.u8, rs.String] { return [v[0], v[1]]; } @@ -188,7 +188,7 @@ export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } -export function drop$pointers_List_String(_1: List.List): void { +export function drop$pointers_List_String(_1: List.List): void { List.drop$ops_Drop_String(_1); } diff --git a/ts/fixtures/lang/pointers/expected/pointers.List.ts b/ts/fixtures/lang/pointers/expected/pointers.List.ts index 50e9b6466..b812f3f11 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.List.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.List.ts @@ -21,7 +21,7 @@ export class List { } } -export function new$String(): List { +export function new$String(): List { return new List(undefined, undefined, 0); } @@ -29,13 +29,13 @@ export function new$sync_Arc_u8(): List> { return new List(undefined, undefined, 0); } -export function guard$String(self: List): Node.Node { +export function guard$String(self: List): Node.Node { if (self.guard !== undefined) { return self.guard; } - const guard2: Node.Node = Node.new$String(); - const _8: Links.Links = { next: guard2, prev: guard2 }; - const _11: Node.Node = guard2; + const guard2: Node.Node = Node.new$String(); + const _8: Links.Links = { next: guard2, prev: guard2 }; + const _11: Node.Node = guard2; _11.link.at0 = _8.next; _11.link.at4 = _8.prev; self.guard = guard2; @@ -55,11 +55,11 @@ export function guard$sync_Arc_u8(self: List>): Node.Node): Node.Node { +export function alloc$String(self: List): Node.Node { if (self.free === undefined) { return Node.new$String(); } - const free: Node.Node = self.free; + const free: Node.Node = self.free; self.free = free.link.at0; return free; } @@ -73,10 +73,10 @@ export function alloc$sync_Arc_u8(self: List>): Node.Node, key: rs.u8, value: string): void { - const guard: Node.Node = guard$String(self); - const node: Node.Node = alloc$String(self); - rs.ptrWrite(node.entry, [key, value] as [rs.u8, string]); +export function pushBack$String(self: List, key: rs.u8, value: rs.String): void { + const guard: Node.Node = guard$String(self); + const node: Node.Node = alloc$String(self); + rs.ptrWrite(node.entry, [key, value] as [rs.u8, rs.String]); attachBefore$String(node, guard); self.len = rs.usizeAdd(self.len, 1); } @@ -89,14 +89,14 @@ export function pushBack$sync_Arc_u8(self: List>, key: rs.u8, valu self.len = rs.usizeAdd(self.len, 1); } -export function find$String(self: List, key: rs.u8): Node.Node | undefined { - const _4: Node.Node | undefined = self.guard; +export function find$String(self: List, key: rs.u8): Node.Node | undefined { + const _4: Node.Node | undefined = self.guard; if (_4 !== undefined) { - const guard: Node.Node = _4; - let at: Node.Node = guard.link.at0 as Node.Node; + const guard: Node.Node = _4; + let at: Node.Node = guard.link.at0 as Node.Node; while (at !== guard) { if (!(at.entry[0] === key)) { - at = at.link.at0 as Node.Node; + at = at.link.at0 as Node.Node; } else { return at; } @@ -123,13 +123,13 @@ export function find$sync_Arc_u8(self: List>, key: rs.u8): Node.No return undefined; } -export function remove$String(self: List, key: rs.u8): [rs.u8, string] | undefined { - const _4: Node.Node | undefined = find$String(self, key); +export function remove$String(self: List, key: rs.u8): [rs.u8, rs.String] | undefined { + const _4: Node.Node | undefined = find$String(self, key); if (_4 !== undefined) { - const node: Node.Node = _4; + const node: Node.Node = _4; detach$String(node); - const entry: [rs.u8, string] = copy$tuple2_u8_String(node.entry); - const _16: Free.Free = { next: self.free }; + const entry: [rs.u8, rs.String] = copy$tuple2_u8_String(node.entry); + const _16: Free.Free = { next: self.free }; node.link.at0 = _16.next; self.free = node; self.len = rs.usizeSub(self.len, 1); @@ -153,14 +153,14 @@ export function remove$sync_Arc_u8(self: List>, key: rs.u8): [rs.u return undefined; } -export function toFront$String(self: List, key: rs.u8): boolean { - const _4: Node.Node | undefined = find$String(self, key); +export function toFront$String(self: List, key: rs.u8): boolean { + const _4: Node.Node | undefined = find$String(self, key); if (_4 !== undefined) { - const node: Node.Node = _4; + const node: Node.Node = _4; if (self.guard !== undefined) { - const guard: Node.Node = self.guard; + const guard: Node.Node = self.guard; detach$String(node); - attachBefore$String(node, guard.link.at0 as Node.Node); + attachBefore$String(node, guard.link.at0 as Node.Node); return true; } return false; @@ -183,39 +183,38 @@ export function toFront$sync_Arc_u8(self: List>, key: rs.u8): bool return false; } -export function getMut$String(self: List, key: rs.u8): rs.Place | undefined { - const _3: Node.Node | undefined = find$String(self, key); +export function getMut$String(self: List, key: rs.u8): rs.String | undefined { + const _3: Node.Node | undefined = find$String(self, key); if (_3 !== undefined) { - const _9: [rs.u8, string] = _3.entry; - return rs.place(() => _9[1], (value) => _9[1] = value); + return _3.entry[1]; } return undefined; } -export function each$String(self: List, out: rs.ByteVec): void { +export function each$String(self: List, out: rs.ByteVec): void { b0: { if (self.guard !== undefined) { - const guard: Node.Node = self.guard; - let at: Node.Node = guard.link.at0 as Node.Node; + const guard: Node.Node = self.guard; + let at: Node.Node = guard.link.at0 as Node.Node; while (true) { if (!(at !== guard)) { break b0; } - const _13: [rs.u8, string] = at.entry; + const _13: [rs.u8, rs.String] = at.entry; rs.byteVecPush(out, _13[0]); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_13[1])); - at = at.link.at0 as Node.Node; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_13[1].v)); + at = at.link.at0 as Node.Node; } } } } -export function drop$ops_Drop_String(self: List): void { +export function drop$ops_Drop_String(self: List): void { if (self.guard !== undefined) { - const guard: Node.Node = self.guard; - let at: Node.Node = guard.link.at0 as Node.Node; + const guard: Node.Node = self.guard; + let at: Node.Node = guard.link.at0 as Node.Node; while (at !== guard) { - at = at.link.at0 as Node.Node; + at = at.link.at0 as Node.Node; } } while (self.free !== undefined) { diff --git a/ts/fixtures/lang/pointers/expected/pointers.Named.ts b/ts/fixtures/lang/pointers/expected/pointers.Named.ts index 92a0ccf4c..eba15262f 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Named.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Named.ts @@ -1,16 +1,17 @@ // Generated by rust2-ts. Do not edit. +import * as rs from "./rs.ts"; import { copy$pointers_Spot } from "./lib.ts"; import * as Spot from "./pointers.Spot.ts"; export function clone$Clone(self: Named): Named { - return { spot: copy$pointers_Spot(Spot.clone$Clone(self.spot)), name: self.name }; + return { spot: copy$pointers_Spot(Spot.clone$Clone(self.spot)), name: rs.stringClone(self.name) }; } /** A value of each that holds no copy of its own but is cloned by its parts. */ export interface Named { spot: Spot.Spot; - name: string; + name: rs.String; } //# sourceMappingURL=pointers.Named.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Node.ts b/ts/fixtures/lang/pointers/expected/pointers.Node.ts index 7a3d3504f..bcee03554 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Node.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Node.ts @@ -9,10 +9,10 @@ export interface Node { link: Link.Link; } -export function new$String(): Node { - const _1: [rs.u8, string] = ([undefined, undefined] as unknown) as [rs.u8, string]; - const _3: Links.Links = { next: rs.DANGLING, prev: rs.DANGLING }; - return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link }; +export function new$String(): Node { + const _1: [rs.u8, rs.String] = ([undefined, undefined] as unknown) as [rs.u8, rs.String]; + const _3: Links.Links = { next: rs.DANGLING, prev: rs.DANGLING }; + return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link }; } export function new$sync_Arc_u8(): Node> { diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index 2f6d348aa..55efc0b91 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -48,13 +48,13 @@ import * as Wrapped from "./pointers.Wrapped.ts"; import type * as Written from "./pointers.Written.ts"; /** Put `node` in the list just before `at`. */ -export function attachBefore$String(node: Node.Node, at: Node.Node): void { - const _3: Links.Links = { next: at, prev: at.link.at4 }; - const _8: Node.Node = node; +export function attachBefore$String(node: Node.Node, at: Node.Node): void { + const _3: Links.Links = { next: at, prev: at.link.at4 }; + const _8: Node.Node = node; _8.link.at0 = _3.next; _8.link.at4 = _3.prev; at.link.at4 = node; - (node.link.at4.link.at0 as Node.Node) = node; + (node.link.at4.link.at0 as Node.Node) = node; } /** Put `node` in the list just before `at`. */ @@ -67,9 +67,9 @@ export function attachBefore$sync_Arc_u8(node: Node.Node>, at: Nod (node.link.at4.link.at0 as Node.Node>) = node; } -export function detach$String(node: Node.Node): void { - (node.link.at4.link.at0 as Node.Node) = node.link.at0 as Node.Node; - (node.link.at0 as Node.Node).link.at4 = node.link.at4; +export function detach$String(node: Node.Node): void { + (node.link.at4.link.at0 as Node.Node) = node.link.at0 as Node.Node; + (node.link.at0 as Node.Node).link.at4 = node.link.at4; } export function detach$sync_Arc_u8(node: Node.Node>): void { @@ -82,7 +82,7 @@ export function detach$sync_Arc_u8(node: Node.Node>): void { * finds and then the list in order. */ export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - const list: List.List = List.new$String(); + const list: List.List = List.new$String(); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; @@ -104,25 +104,26 @@ export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, if (!(_26 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _26); } - List.pushBack$String(list, key2, ["", "v", "vv"][_26]); + const _21: rs.String = rs.stringFrom(["", "v", "vv"][_26]); + List.pushBack$String(list, key2, _21); } else if (_18 === 1) { - const _30: [rs.u8, string] | undefined = List.remove$String(list, key2); + const _30: [rs.u8, rs.String] | undefined = List.remove$String(list, key2); if (_30 === undefined) { rs.byteVecPush(out, 255); } else { const k: rs.u8 = _30[0]; - const v: string = _30[1]; + const v: rs.String = _30[1]; rs.byteVecPush(out, k); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(v)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(v.v)); } } else if (_18 === 2) { rs.byteVecPush(out, List.toFront$String(list, key2) ? 1 : 0); } else { - const _42: rs.Place | undefined = List.getMut$String(list, key2); + const _42: rs.String | undefined = List.getMut$String(list, key2); if (_42 === undefined) { rs.byteVecPush(out, 254); } else { - _42.v = _42.v + "w"; + rs.stringPush(_42, 119); } } } @@ -416,7 +417,7 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { const count: rs.Arc = new rs.Arc(undefined); let num: rs.Cell = new rs.Cell(4294967295 - 1); const pair: rs.Cell = new rs.Cell({ _0: 0, _1: 255 }); - let text: rs.Cell = new rs.Cell(""); + let text: rs.Cell = new rs.Cell(rs.stringNew()); const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new Held.Held(0, rs.arcClone(count))); for (const op of rs.byteSliceView(data)) { const n: rs.u8 = rs.u8Div(op, 8); @@ -442,11 +443,9 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { _67._1 = _67._1 ^ 128; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(before2._0, before2._1, between._0, between._1, pair.v._0, pair.v._1)), undefined, true); } else if (_23 === 3) { - const _83: rs.Place = text; - _83.v = _83.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(n, 26)) as rs.char); - const _91: rs.Place = text; - _91.v = _91.v + "!"; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); + rs.stringPush(text.v, rs.u8Add(97, rs.u8Rem(n, 26)) as rs.char); + rs.stringPush(text.v, 33); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v.v))), undefined, true); } else if (_23 === 4) { const _99: rs.Arc = rs.arcClone(count); const fresh: Held.Held = new Held.Held(n, _99); @@ -484,10 +483,10 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { const old3 = num; num = _126; rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(old3.v).reverse()), undefined, true); - const _133: rs.Cell = new rs.Cell(rs.fmtToString((f: rs.Formatter) => rs.u8Display(n, f))); + const _133: rs.Cell = new rs.Cell(rs.fmtToString((f: rs.Formatter) => rs.u8Display(n, f), 0)); const old4 = text; text = _133; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(old4.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(old4.v.v))), undefined, true); const _140: Duo.Duo = { _0: n, _1: ~n & 0xff }; Object.assign(pair.v, _140); } else { @@ -506,7 +505,7 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(num.v).reverse()), undefined, true); const _169: Duo.Duo = pair.v; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_169._0, _169._1)), undefined, true); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v.v))), undefined, true); held[Symbol.dispose](); rs.byteVecPush(out, count.strong & 0xff); count[Symbol.dispose](); @@ -2456,7 +2455,7 @@ export function distinct(data: rs.ByteSlice, out: rs.ByteVec): void { const _60: [[rs.u16, rs.u8], [rs.u16, rs.u8]] = [[0, 1], [0, 1]]; const origin: [rs.u16, rs.u8] = _60[0]; const other: [rs.u16, rs.u8] = _60[1]; - const _64: string = "a"; + const _64: rs.String = rs.stringFrom("a"); const named: Named.Named = { spot: copy$pointers_Spot(spot), name: _64 }; const renamed: Named.Named = Named.clone$Clone(named); const _69: rs.u8 = x.value === y.value ? 1 : 0; @@ -2494,7 +2493,7 @@ export function distinct(data: rs.ByteSlice, out: rs.ByteVec): void { const arc7 = unwrapped; const _280: [rs.u16, rs.u8] = rs.arcRaw(arc7, arc7.value, "Arc"); const arc8 = y; - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_238, _244, _250, _256, _262, _270, _280 === rs.arcRaw(arc8, arc8.value, "Arc") ? 1 : 0, rewrapped.value === p.value ? 1 : 0, rewrapped.value.at === p.value.at ? 1 : 0, p.strong & 0xff, swapped[1] ^ unwrapped.value[1] ^ rewrapped.value.tag ^ (rs.stringLen(_64) & 0xff))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_238, _244, _250, _256, _262, _270, _280 === rs.arcRaw(arc8, arc8.value, "Arc") ? 1 : 0, rewrapped.value === p.value ? 1 : 0, rewrapped.value.at === p.value.at ? 1 : 0, p.strong & 0xff, swapped[1] ^ unwrapped.value[1] ^ rewrapped.value.tag ^ (_64.len & 0xff))), undefined, true); const item = copy$tuple2_u16_u8(pair); const repeated: rs.Vec<[rs.u16, rs.u8]> = rs.vecFrom(Array.from({ length: 2 }, (): [rs.u16, rs.u8] => { return copy$tuple2_u16_u8(item); diff --git a/ts/fixtures/lang/refs/expected/core/option.ts b/ts/fixtures/lang/refs/expected/core/option.ts index ec78ea0d7..1bd5eb5e8 100644 --- a/ts/fixtures/lang/refs/expected/core/option.ts +++ b/ts/fixtures/lang/refs/expected/core/option.ts @@ -23,9 +23,9 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function unwrapOrDefault$165pyh5(self: string | undefined): string { +export function unwrapOrDefault$1exlfpa(self: rs.String | undefined): rs.String { if (self === undefined) { - return ""; + return rs.stringNew(); } return self; } @@ -65,7 +65,7 @@ export function mapOr$1rg5gkk(self: rs.u8 | undefined | rs.None, default_: rs.u8 return f(self); } -export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { +export function mapOr$1fzqoua(self: rs.String | undefined, default_: rs.u8, f: (a0: rs.String) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index e4e42d189..0f3029fba 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { copy$Option_tuple2_u8_u8, copy$array_u32, out$u8 } from "./lib.ts"; import { thenSome$1c6ozzd, then$17csa2h } from "./core/bool.ts"; -import { unwrapOr$0w1py1w as option_unwrapOr$0w1py1w, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$0cwxh6b as option_map$0cwxh6b, map$1pv2dfs as option_map$1pv2dfs, map$1yjmt5m as option_map$1yjmt5m, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$14runhi as option_mapOr$14runhi, mapOr$1ldmp8y as option_mapOr$1ldmp8y, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0rvzdvd as option_mapOr$0rvzdvd, mapOr$0vxw5sq as option_mapOr$0vxw5sq, andThen$1x5wmg5 as option_andThen$1x5wmg5, filter$00vpwuf, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; +import { unwrapOr$0w1py1w as option_unwrapOr$0w1py1w, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1exlfpa as option_unwrapOrDefault$1exlfpa, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$0cwxh6b as option_map$0cwxh6b, map$1pv2dfs as option_map$1pv2dfs, map$1yjmt5m as option_map$1yjmt5m, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1fzqoua as option_mapOr$1fzqoua, mapOr$14runhi as option_mapOr$14runhi, mapOr$1ldmp8y as option_mapOr$1ldmp8y, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0rvzdvd as option_mapOr$0rvzdvd, mapOr$0vxw5sq as option_mapOr$0vxw5sq, andThen$1x5wmg5 as option_andThen$1x5wmg5, filter$00vpwuf, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; import { err$1igyjfc, asRef$1pwjn59 } from "./core/result.ts"; import * as Counts from "./refs.Counts.ts"; import * as Cursor from "./refs.Cursor.ts"; @@ -54,9 +54,9 @@ export function takeLargest(seen: rs.Place, next: rs.u8): rs. } /** A name replaced through a parameter, its old one returned. */ -export function rename(name: rs.Place, b: rs.u8): string | undefined { +export function rename(name: rs.Place, b: rs.u8): rs.String | undefined { const _5: rs.char = rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; - const _3: string = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_5, f)); + const _3: rs.String = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_5, f), 0); const old = name.v; name.v = _3; return old; @@ -108,18 +108,16 @@ export function refuse(f: rs.Place): void { f.v = _2; } -export function pushTo(s: rs.Place, c: rs.char): void { - s.v = s.v + String.fromCodePoint(c); +export function pushTo(s: rs.String, c: rs.char): void { + rs.stringPush(s, c); if (c === 122) { - const taken = s.v; - s.v = ""; - const iter: rs.Iter = rs.iterTake(rs.strChars(taken), 2); + const iter: rs.Iter = rs.iterTake(rs.strChars(rs.replaceIn(s, rs.stringNew()).v), 2); while (true) { const _12: rs.char | rs.Done = iter.next(); if (_12 === rs.DONE) { break; } - s.v = s.v + String.fromCodePoint(_12); + rs.stringPush(s, _12); } } } @@ -152,7 +150,7 @@ export function readThrough(a: rs.Place, b: rs.Place, out: rs.By rs.byteVecPush(out, a.v < b.v ? 1 : 0); rs.byteVecPush(out, rs.cmp(a.v, b.v) & 0xff); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a.v, f), (f: rs.Formatter) => rs.u32Debug(b.v, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", args2[1]]).v)); } /** A `&mut Box` dereferenced through `DerefMut`, as generic code over it would. */ @@ -161,11 +159,11 @@ export function derefBox(b: rs.Place, to: rs.u8): void { } /** Methods that take `&self`, called through a `&mut`. */ -export function fill(seen: rs.Place, s: rs.Place, next: rs.u8): rs.u8 { +export function fill(seen: rs.Place, s: rs.String, next: rs.u8): rs.u8 { if (seen.v === undefined) { seen.v = next; } - return rs.u8WrappingAdd(option_unwrapOr$1fr498u(seen.v, 238), rs.stringLen(s.v) & 0xff); + return rs.u8WrappingAdd(option_unwrapOr$1fr498u(seen.v, 238), s.len & 0xff); } export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { @@ -228,13 +226,13 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, option_unwrapOr$1fr498u(slot, 238)); let last = undefined as rs.u8 | undefined; - let name: string | undefined = undefined; + let name: rs.String | undefined = undefined; for (const b2 of rs.byteSliceView(data)) { const old = last; last = b2; rs.byteVecPush(out, option_unwrapOr$1fr498u(old, 238)); - rs.byteVecPush(out, option_mapOr$1nyk1yj(rename(rs.place(() => name, (value7) => name = value7), b2), 238, (n2: string): rs.u8 => { - const _3: rs.ByteSlice = rs.stringAsBytes(n2); + rs.byteVecPush(out, option_mapOr$1fzqoua(rename(rs.place(() => name, (value7) => name = value7), b2), 238, (n2: rs.String): rs.u8 => { + const _3: rs.ByteSlice = rs.stringAsBytes(n2.v); rs.idx(_3, 0); return _3.data[_3.start]; })); @@ -250,13 +248,12 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Pair.Pair = { n: by }; const pair: [rs.u8, rs.u8] = [by, rs.u8WrappingAdd(by, 1)]; let fetch = { tag: "Idle" } as Fetch.Fetch; - let text: string = ""; + const text: rs.String = rs.stringNew(); for (const b3 of rs.byteSliceView(data)) { rebox(rs.place(() => boxed, (value8) => boxed = value8), b3); swapPair(pair); refuse(rs.place(() => fetch, (value9) => fetch = value9)); - const _157: rs.char = rs.u8Add(97, rs.u8Rem(b3, 26)) as rs.char; - pushTo(rs.place(() => text, (value10) => text = value10), _157); + pushTo(text, rs.u8Add(97, rs.u8Rem(b3, 26)) as rs.char); } rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(boxed.n, pair[0], pair[1]))); if (fetch.tag === "Idle") { @@ -267,13 +264,13 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { _170 = 255; } rs.byteVecPush(out, _170); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); let empty: rs.u8 | undefined = undefined; - rs.byteVecPush(out, fill(rs.place(() => empty, (value11) => empty = value11), rs.place(() => text, (value12) => text = value12), by)); + rs.byteVecPush(out, fill(rs.place(() => empty, (value10) => empty = value10), text, by)); const _185: rs.u8 = rs.u8WrappingAdd(by, 1); - rs.byteVecPush(out, fill(rs.place(() => empty, (value13) => empty = value13), rs.place(() => text, (value14) => text = value14), _185)); + rs.byteVecPush(out, fill(rs.place(() => empty, (value11) => empty = value11), text, _185)); let at: rs.usize = 0; - const cursor: Cursor.Cursor = { at: rs.place(() => at, (value15) => at = value15), dataData: data.data, dataStart: data.start, dataLen: data.length }; + const cursor: Cursor.Cursor = { at: rs.place(() => at, (value12) => at = value12), dataData: data.data, dataStart: data.start, dataLen: data.length }; let sum: rs.u8 = 0; while (true) { const _190: rs.u8 | undefined = Cursor.next(cursor); @@ -290,14 +287,14 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, sum); rs.byteVecPush(out, at & 0xff); let remaining: rs.usize = rs.u8Rem(by, 5) as rs.usize; - rs.byteVecPush(out, skip(rs.place(() => remaining, (value16) => remaining = value16), data) & 0xff); + rs.byteVecPush(out, skip(rs.place(() => remaining, (value13) => remaining = value13), data) & 0xff); rs.byteVecPush(out, remaining & 0xff); const _214: [Pair.Pair, Pair.Pair] = [{ n: 1 }, { n: 2 }]; const a: Pair.Pair = _214[0]; const b5: Pair.Pair = _214[1]; let p: Pair.Pair = a; const borrowed = p; - const r: rs.Place = rs.place(() => borrowed.n, (value17) => borrowed.n = value17); + const r: rs.Place = rs.place(() => borrowed.n, (value14) => borrowed.n = value14); p = b5; bumpByte(r); p.n = rs.u8Add(p.n, 10); @@ -328,17 +325,17 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { } let total: rs.u32 = 0; for (const b7 of rs.byteSliceView(data)) { - _275(rs.place(() => total, (value18) => total = value18), b7); + _275(rs.place(() => total, (value15) => total = value15), b7); } rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(total))); const _293: [rs.u32, rs.u32] = [by as rs.u32, option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 5) as rs.u32]; let x2: rs.u32 = _293[0]; let y: rs.u32 = _293[1]; - readThrough(rs.place(() => x2, (value19) => x2 = value19), rs.place(() => y, (value20) => y = value20), out); + readThrough(rs.place(() => x2, (value16) => x2 = value16), rs.place(() => y, (value17) => y = value17), out); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x2 & 0xff, y & 0xff))); let boxed2: rs.u8 | undefined = undefined as rs.u8 | undefined; const _314: rs.u8 = total & 0xff; - derefBox(rs.place(() => boxed2, (value21) => boxed2 = value21), _314); + derefBox(rs.place(() => boxed2, (value18) => boxed2 = value18), _314); rs.byteVecPush(out, option_unwrapOr$1fr498u(boxed2, 238)); lent(data, out); } @@ -351,7 +348,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { let at!: rs.Place; let seen: rs.u32 | undefined = undefined; let last = undefined as [rs.u8, rs.u8] | undefined; - let text = undefined as string | undefined; + let text = undefined as rs.String | undefined; const held: rs.Vec> = new rs.Vec(); const spare: Array = [undefined, 9]; for (const b of rs.byteSliceView(data)) { @@ -418,14 +415,14 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { return x5.v; })))); if (text === undefined) { - text = ""; + text = rs.stringNew(); } - text = (text as string) + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char); + rs.stringPush(text as rs.String, rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(seen, 61166)))); } const _82: [rs.u8, rs.u8] = option_unwrapOr$0w1py1w(last, [238, 238] as [rs.u8, rs.u8]); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_82[0], _82[1]))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$165pyh5(text))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$1exlfpa(text).v)); const counts: Pair2.Pair2 = { a: undefined, b: undefined }; const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { @@ -527,7 +524,7 @@ export function defaulted(data: rs.ByteSlice, out: rs.ByteVec): void { } } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(listing, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } export function list$defaulted(listing: rs.Place, b: rs.u8): void { @@ -580,7 +577,7 @@ export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { }) as rs.u32))); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(held)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(wide.items, f, rs.u32Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); const pair: [rs.ByteVec, Listing.Listing] = [rs.byteSliceToByteVec(data), Listing.default$Default()]; const swap: (a0: rs.u8) => rs.ByteVec = (b5: rs.u8): rs.ByteVec => { const _36: rs.ByteVec = rs.byteVecOf(b5, rs.u8Rem(b5, 4) as rs.usize); @@ -611,7 +608,7 @@ export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(taken3)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(swapped)); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair[0]), f, rs.u8Debug), (f: rs.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]).v)); } export function poll$taken_refs_taken_closure1(data: rs.ByteSlice, f: (a0: rs.u8) => boolean): rs.usize { @@ -1266,11 +1263,11 @@ export function toRefs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(tail2.data[tail2.start]))); tail2 = rs.sliceRange(tail2, 1); } - let text: string = ""; + const text: rs.String = rs.stringNew(); for (const _59 of rs.byteSliceView(rs.byteSliceRange(data, 1))) { - text = text + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(_59, 26)) as rs.char); + rs.stringPush(text, rs.u8Add(97, rs.u8Rem(_59, 26)) as rs.char); } - let s: string = text; + let s: string = text.v; s = rs.strSlice(s, rs.min(rs.usizeRem(n, 3), rs.stringLen(s))); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); const part2 = rs.usizeDiv(rs.byteSliceRange(data, 1).length, 2); diff --git a/ts/fixtures/lang/rings/expected/rings.ts b/ts/fixtures/lang/rings/expected/rings.ts index 89289b6b3..1fbd9d8d2 100644 --- a/ts/fixtures/lang/rings/expected/rings.ts +++ b/ts/fixtures/lang/rings/expected/rings.ts @@ -20,14 +20,14 @@ export function bump$rings_Item_u32(self: rs.Place): void { self.v = rs.u32Add(self.v, 1); } -export function make$rings_Item_String(b: rs.u8): string { +export function make$rings_Item_String(b: rs.u8): rs.String { const part = rs.u8Rem(b, 16); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; return rs.fmtFormat(["s", args2[0]]); } -export function bump$rings_Item_String(self: rs.Place): void { - self.v = self.v + "!"; +export function bump$rings_Item_String(self: rs.String): void { + rs.stringPush(self, 33); } export function make$rings_Item_unit(_1: rs.u8): void { @@ -58,219 +58,219 @@ export function put(out: rs.ByteVec, n: rs.usize): void { } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_String(out: rs.ByteVec, value: string | undefined): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); +export function text$Option_ref_String(out: rs.ByteVec, value: rs.String | undefined): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_rings_Big(out: rs.ByteVec, value: Big.Big | undefined): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_u32(out: rs.ByteVec, value: rs.u32 | undefined): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_u8(out: rs.ByteVec, value: rs.u8 | undefined): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_unit(out: rs.ByteVec, value: undefined | rs.None): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$Result_usize_usize(out: rs.ByteVec, value: rs.Result): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(value, f, rs.usizeDebug, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ -export function text$String(out: rs.ByteVec, value: string): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); +export function text$String(out: rs.ByteVec, value: rs.String): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(value.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_String(out: rs.ByteVec, value: rs.Iter): void { +export function text$collections_vec_deque_Drain_String(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_rings_Big(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_u32(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_u8(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_unit(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_String(out: rs.ByteVec, value: rs.Iter>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_IterMut_String(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), "IterMut")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_rings_Big(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_u32(out: rs.ByteVec, value: rs.Iter>): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_u8(out: rs.ByteVec, value: rs.Iter>): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_unit(out: rs.ByteVec, value: rs.Iter>): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_String(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Iter_String(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_rings_Big(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_u32(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_u8(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_unit(out: rs.ByteVec, value: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_String(out: rs.ByteVec, value: rs.Slice): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtStr)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); +export function text$mut_slice_String(out: rs.ByteVec, value: rs.Slice): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_rings_Big(out: rs.ByteVec, value: rs.Slice): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_u32(out: rs.ByteVec, value: rs.Slice): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u32Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_u8(out: rs.ByteVec, value: rs.ByteSlice): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_unit(out: rs.ByteVec, value: rs.Slice): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtUnit)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$rings_Big(out: rs.ByteVec, value: Big.Big): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_String_ref_slice_String(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtStr)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); +export function text$tuple2_ref_slice_String_ref_slice_String(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.u32Debug)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rs.ByteVec, value: [rs.ByteSlice, rs.ByteSlice]): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[1]), f, rs.u8Debug)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtUnit)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$u32(out: rs.ByteVec, value: rs.u32): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$u8(out: rs.ByteVec, value: rs.u8): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** What `{:?}` writes of `value`. */ export function text$unit(out: rs.ByteVec, _value: undefined): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); } /** @@ -278,7 +278,7 @@ export function text$unit(out: rs.ByteVec, _value: undefined): void { * each pair after it steps: after each, its length, capacity, and two slices. */ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let q!: rs.VecDeque; + let q!: rs.VecDeque; const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; @@ -287,11 +287,13 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rs.dequeNew(12) as rs.VecDeque; + q = rs.dequeNew(12) as rs.VecDeque; } else if (_17 === 1) { - q = rs.dequeWithCapacity(n, 12) as rs.VecDeque; + q = rs.dequeWithCapacity(n, 12) as rs.VecDeque; } else { - q = rs.dequeFromVec(rs.vecFromElem(make$rings_Item_String(first), n, undefined), 12) as rs.VecDeque; + q = rs.dequeFromVec(rs.vecFromElem(make$rings_Item_String(first), n, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }), 12) as rs.VecDeque; } const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { @@ -330,7 +332,7 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { let kept: rs.u8 = arg; - rs.dequeRetain(q, (_25: string): boolean => { + rs.dequeRetain(q, (_25: rs.String): boolean => { kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); @@ -359,31 +361,33 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n } else if (_46 === 24) { appended$String(q, arg, out); } else if (_46 === 25) { - rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_String(arg), undefined); + rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_String(arg), (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); } else if (_46 === 26) { - rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): string => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): rs.String => { return make$rings_Item_String(arg); }); } else if (_46 === 27) { - const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); put(out, rs.dequeCapacity(tail)); text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(tail)); } else if (_46 === 28) { const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); - const it: rs.Iter> = rs.dequeRangeMut(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); - const _151: rs.Place | rs.Done = it.next(); + const it: rs.Iter = rs.dequeRange(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: rs.String | rs.Done = it.next(); if (_151 !== rs.DONE) { bump$rings_Item_String(_151); } - const _156: rs.Place | undefined = rs.iterToOption(it.nextBack()); + const _156: rs.String | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { bump$rings_Item_String(_156); } text$collections_vec_deque_IterMut_String(out, it); } else if (_46 === 29) { - const v: rs.Vec = rs.dequeToVec(q); + const v: rs.Vec = rs.dequeToVec(q); put(out, rs.vecCapacity(v, 12)); - q = rs.dequeFromVec(v, 12) as rs.VecDeque; + q = rs.dequeFromVec(v, 12) as rs.VecDeque; } else if (_46 === 30) { rs.dequeRotate(q, at); } else if (_46 === 31) { @@ -393,12 +397,12 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: rs.Slice = rs.dequeMakeContiguous(q); - const _190: rs.Place | undefined = rs.sliceFirstMut(s); + const s: rs.Slice = rs.dequeMakeContiguous(q); + const _190: rs.String | undefined = rs.sliceFirst(s); if (_190 !== undefined) { bump$rings_Item_String(_190); } - const _194: rs.Place | undefined = rs.sliceLastMut(s); + const _194: rs.String | undefined = rs.sliceLast(s); if (_194 !== undefined) { bump$rings_Item_String(_194); } @@ -994,62 +998,70 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through * adaptors in place of another. */ -export function remade$String(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { - let _0!: rs.VecDeque; +export function remade$String(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 12) as rs.VecDeque; - const _18: string = make$rings_Item_String(arg); + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 12) as rs.VecDeque; + const _18: rs.String = make$rings_Item_String(arg); rs.dequePushFront(own, _18); if ((arg & 64) === 0) { - rs.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, (a04: rs.String): rs.String => { + return rs.stringClone(a04); + }); } else { - rs.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, (a03: rs.String): rs.String => { + return rs.stringClone(a03); + }); } return own; } - return rs.dequeClone(q); + return rs.dequeClone(q, (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); } if (_8 === 1) { - const it: rs.Iter = rs.dequeIntoIter(q); + const it: rs.Iter = rs.dequeIntoIter(q); let iterStart: rs.usize = 0; const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { rs.iterToOption(it.next()); } rs.iterToOption(it.nextBack()); - return rs.dequeFromIntoIter(it, 12) as rs.VecDeque; + return rs.dequeFromIntoIter(it, 12) as rs.VecDeque; } if (_8 === 2) { - const it2: rs.Iter = rs.dequeIntoIter(q); + const it2: rs.Iter = rs.dequeIntoIter(q); rs.iterNth(it2, skip); - return rs.dequeFromIntoIter(it2, 12) as rs.VecDeque; + return rs.dequeFromIntoIter(it2, 12) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); + const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); let kept: boolean = false; - return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: string): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: rs.String): boolean => { kept = !kept; return kept; - }), "next", 12, false, 12), 12) as rs.VecDeque; + }), "next", 12, false, 12), 12) as rs.VecDeque; } - return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true), 12) as rs.VecDeque; + return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true), 12) as rs.VecDeque; } - const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); + const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); rs.vecReserve(v2, skip, 12); - const it3: rs.Iter = rs.vecIntoIter(v2); + const it3: rs.Iter = rs.vecIntoIter(v2); let iterStart2: rs.usize = 0; const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { rs.iterToOption(it3.next()); } if ((arg & 64) === 0) { - _0 = rs.dequeFromIntoIter(it3, 12) as rs.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 12) as rs.VecDeque; } else { - _0 = rs.dequeFromIntoIter(it3.clone({ v: rs.itself }), 12) as rs.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: (a0: rs.String): rs.String => { + return rs.stringClone(a0); + } }), 12) as rs.VecDeque; } return _0; } @@ -1322,27 +1334,27 @@ export function remade$unit(q: rs.VecDeque, arg: rs.u8): rs.VecDeque< * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { +export function appended$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { let _16!: rs.u8; - const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 12) as rs.VecDeque; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 12) as rs.VecDeque; const _10: rs.u8 = (arg >> 2) & 7; let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { const i: rs.u8 = _16; if (rs.u8Rem(i, 3) === 2) { - const _23: string = make$rings_Item_String(i); + const _23: rs.String = make$rings_Item_String(i); rs.dequePushFront(other, _23); } else { - const _25: string = make$rings_Item_String(i); + const _25: rs.String = make$rings_Item_String(i); rs.dequePushBack(other, _25); } } rs.dequeAppend(q, other); put(out, rs.dequeCapacity(other)); - const _33: string = make$rings_Item_String(arg); + const _33: rs.String = make$rings_Item_String(arg); rs.dequePushFront(other, _33); - const _36: string = make$rings_Item_String(arg); + const _36: rs.String = make$rings_Item_String(arg); rs.dequePushBack(other, _36); text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(other)); } @@ -1464,10 +1476,10 @@ export function appended$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { +export function drained$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { const len: rs.usize = q.n; const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); - const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_String(out, d); if ((arg & 64) !== 0) { rs.iterToOption(d.next()); @@ -1544,27 +1556,27 @@ export function drained$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byte } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Slice] = rs.dequeAsSlices(q); - const _7: rs.Place | undefined = rs.sliceFirstMut(_6[0]); +export function mutated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.Slice] = rs.dequeAsSlices(q); + const _7: rs.String | undefined = rs.sliceFirst(_6[0]); if (_7 !== undefined) { bump$rings_Item_String(_7); } - const _11: rs.Place | undefined = rs.sliceLastMut(_6[1]); + const _11: rs.String | undefined = rs.sliceLast(_6[1]); if (_11 !== undefined) { bump$rings_Item_String(_11); } - const it: rs.Iter> = rs.dequeIterMut(q); + const it: rs.Iter = rs.dequeIter(q); const _18: rs.u8 = rs.u8Rem(arg, 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: rs.Place | rs.Done = it.next(); + const _24: rs.String | rs.Done = it.next(); if (_24 !== rs.DONE) { bump$rings_Item_String(_24); } } - const _29: rs.Place | undefined = rs.iterToOption(it.nextBack()); + const _29: rs.String | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { bump$rings_Item_String(_29); } @@ -1687,20 +1699,20 @@ export function mutated$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byte * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { - const x: string = make$rings_Item_String(arg); +export function searched$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const x: rs.String = make$rings_Item_String(arg); text$Result_usize_usize(out, rs.dequeBinarySearch(q, x, rs.cmpStr)); - text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: string): rs.Ordering => { + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: rs.String): rs.Ordering => { text$String(out, y); return rs.cmpStr(y, x); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: string): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(x.v, f)]; + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.String): rs.String => { text$String(out, y2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(y2, f)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(y2.v, f)]; return rs.fmtFormat([args4[0]]); }, rs.cmpStr)); - put(out, rs.dequePartitionPoint(q, (y3: string): boolean => { + put(out, rs.dequePartitionPoint(q, (y3: rs.String): boolean => { text$String(out, y3); return rs.cmpStr(y3, x) === -1; })); @@ -1718,7 +1730,7 @@ export function searched$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs. return Big.cmp$cmp_Ord(y, x); })); const args2: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: Big.Big): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: Big.Big): rs.String => { text$rings_Big(out, y2); const args4: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(y2, f)]; return rs.fmtFormat([args4[0]]); @@ -1741,7 +1753,7 @@ export function searched$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec return rs.cmp(y, x); })); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u32): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u32): rs.String => { text$u32(out, y2); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(y2, f)]; return rs.fmtFormat([args4[0]]); @@ -1764,7 +1776,7 @@ export function searched$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): return rs.cmp(y, x); })); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u8): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u8): rs.String => { text$u8(out, y2); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(y2, f)]; return rs.fmtFormat([args4[0]]); @@ -1787,7 +1799,7 @@ export function searched$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt return rs.cmpNothing(y, undefined); })); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: undefined): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: undefined): rs.String => { text$unit(out, y2); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; return rs.fmtFormat([args4[0]]); @@ -1799,10 +1811,10 @@ export function searched$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { +export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { let _10!: rs.u32; - let read!: string | undefined; - const it: rs.Iter = rs.dequeIter(q); + let read!: rs.String | undefined; + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_String(out, it); let iterStart: rs.u32 = 0; const iterEnd: rs.u32 = 3; @@ -1819,12 +1831,12 @@ export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.Byte } else if (_22 === 3) { read = rs.iterNthBack(it, count as rs.usize); } else if (_22 === 4) { - read = rs.iterFind(it, (_24: string): boolean => { + read = rs.iterFind(it, (_24: rs.String): boolean => { count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else if (_22 === 5) { - read = rs.iterRfind(it, (_2: string): boolean => { + read = rs.iterRfind(it, (_2: rs.String): boolean => { count = rs.u8SaturatingSub(count, 1); return count === 0; }); diff --git a/ts/fixtures/lang/saturates/expected/saturates.ts b/ts/fixtures/lang/saturates/expected/saturates.ts index d315932d5..11323d7fb 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.ts @@ -365,7 +365,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { const all: rs.u8[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u8SaturatingAdd, 0); @@ -390,7 +390,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u8(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u8(x7), hashed$num_Saturating_u8(a)) ? 1 : 0); @@ -563,7 +563,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { const all: rs.u16[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u16SaturatingAdd, 0); @@ -588,7 +588,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u16(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u16(x7), hashed$num_Saturating_u16(a)) ? 1 : 0); @@ -761,7 +761,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { const all: rs.u32[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u32SaturatingAdd, 0); @@ -786,7 +786,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u32(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u32(x7), hashed$num_Saturating_u32(a)) ? 1 : 0); @@ -959,7 +959,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { const all: rs.u64[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u64SaturatingAdd, 0); @@ -984,7 +984,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u64(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u64(x7), hashed$num_Saturating_u64(a)) ? 1 : 0); @@ -1157,7 +1157,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { const all: rs.u128[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u128SaturatingAdd, 0); @@ -1182,7 +1182,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u128(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u128(x7), hashed$num_Saturating_u128(a)) ? 1 : 0); @@ -1355,7 +1355,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { const all: rs.usize[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.usizeSaturatingAdd, 0); @@ -1380,7 +1380,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_usize(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_usize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_usize(x7), hashed$num_Saturating_usize(a)) ? 1 : 0); @@ -1560,7 +1560,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1573,7 +1573,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i8(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i8(x7), hashed$num_Saturating_i8(a)) ? 1 : 0); @@ -1754,7 +1754,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1767,7 +1767,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i16(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i16(x7), hashed$num_Saturating_i16(a)) ? 1 : 0); @@ -1948,7 +1948,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1961,7 +1961,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i32(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i32(x7), hashed$num_Saturating_i32(a)) ? 1 : 0); @@ -2142,7 +2142,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2155,7 +2155,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i64(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i64(x7), hashed$num_Saturating_i64(a)) ? 1 : 0); @@ -2336,7 +2336,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2349,7 +2349,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i128(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i128(x7), hashed$num_Saturating_i128(a)) ? 1 : 0); @@ -2530,7 +2530,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2543,7 +2543,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_isize(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_isize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_isize(x7), hashed$num_Saturating_isize(a)) ? 1 : 0); diff --git a/ts/fixtures/lang/searches/expected/harness.ts b/ts/fixtures/lang/searches/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/searches/expected/harness.ts +++ b/ts/fixtures/lang/searches/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/searches/expected/searches.ts b/ts/fixtures/lang/searches/expected/searches.ts index 7d69a5ddd..ef028f3dd 100644 --- a/ts/fixtures/lang/searches/expected/searches.ts +++ b/ts/fixtures/lang/searches/expected/searches.ts @@ -3615,8 +3615,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); const pick: rs.u8 = _6[0]; - const s: string = text(_6[1]); - const alphabet: rs.Vec = rs.iterToVec(rs.strChars(text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(pick, 16), rs.u8Div(pick, 16))))), "next", 4); + const s: rs.String = text(_6[1]); + const alphabet: rs.Vec = rs.iterToVec(rs.strChars(text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(pick, 16), rs.u8Div(pick, 16)))).v), "next", 4); const _25: rs.char = alphabet.items[rs.idx(alphabet.items, 0)]; const _24: [rs.char, rs.char] = [_25, alphabet.items[rs.idx(alphabet.items, 1)]]; const c: rs.char = _25; @@ -3635,7 +3635,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }; const _42: rs.u8 = rs.u8Rem(rs.u8Div(kind, 17), 5); if (_42 === 0) { - const _50: string = s; + const _50: string = s.v; const part4 = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_50, String.fromCodePoint(c))); @@ -3662,8 +3662,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_50, String.fromCodePoint(c))); putOption(out, rs.strStripSuffix(_50, String.fromCodePoint(c))); } else if (m === 2) { - harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "<>")); - harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "é", n)); + harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "<>", true).v); + harness_put(out, rs.strReplacen(_50, String.fromCodePoint(c), "é", n).v); } else if (m === 3) { front$ref_str_str_Split_char(rs.strSplit(_50, String.fromCodePoint(c)), out); front$ref_str_str_RSplit_char(rs.strRsplit(_50, String.fromCodePoint(c)), out); @@ -3683,37 +3683,39 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_char(rs.strRmatchIndices(_50, String.fromCodePoint(c)), out); } } else if (_42 === 1) { - const needle: string = rs.stringExtendChars("", rs.iterTake(rs.iterSkip(rs.strChars(s), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize)); + const _109: rs.Iter = rs.iterTake(rs.iterSkip(rs.strChars(s.v), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize); + const needle: rs.String = rs.stringExtendChars(rs.stringNew(), _109); + const _125: string = s.v; const _127: rs.u8 = rs.u8Rem(m, 9); if (_127 === 0) { - putOffset(out, rs.strFind(s, needle)); - putOffset(out, rs.strRfind(s, needle)); + putOffset(out, rs.strFind(_125, needle.v)); + putOffset(out, rs.strRfind(_125, needle.v)); } else if (_127 === 1) { - putOption(out, rs.strStripPrefix(s, needle)); - putOption(out, rs.strStripSuffix(s, needle)); + putOption(out, rs.strStripPrefix(_125, needle.v)); + putOption(out, rs.strStripSuffix(_125, needle.v)); } else if (_127 === 2) { - harness_put(out, rs.strReplace(s, needle, "<>")); - harness_put(out, rs.strReplace(s, needle, "é", n)); + harness_put(out, rs.strReplace(_125, needle.v, "<>", true).v); + harness_put(out, rs.strReplacen(_125, needle.v, "é", n).v); } else if (_127 === 3) { - front$ref_str_str_Split_ref_str(rs.strSplit(s, needle), out); - front$ref_str_str_RSplit_ref_str(rs.strRsplit(s, needle), out); + front$ref_str_str_Split_ref_str(rs.strSplit(_125, needle.v), out); + front$ref_str_str_RSplit_ref_str(rs.strRsplit(_125, needle.v), out); } else if (_127 === 4) { - front$ref_str_str_SplitTerminator_ref_str(rs.strSplitTerminator(s, needle), out); - front$ref_str_str_RSplitTerminator_ref_str(rs.strRsplitTerminator(s, needle), out); + front$ref_str_str_SplitTerminator_ref_str(rs.strSplitTerminator(_125, needle.v), out); + front$ref_str_str_RSplitTerminator_ref_str(rs.strRsplitTerminator(_125, needle.v), out); } else if (_127 === 5) { - front$ref_str_str_SplitN_ref_str(rs.strSplitn(s, n, needle), out); - front$ref_str_str_RSplitN_ref_str(rs.strRsplitn(s, n, needle), out); + front$ref_str_str_SplitN_ref_str(rs.strSplitn(_125, n, needle.v), out); + front$ref_str_str_RSplitN_ref_str(rs.strRsplitn(_125, n, needle.v), out); } else if (_127 === 6) { - front$ref_str_str_SplitInclusive_ref_str(rs.strSplitInclusive(s, needle), out); + front$ref_str_str_SplitInclusive_ref_str(rs.strSplitInclusive(_125, needle.v), out); } else if (_127 === 7) { - front$ref_str_str_Matches_ref_str(rs.strMatches(s, needle), out); - front$ref_str_str_RMatches_ref_str(rs.strRmatches(s, needle), out); + front$ref_str_str_Matches_ref_str(rs.strMatches(_125, needle.v), out); + front$ref_str_str_RMatches_ref_str(rs.strRmatches(_125, needle.v), out); } else { - front$tuple2_usize_ref_str_str_MatchIndices_ref_str(rs.strMatchIndices(s, needle), out); - front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(rs.strRmatchIndices(s, needle), out); + front$tuple2_usize_ref_str_str_MatchIndices_ref_str(rs.strMatchIndices(_125, needle.v), out); + front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(rs.strRmatchIndices(_125, needle.v), out); } } else if (_42 === 2) { - const _206: string = s; + const _206: string = s.v; const part3 = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_206, rs.patternChars([c, d]))); @@ -3740,8 +3742,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_206, rs.patternChars([c, d]))); putOption(out, rs.strStripSuffix(_206, rs.patternChars([c, d]))); } else if (m === 2) { - harness_put(out, rs.strReplace(_206, rs.patternChars([c, d]), "<>")); - harness_put(out, rs.strReplace(_206, rs.patternChars([c, d]), "é", n)); + harness_put(out, rs.strReplace(_206, rs.patternChars([c, d]), "<>", false).v); + harness_put(out, rs.strReplacen(_206, rs.patternChars([c, d]), "é", n).v); } else if (m === 3) { front$ref_str_str_Split_ref_slice_char(rs.strSplit(_206, rs.patternChars([c, d])), out); front$ref_str_str_RSplit_ref_slice_char(rs.strRsplit(_206, rs.patternChars([c, d])), out); @@ -3761,7 +3763,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(rs.strRmatchIndices(_206, rs.patternChars([c, d])), out); } } else if (_42 === 3) { - const _349: string = s; + const _349: string = s.v; const part2 = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_349, rs.patternChars([c, d]))); @@ -3788,8 +3790,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_349, rs.patternChars([c, d]))); putOption(out, rs.strStripSuffix(_349, rs.patternChars([c, d]))); } else if (m === 2) { - harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "<>")); - harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "é", n)); + harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "<>", false).v); + harness_put(out, rs.strReplacen(_349, rs.patternChars([c, d]), "é", n).v); } else if (m === 3) { front$ref_str_str_Split_array2_char(rs.strSplit(_349, rs.patternChars([c, d])), out); front$ref_str_str_RSplit_array2_char(rs.strRsplit(_349, rs.patternChars([c, d])), out); @@ -3809,7 +3811,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(rs.strRmatchIndices(_349, rs.patternChars([c, d])), out); } } else { - const _438: string = s; + const _438: string = s.v; const part = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_438, p)); @@ -3836,8 +3838,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_438, p)); putOption(out, rs.strStripSuffix(_438, p)); } else if (m === 2) { - harness_put(out, rs.strReplace(_438, p, "<>")); - harness_put(out, rs.strReplace(_438, p, "é", n)); + harness_put(out, rs.strReplace(_438, p, "<>", false).v); + harness_put(out, rs.strReplacen(_438, p, "é", n).v); } else if (m === 3) { front$ref_str_str_Split_searches_searches_closure1(rs.strSplit(_438, p), out); front$ref_str_str_RSplit_searches_searches_closure1(rs.strRsplit(_438, p), out); @@ -3874,27 +3876,28 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * low bits of each byte, read from the end each byte's high bit picks. */ export function texts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { const _52: rs.usize = rs.u8Rem(_2, 16) as rs.usize; if (!(_52 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _52); } return [10, 13, 97, 32, 9, 11, 133, 160, 5760, 8202, 8203, 8232, 12288, 65279, 233, 128512][_52]; - })); + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _5); const _7: rs.u8 = rs.u8Rem(kind, 5); if (_7 === 0) { - both$tuple2_usize_char_str_CharIndices(rs.strCharIndices(s), data, out); + both$tuple2_usize_char_str_CharIndices(rs.strCharIndices(s.v), data, out); } else if (_7 === 1) { - both$ref_str_str_Lines(rs.strLines(s), data, out); + both$ref_str_str_Lines(rs.strLines(s.v), data, out); } else if (_7 === 2) { - both$ref_str_str_SplitWhitespace(rs.strSplitWhitespace(s), data, out); + both$ref_str_str_SplitWhitespace(rs.strSplitWhitespace(s.v), data, out); } else if (_7 === 3) { - both$ref_str_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(s), data, out); + both$ref_str_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(s.v), data, out); } else { - harness_put(out, rs.strTrimMatches(s, rs.charIsWhitespace)); - harness_put(out, rs.strTrimStartMatches(s, rs.charIsWhitespace)); - harness_put(out, rs.strTrimEndMatches(s, rs.charIsWhitespace)); - for (const _40 of rs.iterToVec(rs.iterMap(rs.strChars(s), (a0: rs.char): boolean => { + harness_put(out, rs.strTrimMatches(s.v, rs.charIsWhitespace)); + harness_put(out, rs.strTrimStartMatches(s.v, rs.charIsWhitespace)); + harness_put(out, rs.strTrimEndMatches(s.v, rs.charIsWhitespace)); + for (const _40 of rs.iterToVec(rs.iterMap(rs.strChars(s.v), (a0: rs.char): boolean => { return rs.charIsWhitespace(a0); }), "next", 1).items) { rs.byteVecPush(out, _40 ? 1 : 0); diff --git a/ts/fixtures/lang/separated/expected/core/option.ts b/ts/fixtures/lang/separated/expected/core/option.ts index 505b0482a..550101f69 100644 --- a/ts/fixtures/lang/separated/expected/core/option.ts +++ b/ts/fixtures/lang/separated/expected/core/option.ts @@ -4,7 +4,7 @@ import * as rs from "../rs.ts"; import { sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; import type * as Pair from "../separated.Pair.ts"; -export function map$13p7ywa(self: rs.Slice | undefined, _: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { +export function map$0k3subg(self: rs.Slice | undefined, _: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } @@ -39,7 +39,7 @@ export function map$0x0c7ki(self: rs.ByteSlice | undefined, _: (a0: rs.ByteSlice return sum(self); } -export function mapOr$1dcbyoa(self: rs.Slice | undefined, default_: rs.u8, _: (a0: rs.Slice) => rs.u8): rs.u8 { +export function mapOr$1jad7d1(self: rs.Slice | undefined, default_: rs.u8, _: (a0: rs.Slice) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/separated/expected/separated.ts b/ts/fixtures/lang/separated/expected/separated.ts index 43146b0a5..0d7631729 100644 --- a/ts/fixtures/lang/separated/expected/separated.ts +++ b/ts/fixtures/lang/separated/expected/separated.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { map$13p7ywa as option_map$13p7ywa, map$1fgo7n1 as option_map$1fgo7n1, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1dcbyoa as option_mapOr$1dcbyoa, mapOr$1bxom2b as option_mapOr$1bxom2b, mapOr$1khlwl8 as option_mapOr$1khlwl8, mapOr$0r061yq as option_mapOr$0r061yq, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; +import { map$0k3subg as option_map$0k3subg, map$1fgo7n1 as option_map$1fgo7n1, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1jad7d1 as option_mapOr$1jad7d1, mapOr$1bxom2b as option_mapOr$1bxom2b, mapOr$1khlwl8 as option_mapOr$1khlwl8, mapOr$0r061yq as option_mapOr$0r061yq, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import * as Below from "./separated.Below.ts"; import * as Pair from "./separated.Pair.ts"; @@ -41,9 +41,9 @@ export function sumPairs(part: rs.Slice): rs.u8 { }); } -export function sumTexts(part: rs.Slice): rs.u8 { - return rs.iterFold(rs.iterSlice(rs.sliceItems(part)), part.length & 0xff, (acc: rs.u8, s: string): rs.u8 => { - return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), rs.stringLen(s) & 0xff); +export function sumTexts(part: rs.Slice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.sliceItems(part)), part.length & 0xff, (acc: rs.u8, s: rs.String): rs.u8 => { + return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), s.len & 0xff); }); } @@ -130,9 +130,9 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi let _151!: rs.Slice | undefined; let _184!: rs.i32; let p4!: rs.Slice | undefined; - let _262!: rs.Slice | undefined; + let _262!: rs.Slice | undefined; let _295!: rs.i32; - let p6!: rs.Slice | undefined; + let p6!: rs.Slice | undefined; let _360!: rs.i32; let _425!: rs.ByteSlice | undefined; let _456!: rs.i32; @@ -140,9 +140,9 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi let _524!: rs.Slice | undefined; let _557!: rs.i32; let p10!: rs.Slice | undefined; - let _635!: rs.Slice | undefined; + let _635!: rs.Slice | undefined; let _668!: rs.i32; - let p12!: rs.Slice | undefined; + let p12!: rs.Slice | undefined; let _751!: rs.Slice | undefined; let _784!: rs.i32; let p14!: rs.Slice | undefined; @@ -192,12 +192,12 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const b2: rs.u8 = _24; return { a: b2, b: rs.u16Mul(b2 as rs.u16, 3) }; }), undefined, 4, true); - const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): string => { + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.String => { const _7: rs.usize = rs.usizeRem(_27 as rs.usize, 3); if (!(_7 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _7); } - return ["", "a", "ab"][_7]; + return rs.stringFrom(["", "a", "ab"][_7]); }), undefined, 12, true); const test: (a0: rs.u8) => boolean = (_28: rs.u8): boolean => { const b4: rs.u8 = _28; @@ -219,12 +219,11 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.refMutRelease(_63); return (p35.a as rs.u16) < bound; }; - const testTexts: (a0: string) => boolean = (s: string): boolean => { + const testTexts: (a0: rs.String) => boolean = (s: rs.String): boolean => { const _67: rs.RefCell = rs.refCellBorrowMut(log); - const _79: rs.u8 = (rs.stringLen(s) & 0xff) | 128; - rs.byteVecPush(_67.value, _79); + rs.byteVecPush(_67.value, (s.len & 0xff) | 128); rs.refMutRelease(_67); - return rs.stringLen(s) < rs.usizeRem(bound as rs.usize, 3); + return s.len < rs.usizeRem(bound as rs.usize, 3); }; b2: { const _35: rs.u8 = rs.u8Rem(kind, 8); @@ -336,7 +335,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back3: boolean = _251; - const it5: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); + const it5: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); hint(it5.sizeHint(), out); flush(log, out); while (true) { @@ -356,7 +355,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it6: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); + const it6: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); let iterStart3: rs.i32 = 0; const iterEnd3: rs.i32 = 12; while ((_295 = iterStart3++) < iterEnd3) { @@ -365,15 +364,15 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { p6 = rs.iterToOption(it6.nextBack()); } - rs.byteVecPush(out, option_mapOr$1dcbyoa(p6, 252, sumTexts)); + rs.byteVecPush(out, option_mapOr$1jad7d1(p6, 252, sumTexts)); hint(it6.sizeHint(), out); flush(log, out); } - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNth(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNth(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNthBack(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNthBack(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterLast(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterLast(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); flush(log, out); rs.byteVecPush(out, rs.iterCount(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts)) & 0xff); flush(log, out); @@ -510,7 +509,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back6: boolean = _624; - const it13: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); + const it13: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); hint(it13.sizeHint(), out); flush(log, out); while (true) { @@ -530,7 +529,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it14: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); + const it14: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); let iterStart7: rs.i32 = 0; const iterEnd7: rs.i32 = 12; while ((_668 = iterStart7++) < iterEnd7) { @@ -539,15 +538,15 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { p12 = rs.iterToOption(it14.nextBack()); } - rs.byteVecPush(out, option_mapOr$1dcbyoa(p12, 252, sumTexts)); + rs.byteVecPush(out, option_mapOr$1jad7d1(p12, 252, sumTexts)); hint(it14.sizeHint(), out); flush(log, out); } - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNth(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNth(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNthBack(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNthBack(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterLast(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterLast(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); flush(log, out); rs.byteVecPush(out, rs.iterCount(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts)) & 0xff); flush(log, out); @@ -910,10 +909,10 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break b2; } const n5: rs.usize = _1447; - const it29: rs.Iter> = rs.sliceSplitn(rs.sliceFrom(texts.items), n5, testTexts); + const it29: rs.Iter> = rs.sliceSplitn(rs.sliceFrom(texts.items), n5, testTexts); hint(it29.sizeHint(), out); while (true) { - const _1457: rs.Slice | rs.Done = it29.next(); + const _1457: rs.Slice | rs.Done = it29.next(); if (_1457 !== rs.DONE) { rs.byteVecPush(out, sumTexts(_1457)); hint(it29.sizeHint(), out); diff --git a/ts/fixtures/lang/shapes/caller.ts b/ts/fixtures/lang/shapes/caller.ts index 1ad079026..2de8cfdf6 100644 --- a/ts/fixtures/lang/shapes/caller.ts +++ b/ts/fixtures/lang/shapes/caller.ts @@ -23,7 +23,7 @@ export function run(input: rs.ByteSlice): rs.ByteVec { "|", rs.fmtSpec({ alternate: true }, debug), ]); - return rs.byteVecFrom(new TextEncoder().encode(text)); + return rs.byteVecFrom(new TextEncoder().encode(text.v)); } /** `shapes::loops` with each first byte that one of its cases of `!` takes, with one more byte and without. */ diff --git a/ts/fixtures/lang/shapes/expected/fmt.Capped.ts b/ts/fixtures/lang/shapes/expected/fmt.Capped.ts index 738829a72..6c778ed33 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Capped.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Capped.ts @@ -4,21 +4,21 @@ import * as rs from "./rs.ts"; /** A writer of the crate's own that fails a `write_str` past `cap` bytes, and counts each. */ export interface Capped { - text: string; + text: rs.String; calls: rs.u8; cap: rs.usize; } export function writeStr$fmt_Write(self: Capped, s: string): rs.Result { self.calls = rs.u8Add(self.calls, 1); - if (!(rs.usizeAdd(rs.stringLen(self.text), rs.stringLen(s)) > self.cap)) { + if (!(rs.usizeAdd(self.text.len, rs.stringLen(s)) > self.cap)) { const iter: rs.Iter = rs.strChars(s); while (true) { const _14: rs.char | rs.Done = iter.next(); if (_14 === rs.DONE) { break; } - self.text = self.text + String.fromCodePoint(_14); + rs.stringPush(self.text, _14); } return rs.OK; } diff --git a/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts b/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts index 77eb25d3a..92526ca12 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts @@ -25,7 +25,7 @@ export function fmt$fmt_Debug(self: Dropper, f: rs.Formatter): rs.Result { const arg = self.tag; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - return rs.fmtPad(f, rs.fmtFormat(["n", args2[0]])); + return rs.fmtPad(f, rs.fmtFormat(["n", args2[0]]).v); } export function drop$ops_Drop(self: Dropper): void { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Log.ts b/ts/fixtures/lang/shapes/expected/fmt.Log.ts index f410c4458..04e3bfbb3 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Log.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Log.ts @@ -7,28 +7,28 @@ import * as rs from "./rs.ts"; * a `write_char` by `c` before its text, and fails each call past its `budget` with `!`. */ export interface Log { - text: string; + text: rs.String; budget: rs.usize; } function new_(budget: rs.usize): Log { - return { text: "", budget }; + return { text: rs.stringNew(), budget }; } export function open(self: Log, kind: rs.char): rs.Result { if (!(self.budget === 0)) { self.budget = rs.usizeSub(self.budget, 1); - self.text = self.text + String.fromCodePoint(kind); + rs.stringPush(self.text, kind); return rs.OK; } - self.text = self.text + "!"; + rs.stringPush(self.text, 33); return rs.Err(new rs.FmtError()); } export function writeStr$fmt_Write(self: Log, s: string): rs.Result { if (open(self, 115).ok) { - self.text = self.text + s; - self.text = self.text + "\u0001"; + rs.stringPushStr(self.text, s); + rs.stringPush(self.text, 1); return rs.OK; } return rs.Err(new rs.FmtError()); @@ -36,8 +36,8 @@ export function writeStr$fmt_Write(self: Log, s: string): rs.Result { if (open(self, 99).ok) { - self.text = self.text + String.fromCodePoint(c); - self.text = self.text + "\u0001"; + rs.stringPush(self.text, c); + rs.stringPush(self.text, 1); return rs.OK; } return rs.Err(new rs.FmtError()); diff --git a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts index 415817080..3e32cc85d 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts @@ -8,18 +8,18 @@ import * as Shape from "./shapes.Shape.ts"; export function fmt$fmt_Debug(self: Nested, f: rs.Formatter): rs.Result { const names: string[] = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; - return rs.fmtDebugStructFields(f, "Nested", names, [(f: rs.Formatter) => rs.fmtStr(self.name, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.tags), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.maybe, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.none, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(self.list, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); + return rs.fmtDebugStructFields(f, "Nested", names, [(f: rs.Formatter) => rs.fmtStr(self.name.v, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.tags), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.maybe, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.none, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(self.list, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); } export interface Nested { - name: string; + name: rs.String; point: Point.Point; shape: Shape.Shape; tags: rs.ByteVec; pairs: rs.Vec; maybe: Pair.Pair | undefined; none: rs.u8 | undefined; - result: rs.Result; + result: rs.Result; list: rs.i16[]; tuple: [rs.u8, boolean, string]; single: [rs.u8]; diff --git a/ts/fixtures/lang/shapes/expected/fmt.Twice.ts b/ts/fixtures/lang/shapes/expected/fmt.Twice.ts index 170f4857d..052d92ae7 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Twice.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Twice.ts @@ -4,7 +4,7 @@ import * as rs from "./rs.ts"; /** A writer of the crate's own that writes each `char` twice through its own `write_char`. */ export interface Twice { - _0: string; + _0: rs.String; } export function writeStr$fmt_Write(self: Twice, s: string): rs.Result { @@ -14,14 +14,14 @@ export function writeStr$fmt_Write(self: Twice, s: string): rs.Result { - self._0 = self._0 + String.fromCodePoint(c); - self._0 = self._0 + String.fromCodePoint(c); + rs.stringPush(self._0, c); + rs.stringPush(self._0, c); return rs.OK; } diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index 08f41a537..b41781828 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -44,144 +44,144 @@ export function ints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); const v: rs.u8 = rs.u8FromBeBytes(buf); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8Debug(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8UpperHex(v, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rs.fmtSpec({ alternate: true }, args2[1]), " ", rs.fmtSpec({ width: 3 }, args2[1])])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rs.fmtSpec({ alternate: true }, args2[1]), " ", rs.fmtSpec({ width: 3 }, args2[1])]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8Binary(v, f), (f: rs.Formatter) => rs.u8Octal(v, f), (f: rs.Formatter) => rs.u8Debug(v, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args4[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args4[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args4[1]), " ", args4[0], " ", rs.fmtSpec({ precision: 3 }, args4[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args4[0]), "|", args4[2], " ", rs.fmtSpec({ alternate: true }, args4[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args4[2]), " ", args4[3], " ", rs.fmtSpec({ alternate: true }, args4[3]), " ", rs.fmtSpec({ plus: true }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args4[4]), " ", rs.fmtSpec({ plus: true }, args4[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args4[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args4[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args4[1]), " ", args4[0], " ", rs.fmtSpec({ precision: 3 }, args4[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args4[0]), "|", args4[2], " ", rs.fmtSpec({ alternate: true }, args4[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args4[2]), " ", args4[3], " ", rs.fmtSpec({ alternate: true }, args4[3]), " ", rs.fmtSpec({ plus: true }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args4[4]), " ", rs.fmtSpec({ plus: true }, args4[4])]).v); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerExp(v, f), (f: rs.Formatter) => rs.u8UpperExp(v, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 3 }, args6[0]), " ", rs.fmtSpec({ precision: 45 }, args6[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args6[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args6[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args6[0]), "| ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args6[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(v, f))); + put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 3 }, args6[0]), " ", rs.fmtSpec({ precision: 45 }, args6[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args6[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args6[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args6[0]), "| ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args6[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(v, f), 0).v); } else if (_4 === 1) { const buf2: Uint8Array = rs.bytes(2); const n2: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf2).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(data, 0, n2)); const v2: rs.u16 = rs.u16FromBeBytes(buf2); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16UpperHex(v2, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", rs.fmtSpec({ width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rs.fmtSpec({ alternate: true }, args8[2]), " ", rs.fmtSpec({ alternate: true }, args8[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rs.fmtSpec({ alternate: true }, args8[1]), " ", rs.fmtSpec({ width: 3 }, args8[1])])); + put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", rs.fmtSpec({ width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rs.fmtSpec({ alternate: true }, args8[2]), " ", rs.fmtSpec({ alternate: true }, args8[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rs.fmtSpec({ alternate: true }, args8[1]), " ", rs.fmtSpec({ width: 3 }, args8[1])]).v); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16Binary(v2, f), (f: rs.Formatter) => rs.u16Octal(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args10[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args10[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args10[1]), " ", args10[0], " ", rs.fmtSpec({ precision: 3 }, args10[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args10[0]), "|", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args10[2]), " ", args10[3], " ", rs.fmtSpec({ alternate: true }, args10[3]), " ", rs.fmtSpec({ plus: true }, args10[3]), "|", rs.fmtSpec({ debugHex: "x" }, args10[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args10[4]), " ", rs.fmtSpec({ plus: true }, args10[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args10[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args10[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args10[1]), " ", args10[0], " ", rs.fmtSpec({ precision: 3 }, args10[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args10[0]), "|", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args10[2]), " ", args10[3], " ", rs.fmtSpec({ alternate: true }, args10[3]), " ", rs.fmtSpec({ plus: true }, args10[3]), "|", rs.fmtSpec({ debugHex: "x" }, args10[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args10[4]), " ", rs.fmtSpec({ plus: true }, args10[4])]).v); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u16LowerExp(v2, f), (f: rs.Formatter) => rs.u16UpperExp(v2, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 3 }, args12[0]), " ", rs.fmtSpec({ precision: 45 }, args12[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args12[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args12[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args12[0]), "| ", rs.fmtSpec({ alternate: true }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args12[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u16Display(v2, f))); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 3 }, args12[0]), " ", rs.fmtSpec({ precision: 45 }, args12[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args12[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args12[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args12[0]), "| ", rs.fmtSpec({ alternate: true }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args12[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u16Display(v2, f), 0).v); } else if (_4 === 2) { const buf3: Uint8Array = rs.bytes(4); const n3: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf3).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(data, 0, n3)); const v3: rs.u32 = rs.u32FromBeBytes(buf3); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32UpperHex(v3, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rs.fmtSpec({ alternate: true }, args14[2]), " ", rs.fmtSpec({ alternate: true }, args14[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rs.fmtSpec({ alternate: true }, args14[1]), " ", rs.fmtSpec({ width: 3 }, args14[1])])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rs.fmtSpec({ alternate: true }, args14[2]), " ", rs.fmtSpec({ alternate: true }, args14[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rs.fmtSpec({ alternate: true }, args14[1]), " ", rs.fmtSpec({ width: 3 }, args14[1])]).v); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32Binary(v3, f), (f: rs.Formatter) => rs.u32Octal(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args16[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args16[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args16[1]), " ", args16[0], " ", rs.fmtSpec({ precision: 3 }, args16[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args16[0]), "|", args16[2], " ", rs.fmtSpec({ alternate: true }, args16[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args16[2]), " ", args16[3], " ", rs.fmtSpec({ alternate: true }, args16[3]), " ", rs.fmtSpec({ plus: true }, args16[3]), "|", rs.fmtSpec({ debugHex: "x" }, args16[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args16[4]), " ", rs.fmtSpec({ plus: true }, args16[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args16[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args16[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args16[1]), " ", args16[0], " ", rs.fmtSpec({ precision: 3 }, args16[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args16[0]), "|", args16[2], " ", rs.fmtSpec({ alternate: true }, args16[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args16[2]), " ", args16[3], " ", rs.fmtSpec({ alternate: true }, args16[3]), " ", rs.fmtSpec({ plus: true }, args16[3]), "|", rs.fmtSpec({ debugHex: "x" }, args16[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args16[4]), " ", rs.fmtSpec({ plus: true }, args16[4])]).v); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerExp(v3, f), (f: rs.Formatter) => rs.u32UpperExp(v3, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", rs.fmtSpec({ precision: 0 }, args18[0]), " ", rs.fmtSpec({ precision: 1 }, args18[0]), " ", rs.fmtSpec({ precision: 3 }, args18[0]), " ", rs.fmtSpec({ precision: 45 }, args18[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args18[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args18[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args18[0]), "| ", rs.fmtSpec({ alternate: true }, args18[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args18[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u32Display(v3, f))); + put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", rs.fmtSpec({ precision: 0 }, args18[0]), " ", rs.fmtSpec({ precision: 1 }, args18[0]), " ", rs.fmtSpec({ precision: 3 }, args18[0]), " ", rs.fmtSpec({ precision: 45 }, args18[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args18[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args18[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args18[0]), "| ", rs.fmtSpec({ alternate: true }, args18[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args18[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u32Display(v3, f), 0).v); } else if (_4 === 3) { const buf4: Uint8Array = rs.bytes(8); const n4: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf4).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf4), 0, n4), rs.byteSliceRange(data, 0, n4)); const v4: rs.u64 = rs.u64FromBeBytes(buf4); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64UpperHex(v4, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rs.fmtSpec({ alternate: true }, args20[2]), " ", rs.fmtSpec({ alternate: true }, args20[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ width: 3 }, args20[1])])); + put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rs.fmtSpec({ alternate: true }, args20[2]), " ", rs.fmtSpec({ alternate: true }, args20[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ width: 3 }, args20[1])]).v); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64Binary(v4, f), (f: rs.Formatter) => rs.u64Octal(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args22[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args22[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args22[1]), " ", args22[0], " ", rs.fmtSpec({ precision: 3 }, args22[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args22[0]), "|", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args22[2]), " ", args22[3], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ plus: true }, args22[3]), "|", rs.fmtSpec({ debugHex: "x" }, args22[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args22[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args22[4]), " ", rs.fmtSpec({ plus: true }, args22[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args22[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args22[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args22[1]), " ", args22[0], " ", rs.fmtSpec({ precision: 3 }, args22[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args22[0]), "|", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args22[2]), " ", args22[3], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ plus: true }, args22[3]), "|", rs.fmtSpec({ debugHex: "x" }, args22[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args22[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args22[4]), " ", rs.fmtSpec({ plus: true }, args22[4])]).v); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u64LowerExp(v4, f), (f: rs.Formatter) => rs.u64UpperExp(v4, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", rs.fmtSpec({ precision: 0 }, args24[0]), " ", rs.fmtSpec({ precision: 1 }, args24[0]), " ", rs.fmtSpec({ precision: 3 }, args24[0]), " ", rs.fmtSpec({ precision: 45 }, args24[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args24[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args24[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args24[0]), "| ", rs.fmtSpec({ alternate: true }, args24[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args24[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u64Display(v4, f))); + put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", rs.fmtSpec({ precision: 0 }, args24[0]), " ", rs.fmtSpec({ precision: 1 }, args24[0]), " ", rs.fmtSpec({ precision: 3 }, args24[0]), " ", rs.fmtSpec({ precision: 45 }, args24[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args24[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args24[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args24[0]), "| ", rs.fmtSpec({ alternate: true }, args24[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args24[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u64Display(v4, f), 0).v); } else if (_4 === 4) { const buf5: Uint8Array = rs.bytes(16); const n5: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf5).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf5), 0, n5), rs.byteSliceRange(data, 0, n5)); const v5: rs.u128 = rs.u128FromBeBytes(buf5); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128UpperHex(v5, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rs.fmtSpec({ alternate: true }, args26[2]), " ", rs.fmtSpec({ alternate: true }, args26[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rs.fmtSpec({ alternate: true }, args26[1]), " ", rs.fmtSpec({ width: 3 }, args26[1])])); + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rs.fmtSpec({ alternate: true }, args26[2]), " ", rs.fmtSpec({ alternate: true }, args26[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rs.fmtSpec({ alternate: true }, args26[1]), " ", rs.fmtSpec({ width: 3 }, args26[1])]).v); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128Binary(v5, f), (f: rs.Formatter) => rs.u128Octal(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args28[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args28[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args28[1]), " ", args28[0], " ", rs.fmtSpec({ precision: 3 }, args28[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args28[0]), "|", args28[2], " ", rs.fmtSpec({ alternate: true }, args28[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args28[2]), " ", args28[3], " ", rs.fmtSpec({ alternate: true }, args28[3]), " ", rs.fmtSpec({ plus: true }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args28[4]), " ", rs.fmtSpec({ plus: true }, args28[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args28[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args28[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args28[1]), " ", args28[0], " ", rs.fmtSpec({ precision: 3 }, args28[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args28[0]), "|", args28[2], " ", rs.fmtSpec({ alternate: true }, args28[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args28[2]), " ", args28[3], " ", rs.fmtSpec({ alternate: true }, args28[3]), " ", rs.fmtSpec({ plus: true }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args28[4]), " ", rs.fmtSpec({ plus: true }, args28[4])]).v); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u128LowerExp(v5, f), (f: rs.Formatter) => rs.u128UpperExp(v5, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", rs.fmtSpec({ precision: 0 }, args30[0]), " ", rs.fmtSpec({ precision: 1 }, args30[0]), " ", rs.fmtSpec({ precision: 3 }, args30[0]), " ", rs.fmtSpec({ precision: 45 }, args30[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args30[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args30[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args30[0]), "| ", rs.fmtSpec({ alternate: true }, args30[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args30[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u128Display(v5, f))); + put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", rs.fmtSpec({ precision: 0 }, args30[0]), " ", rs.fmtSpec({ precision: 1 }, args30[0]), " ", rs.fmtSpec({ precision: 3 }, args30[0]), " ", rs.fmtSpec({ precision: 45 }, args30[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args30[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args30[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args30[0]), "| ", rs.fmtSpec({ alternate: true }, args30[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args30[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u128Display(v5, f), 0).v); } else if (_4 === 5) { const buf6: Uint8Array = rs.bytes(4); const n6: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf6).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf6), 0, n6), rs.byteSliceRange(data, 0, n6)); const v6: rs.usize = rs.usizeFromBeBytes(buf6); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeUpperHex(v6, f)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rs.fmtSpec({ alternate: true }, args32[2]), " ", rs.fmtSpec({ alternate: true }, args32[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rs.fmtSpec({ alternate: true }, args32[1]), " ", rs.fmtSpec({ width: 3 }, args32[1])])); + put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rs.fmtSpec({ alternate: true }, args32[2]), " ", rs.fmtSpec({ alternate: true }, args32[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rs.fmtSpec({ alternate: true }, args32[1]), " ", rs.fmtSpec({ width: 3 }, args32[1])]).v); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeBinary(v6, f), (f: rs.Formatter) => rs.usizeOctal(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args34[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args34[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args34[1]), " ", args34[0], " ", rs.fmtSpec({ precision: 3 }, args34[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", args34[2], " ", rs.fmtSpec({ alternate: true }, args34[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args34[2]), " ", args34[3], " ", rs.fmtSpec({ alternate: true }, args34[3]), " ", rs.fmtSpec({ plus: true }, args34[3]), "|", rs.fmtSpec({ debugHex: "x" }, args34[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args34[4]), " ", rs.fmtSpec({ plus: true }, args34[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args34[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args34[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args34[1]), " ", args34[0], " ", rs.fmtSpec({ precision: 3 }, args34[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", args34[2], " ", rs.fmtSpec({ alternate: true }, args34[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args34[2]), " ", args34[3], " ", rs.fmtSpec({ alternate: true }, args34[3]), " ", rs.fmtSpec({ plus: true }, args34[3]), "|", rs.fmtSpec({ debugHex: "x" }, args34[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args34[4]), " ", rs.fmtSpec({ plus: true }, args34[4])]).v); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeLowerExp(v6, f), (f: rs.Formatter) => rs.usizeUpperExp(v6, f)]; - put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", rs.fmtSpec({ precision: 0 }, args36[0]), " ", rs.fmtSpec({ precision: 1 }, args36[0]), " ", rs.fmtSpec({ precision: 3 }, args36[0]), " ", rs.fmtSpec({ precision: 45 }, args36[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args36[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args36[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args36[0]), "| ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args36[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v6, f))); + put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", rs.fmtSpec({ precision: 0 }, args36[0]), " ", rs.fmtSpec({ precision: 1 }, args36[0]), " ", rs.fmtSpec({ precision: 3 }, args36[0]), " ", rs.fmtSpec({ precision: 45 }, args36[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args36[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args36[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args36[0]), "| ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args36[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v6, f), 0).v); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); const n7: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf7).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf7), 0, n7), rs.byteSliceRange(data, 0, n7)); const v7: rs.i8 = rs.i8FromBeBytes(buf7); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8UpperHex(v7, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", rs.fmtSpec({ width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rs.fmtSpec({ alternate: true }, args38[2]), " ", rs.fmtSpec({ alternate: true }, args38[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rs.fmtSpec({ alternate: true }, args38[1]), " ", rs.fmtSpec({ width: 3 }, args38[1])])); + put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", rs.fmtSpec({ width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rs.fmtSpec({ alternate: true }, args38[2]), " ", rs.fmtSpec({ alternate: true }, args38[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rs.fmtSpec({ alternate: true }, args38[1]), " ", rs.fmtSpec({ width: 3 }, args38[1])]).v); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8Binary(v7, f), (f: rs.Formatter) => rs.i8Octal(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args40[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args40[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args40[1]), " ", args40[0], " ", rs.fmtSpec({ precision: 3 }, args40[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args40[0]), "|", args40[2], " ", rs.fmtSpec({ alternate: true }, args40[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args40[2]), " ", args40[3], " ", rs.fmtSpec({ alternate: true }, args40[3]), " ", rs.fmtSpec({ plus: true }, args40[3]), "|", rs.fmtSpec({ debugHex: "x" }, args40[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args40[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args40[4]), " ", rs.fmtSpec({ plus: true }, args40[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args40[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args40[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args40[1]), " ", args40[0], " ", rs.fmtSpec({ precision: 3 }, args40[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args40[0]), "|", args40[2], " ", rs.fmtSpec({ alternate: true }, args40[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args40[2]), " ", args40[3], " ", rs.fmtSpec({ alternate: true }, args40[3]), " ", rs.fmtSpec({ plus: true }, args40[3]), "|", rs.fmtSpec({ debugHex: "x" }, args40[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args40[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args40[4]), " ", rs.fmtSpec({ plus: true }, args40[4])]).v); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.i8LowerExp(v7, f), (f: rs.Formatter) => rs.i8UpperExp(v7, f)]; - put(out, rs.fmtFormat([args42[0], " ", args42[1], " ", rs.fmtSpec({ precision: 0 }, args42[0]), " ", rs.fmtSpec({ precision: 1 }, args42[0]), " ", rs.fmtSpec({ precision: 3 }, args42[0]), " ", rs.fmtSpec({ precision: 45 }, args42[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args42[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args42[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args42[0]), "| ", rs.fmtSpec({ alternate: true }, args42[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args42[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i8Display(v7, f))); + put(out, rs.fmtFormat([args42[0], " ", args42[1], " ", rs.fmtSpec({ precision: 0 }, args42[0]), " ", rs.fmtSpec({ precision: 1 }, args42[0]), " ", rs.fmtSpec({ precision: 3 }, args42[0]), " ", rs.fmtSpec({ precision: 45 }, args42[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args42[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args42[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args42[0]), "| ", rs.fmtSpec({ alternate: true }, args42[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args42[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i8Display(v7, f), 3).v); } else if (_4 === 7) { const buf8: Uint8Array = rs.bytes(2); const n8: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf8).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf8), 0, n8), rs.byteSliceRange(data, 0, n8)); const v8: rs.i16 = rs.i16FromBeBytes(buf8); const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16UpperHex(v8, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", rs.fmtSpec({ width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rs.fmtSpec({ alternate: true }, args44[2]), " ", rs.fmtSpec({ alternate: true }, args44[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rs.fmtSpec({ alternate: true }, args44[1]), " ", rs.fmtSpec({ width: 3 }, args44[1])])); + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", rs.fmtSpec({ width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rs.fmtSpec({ alternate: true }, args44[2]), " ", rs.fmtSpec({ alternate: true }, args44[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rs.fmtSpec({ alternate: true }, args44[1]), " ", rs.fmtSpec({ width: 3 }, args44[1])]).v); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16Binary(v8, f), (f: rs.Formatter) => rs.i16Octal(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args46[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args46[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args46[1]), " ", args46[0], " ", rs.fmtSpec({ precision: 3 }, args46[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args46[0]), "|", args46[2], " ", rs.fmtSpec({ alternate: true }, args46[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args46[2]), " ", args46[3], " ", rs.fmtSpec({ alternate: true }, args46[3]), " ", rs.fmtSpec({ plus: true }, args46[3]), "|", rs.fmtSpec({ debugHex: "x" }, args46[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args46[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args46[4]), " ", rs.fmtSpec({ plus: true }, args46[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args46[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args46[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args46[1]), " ", args46[0], " ", rs.fmtSpec({ precision: 3 }, args46[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args46[0]), "|", args46[2], " ", rs.fmtSpec({ alternate: true }, args46[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args46[2]), " ", args46[3], " ", rs.fmtSpec({ alternate: true }, args46[3]), " ", rs.fmtSpec({ plus: true }, args46[3]), "|", rs.fmtSpec({ debugHex: "x" }, args46[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args46[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args46[4]), " ", rs.fmtSpec({ plus: true }, args46[4])]).v); const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.i16LowerExp(v8, f), (f: rs.Formatter) => rs.i16UpperExp(v8, f)]; - put(out, rs.fmtFormat([args48[0], " ", args48[1], " ", rs.fmtSpec({ precision: 0 }, args48[0]), " ", rs.fmtSpec({ precision: 1 }, args48[0]), " ", rs.fmtSpec({ precision: 3 }, args48[0]), " ", rs.fmtSpec({ precision: 45 }, args48[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args48[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args48[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args48[0]), "| ", rs.fmtSpec({ alternate: true }, args48[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args48[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i16Display(v8, f))); + put(out, rs.fmtFormat([args48[0], " ", args48[1], " ", rs.fmtSpec({ precision: 0 }, args48[0]), " ", rs.fmtSpec({ precision: 1 }, args48[0]), " ", rs.fmtSpec({ precision: 3 }, args48[0]), " ", rs.fmtSpec({ precision: 45 }, args48[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args48[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args48[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args48[0]), "| ", rs.fmtSpec({ alternate: true }, args48[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args48[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i16Display(v8, f), 5).v); } else if (_4 === 8) { const buf9: Uint8Array = rs.bytes(4); const n9: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf9).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf9), 0, n9), rs.byteSliceRange(data, 0, n9)); const v9: rs.i32 = rs.i32FromBeBytes(buf9); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32UpperHex(v9, f)]; - put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", rs.fmtSpec({ width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rs.fmtSpec({ alternate: true }, args50[2]), " ", rs.fmtSpec({ alternate: true }, args50[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rs.fmtSpec({ alternate: true }, args50[1]), " ", rs.fmtSpec({ width: 3 }, args50[1])])); + put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", rs.fmtSpec({ width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rs.fmtSpec({ alternate: true }, args50[2]), " ", rs.fmtSpec({ alternate: true }, args50[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rs.fmtSpec({ alternate: true }, args50[1]), " ", rs.fmtSpec({ width: 3 }, args50[1])]).v); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32Binary(v9, f), (f: rs.Formatter) => rs.i32Octal(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args52[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args52[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args52[1]), " ", args52[0], " ", rs.fmtSpec({ precision: 3 }, args52[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args52[0]), "|", args52[2], " ", rs.fmtSpec({ alternate: true }, args52[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args52[2]), " ", args52[3], " ", rs.fmtSpec({ alternate: true }, args52[3]), " ", rs.fmtSpec({ plus: true }, args52[3]), "|", rs.fmtSpec({ debugHex: "x" }, args52[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args52[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args52[4]), " ", rs.fmtSpec({ plus: true }, args52[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args52[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args52[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args52[1]), " ", args52[0], " ", rs.fmtSpec({ precision: 3 }, args52[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args52[0]), "|", args52[2], " ", rs.fmtSpec({ alternate: true }, args52[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args52[2]), " ", args52[3], " ", rs.fmtSpec({ alternate: true }, args52[3]), " ", rs.fmtSpec({ plus: true }, args52[3]), "|", rs.fmtSpec({ debugHex: "x" }, args52[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args52[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args52[4]), " ", rs.fmtSpec({ plus: true }, args52[4])]).v); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.i32LowerExp(v9, f), (f: rs.Formatter) => rs.i32UpperExp(v9, f)]; - put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", rs.fmtSpec({ precision: 0 }, args54[0]), " ", rs.fmtSpec({ precision: 1 }, args54[0]), " ", rs.fmtSpec({ precision: 3 }, args54[0]), " ", rs.fmtSpec({ precision: 45 }, args54[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args54[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args54[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args54[0]), "| ", rs.fmtSpec({ alternate: true }, args54[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args54[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i32Display(v9, f))); + put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", rs.fmtSpec({ precision: 0 }, args54[0]), " ", rs.fmtSpec({ precision: 1 }, args54[0]), " ", rs.fmtSpec({ precision: 3 }, args54[0]), " ", rs.fmtSpec({ precision: 45 }, args54[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args54[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args54[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args54[0]), "| ", rs.fmtSpec({ alternate: true }, args54[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args54[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i32Display(v9, f), 10).v); } else if (_4 === 9) { const buf10: Uint8Array = rs.bytes(8); const n10: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf10).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf10), 0, n10), rs.byteSliceRange(data, 0, n10)); const v10: rs.i64 = rs.i64FromBeBytes(buf10); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64UpperHex(v10, f)]; - put(out, rs.fmtFormat([args56[0], " ", args56[1], " ", rs.fmtSpec({ width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rs.fmtSpec({ alternate: true }, args56[2]), " ", rs.fmtSpec({ alternate: true }, args56[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rs.fmtSpec({ alternate: true }, args56[1]), " ", rs.fmtSpec({ width: 3 }, args56[1])])); + put(out, rs.fmtFormat([args56[0], " ", args56[1], " ", rs.fmtSpec({ width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rs.fmtSpec({ alternate: true }, args56[2]), " ", rs.fmtSpec({ alternate: true }, args56[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rs.fmtSpec({ alternate: true }, args56[1]), " ", rs.fmtSpec({ width: 3 }, args56[1])]).v); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64Binary(v10, f), (f: rs.Formatter) => rs.i64Octal(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args58[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args58[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args58[1]), " ", args58[0], " ", rs.fmtSpec({ precision: 3 }, args58[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args58[0]), "|", args58[2], " ", rs.fmtSpec({ alternate: true }, args58[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args58[2]), " ", args58[3], " ", rs.fmtSpec({ alternate: true }, args58[3]), " ", rs.fmtSpec({ plus: true }, args58[3]), "|", rs.fmtSpec({ debugHex: "x" }, args58[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args58[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args58[4]), " ", rs.fmtSpec({ plus: true }, args58[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args58[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args58[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args58[1]), " ", args58[0], " ", rs.fmtSpec({ precision: 3 }, args58[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args58[0]), "|", args58[2], " ", rs.fmtSpec({ alternate: true }, args58[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args58[2]), " ", args58[3], " ", rs.fmtSpec({ alternate: true }, args58[3]), " ", rs.fmtSpec({ plus: true }, args58[3]), "|", rs.fmtSpec({ debugHex: "x" }, args58[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args58[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args58[4]), " ", rs.fmtSpec({ plus: true }, args58[4])]).v); const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.i64LowerExp(v10, f), (f: rs.Formatter) => rs.i64UpperExp(v10, f)]; - put(out, rs.fmtFormat([args60[0], " ", args60[1], " ", rs.fmtSpec({ precision: 0 }, args60[0]), " ", rs.fmtSpec({ precision: 1 }, args60[0]), " ", rs.fmtSpec({ precision: 3 }, args60[0]), " ", rs.fmtSpec({ precision: 45 }, args60[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args60[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args60[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args60[0]), "| ", rs.fmtSpec({ alternate: true }, args60[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args60[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i64Display(v10, f))); + put(out, rs.fmtFormat([args60[0], " ", args60[1], " ", rs.fmtSpec({ precision: 0 }, args60[0]), " ", rs.fmtSpec({ precision: 1 }, args60[0]), " ", rs.fmtSpec({ precision: 3 }, args60[0]), " ", rs.fmtSpec({ precision: 45 }, args60[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args60[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args60[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args60[0]), "| ", rs.fmtSpec({ alternate: true }, args60[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args60[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i64Display(v10, f), 19).v); } else if (_4 === 10) { const buf11: Uint8Array = rs.bytes(16); const n11: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf11).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf11), 0, n11), rs.byteSliceRange(data, 0, n11)); const v11: rs.i128 = rs.i128FromBeBytes(buf11); const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128UpperHex(v11, f)]; - put(out, rs.fmtFormat([args62[0], " ", args62[1], " ", rs.fmtSpec({ width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rs.fmtSpec({ alternate: true }, args62[2]), " ", rs.fmtSpec({ alternate: true }, args62[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rs.fmtSpec({ alternate: true }, args62[1]), " ", rs.fmtSpec({ width: 3 }, args62[1])])); + put(out, rs.fmtFormat([args62[0], " ", args62[1], " ", rs.fmtSpec({ width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rs.fmtSpec({ alternate: true }, args62[2]), " ", rs.fmtSpec({ alternate: true }, args62[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rs.fmtSpec({ alternate: true }, args62[1]), " ", rs.fmtSpec({ width: 3 }, args62[1])]).v); const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128Binary(v11, f), (f: rs.Formatter) => rs.i128Octal(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args64[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args64[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args64[1]), " ", args64[0], " ", rs.fmtSpec({ precision: 3 }, args64[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args64[0]), "|", args64[2], " ", rs.fmtSpec({ alternate: true }, args64[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args64[2]), " ", args64[3], " ", rs.fmtSpec({ alternate: true }, args64[3]), " ", rs.fmtSpec({ plus: true }, args64[3]), "|", rs.fmtSpec({ debugHex: "x" }, args64[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args64[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args64[4]), " ", rs.fmtSpec({ plus: true }, args64[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args64[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args64[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args64[1]), " ", args64[0], " ", rs.fmtSpec({ precision: 3 }, args64[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args64[0]), "|", args64[2], " ", rs.fmtSpec({ alternate: true }, args64[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args64[2]), " ", args64[3], " ", rs.fmtSpec({ alternate: true }, args64[3]), " ", rs.fmtSpec({ plus: true }, args64[3]), "|", rs.fmtSpec({ debugHex: "x" }, args64[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args64[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args64[4]), " ", rs.fmtSpec({ plus: true }, args64[4])]).v); const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.i128LowerExp(v11, f), (f: rs.Formatter) => rs.i128UpperExp(v11, f)]; - put(out, rs.fmtFormat([args66[0], " ", args66[1], " ", rs.fmtSpec({ precision: 0 }, args66[0]), " ", rs.fmtSpec({ precision: 1 }, args66[0]), " ", rs.fmtSpec({ precision: 3 }, args66[0]), " ", rs.fmtSpec({ precision: 45 }, args66[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args66[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args66[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args66[0]), "| ", rs.fmtSpec({ alternate: true }, args66[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args66[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i128Display(v11, f))); + put(out, rs.fmtFormat([args66[0], " ", args66[1], " ", rs.fmtSpec({ precision: 0 }, args66[0]), " ", rs.fmtSpec({ precision: 1 }, args66[0]), " ", rs.fmtSpec({ precision: 3 }, args66[0]), " ", rs.fmtSpec({ precision: 45 }, args66[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args66[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args66[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args66[0]), "| ", rs.fmtSpec({ alternate: true }, args66[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args66[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i128Display(v11, f), 39).v); } else { const buf12: Uint8Array = rs.bytes(4); const n12: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf12).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf12), 0, n12), rs.byteSliceRange(data, 0, n12)); const v12: rs.isize = rs.isizeFromBeBytes(buf12); const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeUpperHex(v12, f)]; - put(out, rs.fmtFormat([args68[0], " ", args68[1], " ", rs.fmtSpec({ width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rs.fmtSpec({ alternate: true }, args68[2]), " ", rs.fmtSpec({ alternate: true }, args68[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rs.fmtSpec({ alternate: true }, args68[1]), " ", rs.fmtSpec({ width: 3 }, args68[1])])); + put(out, rs.fmtFormat([args68[0], " ", args68[1], " ", rs.fmtSpec({ width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rs.fmtSpec({ alternate: true }, args68[2]), " ", rs.fmtSpec({ alternate: true }, args68[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rs.fmtSpec({ alternate: true }, args68[1]), " ", rs.fmtSpec({ width: 3 }, args68[1])]).v); const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeBinary(v12, f), (f: rs.Formatter) => rs.isizeOctal(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args70[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args70[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args70[1]), " ", args70[0], " ", rs.fmtSpec({ precision: 3 }, args70[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args70[0]), "|", args70[2], " ", rs.fmtSpec({ alternate: true }, args70[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args70[2]), " ", args70[3], " ", rs.fmtSpec({ alternate: true }, args70[3]), " ", rs.fmtSpec({ plus: true }, args70[3]), "|", rs.fmtSpec({ debugHex: "x" }, args70[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args70[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args70[4]), " ", rs.fmtSpec({ plus: true }, args70[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args70[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args70[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args70[1]), " ", args70[0], " ", rs.fmtSpec({ precision: 3 }, args70[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args70[0]), "|", args70[2], " ", rs.fmtSpec({ alternate: true }, args70[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args70[2]), " ", args70[3], " ", rs.fmtSpec({ alternate: true }, args70[3]), " ", rs.fmtSpec({ plus: true }, args70[3]), "|", rs.fmtSpec({ debugHex: "x" }, args70[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args70[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args70[4]), " ", rs.fmtSpec({ plus: true }, args70[4])]).v); const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeLowerExp(v12, f), (f: rs.Formatter) => rs.isizeUpperExp(v12, f)]; - put(out, rs.fmtFormat([args72[0], " ", args72[1], " ", rs.fmtSpec({ precision: 0 }, args72[0]), " ", rs.fmtSpec({ precision: 1 }, args72[0]), " ", rs.fmtSpec({ precision: 3 }, args72[0]), " ", rs.fmtSpec({ precision: 45 }, args72[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args72[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args72[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args72[0]), "| ", rs.fmtSpec({ alternate: true }, args72[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args72[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v12, f))); + put(out, rs.fmtFormat([args72[0], " ", args72[1], " ", rs.fmtSpec({ precision: 0 }, args72[0]), " ", rs.fmtSpec({ precision: 1 }, args72[0]), " ", rs.fmtSpec({ precision: 3 }, args72[0]), " ", rs.fmtSpec({ precision: 45 }, args72[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args72[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args72[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args72[0]), "| ", rs.fmtSpec({ alternate: true }, args72[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args72[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v12, f), 10).v); } } @@ -195,22 +195,22 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_15]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ width: 8 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ width: 12 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ width: 8 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ width: 12 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args4[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args4[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args4[0]), "|", rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 20 }, args4[0]), "|", rs.fmtSpec({ precision: 2 }, args4[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args4[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args4[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args4[0]), "|", rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 20 }, args4[0]), "|", rs.fmtSpec({ precision: 2 }, args4[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[0])]).v); } const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 257)), 63); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ precision: 0 }, args6[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args6[0]), "|", rs.fmtSpec({ precision: 0 }, args6[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args6[1])])); - const _70: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ precision: 0 }, args6[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args6[0]), "|", rs.fmtSpec({ precision: 0 }, args6[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args6[1])]).v); + const _70: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_70.ok) { - const s2: string = _70.value; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s2, f), (f: rs.Formatter) => rs.fmtPad(f, s2)]; - put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args8[1]), " ", rs.fmtSpec({ precision: 1 }, args8[1])])); + const s2: rs.String = _70.value; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s2.v, f), (f: rs.Formatter) => rs.fmtPad(f, s2.v)]; + put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args8[1]), " ", rs.fmtSpec({ precision: 1 }, args8[1])]).v); } else { const e: rs.FromUtf8Error = _70.error; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(e, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args10[0]), " ", rs.fmtSpec({ precision: 4 }, args10[0]), " ", rs.fmtSpec({ debugHex: "x" }, args10[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[1])])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args10[0]), " ", rs.fmtSpec({ precision: 4 }, args10[0]), " ", rs.fmtSpec({ debugHex: "x" }, args10[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[1])]).v); } const _100: rs.u8 | undefined = rs.byteSliceFirst(data); b3: { @@ -223,25 +223,25 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { flag = false; } const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args12[1]), " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3]), " ", rs.fmtSpec({ precision: 1 }, args12[4])])); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args12[1]), " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3]), " ", rs.fmtSpec({ precision: 1 }, args12[4])]).v); const _130: boolean = flag; - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_130, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_130, f), 0).v); const _131: rs.Result = rs.u8TryFrom(rs.i32Sub(data.length | 0, 3)); if (_131.ok) { const arg = _131.value; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([args14[0]]).v); } else { const e2: rs.TryFromIntError = _131.error; const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtTryFromIntErrorDebug(e2, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args16[0]), "| ", rs.fmtSpec({ precision: 6 }, args16[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args16[0]), "|"])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args16[0]), "| ", rs.fmtSpec({ precision: 6 }, args16[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args16[0]), "|"]).v); } } export function nested(data: rs.ByteSlice): Nested.Nested { let _22!: Shape.Shape; let _49!: Pair.Pair | undefined; - let _61!: rs.Result; + let _61!: rs.Result; let _90!: Kind.Kind; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); @@ -250,7 +250,7 @@ export function nested(data: rs.ByteSlice): Nested.Nested { if (!(_5 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); } - const _3: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_5]; + const _3: rs.String = rs.stringFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_5]); const _15: Point.Point = { x: rs.i32Sub(at(1) as rs.i32, 128), y: -7 }; const _23: rs.u8 = rs.u8Rem(at(2), 3); if (_23 === 0) { @@ -269,7 +269,7 @@ export function nested(data: rs.ByteSlice): Nested.Nested { } const _60: rs.u8 | undefined = undefined; if (!(rs.u8Rem(at(6), 2) === 0)) { - _61 = rs.Err("no"); + _61 = rs.Err(rs.stringFrom("no")); } else { _61 = rs.Ok(at(6)); } @@ -295,44 +295,44 @@ export function derived(data: rs.ByteSlice, out: rs.ByteVec): void { }; const value: Nested.Nested = nested(data); const args2: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); const args6: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args6[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args6[0])]).v); const args8: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, args8[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, args8[0])]).v); const args10: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, args10[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, args10[0])]).v); const wide: fmt_Wide.Wide = { a: at(0), b: 300, c: 70000, d: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, e: -1, f: at(1) > 10 }; const six: Six.Six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; const _87: Unit.Unit = {}; const _88: Unit.Unit = {}; const args12: rs.Fmt[] = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_88, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3])])); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3])]).v); const args14: rs.Fmt[] = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ alternate: true }, args14[1])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ alternate: true }, args14[1])]).v); const point: Point.Point = { x: at(2) as rs.i32, y: -1 }; const _125: Pair.Pair = { _0: at(3), _1: -9 }; const args16: rs.Fmt[] = [(f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_125, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args16[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[1])])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args16[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[1])]).v); const kinds: Kind.Kind[] = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rs.ByteVec() } as Kind.Kind]; const _154: Kind.Kind = kinds[1]; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(kinds, f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => Kind.fmt$fmt_Debug(_154, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1]])); + put(out, rs.fmtFormat([args18[0], " ", args18[1]]).v); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(kinds, f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args20[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args20[0])]).v); const words: rs.u16[] = [at(5) as rs.u16, 65535]; const _189: rs.u8 | undefined = rs.byteSliceFirst(data); const _191: rs.u8 | undefined = rs.byteSliceGet(data, 100); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(data), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(_189, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_191, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3]])); + put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3]]).v); const _208: Braced.Braced = {}; const _209: Braced.Braced = {}; const _210: Bare.Bare = {}; const _211: Bare.Bare = {}; const args24: rs.Fmt[] = [(f: rs.Formatter) => Braced.fmt$fmt_Debug(_208, f), (f: rs.Formatter) => Braced.fmt$fmt_Debug(_209, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_210, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_211, f)]; - put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[1]), " ", args24[2], " ", rs.fmtSpec({ alternate: true }, args24[3])])); + put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[1]), " ", args24[2], " ", rs.fmtSpec({ alternate: true }, args24[3])]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(Braced.eq$cmp_PartialEq({}, {}) ? 1 : 0, Bare.eq$cmp_PartialEq({}, {}) ? 1 : 0))); } @@ -343,7 +343,7 @@ export function note(log: rs.ByteVec, v: rs.u8): rs.u8 { } /** Arguments that read `log` before and after one changes it, through a reference. */ -export function logged(log: rs.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): string { +export function logged(log: rs.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): rs.String { const _7: rs.usize = log.length; if (0 >= dataLen) { rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + 0); @@ -367,21 +367,21 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { }; const hex: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; const args2: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1])]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Binary(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Octal(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_LowerExp(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_UpperExp(hex, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rs.fmtSpec({ precision: 2 }, args4[3]), "|", args4[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args4[0])])); - put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f))); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rs.fmtSpec({ precision: 2 }, args4[3]), "|", args4[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args4[0])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f)).v); const arg = { _0: "pad" }; const args6: rs.Fmt[] = [(f: rs.Formatter) => Padded.fmt$fmt_Display(arg, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args6[0]), "|", rs.fmtSpec({ width: 30 }, args6[0]), "|"])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args6[0]), "|", rs.fmtSpec({ width: 30 }, args6[0]), "|"]).v); const manual: Manual.Manual = { id: at(1), list: rs.vecFrom([1, at(2) as rs.u16].slice()) }; const empty: Manual.Manual = { id: 0, list: new rs.Vec() }; const args8: rs.Fmt[] = [(f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; - put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]])); + put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]]).v); const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice()) }; const none: Seq.Seq = { _0: new rs.Vec() }; const args10: rs.Fmt[] = [(f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(none, f)]; - put(out, rs.fmtFormat([args10[0], " ", rs.fmtSpec({ alternate: true }, args10[0]), " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])])); + put(out, rs.fmtFormat([args10[0], " ", rs.fmtSpec({ alternate: true }, args10[0]), " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])]).v); const _113: rs.u8 = at(4); if (!(rs.u8Rem(at(5), 2) === 0)) { _116 = undefined; @@ -390,14 +390,14 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { } const arg2 = { _0: _113, _1: _116 }; const args12: rs.Fmt[] = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(arg2, f)]; - put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])])); + put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]).v); const part = { _0: at(6) & (~1 & 0xff) }; const args14: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part, f)]; - put(out, rs.fmtFormat([args14[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args14[0])])); + put(out, rs.fmtFormat([args14[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args14[0])]).v); const _164: rs.u8 = at(7); const _168: rs.u8 = at(8); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_168, f), (f: rs.Formatter) => rs.u8Display(_164, f), (f: rs.Formatter) => rs.u8Debug(_164, f), (f: rs.Formatter) => rs.fmtPad(f, "named")]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args16[3])])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args16[3])]).v); const log: rs.ByteVec = new rs.ByteVec(); const _187: rs.u8 = at(9); const _185: rs.u8 = note(log, _187); @@ -405,21 +405,21 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { const _191: boolean = note(log, _194) === 3; const _198: rs.usize = log.length; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_191, f), (f: rs.Formatter) => rs.u8Display(_185, f), (f: rs.Formatter) => rs.u8Debug(_185, f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " ", args18[3], " ", args18[1]])); + put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " ", args18[3], " ", args18[1]]).v); const _218: Noted.Noted = { _0: at(11) }; const _222: Noted.Noted = { _0: 2 }; const args20: rs.Fmt[] = [(f: rs.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rs.Formatter) => Noted.fmt$fmt_Display(_222, f)]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args20[1])])); + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args20[1])]).v); if (!(data.length === 0)) { - put(out, logged(log, data.data, data.start, data.length)); + put(out, logged(log, data.data, data.start, data.length).v); } const _241: rs.u8 = at(13); const part2 = note(log, _241); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(part2, f)]; - const once: string = rs.fmtFormat([args22[0]]); + const once: rs.String = rs.fmtFormat([args22[0]]); const _257: rs.usize = log.length; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, once), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1]])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, once.v), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; + put(out, rs.fmtFormat([args24[0], " ", args24[1]]).v); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); if (at(12) > 250) { const _277: rs.u8 = at(12); @@ -452,17 +452,17 @@ export function counts(data: rs.ByteSlice, out: rs.ByteVec): void { } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_39]; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v, f), rs.fmtCount(w), (f: rs.Formatter) => rs.i64LowerExp(v, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(p), (f: rs.Formatter) => rs.usizeDisplay(w, f), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args2[1]) }, args2[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[6]) }, args2[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args2[8]), precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[3]) }, args2[9])])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args2[1]) }, args2[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[6]) }, args2[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args2[8]), precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[3]) }, args2[9])]).v); const log: rs.ByteVec = new rs.ByteVec(); const _87: rs.u8 = at(4); const _85: rs.u8 = note(log, _87); const _91: rs.usize = note(log, 6) as rs.usize; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_85, f), rs.fmtCount(_91), (f: rs.Formatter) => rs.fmtPad(f, s)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[1]) }, args4[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[1]) }, args4[2])])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[1]) }, args4[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[1]) }, args4[2])]).v); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); const big: rs.usize = rs.usizeAdd(65535 as rs.usize, rs.u8Rem(at(5), 2) as rs.usize); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(big)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args6[1]) }, args6[0]), "|"])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args6[1]) }, args6[0]), "|"]).v); } /** `{:e}` at each rounding: below, above, and ties to even, which may carry a digit. */ @@ -474,10 +474,10 @@ export function rounding(out: rs.ByteVec): void { break; } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerExp(_5, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args2[0]), " ", rs.fmtSpec({ precision: 1 }, args2[0]), " ", rs.fmtSpec({ precision: 2 }, args2[0]), " ", args2[0]])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args2[0]), " ", rs.fmtSpec({ precision: 1 }, args2[0]), " ", rs.fmtSpec({ precision: 2 }, args2[0]), " ", args2[0]]).v); } const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u128LowerExp({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, f), (f: rs.Formatter) => rs.i128LowerExp({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, f), (f: rs.Formatter) => rs.i64UpperExp({ hi: -0x80000000, lo: 0 } as rs.i64, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), " ", args4[1], " ", rs.fmtSpec({ precision: 3 }, args4[2])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), " ", args4[1], " ", rs.fmtSpec({ precision: 3 }, args4[2])]).v); } /** Panics, each with the message native Rust formats. */ @@ -529,7 +529,7 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { r = rs.Err({ tag: "Many", count: 1, items: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(n))) } as Kind.Kind); } const _100: rs.u8 = rs.resultUnwrap(r, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_100, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_100, f), 0).v); } else if (_7 === 8) { if (!(n > 128)) { r2 = rs.Err({ _0: n, _1: -2 }); @@ -537,22 +537,22 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { r2 = rs.Ok(n); } const _110: rs.u8 = rs.resultExpect(r2, "expected a byte", (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_110, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_110, f), 0).v); } else if (_7 === 9) { const _121: rs.u8 = rs.resultUnwrapErr(rs.Ok({ x: n as rs.i32, y: 0 }), (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f)); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_121, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_121, f), 0).v); } else if (_7 === 10) { const missing: rs.u8 | undefined = rs.byteSliceGet(rest, 200); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - const _129: rs.u8 = rs.optionExpect(missing, rs.fmtFormat(["missing ", args10[0]])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_129, f))); + const _129: rs.u8 = rs.optionExpect(missing, rs.fmtFormat(["missing ", args10[0]]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_129, f), 0).v); } else if (_7 === 11) { const part3 = { _0: n }; const args12: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part3, f)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([args12[0]]).v); } else if (_7 === 12) { const _157: Fails.Fails = { _0: n }; - put(out, rs.fmtToString((f: rs.Formatter) => Fails.fmt$fmt_Display(_157, f))); + put(out, rs.fmtToString((f: rs.Formatter) => Fails.fmt$fmt_Display(_157, f)).v); } else if (_7 === 13) { const _162: Hex.Hex = { _0: n as rs.u32 }; const _165: Fails.Fails = { _0: n }; @@ -565,22 +565,22 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const _189: rs.ByteSlice = rs.byteSliceRange(rest, start); const _193: rs.ByteSlice = rs.byteSliceRange(rest, start, end); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_189), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_193), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1]])); + put(out, rs.fmtFormat([args16[0], " ", args16[1]]).v); } else if (_7 === 15) { const buf: Uint8Array = rs.bytes(3); rs.byteSliceCopyFromSlice(rs.byteSliceFrom(buf), rs.byteSliceRange(rest, 0, rs.min(rest.length, 4))); const arg3 = rs.byteSliceFrom(buf); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([args18[0]]).v); } else if (_7 === 16) { - const _221: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rest)); + const _221: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rest)); if (_221.ok) { - r4 = rs.Ok(rs.stringLen(_221.value) & 0xff); + r4 = rs.Ok(_221.value.len & 0xff); } else { r4 = _221 as rs.Result; } const _234: rs.u8 = rs.resultUnwrap(r4, rs.fmtFromUtf8ErrorDebug); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_234, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_234, f), 0).v); } else if (_7 === 17) { const buf2: Uint8Array = Uint8Array.of(1, 2, 3, 4); const dest: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(rest, 1), 0) as rs.usize, 4); @@ -589,12 +589,12 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyWithin(_244, _246.start, _246.end, dest); const arg2 = rs.byteSliceFrom(buf2); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([args20[0]]).v); } else if (_7 === 18) { const _271: rs.usize = rs.u8Rem(n, 8) as rs.usize; rs.idx(rest, _271); const arg = rest.data[rest.start + _271]; - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0).v); } else { if (!(rs.u8Rem(n, 2) === 0)) { r5 = rs.Ok(n); @@ -603,7 +603,7 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { } const part = rs.resultUnwrapErr(r5, rs.u8Debug); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([args22[0]]).v); } } @@ -625,7 +625,7 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _39: { end: rs.i32 } = { end: b }; const _41: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_33, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_35, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_37, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_39, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_41, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]]).v); const _60: rs.Range = new rs.Range(a, b); const _62: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); const _72: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); @@ -636,7 +636,7 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _74: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; const _77: rs.Range = new rs.Range(a, b); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_60, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_62, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_64, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_66, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_68, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRange(_70, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_72, f, rs.i32Debug), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_74, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f), (f: rs.Formatter) => rs.fmtRange(_77, f, rs.i32Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args4[7]) }, args4[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args4[7]) }, args4[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args4[9]), "|", rs.fmtSpec({ alternate: true }, args4[10])])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args4[7]) }, args4[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args4[7]) }, args4[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args4[9]), "|", rs.fmtSpec({ alternate: true }, args4[10])]).v); const _96: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_96 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _96); @@ -653,7 +653,7 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _133: rs.RangeFrom = new rs.RangeFrom(lo); const _135: { end: Clip.Clip; inclusive: true } = { end: lo, inclusive: true }; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_127, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_131, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args6[1]), "|", rs.fmtSpec({ alternate: true }, args6[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args6[4]), precision: 1 }, args6[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args6[5])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args6[1]), "|", rs.fmtSpec({ alternate: true }, args6[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args6[4]), precision: 1 }, args6[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args6[5])]).v); const _148: [rs.u32, rs.u32] = [rs.u32Mul(at(5) as rs.u32, 257), at(6) as rs.u32]; const x: rs.u32 = _148[0]; const y: rs.u32 = _148[1]; @@ -661,10 +661,10 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _171: rs.RangeInclusive = new rs.RangeInclusive({ _0: x }, { _0: y }); const _175: { end: Hex.Hex } = { end: { _0: y } }; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_167, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_171, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_175, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[2])])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[2])]).v); const part3 = new rs.Range({ _0: at(7), _1: -1 }, { _0: 1, _1: { hi: -0x80000000, lo: 0 } as rs.i64 }); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ plus: true }, args10[0])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ plus: true }, args10[0])]).v); const drained: rs.RangeInclusive = new rs.RangeInclusive(rs.u8Rem(at(8), 4), rs.u8Rem(at(9), 4), rs.u8Step); while (rs.iterToOption(drained.next()) !== undefined) { } @@ -679,40 +679,40 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterNth(far, _244); const _257: rs.RangeInclusive = new rs.RangeInclusive(0, 0, rs.i32Step); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRangeInclusive(drained, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(top, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(back, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(far, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_257, f, rs.i32Debug)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4]])); + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4]]).v); const arc: rs.Arc = new rs.Arc({ _0: x }); const args14: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(arc.value, f)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args14[0]), "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args14[1]), "|", rs.fmtSpec({ alternate: true }, args14[1])])); - put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f))); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args14[0]), "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args14[1]), "|", rs.fmtSpec({ alternate: true }, args14[1])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f)).v); const nested: rs.Arc> = new rs.Arc(new rs.Arc(a)); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(nested.value.value, f), (f: rs.Formatter) => rs.i32Debug(nested.value.value, f), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ debugHex: "x" }, args16[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args16[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args16[2]) }, args16[0])])); + put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ debugHex: "x" }, args16[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args16[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args16[2]) }, args16[0])]).v); const _310: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_310 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _310); } - const rc: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310]); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rc.value), (f: rs.Formatter) => rs.fmtStr(rc.value, f)]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args18[0]), "|", args18[1]])); + const rc: rs.Arc = new rs.Arc(rs.stringFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rc.value.v), (f: rs.Formatter) => rs.fmtStr(rc.value.v, f)]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args18[0]), "|", args18[1]]).v); const list: rs.Arc> = new rs.Arc(rs.vecFrom([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice())); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(list.value.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])])); + put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])]).v); const held: rs.Range> = new rs.Range(new rs.Arc(a), new rs.Arc(b)); const _366: rs.Range> = new rs.Range(new rs.Arc(lo), new rs.Arc(hi)); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(held, f, (value: rs.Arc, f: rs.Formatter) => rs.i32Debug(value.value, f)), (f: rs.Formatter) => rs.fmtRange(_366, f, (value: rs.Arc, f: rs.Formatter) => Clip.fmt$fmt_Debug(value.value, f))]; - const _362: string = rs.fmtFormat([args22[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args22[0]), " ", args22[1]]); + const _362: rs.String = rs.fmtFormat([args22[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args22[0]), " ", args22[1]]); rs.dropAll([_366.start, _366.end]); - put(out, _362); + put(out, _362.v); const shared: Shared.Shared = new Shared.Shared(new rs.Arc({ _0: at(7), _1: 5 }), new rs.Range(at(8) as rs.u16, 300), { end: at(9), inclusive: true }); const args24: rs.Fmt[] = [(f: rs.Formatter) => Shared.fmt$fmt_Debug(shared, f)]; - put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[0])])); + put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[0])]).v); const _405: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_405 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _405); } const t: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_405]); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, t.value), (f: rs.Formatter) => rs.fmtStr(t.value, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args26[0])])); + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args26[0])]).v); t[Symbol.dispose](); shared[Symbol.dispose](); rs.dropAll([held.start, held.end]); @@ -747,7 +747,7 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { } } const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(q), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]).v); const wrapped: rs.VecDeque = rs.dequeWithCapacity(4, 4) as rs.VecDeque; rs.dequeExtend(wrapped, rs.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); const _48: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; @@ -756,24 +756,24 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { rs.dequePushFront(wrapped, _57); rs.dequePopBack(wrapped); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - const mid: string = rs.fmtFormat([args4[0]]); + const mid: rs.String = rs.fmtFormat([args4[0]]); rs.dequePopBack(wrapped); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, mid), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1]), "|", rs.fmtSpec({ width: 6 }, args6[1])])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, mid.v), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1]), "|", rs.fmtSpec({ width: 6 }, args6[1])]).v); const empty: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; const units: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(2), 3)), (_2: rs.u8): undefined => {}), undefined, 0, true), 0) as rs.VecDeque; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(units), f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]]).v); const part = rs.dequeFromArray([rs.dequeNew(16) as rs.VecDeque, rs.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rs.VecDeque], 16) as rs.VecDeque>; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(part), f, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0])]).v); const _135: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.u8 | undefined => { const b5: rs.u8 = _25; return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, rs.u8Rem(b5, 8)); }); const part2 = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _135, true, undefined, undefined, 2, true); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(part2), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args12[0])])); + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args12[0])]).v); const map: rs.BTreeMap> = rs.btreeNew(rs.cmp) as rs.BTreeMap>; const iter2: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); while (true) { @@ -789,7 +789,7 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { const _176: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _178: rs.BTreeSet = rs.btreeNew(rs.cmp) as rs.BTreeSet; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(_176), f, rs.u8Debug, rs.u8Debug), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(_178), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[2])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[2])]).v); const _188: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew() as rs.HashSet]; const one: rs.HashMap = _188[0]; const set: rs.HashSet = _188[1]; @@ -805,7 +805,7 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { rs.hashAdd(set, _202); } const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.hashIter(one), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtSet(rs.hashKeys(set), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args16[1])])); + put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args16[1])]).v); } /** @@ -825,7 +825,7 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const w: rs.usize = rs.u8Rem(at(0), 10) as rs.usize; const n: rs.RangeBound = pick$enums_u8(at(1), at(2)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(n, f, rs.u8Debug), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args2[0])]).v); const _32: rs.u8 = at(3); const _37: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_37 < 14)) { @@ -833,16 +833,16 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { } const s: rs.RangeBound = pick$enums_ref_str(_32, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_37]); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(s, f, rs.fmtStr), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args4[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args4[1]), precision: 2 }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args4[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args4[1]), precision: 2 }, args4[0])]).v); const part = pick$enums_char(at(5), at(6) as rs.char); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args6[0])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args6[0])]).v); const part2 = pick$enums_Option_u8(at(7), thenSome$0quywni(rs.u8Rem(at(8), 2) === 0, at(9))); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ debugHex: "x" }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0])])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ debugHex: "x" }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0])]).v); const part4 = pick$enums_ref_slice_u8(at(10), rs.byteSliceRange(data, 0, rs.min(data.length, 3))); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part4, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ width: 3 }, args10[0])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ width: 3 }, args10[0])]).v); const _128: rs.u8 = at(11); const _134: rs.usize = rs.usizeRem(at(12) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_134 < 14)) { @@ -853,7 +853,7 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const _155: rs.RangeBound | undefined = clip; const _157: [rs.RangeBound, rs.RangeBound] = [n, s]; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_152, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(_155, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBound(_157[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_157[1], f, rs.fmtStr)], f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args12[0]), "|", rs.fmtSpec({ alternate: true }, args12[1]), "|", args12[2]])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args12[0]), "|", rs.fmtSpec({ alternate: true }, args12[1]), "|", args12[2]]).v); const r: rs.RangeInclusive = new rs.RangeInclusive(at(1), at(2), rs.u8Step); const _179: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _182: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; @@ -862,11 +862,11 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const _192: rs.RangeBound = { tag: "Excluded", _0: { end: at(2) }.end } as rs.RangeBound; const _199: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_179, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_182, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_185, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_192, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_199, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", rs.fmtSpec({ debugHex: "x" }, args14[3]), " ", rs.fmtSpec({ alternate: true }, args14[4])])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", rs.fmtSpec({ debugHex: "x" }, args14[3]), " ", rs.fmtSpec({ alternate: true }, args14[4])]).v); const ord: rs.Ordering = rs.cmp(at(1), at(2)); const all: rs.Ordering[] = [-1, 0, 1]; const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOrdering(ord, f), (f: rs.Formatter) => rs.fmtList(all, f, rs.fmtOrdering)]; - put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args16[0]), "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1])])); + put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args16[0]), "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1])]).v); const rev: rs.u8 = at(1); const _244: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_244 < 14)) { @@ -874,7 +874,7 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { } const nested: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_244]; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.u8Debug(rev, f)]), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtStr(nested, f)])])]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0]), "|", rs.fmtSpec({ debugHex: "x" }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[1]) }, args18[0]), "|", args18[2], "|", rs.fmtSpec({ alternate: true }, args18[2])])); + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0]), "|", rs.fmtSpec({ debugHex: "x" }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[1]) }, args18[0]), "|", args18[2], "|", rs.fmtSpec({ alternate: true }, args18[2])]).v); const _272: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_272 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _272); @@ -886,21 +886,21 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { flow = rs.Ok(rs.u16Mul(at(2) as rs.u16, 300)); } const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(flow, f, rs.u16Debug, rs.fmtStr), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", rs.fmtSpec({ debugHex: "x" }, args20[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args20[1]) }, args20[0])])); + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", rs.fmtSpec({ debugHex: "x" }, args20[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args20[1]) }, args20[0])]).v); if (rs.u8Rem(at(1), 2) === 0) { unit = rs.Err(at(2)); } else { unit = rs.OK; } const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(unit, f, rs.fmtUnit, rs.u8Debug)]; - put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args22[0])])); + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args22[0])]).v); if (rs.u8Rem(at(1), 2) === 0) { erred = rs.Err(at(2)); } else { erred = rs.Ok(at(2) as rs.u16); } const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(erred, f, rs.u16Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value), rs.u8Debug), true)]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args24[0])])); + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args24[0])]).v); if (rs.u8Rem(at(1), 2) === 0) { none = undefined; } else { @@ -912,10 +912,10 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { unitNone = undefined; } const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlowOption(none, f, rs.u8Debug, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value))), (f: rs.Formatter) => rs.fmtControlFlowOption(unitNone, f, rs.fmtUnit, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value)), rs.None)]; - put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args26[0]), "|", args26[1], "|", rs.fmtSpec({ alternate: true }, args26[1])])); + put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args26[0]), "|", args26[1], "|", rs.fmtSpec({ alternate: true }, args26[1])]).v); const part5 = rs.Ok(at(2)); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u8Debug, (value: never, _f: rs.Formatter) => rs.unreachable(value))]; - put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0])])); + put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0])]).v); } export function pick$enums_Option_u8(by: rs.u8, x: rs.u8 | undefined): rs.RangeBound { @@ -998,30 +998,30 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const back: rs.usize = _6[1]; const part = ends$iters_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data)), front, back); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0])]).v); const part2 = ends$iters_slice_IterMut_u8(rs.iterSliceMut(rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), undefined, true))), front, back); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part2, f, rs.u8Debug, ["IterMut"])]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])]).v); const part3 = ends$iters_vec_IntoIter_fmt_Pair(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Pair.Pair => { const b2: rs.u8 = _2; return { _0: b2, _1: rs.i64Neg(b2 as rs.i64) }; }), undefined, 16, true)), front, back); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])]).v); const part4 = ends$iters_vec_IntoIter_u8(rs.byteVecIntoIter(rs.byteSliceToByteVec(data)), front, back); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part4, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args8[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args8[0])]).v); const it4: rs.Iter = ends$iters_vec_Drain_fmt_Hex(rs.vecDrain(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), (_23: rs.u8): Hex.Hex => { return { _0: rs.u32Mul(_23 as rs.u32, 257) }; }), undefined, 4, true), new rs.RangeFrom(1, rs.usizeStep)), front, back); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it4, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f), ["Drain"])]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])]).v); rs.drop(it4); const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const _111: { end: rs.usize } = { end: rs.usizeDiv(data.length, 2) }; const it5: rs.Iter = ends$iters_vec_Drain_u8(rs.byteVecDrain(bytes, _111), front, back); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it5, f, rs.u8Debug, ["Drain"])]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args12[0])])); + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args12[0])]).v); rs.drop(it5); const arrays: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); @@ -1031,50 +1031,51 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true); const part5 = ends$iters_slice_Iter_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), front, back); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part5, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"])]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])]).v); const part6 = ends$iters_slice_IterMut_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), back, front); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([args16[0]]).v); const _165: Array = []; const _174: rs.Iter = rs.iterSlice(_165); const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_174, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["Iter"]), (f: rs.Formatter) => rs.fmtIter(_176, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])]).v); const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), rs.le, rs.ge, rs.lt); const part7 = ends$iters_collections_binary_heap_Iter_u8(rs.heapIter(heap), front, back); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part7, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])])); + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])]).v); const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rs.heapIter(rs.heapClone(heap, undefined)), front, back); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part8, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([args22[0]]).v); const it8: rs.Iter = ends$iters_collections_binary_heap_Drain_u8(rs.heapDrain(rs.heapClone(heap, undefined)), front, back); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it8, f, rs.u8Debug, [["Drain", "iter"], "Drain"])]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])])); + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])]).v); rs.drop(it8); const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rs.dequeIntoIter(rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.u8 | undefined => { const b4: rs.u8 = _27; return thenSome$0quywni(rs.u8Rem(b4, 3) !== 0, b4); }), undefined, 2, true), 2) as rs.VecDeque), front, back); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part9, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["IntoIter"])]; - put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])])); - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { + put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])]).v); + const _253: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { const _59: rs.usize = rs.u8Rem(_28, 6) as rs.usize; if (!(_59 < 6)) { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _59); } return [97, 233, 20013, 129408, 10, 39][_59]; - })); - const part10 = ends$iters_str_Chars(rs.strChars(text), front, back); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _253); + const part10 = ends$iters_str_Chars(rs.strChars(text.v), front, back); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChars(part10, f)]; - put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[0])])); - const part11 = ends$iters_str_Bytes(rs.strBytes(text), front, back); + put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[0])]).v); + const part11 = ends$iters_str_Bytes(rs.strBytes(text.v), front, back); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part11, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ debugHex: "x" }, args30[0])])); + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ debugHex: "x" }, args30[0])]).v); const _295: rs.Iter = rs.strChars(""); const _298: rs.Iter = rs.strChars(""); const _301: rs.Iter = rs.strBytes(""); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChars(_295, f), (f: rs.Formatter) => rs.fmtChars(_298, f), (f: rs.Formatter) => rs.fmtIter(_301, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[1]), "|", args32[2]])); + put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[1]), "|", args32[2]]).v); const _310: rs.Iter<[rs.u8, rs.u8 | undefined]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): [rs.u8, rs.u8 | undefined] => { const b6: rs.u8 = _29; return [rs.u8Rem(b6, 16), thenSome$0quywni(rs.u8Rem(b6, 3) !== 0, b6)] as [rs.u8, rs.u8 | undefined]; @@ -1082,34 +1083,34 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _310, true, undefined, undefined, undefined, 3, true); const part12 = ends$iters_collections_btree_map_Iter_u8_Option_u8(rs.btreeIter(map), front, back); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part12, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])])); + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])]).v); const _335: rs.Iter = ends$iters_collections_btree_map_Keys_u8_Option_u8(rs.btreeKeys(map), front, back); const _339: rs.Iter = ends$iters_collections_btree_map_Values_u8_Option_u8(rs.btreeValues(map), front, back); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_335, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIter(_339, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args36[0], "|", args36[1]])); + put(out, rs.fmtFormat([args36[0], "|", args36[1]]).v); const lo: rs.u8 = rs.u8Rem(at(2), 16); const _360: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); const _365: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, { end: lo, inclusive: true }), front, back); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_360, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f)), (f: rs.Formatter) => rs.fmtIter(_365, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args38[0], "|", args38[1]])); + put(out, rs.fmtFormat([args38[0], "|", args38[1]]).v); const part13 = ends$iters_collections_btree_map_IterMut_u8_Option_u8(rs.btreeIterMut(map), front, back); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part13, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([args40[0]]).v); const part14 = ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(rs.btreeValuesMut(map), front, back); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part14, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([args42[0]]).v); const part15 = ends$iters_collections_btree_map_RangeMut_u8_Option_u8(rs.btreeRangeMut(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part15, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([args44[0]]).v); const part16 = ends$iters_collections_btree_map_IntoIter_u8_Option_u8(rs.btreeIter(rs.btreeClone(map, undefined, undefined)), front, back); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part16, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([args46[0]]).v); const part17 = ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(rs.btreeKeys(rs.btreeClone(map, undefined, undefined)), front, back); const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part17, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args48[0]])); + put(out, rs.fmtFormat([args48[0]]).v); const part18 = ends$iters_collections_btree_map_IntoValues_u8_Option_u8(rs.btreeValues(map), front, back); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part18, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([args50[0]]).v); const _468: rs.Iter<[Uint8Array, Hex.Hex]> = rs.iterMap(rs.byteSliceChunksExact(data, 2), (c2: rs.ByteSlice): [Uint8Array, Hex.Hex] => { rs.idx(c2, 0); const _411: rs.u8 = c2.data[c2.start]; @@ -1124,28 +1125,28 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }), front, back); const _481: rs.Iter = ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(rs.iterLend(rs.btreeKeys(keyed), rs.byteSliceFrom), back, front); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.u8Debug), (f: rs.Formatter) => Hex.fmt$fmt_Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_481, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args52[0]), "|", args52[1]])); + put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args52[0]), "|", args52[1]]).v); const _491: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 => { return rs.u8Rem(_212, 16); }); const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _491, true, undefined, undefined, 1, true); const part19 = ends$iters_collections_btree_set_Iter_u8(rs.btreeKeys(set), front, back); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part19, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0])])); + put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0])]).v); const part20 = ends$iters_collections_btree_set_Range_u8(rs.btreeRangeKeys(set, new rs.RangeFrom(lo, rs.u8Step)), front, back); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part20, f, rs.fmtSetVal(rs.u8Debug), [["Range", "iter"]])]; - put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0]), "|", rs.fmtSpec({ debugHex: "x" }, args56[0])])); + put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0]), "|", rs.fmtSpec({ debugHex: "x" }, args56[0])]).v); const part21 = ends$iters_collections_btree_set_IntoIter_u8(rs.btreeKeys(set), front, back); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part21, f, rs.fmtSetVal(rs.u8Debug), [["IntoIter", "iter"]])]; - put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0])])); + put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0])]).v); const empty2: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _547: rs.Iter<[rs.u8, rs.u8]> = rs.btreeIter(empty2); const _550: rs.Iter = rs.btreeKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet); const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_547, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_550, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[1])])); + put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[1])]).v); const part22 = rs.btreeKeys(empty2); const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part22, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args62[0]])); + put(out, rs.fmtFormat([args62[0]]).v); const _573: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet]; const one: rs.HashMap = _573[0]; const keys: rs.HashSet = _573[1]; @@ -1161,34 +1162,34 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _608: rs.Iter<[rs.u8 | undefined, rs.u16]> = rs.hashIter(one); const _611: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Iter_Option_u8_u16(rs.hashIter(one), n); const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_608, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_611, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[1])])); + put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[1])]).v); const _627: rs.Iter = skip$iters_collections_hash_map_Keys_Option_u8_u16(rs.hashKeys(one), n); const _631: rs.Iter = skip$iters_collections_hash_map_Values_Option_u8_u16(rs.hashValues(one), n); const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_627, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_631, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args66[0], "|", args66[1]])); + put(out, rs.fmtFormat([args66[0], "|", args66[1]]).v); const part23 = skip$iters_collections_hash_map_IterMut_Option_u8_u16(rs.hashIterMut(one), n); const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part23, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args68[0]])); + put(out, rs.fmtFormat([args68[0]]).v); const part24 = skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(rs.hashValuesMut(one), rs.usizeSub(1, n)); const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part24, f, rs.u16Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args70[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args70[0])]).v); const part25 = skip$iters_collections_hash_map_IntoIter_Option_u8_u16(rs.hashIter(rs.hashClone(one, undefined, undefined)), n); const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part25, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args72[0]])); + put(out, rs.fmtFormat([args72[0]]).v); const _695: rs.Iter = rs.hashKeys(rs.hashClone(one, undefined, undefined)); const _699: rs.Iter = skip$iters_collections_hash_map_IntoValues_Option_u8_u16(rs.hashValues(rs.hashClone(one, undefined, undefined)), n); const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_695, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_699, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args74[0], "|", args74[1]])); + put(out, rs.fmtFormat([args74[0], "|", args74[1]]).v); const it17: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Drain_Option_u8_u16(rs.hashDrain(one), n); const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it17, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ alternate: true }, args76[0])])); + put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ alternate: true }, args76[0])]).v); const _732: rs.Iter = skip$iters_collections_hash_set_Iter_array2_u8(rs.iterLend(rs.hashKeys(keys), rs.byteSliceFrom), n); const _736: rs.Iter = rs.hashKeys(rs.hashClone(keys, copy$array_u8, undefined)); const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_732, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_736, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[1])])); + put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[1])]).v); const part26 = skip$iters_collections_hash_set_Drain_array2_u8(rs.hashDrainKeys(keys), rs.usizeSub(1, n)); const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part26, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([args80[0]]).v); } export function skip$iters_collections_binary_heap_Drain_u8(it: rs.Iter, n: rs.usize): rs.Iter { @@ -1869,39 +1870,41 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u8Add(b, 1); }), front, back); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part2, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])]).v); const part3 = ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(rs.iterFilter(rs.iterSlice(rs.byteSliceView(bytes)), (_2: rs.u8): boolean => { return rs.u8Rem(_2, 2) === 0; }), front, back); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part3, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])]).v); const part4 = ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_23: rs.u8): rs.u8 | undefined => { return rs.u8CheckedSub(_23, 9); }), front, back); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part4, f, "FilterMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([args6[0]]).v); const part5 = ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(rs.iterInspect(rs.iterSlice(rs.byteSliceView(bytes)), (_26: rs.u8): undefined => {}), front, back); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part5, f, "Inspect", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([args8[0]]).v); const part6 = fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_28: rs.u8): rs.u8 | undefined => { return rs.u8CheckedSub(_28, 3); }), front); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part6, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([args10[0]]).v); const part7 = ends$adaptors_iter_Rev_slice_Iter_u8(rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part7, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0])])); + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0])]).v); const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(bytes)), front, back); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part8, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])]).v); const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rs.iterCloned(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part9, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), "it")]; - put(out, rs.fmtFormat([args16[0]])); - const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rs.iterCloned(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b5: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b5, f)); - }), undefined, 12, true).items)), front, back); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0])])); + put(out, rs.fmtFormat([args16[0]]).v); + const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b5: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b5, f), 0); + }), undefined, 12, true).items), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }), front, back); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), ["Iter"]), "it")]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0])]).v); const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); const _32: rs.u8 = c.data[c.start]; @@ -1909,160 +1912,161 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { return Uint8Array.of(_32, c.data[c.start + 1]); }), undefined, 2, true).items), rs.byteSliceFrom), rs.byteSliceToArray), front, back); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part11, f, "Copied", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"]), "it")]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([args20[0]]).v); const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEnumerate(part12, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ debugHex: "x" }, args22[0])])); + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ debugHex: "x" }, args22[0])]).v); const it12: rs.Iter = rs.iterSkip(rs.iterSlice(rs.byteSliceView(bytes)), at(2) as rs.usize); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])])); + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])]).v); rs.iterToOption(it12.nextBack()); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args26[0]])); + put(out, rs.fmtFormat([args26[0]]).v); it12.next(); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args28[0]])); + put(out, rs.fmtFormat([args28[0]]).v); const part13 = ends$adaptors_iter_Take_slice_Iter_u8(rs.iterTake(rs.iterSlice(rs.byteSliceView(bytes)), rs.u8Rem(at(2), 8) as rs.usize), front, back); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])])); + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])]).v); const it14: rs.Iter = rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_211: rs.u8): boolean => { return rs.u8Rem(_211, 3) !== 0; }); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args32[0]])); + put(out, rs.fmtFormat([args32[0]]).v); it14.next(); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])])); + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])]).v); const it15: rs.Iter = rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): boolean => { return rs.u8Rem(_212, 5) !== 0; }); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args36[0]])); + put(out, rs.fmtFormat([args36[0]]).v); let iterStart: rs.usize = 0; const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { it15.next(); } const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0])])); + put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0])]).v); const part14 = fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), 0, (sum: rs.Place, _33: rs.u8): rs.u32 | undefined => { sum.v = rs.u32Add(sum.v, _33 as rs.u32); return sum.v; }, true), front); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part14, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u32Debug)]; - put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ debugHex: "x" }, args40[0])])); - const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), "", (s: rs.Place, _34: rs.u8): rs.usize | undefined => { + put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ debugHex: "x" }, args40[0])]).v); + const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), rs.stringNew(), (s: rs.String, _34: rs.u8): rs.usize | undefined => { const b9: rs.u8 = _34; - s.v = s.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b9, 26)) as rs.char); + rs.stringPush(s, rs.u8Add(97, rs.u8Rem(b9, 26)) as rs.char); return then$1uoo7un(rs.u8Rem(b9, 7) !== 0, (): rs.usize => { - return rs.stringLen(s.v); + return s.len; }); - }, true), front); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.fmtStr)]; - put(out, rs.fmtFormat([args42[0]])); + }), front); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([args42[0]]).v); const it18: rs.Peekable = ends$adaptors_iter_Peekable_slice_Iter_u8(rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([args44[0]]).v); rs.peekablePeek(it18); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args46[0], "|", rs.fmtSpec({ alternate: true }, args46[0])])); + put(out, rs.fmtFormat([args46[0], "|", rs.fmtSpec({ alternate: true }, args46[0])]).v); it18.next(); const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args48[0]])); + put(out, rs.fmtFormat([args48[0]]).v); const it19: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(bytes.length, 1))))); it19.next(); rs.peekablePeek(it19); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])])); + put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])]).v); const part19 = ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(2, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, rs.min(2, bytes.length))))), front, back); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0])])); + put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0])]).v); const it21: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(1, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(7, 8))))); rs.iterToOption(it21.nextBack()); rs.iterToOption(it21.nextBack()); rs.iterToOption(it21.nextBack()); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(it21, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([args54[0]]).v); const part21 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b10: rs.u8): rs.u8 => { return b10 ^ 1; }), [false, true]), front, back); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part21, f)]; - put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])])); + put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])]).v); const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), "len"), front, back); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args58[0]])); - const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { + put(out, rs.fmtFormat([args58[0]]).v); + const _509: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { const _511: rs.usize = rs.u8Rem(_213, 4) as rs.usize; if (!(_511 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _511); } return [97, 233, 20013, 129408][_511]; - }))), rs.iterSlice(rs.byteSliceView(bytes))), front); + }); + const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars(rs.stringNew(), _509).v), rs.iterSlice(rs.byteSliceView(bytes))), front); const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part23, f, rs.fmtChars, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[0])])); + put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[0])]).v); const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rs.iterCycle(rs.iterSlice(rs.byteSliceView(bytes))), rs.usizeAdd(front, rs.u8Rem(at(2), 8) as rs.usize)); const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCycle(part24, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])])); + put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])]).v); const part25 = fronts$adaptors_iter_Fuse_slice_Iter_u8(rs.iterFuse(rs.iterSlice(rs.byteSliceView(bytes)), true), rs.usizeAdd(front, 6)); const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part25, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])])); + put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])]).v); const part26 = fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(rs.iterFuse(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), 2), true), rs.usizeAdd(front, 2)); const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part26, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtStepBy(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0])])); + put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0])]).v); const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rs.iterFuse(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_216: rs.u8): rs.u8 | undefined => { const b12: rs.u8 = _216; return thenSome$0quywni(rs.u8Rem(b12, 4) !== 0, b12); })), rs.usizeMul(front, 2)); const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part27, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args68[0]])); + put(out, rs.fmtFormat([args68[0]]).v); const step: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); const part28 = ends$adaptors_iter_StepBy_slice_Iter_u8(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), step), front, back); const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part28, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])])); + put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])]).v); const _630: [rs.u8, rs.u8] = [rs.u8Rem(at(4), 16), at(5)]; const lo: rs.u8 = _630[0]; const hi: rs.u8 = _630[1]; const part29 = ends$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(lo, hi), step, undefined, 255), front, back); const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part29, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])])); + put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])]).v); const part30 = fronts$adaptors_iter_StepBy_ops_Range_u32(rs.iterStepBy(new rs.Range(lo as rs.u32, hi as rs.u32), step, undefined, 4294967295), front); const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part30, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u32Debug))]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([args74[0]]).v); const part31 = ends$adaptors_iter_StepBy_ops_Range_usize(rs.iterStepBy(new rs.Range(lo as rs.usize, hi as rs.usize), step, undefined, 4294967295), front, back); const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part31, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.usizeDebug))]; - put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ debugHex: "x" }, args76[0])])); + put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ debugHex: "x" }, args76[0])]).v); const part32 = ends$adaptors_iter_StepBy_ops_Range_u16(rs.iterStepBy(new rs.Range(lo as rs.u16, hi as rs.u16), step, undefined, 65535), front, back); const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part32, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u16Debug))]; - put(out, rs.fmtFormat([args78[0]])); + put(out, rs.fmtFormat([args78[0]]).v); const part33 = ends$adaptors_iter_StepBy_ops_Range_i32(rs.iterStepBy(new rs.Range(lo as rs.i32, hi as rs.i32), step), front, back); const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part33, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.i32Debug))]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([args80[0]]).v); const part34 = fronts$adaptors_iter_StepBy_ops_Range_u64(rs.iterStepBy(new rs.Range(lo as rs.u64, hi as rs.u64, rs.u64Step), step), front); const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part34, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u64Debug))]; - put(out, rs.fmtFormat([args82[0]])); + put(out, rs.fmtFormat([args82[0]]).v); const part35 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), 300, undefined, 255), front); const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part35, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args84[0]])); + put(out, rs.fmtFormat([args84[0]]).v); const part36 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), rs.usizeAdd(at(3) as rs.usize, 1), undefined, 255), front); const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part36, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([args86[0]]).v); const part37 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(hi, 255), rs.usizeAdd(step, 200), undefined, 255), front); const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part37, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args88[0]])); - const lists: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(bytes, 2), (a0: rs.ByteSlice): rs.ByteVec => { - return rs.byteSliceToByteVec(a0); + put(out, rs.fmtFormat([args88[0]]).v); + const lists: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(bytes, 2), (a02: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(a02); }), undefined, 12, true); const part38 = ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), front, back); const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlatten(part38, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])]).v); const part39 = ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(rs.iterFlatMap(rs.iterSlice(lists.items), (v: rs.ByteVec): rs.Iter => { return rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))); }, undefined, true), front, back); const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlatten(part39, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])])); + put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])]).v); const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rs.iterFuse(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), true), rs.usizeAdd(front, 6)); const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part40, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([args94[0]]).v); const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_218: rs.u8): rs.u16 => { const _517: rs.usize = rs.u8Rem(_218, 5) as rs.usize; if (!(_517 < 5)) { @@ -2072,54 +2076,55 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true); const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterSlice(units.items)), front); const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part41, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[0]), "|", rs.fmtSpec({ debugHex: "x" }, args96[0])])); + put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[0]), "|", rs.fmtSpec({ debugHex: "x" }, args96[0])]).v); const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rs.charDecodeUtf16(rs.vecIntoIter(rs.vecFrom([55296, 97, 98]))), rs.u8Rem(at(2), 3) as rs.usize); const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))]; - put(out, rs.fmtFormat([args98[0]])); - const quoted: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_219: rs.u8): rs.char => { + put(out, rs.fmtFormat([args98[0]]).v); + const _893: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_219: rs.u8): rs.char => { const _519: rs.usize = rs.u8Rem(_219, 6) as rs.usize; if (!(_519 < 6)) { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _519); } return [97, 34, 10, 769, 233, 39][_519]; - })); - const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted), rs.usizeMul(front, 2)); + }); + const quoted: rs.String = rs.stringExtendChars(rs.stringNew(), _893); + const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted.v), rs.usizeMul(front, 2)); const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part43, f, "EscapeDebug", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDebug")))]; - put(out, rs.fmtFormat([args100[0], "|", rs.fmtSpec({ alternate: true }, args100[0])])); - const part44 = fronts$adaptors_str_EscapeDefault(rs.strEscapeDefault(quoted), rs.usizeMul(front, 3)); + put(out, rs.fmtFormat([args100[0], "|", rs.fmtSpec({ alternate: true }, args100[0])]).v); + const part44 = fronts$adaptors_str_EscapeDefault(rs.strEscapeDefault(quoted.v), rs.usizeMul(front, 3)); const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part44, f, "EscapeDefault", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDefault")))]; - put(out, rs.fmtFormat([args102[0]])); - const part45 = fronts$adaptors_str_EscapeUnicode(rs.strEscapeUnicode(quoted), rs.usizeMul(front, 5)); + put(out, rs.fmtFormat([args102[0]]).v); + const part45 = fronts$adaptors_str_EscapeUnicode(rs.strEscapeUnicode(quoted.v), rs.usizeMul(front, 5)); const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeUnicode")))]; - put(out, rs.fmtFormat([args104[0], "|", rs.fmtSpec({ alternate: true }, args104[0])])); + put(out, rs.fmtFormat([args104[0], "|", rs.fmtSpec({ alternate: true }, args104[0])]).v); const base: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); base.next(); const part46 = rs.iterSkip(rs.iterMap(rs.iterBorrow(base), (b15: rs.u8): rs.u8 => { return rs.u8Add(b15, 1); }), 1); const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part46, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true }, args106[0])])); + put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true }, args106[0])]).v); const part47 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterBorrow(rs.iterSlice(units.items))), front); const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part47, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args108[0]])); + put(out, rs.fmtFormat([args108[0]]).v); const part48 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(bytes))), front); const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part48, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[0])])); + put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[0])]).v); const part49 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(rs.iterMap(rs.iterBox(rs.iterSlice(rs.byteSliceView(bytes))), (b16: rs.u8): rs.u8 => { return rs.u8Add(b16, 1); }), front); const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part49, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args112[0]])); + put(out, rs.fmtFormat([args112[0]]).v); const boxed: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))); const _1027: Countdown.Countdown = { _0: 4 }; const part50 = fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(rs.iterZip(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed))), rs.iterBox(rs.iterFrom(_1027, Countdown.next$iter_Iterator))), front); const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part50, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args114[0]])); + put(out, rs.fmtFormat([args114[0]]).v); const part51 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(rs.iterEnumerate(rs.iterMap(rs.iterFrom({ _0: rs.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rs.u8): rs.u8 => { return rs.u8Mul(n, 2); })), front); const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEnumerate(part51, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args116[0], "|", rs.fmtSpec({ alternate: true }, args116[0])])); + put(out, rs.fmtFormat([args116[0], "|", rs.fmtSpec({ alternate: true }, args116[0])]).v); if (!(rs.u8Rem(at(3), 2) === 0)) { toggle = "Done" as Toggle.Toggle; } else { @@ -2129,60 +2134,60 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { return x; }); const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part52, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])])); + put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])]).v); const part53 = rs.iterMap(rs.iterFrom(rs.place(() => toggle, (value3) => toggle = value3), Toggle.next$iter_Iterator), (x2: rs.u8): rs.u8 => { return x2; }); const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part53, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args120[0]])); + put(out, rs.fmtFormat([args120[0]]).v); let boxed2: Toggle.Toggle = toggle; const part54 = fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value5) => boxed2 = value5), Toggle.next$iter_Iterator))), (x3: rs.u8): rs.u8 => { return x3; }), front); const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part54, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0])])); + put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0])]).v); const part55 = fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(rs.iterMap(rs.iterBox(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value6) => boxed2 = value6), Toggle.next$iter_Iterator)))), (x4: rs.u8): rs.u8 => { return x4; }), front); const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part55, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args124[0]])); + put(out, rs.fmtFormat([args124[0]]).v); const part56 = fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(rs.iterMap(rs.iterBox(rs.iterFrom(rs.place(() => toggle, (value7) => toggle = value7), Toggle.next$iter_Iterator)), (x5: rs.u8): rs.u8 => { return x5; }), front); const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part56, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args126[0]])); + put(out, rs.fmtFormat([args126[0]]).v); let nested: Countdown.Countdown = { _0: rs.u8Rem(at(4), 5) }; const part57 = fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(nested, Countdown.next$iter_Iterator))), (n2: rs.u8): rs.u8 => { return n2; }), front); const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args128[0]])); + put(out, rs.fmtFormat([args128[0]]).v); const part58 = fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(rs.iterMap(rs.iterBox(rs.iterFrom({ _0: rs.u8Rem(at(5), 5) }, Countdown.next$iter_Iterator)), (n3: rs.u8): rs.u8 => { return n3; }), front); const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args130[0]])); + put(out, rs.fmtFormat([args130[0]]).v); const own: Countdown.Countdown = { _0: rs.u8Rem(at(3), 5) }; const part59 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rs.iterPeekable(rs.iterFrom(own, Countdown.next$iter_Iterator)), front); const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f), rs.u8Debug)]; - put(out, rs.fmtFormat([args132[0]])); + put(out, rs.fmtFormat([args132[0]]).v); const part60 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(rs.iterChain(rs.iterFlatMap(rs.iterSlice(lists.items), (v2: rs.ByteVec): Countdown.Countdown => { return { _0: rs.u8Rem(v2.data[rs.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rs.iterFrom(value, Countdown.next$iter_Iterator), true), rs.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part60, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args134[0]])); + put(out, rs.fmtFormat([args134[0]]).v); const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rs.iterTake(rs.iterRev(rs.iterSkip(rs.iterEnumerate(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): Pair.Pair => { return { _0: _221, _1: -1 }; })), 1)), 3), front, back); const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part61, f, "Take", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtCounted(value, f, "Skip", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtEnumerate(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; - put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args136[0])])); + put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args136[0])]).v); const it63: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))); rs.peekablePeek(it63); const part62 = rs.iterChain(rs.iterFilter(rs.iterZip(it63, new rs.RangeFrom(1, rs.u8Step), "len"), (p: [rs.u8, rs.u8]): boolean => { return p[0] !== 0; }), rs.vecIntoIter(rs.vecFrom(copy$array_tuple2_u8_u8([[9, 9] as [rs.u8, rs.u8]]).map(copy$tuple2_u8_u8)))); const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part62, f, (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtZip(value, f, (value: rs.Peekable, f: rs.Formatter) => rs.fmtPeekable(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), rs.u8Debug), (value: rs.RangeFrom, f: rs.Formatter) => rs.fmtRangeFrom(value, f, rs.u8Debug))), (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtIter(value, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f), ["IntoIter"]))]; - put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])])); + put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])]).v); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { @@ -2201,7 +2206,7 @@ export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rs.Iter } } -export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { +export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { let iterStart: rs.usize = 0; const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { @@ -2876,26 +2881,26 @@ export function fronts$adaptors_str_EscapeUnicode(it: rs.Iter, front: r * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_String(w: rs.Place, c: rs.char): rs.Result { - w.v = w.v + "ab"; +export function literals$mut_String(w: rs.String, c: rs.char): rs.Result { + rs.stringPushStr(w, "ab"); if (rs.OK.ok) { - w.v = w.v + ""; + rs.stringPushStr(w, ""); if (rs.OK.ok) { - w.v = w.v + ""; + rs.stringPushStr(w, ""); if (rs.OK.ok) { - w.v = w.v + String.fromCodePoint(c); + rs.stringPush(w, c); if (rs.OK.ok) { - w.v = w.v + "cxd"; + rs.stringPushStr(w, "cxd"); if (rs.OK.ok) { - w.v = w.v + "😀"; + rs.stringPush(w, 128512); if (rs.OK.ok) { - w.v = w.v + "\n"; + rs.stringPushStr(w, "\n"); if (rs.OK.ok) { - w.v = w.v + "{}"; + rs.stringPushStr(w, "{}"); if (rs.OK.ok) { - w.v = w.v + ""; + rs.stringPushStr(w, ""); if (rs.OK.ok) { - w.v = w.v + "end\n"; + rs.stringPushStr(w, "end\n"); return rs.OK; } return rs.Err(new rs.FmtError()); @@ -3026,26 +3031,26 @@ export function literals$mut_fmt_Twice(w: Twice.Twice, c: rs.char): rs.Result>, c: rs.char): rs.Result { - w.v.v = w.v.v + "ab"; +export function literals$mut_mut_String(w: rs.Place, c: rs.char): rs.Result { + rs.stringPushStr(w.v, "ab"); if (rs.OK.ok) { - w.v.v = w.v.v + ""; + rs.stringPushStr(w.v, ""); if (rs.OK.ok) { - w.v.v = w.v.v + ""; + rs.stringPushStr(w.v, ""); if (rs.OK.ok) { - w.v.v = w.v.v + String.fromCodePoint(c); + rs.stringPush(w.v, c); if (rs.OK.ok) { - w.v.v = w.v.v + "cxd"; + rs.stringPushStr(w.v, "cxd"); if (rs.OK.ok) { - w.v.v = w.v.v + "😀"; + rs.stringPush(w.v, 128512); if (rs.OK.ok) { - w.v.v = w.v.v + "\n"; + rs.stringPushStr(w.v, "\n"); if (rs.OK.ok) { - w.v.v = w.v.v + "{}"; + rs.stringPushStr(w.v, "{}"); if (rs.OK.ok) { - w.v.v = w.v.v + ""; + rs.stringPushStr(w.v, ""); if (rs.OK.ok) { - w.v.v = w.v.v + "end\n"; + rs.stringPushStr(w.v, "end\n"); return rs.OK; } return rs.Err(new rs.FmtError()); @@ -3103,20 +3108,18 @@ export function literals$mut_mut_fmt_Capped(w: rs.Place, c: rs.ch } /** Placeholders with options, through a writer std's impl forwards to. */ -export function placed$mut_String(w: rs.Place, n: rs.u8): rs.Result { +export function placed$mut_String(w: rs.String, n: rs.u8): rs.Result { const _8: string = "q\"é"; const _9: rs.char = 223; const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - const written = rs.fmtWriteString(w.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]); - w.v = written.s; - if (written.result.ok) { - w.v = w.v + "é"; + const _6: rs.Arguments = ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]; + if (rs.fmtWriteString(w, _6).ok) { + rs.stringPush(w, 233); if (rs.OK.ok) { const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - const written2 = rs.fmtWriteString(w.v, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); - w.v = written2.s; - return written2.result; + const _29: rs.Arguments = [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]; + return rs.fmtWriteString(w, _29); } return rs.Err(new rs.FmtError()); } @@ -3140,20 +3143,18 @@ export function placed$mut_fmt_Formatter(w: rs.Formatter, n: rs.u8): rs.Result>>, n: rs.u8): rs.Result { +export function placed$mut_mut_mut_String(w: rs.Place>, n: rs.u8): rs.Result { const _8: string = "q\"é"; const _9: rs.char = 223; const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - const written = rs.fmtWriteString(w.v.v.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]); - w.v.v.v = written.s; - if (written.result.ok) { - w.v.v.v = w.v.v.v + "é"; + const _6: rs.Arguments = ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]; + if (rs.fmtWriteString(w.v.v, _6).ok) { + rs.stringPush(w.v.v, 233); if (rs.OK.ok) { const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - const written2 = rs.fmtWriteString(w.v.v.v, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); - w.v.v.v = written2.s; - return written2.result; + const _29: rs.Arguments = [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]; + return rs.fmtWriteString(w.v.v, _29); } return rs.Err(new rs.FmtError()); } @@ -3174,39 +3175,37 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(at(0) as rs.u32, 257)), 63); - let s: string = ""; + const s: rs.String = rs.stringNew(); const _19: rs.u8 = at(1); const _25: rs.u8 = at(2); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_19, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"é", f), (f: rs.Formatter) => rs.u8LowerHex(_25, f)]; - const written = rs.fmtWriteString(s, ["a", args2[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args2[1]), "|", args2[2], "|", args2[3]]); - s = written.s; - result(out, written.result); - s = s + "\n"; + const _16: rs.Arguments = ["a", args2[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args2[1]), "|", args2[2], "|", args2[3]]; + result(out, rs.fmtWriteString(s, _16)); + rs.stringPushStr(s, "\n"); result(out, rs.OK); - s = s + String.fromCodePoint(c); + rs.stringPush(s, c); result(out, rs.OK); - s = s + "tail"; + rs.stringPushStr(s, "tail"); result(out, rs.OK); const _52: Fails.Fails = { _0: at(3) }; const _57: rs.u8 = at(4); const args4: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(_52, f), (f: rs.Formatter) => rs.u8Display(_57, f)]; - const written2 = rs.fmtWriteString(s, ["x", args4[0], "y", args4[1]]); - s = written2.s; - result(out, written2.result); - result(out, literals$mut_String(rs.place(() => s, (value) => s = value), c)); + const _49: rs.Arguments = ["x", args4[0], "y", args4[1]]; + result(out, rs.fmtWriteString(s, _49)); + result(out, literals$mut_String(s, c)); const _71: rs.u8 = at(5); - result(out, placed$mut_String(rs.place(() => s, (value2) => s = value2), _71)); - let inner: rs.Place = rs.place(() => s, (value3) => s = value3); - result(out, literals$mut_mut_String(rs.place(() => inner, (value4) => inner = value4), 223)); - let _81: rs.Place> = rs.place(() => inner, (value5) => inner = value5); + result(out, placed$mut_String(s, _71)); + let inner: rs.String = s; + result(out, literals$mut_mut_String(rs.place(() => inner, (value) => inner = value), 223)); + let _81: rs.Place = rs.place(() => inner, (value2) => inner = value2); const _82: rs.u8 = at(6); - result(out, placed$mut_mut_mut_String(rs.place(() => _81, (value6) => _81 = value6), _82)); - put(out, s); + result(out, placed$mut_mut_mut_String(rs.place(() => _81, (value3) => _81 = value3), _82)); + put(out, s.v); const _96: Placed.Placed = { _0: at(7) }; const _101: Placed.Placed = { _0: at(8) }; const args6: rs.Fmt[] = [(f: rs.Formatter) => Placed.fmt$fmt_Display(_96, f), (f: rs.Formatter) => Placed.fmt$fmt_Display(_101, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args6[1])])); - const capped: Capped.Capped = { text: "", calls: 0, cap: rs.u8Rem(at(9), 40) as rs.usize }; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args6[1])]).v); + const capped: Capped.Capped = { text: rs.stringNew(), calls: 0, cap: rs.u8Rem(at(9), 40) as rs.usize }; result(out, literals$mut_fmt_Capped(capped, c)); result(out, Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c))); result(out, Capped.writeStr$fmt_Write(capped, "z")); @@ -3216,30 +3215,30 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { const _131: rs.Arguments = [rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", args8[1], "|", rs.fmtSpec({ align: "^", width: 5 }, args8[2]), "|", args8[3]]; result(out, rs.fmtWrite((s2) => Capped.writeStr$fmt_Write(capped, s2), (c2) => Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c2)), _131)); let _156: Capped.Capped = capped; - result(out, literals$mut_mut_fmt_Capped(rs.place(() => _156, (value7) => _156 = value7), 233)); + result(out, literals$mut_mut_fmt_Capped(rs.place(() => _156, (value4) => _156 = value4), 233)); rs.byteVecPush(out, capped.calls); - put(out, capped.text); - const twice: Twice.Twice = { _0: "" }; + put(out, capped.text.v); + const twice: Twice.Twice = { _0: rs.stringNew() }; result(out, literals$mut_fmt_Twice(twice, c)); result(out, Twice.writeChar$fmt_Write(twice, 223)); - put(out, twice._0); + put(out, twice._0.v); named(out, at(12), at(13)); } /** Placeholders into writers named as the translation's own callback parameters might be. */ export function named(out: rs.ByteVec, first: rs.u8, second: rs.u8): void { - const s: Twice.Twice = { _0: "" }; - const c: Capped.Capped = { text: "", calls: 0, cap: 64 }; + const s: Twice.Twice = { _0: rs.stringNew() }; + const c: Capped.Capped = { text: rs.stringNew(), calls: 0, cap: 64 }; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtCharDisplay(120, f)]; const _11: rs.Arguments = [args2[0], rs.fmtSpec({ align: ">", width: 3 }, args2[1])]; result(out, rs.fmtWrite((s2) => Twice.writeStr$fmt_Write(s, s2), (c2) => Twice.writeChar$fmt_Write(s, c2), _11)); const _28: rs.Fmt = (f: rs.Formatter) => rs.u8Display(second, f); const arg = s._0; - const args4: rs.Fmt[] = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + const args4: rs.Fmt[] = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg.v)]; const _23: rs.Arguments = [rs.fmtSpec({ align: "<", width: 3 }, args4[0]), args4[1]]; result(out, rs.fmtWrite((s3) => Capped.writeStr$fmt_Write(c, s3), (c3) => Capped.writeStr$fmt_Write(c, String.fromCodePoint(c3)), _23)); - put(out, s._0); - put(out, c.text); + put(out, s._0.v); + put(out, c.text.v); rs.byteVecPush(out, c.calls); } @@ -3256,7 +3255,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const tags: rs.ByteVec = taken; rs.refMutRelease(_6); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(tags), f, rs.u8Debug)]; - put(out2, rs.fmtFormat([args32[0], " "])); + put(out2, rs.fmtFormat([args32[0], " "]).v); }; const shown: rs.Vec = new rs.Vec(); const written: rs.Vec = new rs.Vec(); @@ -3280,21 +3279,21 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { written.items.push(_35); } else { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(x, f)]; - const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", args2[0]]), (value: string, f: rs.Formatter) => rs.fmtPad(f, value)); + const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", args2[0]]), (value: rs.String, f: rs.Formatter) => rs.fmtPad(f, value.v)); written.items.push(_41); } } for (const _55 of shown.items) { const args4: rs.Fmt[] = [(f: rs.Formatter) => _55(f)]; - put(out, rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " "])); + put(out, rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " "]).v); } for (const _74 of written.items) { const args6: rs.Fmt[] = [(f: rs.Formatter) => _74(f)]; - put(out, rs.fmtFormat([args6[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "] "])); + put(out, rs.fmtFormat([args6[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "] "]).v); } const up: rs.Fmt = rs.fmtOwned(data.length, rs.usizeDebug); const args8: rs.Fmt[] = [(f: rs.Formatter) => up(f)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([args8[0], " "]).v); rs.dropVec(written); dropped(out); rs.vecTruncate(shown, 1, rs.drop); @@ -3310,7 +3309,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const kept: rs.Arc = rs.arcClone(shared); const _135: rs.usize = kept.strong; const args10: rs.Fmt[] = [(f: rs.Formatter) => shared.value(f), (f: rs.Formatter) => rs.usizeDisplay(_135, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " "])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " "]).v); const counted: rs.Arc = new rs.Arc(dropper(data.data[data.start])); const _149: rs.Arc = rs.arcClone(counted); const asDisplay: rs.Arc = new rs.ArcDyn(_149, rs.fmtOwned(_149.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop)); @@ -3318,7 +3317,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const asDebug: rs.Arc = new rs.ArcDyn(counted, rs.fmtOwned(counted.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop)); const _160: rs.usize = asDebug.strong; const args12: rs.Fmt[] = [(f: rs.Formatter) => asDisplay.value(f), (f: rs.Formatter) => rs.usizeDisplay(_160, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args12[0]), "| ", args12[1], " "])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args12[0]), "| ", args12[1], " "]).v); asDisplay[Symbol.dispose](); dropped(out); if (rs.u8Rem(b, 2) === 0) { @@ -3326,27 +3325,26 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { asDebug[Symbol.dispose](); } else { const args14: rs.Fmt[] = [(f: rs.Formatter) => asDebug.value(f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([args14[0], " "]).v); } dropped(out); shared[Symbol.dispose](); const _198: rs.usize = kept.strong; const args16: rs.Fmt[] = [(f: rs.Formatter) => kept.value(f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " "])); + put(out, rs.fmtFormat([args16[0], " ", args16[1], " "]).v); let n: rs.u8 = rs.u8WrappingMul(data.data[data.start], 3); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - let text: string = rs.fmtFormat(["t", args18[0]]); + const text: rs.String = rs.fmtFormat(["t", args18[0]]); const owned: Dropper.Dropper = dropper(b); const part5 = rs.u8WrappingAdd(b, 1); let boxed: rs.Fmt = rs.fmtOwned(dropper(part5), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop); const cell: rs.Cell = new rs.Cell(data.data[data.start]); const pair: [fmt_Gauge.Gauge, rs.u8] = [{ _0: cell }, b]; const _237: rs.Place = rs.place(() => n, (value) => n = value); - const arg = rs.place(() => text, (value2) => text = value2); - const _238: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(arg.v, f); + const _238: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(text.v, f); const _240: rs.Fmt = (f: rs.Formatter) => Dropper.fmt$fmt_Debug(owned, f); - const arg2 = rs.place(() => boxed, (value3) => boxed = value3); - const objects: rs.Vec = rs.vecFrom([(f: rs.Formatter) => rs.u8Debug(_237.v, f), _238, _240, (f: rs.Formatter) => arg2.v(f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => fmt_Gauge.fmt$fmt_Debug(pair[0], f), (f: rs.Formatter) => rs.u8Debug(pair[1], f)], f)]); + const arg = rs.place(() => boxed, (value2) => boxed = value2); + const objects: rs.Vec = rs.vecFrom([(f: rs.Formatter) => rs.u8Debug(_237.v, f), _238, _240, (f: rs.Formatter) => arg.v(f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => fmt_Gauge.fmt$fmt_Debug(pair[0], f), (f: rs.Formatter) => rs.u8Debug(pair[1], f)], f)]); const iter4: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(objects.items)); while (true) { const _251: rs.Place | rs.Done = iter4.next(); @@ -3354,28 +3352,27 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const args20: rs.Fmt[] = [(f: rs.Formatter) => _251.v(f)]; - put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " "])); + put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " "]).v); } const _269: rs.u8 = rs.u8WrappingAdd(cell.v, 1); rs.cellSet(cell, _269); const again: rs.Fmt = objects.items[rs.idx(objects.items, 4)]; const args22: rs.Fmt[] = [(f: rs.Formatter) => again(f)]; - put(out, rs.fmtFormat([args22[0], " "])); + put(out, rs.fmtFormat([args22[0], " "]).v); const args24: rs.Fmt[] = [(f: rs.Formatter) => again(f)]; - put(out, rs.fmtFormat([args24[0], " "])); + put(out, rs.fmtFormat([args24[0], " "]).v); n = rs.u8WrappingAdd(n, 1); - const _304: rs.Place = rs.place(() => n, (value4) => n = value4); + const _304: rs.Place = rs.place(() => n, (value3) => n = value3); const part6 = (f: rs.Formatter) => rs.u8Display(_304.v, f); const args26: rs.Fmt[] = [(f: rs.Formatter) => part6(f)]; - put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, args26[0]), "] "])); + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, args26[0]), "] "]).v); const part7 = (f: rs.Formatter) => Dropper.fmt$fmt_Display(owned, f); const args28: rs.Fmt[] = [(f: rs.Formatter) => part7(f)]; - put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, args28[0]), "] "])); - text = text + "!"; - const arg3 = rs.place(() => text, (value5) => text = value5); - const part8 = (f: rs.Formatter) => rs.fmtPad(f, arg3.v); + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, args28[0]), "] "]).v); + rs.stringPush(text, 33); + const part8 = (f: rs.Formatter) => rs.fmtPad(f, text.v); const args30: rs.Fmt[] = [(f: rs.Formatter) => part8(f)]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([args30[0], " "]).v); rs.drop(boxed); dropped(out); owned[Symbol.dispose](); @@ -3408,25 +3405,25 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const bytes: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 7)); const part2 = fronts$sources_iter_Once_u8(rs.iterOnce(b), rs.usizeRem(front, 2)); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part2, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])]).v); const part3 = rs.iterOnce(thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: -1 })); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part3, f, (value: Pair.Pair | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])]).v); const maybe: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); const _72: rs.Iter = rs.iterOption(maybe); const _75: rs.Iter = rs.iterOption(maybe); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_72, f, rs.u8Debug, [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_75, f, rs.u8Debug, [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[1])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[1])]).v); const pair: Pair.Pair | undefined = thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: 2 }); const part4 = fronts$sources_option_Iter_fmt_Pair(rs.iterOption(pair), rs.usizeRem(front, 2)); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part4, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([args8[0]]).v); const part5 = rs.iterOption(pair); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part5, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([args10[0]]).v); const part6 = rs.iterOption(pair); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part6, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([args12[0]]).v); const _132: Array = [rs.None, undefined, b]; const _138: rs.usize = rs.u8Rem(b, 3) as rs.usize; if (!(_138 < 3)) { @@ -3436,11 +3433,11 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _150: rs.Iter = rs.iterOption(nested, undefined, rs.None); const _153: rs.Iter = rs.iterOption(nested, undefined, rs.None); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_150, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_153, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ debugHex: "x" }, args14[1])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ debugHex: "x" }, args14[1])]).v); let mine: rs.u8 | undefined = maybe; const part7 = fronts$sources_option_IterMut_u8(rs.iterOption(mine === undefined ? undefined : rs.place(() => mine as rs.u8, (value) => mine = value)), rs.usizeRem(front, 2)); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part7, f, (value: rs.Place, f: rs.Formatter) => rs.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([args16[0]]).v); if (!(rs.u8Rem(b, 2) === 0)) { result = rs.Err({ _0: b, _1: 3 }); } else { @@ -3449,7 +3446,7 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Iter = rs.iterResult(result); const _193: rs.Iter = rs.iterResult(result); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_190, f, rs.u8Debug, [["Iter", "inner"]]), (f: rs.Formatter) => rs.fmtIterOption(_193, f, rs.u8Debug, [["IntoIter", "inner"]])]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])]).v); if (!(rs.u8Rem(b, 3) === 0)) { held = rs.Ok({ _0: b, _1: 4 }); } else { @@ -3457,45 +3454,45 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { } const part8 = fronts$sources_result_IterMut_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([args20[0]]).v); const part9 = fronts$sources_result_IntoIter_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part9, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([args22[0]]).v); const _243: rs.u8 = at(3); const _246: rs.u8 = at(4); const _249: rs.u8 = at(5); const part10 = ends$sources_array_IntoIter_u8_4(rs.iterSlice(Uint8Array.of(b, _243, _246, _249)), front, back); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part10, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args24[0])])); + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args24[0])]).v); const part11 = ends$sources_array_IntoIter_fmt_Pair_2(rs.iterSlice([{ _0: b, _1: 5 }, { _0: at(3), _1: 6 }]), rs.usizeRem(front, 3), rs.usizeRem(back, 2)); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part11, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])])); + put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])]).v); const part12 = rs.iterSlice(Uint8Array.of()); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part12, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args28[0]])); + put(out, rs.fmtFormat([args28[0]]).v); let n: rs.i32 = 0; const it5: rs.Iter = rs.iterFromFn((): rs.i32 | undefined => { n = rs.i32Add(n, 1); return thenSome$05ku0zn(n < 3, n); }); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn")]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])])); + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])]).v); const part13 = rs.iterTake(it5, 2); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (_value: rs.Iter, f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn"))]; - put(out, rs.fmtFormat([args32[0]])); + put(out, rs.fmtFormat([args32[0]]).v); const it6: rs.Iter = rs.iterRepeatWith((): rs.u8 => { return b; }); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])])); + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])]).v); const part14 = rs.iterSkip(it6, 1); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part14, f, "Skip", (_value: rs.Iter, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith")))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args36[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args36[0])]).v); const part15 = fronts$sources_iter_Successors_u8_fmt_sources_closure3(rs.iterSuccessors(b, (_22: rs.u8): rs.u8 | undefined => { return rs.u8CheckedAdd(_22, 100); }), front); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSuccessors(part15, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0])])); + put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0])]).v); const part16 = fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(rs.iterSuccessors(b as rs.u8 | undefined | rs.None, (_26: rs.u8 | undefined): rs.u8 | undefined | rs.None => { return option_andThen$0jc4o0i(_26, (x3: rs.u8): rs.u8 | undefined | rs.None => { return option_map$02rrcvu(rs.u8CheckedSub(x3, 100), (a0: rs.u8): rs.u8 | undefined => { @@ -3504,162 +3501,162 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { }); }, undefined, rs.None), front); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSuccessors(part16, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([args40[0]]).v); const part17 = rs.iterMap(rs.iterChain(rs.iterOnce(b), rs.iterSlice(Uint8Array.of(at(3), at(4)))), (x4: rs.u8): rs.u8 => { return rs.u8Div(x4, 2); }); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part17, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtChain(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIterOption(value, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"])))]; - put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])])); + put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])]).v); const part18 = rs.iterRepeat(b); const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeat(part18, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args44[0], "|", rs.fmtSpec({ alternate: true }, args44[0]), "|", rs.fmtSpec({ debugHex: "x" }, args44[0])])); + put(out, rs.fmtFormat([args44[0], "|", rs.fmtSpec({ alternate: true }, args44[0]), "|", rs.fmtSpec({ debugHex: "x" }, args44[0])]).v); const part19 = ends$sources_iter_Take_iter_Repeat_fmt_Pair(rs.iterTake(rs.iterRepeat({ _0: b, _1: 7 }), 3), front, back); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part19, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtRepeat(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([args46[0]]).v); const n2: rs.usize = rs.u8Rem(at(3), 4) as rs.usize; const part20 = ends$sources_iter_RepeatN_u8(rs.iterRepeatN(b, n2), front, back); const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeatN(part20, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args48[0], "|", rs.fmtSpec({ alternate: true }, args48[0])])); + put(out, rs.fmtFormat([args48[0], "|", rs.fmtSpec({ alternate: true }, args48[0])]).v); const it12: rs.Iter = rs.iterRepeatN({ _0: b, _1: 8 }, n2); const _464: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; rs.iterNth(it12, _464); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeatN(it12, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])])); + put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])]).v); const part21 = ends$sources_iter_OnceWith_fmt_sources_closure6(rs.iterOnceWith((): rs.u8 => { return b; }), rs.usizeRem(front, 2), rs.usizeRem(back, 2)); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOnceWith(part21, f)]; - put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[0])])); - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { + put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[0])]).v); + const _503: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_212, 5) as rs.usize; if (!(_54 < 5)) { rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _54); } return [97, 233, 20013, 129408, 10][_54]; - })); - const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text), front, back); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _503); + const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text.v), front, back); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharIndices(part22, f)]; - put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0]), "|", rs.fmtSpec({ debugHex: "x" }, args54[0])])); - let drained: string = text; - const it15: rs.Iter = ends$sources_string_Drain(rs.stringDrain(rs.place(() => drained, (value3) => drained = value3), undefined), front, back); + put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0]), "|", rs.fmtSpec({ debugHex: "x" }, args54[0])]).v); + const it15: rs.Iter = ends$sources_string_Drain(rs.stringDrain(rs.stringClone(text), undefined), front, back); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStringDrain(it15, f)]; - put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])])); + put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])]).v); rs.drop(it15); const size: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); const part23 = ends$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), front, back); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part23, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0]), "|", rs.fmtSpec({ debugHex: "x" }, args58[0])])); + put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0]), "|", rs.fmtSpec({ debugHex: "x" }, args58[0])]).v); const it17: rs.Iter = rs.byteSliceWindows(bytes, size); const _564: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; rs.iterNth(it17, _564); const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it17, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args60[0]])); + put(out, rs.fmtFormat([args60[0]]).v); const it18: rs.Iter = fronts$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), 8); const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args62[0]])); + put(out, rs.fmtFormat([args62[0]]).v); rs.iterToOption(it18.nextBack()); const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args64[0]])); + put(out, rs.fmtFormat([args64[0]]).v); const it19: rs.Iter = rs.byteSliceWindows(bytes, size); const _613: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; rs.iterNthBack(it19, _613); const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it19, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args66[0]])); + put(out, rs.fmtFormat([args66[0]]).v); const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.u16 => { return rs.u16Mul(_213 as rs.u16, 257); }), undefined, 2, true); const part24 = ends$sources_slice_Windows_u16(rs.sliceWindows(rs.sliceFrom(wide.items), size), front, back); const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part24, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Windows")]; - put(out, rs.fmtFormat([args68[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args68[0])])); + put(out, rs.fmtFormat([args68[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args68[0])]).v); const part25 = ends$sources_slice_Chunks_u8(rs.byteSliceChunks(bytes, size), front, back); const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part25, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Chunks")]; - put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])])); + put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])]).v); const part26 = ends$sources_slice_ChunksExact_u16(rs.sliceChunksExact(rs.sliceFrom(wide.items), size), front, back); const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part26, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "ChunksExact")]; - put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])])); + put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])]).v); const part27 = ends$sources_slice_ChunksExact_u8(rs.byteSliceChunksExact(bytes, size), front, back); const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part27, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "ChunksExact")]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([args74[0]]).v); const part28 = ends$sources_slice_RChunks_u16(rs.sliceRchunks(rs.sliceFrom(wide.items), size), front, back); const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part28, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunks")]; - put(out, rs.fmtFormat([args76[0]])); + put(out, rs.fmtFormat([args76[0]]).v); const part29 = ends$sources_slice_RChunks_u8(rs.byteSliceRchunks(bytes, size), front, back); const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part29, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunks")]; - put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[0])])); + put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[0])]).v); const part30 = ends$sources_slice_RChunksExact_u8(rs.byteSliceRchunksExact(bytes, size), front, back); const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part30, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunksExact")]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([args80[0]]).v); const it27: rs.Iter> = rs.sliceRchunksExact(rs.sliceFrom(wide.items), size); const _743: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; rs.iterNth(it27, _743); const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it27, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunksExact")]; - put(out, rs.fmtFormat([args82[0]])); + put(out, rs.fmtFormat([args82[0]]).v); const part31 = ends$sources_slice_Split_u8_fmt_sources_closure9(rs.byteSliceSplit(bytes, (x5: rs.u8): boolean => { return rs.u8Rem(x5, 3) === 0; }), front, back); const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part31, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false)]; - put(out, rs.fmtFormat([args84[0], "|", rs.fmtSpec({ alternate: true }, args84[0]), "|", rs.fmtSpec({ debugHex: "x" }, args84[0])])); + put(out, rs.fmtFormat([args84[0], "|", rs.fmtSpec({ alternate: true }, args84[0]), "|", rs.fmtSpec({ debugHex: "x" }, args84[0])]).v); const part32 = ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(bytes, (x6: rs.u8): boolean => { return rs.u8Rem(x6, 3) === 0; }), front, back); const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part32, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusive", false)]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([args86[0]]).v); const part33 = ends$sources_slice_RSplit_u8_fmt_sources_closure9(rs.byteSliceRsplit(bytes, (x7: rs.u8): boolean => { return rs.u8Rem(x7, 3) === 0; }), front, back); const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part33, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false)]; - put(out, rs.fmtFormat([args88[0]])); + put(out, rs.fmtFormat([args88[0]]).v); const part34 = fronts$sources_slice_SplitN_u8_fmt_sources_closure9(rs.byteSliceSplitn(bytes, rs.u8Rem(at(4), 4) as rs.usize, (x8: rs.u8): boolean => { return rs.u8Rem(x8, 3) === 0; }), front); const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part34, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false, "SplitN")]; - put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])]).v); const part35 = fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(rs.byteSliceRsplitn(bytes, 2, (x9: rs.u8): boolean => { return rs.u8Rem(x9, 3) === 0; }), front); const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part35, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false, "RSplitN")]; - put(out, rs.fmtFormat([args92[0]])); + put(out, rs.fmtFormat([args92[0]]).v); const part36 = ends$sources_slice_Split_u16_fmt_sources_closure10(rs.sliceSplit(rs.sliceFrom(wide.items), (x10: rs.u16): boolean => { return rs.u16Rem(x10, 3) === 0; }), front, back); const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part36, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false)]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([args94[0]]).v); const part37 = fronts$sources_slice_SplitN_u16_fmt_sources_closure10(rs.sliceSplitn(rs.sliceFrom(wide.items), 2, (x11: rs.u16): boolean => { return rs.u16Rem(x11, 3) === 0; }), front); const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part37, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false, "SplitN")]; - put(out, rs.fmtFormat([args96[0]])); + put(out, rs.fmtFormat([args96[0]]).v); const owned: rs.ByteVec = rs.byteSliceToByteVec(bytes); const part38 = ends$sources_slice_SplitMut_u8_fmt_sources_closure9(rs.byteSliceSplit(rs.byteVecSlice(owned), (x12: rs.u8): boolean => { return rs.u8Rem(x12, 3) === 0; }), front, back); const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part38, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true)]; - put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])])); + put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])]).v); const part39 = ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(rs.byteVecSlice(owned), (x13: rs.u8): boolean => { return rs.u8Rem(x13, 3) === 0; }), front, back); const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part39, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusiveMut", true)]; - put(out, rs.fmtFormat([args100[0]])); + put(out, rs.fmtFormat([args100[0]]).v); const part40 = ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(rs.byteSliceRsplit(rs.byteVecSlice(owned), (x14: rs.u8): boolean => { return rs.u8Rem(x14, 3) === 0; }), front, back); const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part40, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true)]; - put(out, rs.fmtFormat([args102[0]])); + put(out, rs.fmtFormat([args102[0]]).v); const part41 = fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(rs.byteSliceSplitn(rs.byteVecSlice(owned), 2, (x15: rs.u8): boolean => { return rs.u8Rem(x15, 3) === 0; }), front); const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part41, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true, "SplitNMut")]; - put(out, rs.fmtFormat([args104[0]])); + put(out, rs.fmtFormat([args104[0]]).v); const part42 = fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(rs.byteSliceRsplitn(rs.byteVecSlice(owned), rs.u8Rem(at(4), 4) as rs.usize, (x16: rs.u8): boolean => { return rs.u8Rem(x16, 3) === 0; }), front); const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part42, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true, "RSplitNMut")]; - put(out, rs.fmtFormat([args106[0]])); + put(out, rs.fmtFormat([args106[0]]).v); const part43 = ends$sources_slice_SplitMut_u16_fmt_sources_closure10(rs.sliceSplit(rs.sliceFrom(rs.vecFrom(wide.items.slice()).items), (x17: rs.u16): boolean => { return rs.u16Rem(x17, 3) === 0; }), front, back); const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part43, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "SplitMut", true)]; - put(out, rs.fmtFormat([args108[0]])); + put(out, rs.fmtFormat([args108[0]]).v); const _976: [rs.HashSet, rs.HashSet] = [rs.hashNew() as rs.HashSet, rs.hashNew() as rs.HashSet]; const one: rs.HashSet = _976[0]; const other: rs.HashSet = _976[1]; @@ -3674,7 +3671,7 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _1005: rs.Iter = rs.hashSymmetricDifference(one, other); const _1009: rs.Iter = rs.hashUnion(one, other); const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterClone(_997, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1001, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1005, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1009, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1]), "|", args110[2], "|", args110[3]])); + put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1]), "|", args110[2], "|", args110[3]]).v); } export function ends$sources_array_IntoIter_fmt_Pair_2(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { @@ -4220,16 +4217,16 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { } const part = fronts$sets_collections_btree_set_Difference_u8(rs.btreeDifference(_69[0], _69[1]), front); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part, f, rs.u8Debug, "Difference")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0])]).v); const part2 = fronts$sets_collections_btree_set_Intersection_u8(rs.btreeIntersection(_69[0], _69[1]), front); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part2, f, rs.u8Debug, "Intersection")]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])]).v); const part3 = fronts$sets_collections_btree_set_Union_u8(rs.btreeUnion(_69[0], _69[1]), front); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part3, f, rs.u8Debug, "Union")]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])]).v); const part4 = fronts$sets_collections_btree_set_SymmetricDifference_u8(rs.btreeSymmetricDifference(_69[0], _69[1]), front); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part4, f, rs.u8Debug, "SymmetricDifference")]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0])])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0])]).v); } const _131: rs.Iter<[rs.u8, rs.char]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_23: rs.u8): [rs.u8, rs.char] => { return [rs.u8Rem(_23, 4), 112] as [rs.u8, rs.char]; @@ -4241,16 +4238,16 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { const more: rs.BTreeSet<[rs.u8, rs.char]> = rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.char]>, _135, true, undefined, undefined, 8, true); const part5 = fronts$sets_collections_btree_set_Union_tuple2_u8_char(rs.btreeUnion(pairs, more), front); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part5, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Union")]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ debugHex: "x" }, args10[0])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ debugHex: "x" }, args10[0])]).v); const part6 = fronts$sets_collections_btree_set_Difference_tuple2_u8_char(rs.btreeDifference(pairs, more), front); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part6, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Difference")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])]).v); const _172: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); const it7: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(rs.listExtractIfMut(rs.listExtend(rs.listNew() as rs.LinkedList, _172), (x4: rs.Place): boolean => { return rs.u8Rem(x4.v, 2) === 0; }), front); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtListExtractIf(it7, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ debugHex: "x" }, args14[0])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ debugHex: "x" }, args14[0])]).v); const _192: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_210: rs.u8): Pair.Pair => { return { _0: _210, _1: 2 }; }); @@ -4258,7 +4255,7 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u8Rem(p._0, 3) === 0; }), front); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([args16[0]]).v); const _212: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8] => { const x6: rs.u8 = _211; return [x6, x6] as [rs.u8, rs.u8]; @@ -4273,7 +4270,7 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { return k2 > 9; }); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf"))]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])]).v); } export function fronts$sets_collections_btree_set_Difference_tuple2_u8_char(it: rs.Iter<[rs.u8, rs.char]>, front: rs.usize): rs.Iter<[rs.u8, rs.char]> { @@ -4382,8 +4379,8 @@ export function passed(out: rs.ByteVec, budget: rs.usize, args: rs.Arguments): v } else { _23 = 43; } - log.text = log.text + String.fromCodePoint(_23); - put(out, log.text); + rs.stringPush(log.text, _23); + put(out, log.text.v); } const log2: Log.Log = Log.new(budget); if (!rs.fmtWrite((s2) => Log.writeStr$fmt_Write(log2, s2), (c2) => Log.writeChar$fmt_Write(log2, c2), args).ok) { @@ -4391,8 +4388,8 @@ export function passed(out: rs.ByteVec, budget: rs.usize, args: rs.Arguments): v } else { _34 = 43; } - log2.text = log2.text + String.fromCodePoint(_34); - put(out, log2.text); + rs.stringPush(log2.text, _34); + put(out, log2.text.v); } /** @@ -4437,8 +4434,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _56 = 43; } - log.text = log.text + String.fromCodePoint(_56); - put(out, log.text); + rs.stringPush(log.text, _56); + put(out, log.text.v); } const w: rs.u64 = rs.u64FromBeBytes(Uint8Array.of(at(6), at(7), at(8), at(9), at(1), at(2), at(3), at(4))); const n: rs.i128 = rs.i128Mul(v as rs.i128, rs.i128Neg(rs.i128Shl(1, 70))); @@ -4458,8 +4455,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _132 = 43; } - log2.text = log2.text + String.fromCodePoint(_132); - put(out, log2.text); + rs.stringPush(log2.text, _132); + put(out, log2.text.v); } const _139: rs.u8 = rs.u8Rem(at(10), 9); if (_139 === 0) { @@ -4495,8 +4492,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _166 = 43; } - log3.text = log3.text + String.fromCodePoint(_166); - put(out, log3.text); + rs.stringPush(log3.text, _166); + put(out, log3.text.v); } const y: rs.f32 = Math.fround(x); const iter4: rs.Iter = rs.iterSlice([4294967295, budget]); @@ -4513,8 +4510,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _198 = 43; } - log4.text = log4.text + String.fromCodePoint(_198); - put(out, log4.text); + rs.stringPush(log4.text, _198); + put(out, log4.text.v); } const _206: rs.usize = rs.usizeRem(at(11) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_206 < 14)) { @@ -4537,8 +4534,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _265 = 43; } - log5.text = log5.text + String.fromCodePoint(_265); - put(out, log5.text); + rs.stringPush(log5.text, _265); + put(out, log5.text.v); } const value: Nested.Nested = nested(data); const iter6: rs.Iter = rs.iterSlice([4294967295, budget]); @@ -4555,8 +4552,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _291 = 43; } - log6.text = log6.text + String.fromCodePoint(_291); - put(out, log6.text); + rs.stringPush(log6.text, _291); + put(out, log6.text.v); } const iter7: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { @@ -4572,8 +4569,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _316 = 43; } - log7.text = log7.text + String.fromCodePoint(_316); - put(out, log7.text); + rs.stringPush(log7.text, _316); + put(out, log7.text.v); } const manual: Manual.Manual = { id: at(14), list: rs.vecFrom([1, 2].slice()) }; const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(15), _1: -2 }].slice()) }; @@ -4596,8 +4593,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _378 = 43; } - log8.text = log8.text + String.fromCodePoint(_378); - put(out, log8.text); + rs.stringPush(log8.text, _378); + put(out, log8.text.v); } const _385: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_2: rs.u8): [rs.u8, string] => { return [rs.u8Rem(_2, 8), "v"] as [rs.u8, string]; @@ -4630,8 +4627,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _450 = 43; } - log9.text = log9.text + String.fromCodePoint(_450); - put(out, log9.text); + rs.stringPush(log9.text, _450); + put(out, log9.text.v); } const bytes: rs.Iter = rs.byteSliceEscapeAscii(data); if (rs.u8Rem(at(21), 2) === 0) { @@ -4664,8 +4661,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _524 = 43; } - log10.text = log10.text + String.fromCodePoint(_524); - put(out, log10.text); + rs.stringPush(log10.text, _524); + put(out, log10.text.v); } const d: rs.Duration = rs.durationNew(rs.u64Mul(rs.u8Rem(at(23), 3) as rs.u64, at(24) as rs.u64), rs.u32Rem((at(25) << 16) | (at(26) << 8) | at(27), 1000000000)); const iter12: rs.Iter = rs.iterSlice([4294967295, budget]); @@ -4682,8 +4679,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _575 = 43; } - log11.text = log11.text + String.fromCodePoint(_575); - put(out, log11.text); + rs.stringPush(log11.text, _575); + put(out, log11.text.v); } const _581: rs.Result = rs.strFromUtf8(data); if (_581.ok) { @@ -4702,8 +4699,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _603 = 43; } - log12.text = log12.text + String.fromCodePoint(_603); - put(out, log12.text); + rs.stringPush(log12.text, _603); + put(out, log12.text.v); } } else { const e: rs.Utf8Error = _581.error; @@ -4722,8 +4719,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _633 = 43; } - log13.text = log13.text + String.fromCodePoint(_633); - put(out, log13.text); + rs.stringPush(log13.text, _633); + put(out, log13.text.v); } } const _643: rs.Result = rs.strFromUtf8(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(97, 230, 151, at(32))), 0, rs.usizeAdd(3, rs.u8Rem(at(32), 2) as rs.usize))); @@ -4743,8 +4740,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _676 = 43; } - log14.text = log14.text + String.fromCodePoint(_676); - put(out, log14.text); + rs.stringPush(log14.text, _676); + put(out, log14.text.v); } } const layout: rs.Layout = rs.resultUnwrap(rs.layoutFromSizeAlign(at(28) as rs.usize, rs.usizeShl(1, rs.u8Rem(at(29), 8))), rs.fmtLayoutErrorDebug); @@ -4769,8 +4766,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _740 = 43; } - log15.text = log15.text + String.fromCodePoint(_740); - put(out, log15.text); + rs.stringPush(log15.text, _740); + put(out, log15.text.v); } const iter17: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { @@ -4789,8 +4786,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _775 = 43; } - log16.text = log16.text + String.fromCodePoint(_775); - put(out, log16.text); + rs.stringPush(log16.text, _775); + put(out, log16.text.v); } const _785: Pair.Pair = { _0: at(31), _1: 1 }; const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_785, f), (f: rs.Formatter) => rs.fmtStr(s, f)]; @@ -4824,8 +4821,8 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _48 = 43; } - setter.log.text = setter.log.text + String.fromCodePoint(_48); - put(out, setter.log.text); + rs.stringPush(setter.log.text, _48); + put(out, setter.log.text.v); } /** @@ -4841,13 +4838,14 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const front: rs.usize = _6[0]; const back: rs.usize = _6[1]; const rest: rs.ByteSlice = option_unwrapOrDefault$0avqj0t(rs.byteSliceGetRange(data, 4)); - const text2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { + const _23: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { const _5: rs.usize = rs.u8Rem(_2, 9) as rs.usize; if (!(_5 < 9)) { rs.panic("index out of bounds: the len is " + 9 + " but the index is " + _5); } return [97, 98, 233, 129408, 32, 10, 13, 12288, 9][_5]; - })); + }); + const text2: string = rs.stringExtendChars(rs.stringNew(), _23).v; const _30: rs.usize = rs.u8Rem(at(2), 4) as rs.usize; if (!(_30 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); @@ -4855,64 +4853,65 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const c: rs.char = [97, 233, 129408, 32][_30]; const part = ends$searches_str_Split_char(rs.strSplit(text2, String.fromCodePoint(c)), front, back); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part, f, "Split", "CharSearcher")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])]).v); const part2 = ends$searches_str_RSplit_char(rs.strRsplit(text2, String.fromCodePoint(c)), front, back); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part2, f, "RSplit", "CharSearcher")]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([args4[0]]).v); const part3 = ends$searches_str_SplitTerminator_char(rs.strSplitTerminator(text2, String.fromCodePoint(c)), front, back); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([args6[0]]).v); const part4 = ends$searches_str_RSplitTerminator_char(rs.strRsplitTerminator(text2, String.fromCodePoint(c)), front, back); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([args8[0]]).v); const part5 = fronts$searches_str_SplitN_char(rs.strSplitn(text2, rs.u8Rem(at(3), 4) as rs.usize, String.fromCodePoint(c)), front); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part5, f, "SplitN", "CharSearcher")]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([args10[0]]).v); const part6 = fronts$searches_str_RSplitN_char(rs.strRsplitn(text2, 2, String.fromCodePoint(c)), front); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part6, f, "RSplitN", "CharSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])]).v); const part7 = ends$searches_str_SplitInclusive_char(rs.strSplitInclusive(text2, String.fromCodePoint(c)), front, back); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([args14[0]]).v); const part8 = ends$searches_str_Matches_char(rs.strMatches(text2, String.fromCodePoint(c)), front, back); const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part8, f, "Matches", "CharSearcher")]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([args16[0]]).v); const part9 = ends$searches_str_RMatches_char(rs.strRmatches(text2, String.fromCodePoint(c)), front, back); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part9, f, "RMatches", "CharSearcher")]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([args18[0]]).v); const part10 = ends$searches_str_MatchIndices_char(rs.strMatchIndices(text2, String.fromCodePoint(c)), front, back); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args20[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args20[0])]).v); const part11 = ends$searches_str_RMatchIndices_char(rs.strRmatchIndices(text2, String.fromCodePoint(c)), front, back); const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([args22[0]]).v); const set: rs.char[] = [c, 98]; const part12 = ends$searches_str_Split_array2_char(rs.strSplit(text2, rs.patternChars(set)), front, back); const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part12, f, "Split", "CharArraySearcher")]; - put(out, rs.fmtFormat([args24[0]])); + put(out, rs.fmtFormat([args24[0]]).v); const part13 = ends$searches_str_Matches_ref_array2_char(rs.strMatches(text2, rs.patternChars(set)), front, back); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args26[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args26[0])]).v); const part14 = ends$searches_str_RSplit_ref_slice_char(rs.strRsplit(text2, rs.patternChars(rs.sliceItems(rs.sliceRange(rs.sliceFrom(set), 0, 1)))), front, back); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")]; - put(out, rs.fmtFormat([args28[0]])); + put(out, rs.fmtFormat([args28[0]]).v); const part15 = ends$searches_str_Split_fmt_searches_closure3(rs.strSplit(text2, (x: rs.char): boolean => { return x === c; }), front, back); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")]; - put(out, rs.fmtFormat([args30[0]])); + put(out, rs.fmtFormat([args30[0]]).v); const part16 = ends$searches_str_MatchIndices_char_is_whitespace(rs.strMatchIndices(text2, (a0: rs.char): boolean => { return rs.charIsWhitespace(a0); }), front, back); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args32[0])])); - const few2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args32[0])]).v); + const _275: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { const _53: rs.usize = rs.u8Rem(_22, 3) as rs.usize; if (!(_53 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _53); } return [97, 98, 233][_53]; - })); + }); + const few2: string = rs.stringExtendChars(rs.stringNew(), _275).v; const _291: rs.usize = rs.u8Rem(at(2), 10) as rs.usize; if (!(_291 < 10)) { rs.panic("index out of bounds: the len is " + 10 + " but the index is " + _291); @@ -4920,60 +4919,60 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const _281: string[] = ["", "a", "aa", "ab", "aab", "aba", "abab", "bé", "aaba", "éaé"]; const part17 = fronts$searches_str_Split_ref_str(rs.strSplit(few2, _281[_291]), front); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part17, f, "Split", "StrSearcher")]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])])); + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])]).v); const part18 = fronts$searches_str_RSplit_ref_str(rs.strRsplit(few2, _281[_291]), front); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part18, f, "RSplit", "StrSearcher")]; - put(out, rs.fmtFormat([args36[0]])); + put(out, rs.fmtFormat([args36[0]]).v); const part19 = fronts$searches_str_SplitTerminator_ref_str(rs.strSplitTerminator(few2, _281[_291]), front); const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")]; - put(out, rs.fmtFormat([args38[0]])); + put(out, rs.fmtFormat([args38[0]]).v); const part20 = fronts$searches_str_SplitN_ref_str(rs.strSplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part20, f, "SplitN", "StrSearcher")]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([args40[0]]).v); const part21 = fronts$searches_str_RSplitN_ref_str(rs.strRsplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([args42[0]]).v); const part22 = fronts$searches_str_SplitInclusive_ref_str(rs.strSplitInclusive(few2, _281[_291]), front); const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([args44[0]]).v); const part23 = fronts$searches_str_Matches_ref_str(rs.strMatches(few2, _281[_291]), rs.usizeMul(front, 2)); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part23, f, "Matches", "StrSearcher")]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([args46[0]]).v); const part24 = fronts$searches_str_RMatches_ref_str(rs.strRmatches(few2, _281[_291]), rs.usizeMul(front, 2)); const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part24, f, "RMatches", "StrSearcher")]; - put(out, rs.fmtFormat([args48[0]])); + put(out, rs.fmtFormat([args48[0]]).v); const part25 = fronts$searches_str_MatchIndices_ref_str(rs.strMatchIndices(few2, _281[_291]), front); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([args50[0]]).v); const part26 = fronts$searches_str_RMatchIndices_ref_str(rs.strRmatchIndices(few2, _281[_291]), front); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args52[0])])); - const part27 = fronts$searches_str_Split_ref_String(rs.strSplit(text2, _281[_291]), front); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args52[0])]).v); + const part27 = fronts$searches_str_Split_ref_String(rs.strSplit(text2, rs.stringFrom(_281[_291]).v), front); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part27, f, "Split", "StrSearcher")]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([args54[0]]).v); const it3: rs.Iter = rs.strMatches(few2, _281[_291]); while (rs.iterToOption(it3.next()) !== undefined) { } const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; - put(out, rs.fmtFormat([args56[0]])); + put(out, rs.fmtFormat([args56[0]]).v); it3.next(); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; - put(out, rs.fmtFormat([args58[0]])); + put(out, rs.fmtFormat([args58[0]]).v); const it4: rs.Iter<[rs.usize, string]> = rs.strRmatchIndices(few2, _281[_291]); while (rs.iterToOption(it4.next()) !== undefined) { } const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")]; - put(out, rs.fmtFormat([args60[0]])); + put(out, rs.fmtFormat([args60[0]]).v); const part28 = ends$searches_str_Lines(rs.strLines(text2), front, back); const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part28, f, "Lines")]; - put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])])); + put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])]).v); const part29 = ends$searches_str_SplitWhitespace(rs.strSplitWhitespace(text2), front, back); const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part29, f, "SplitWhitespace")]; - put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])])); + put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])]).v); const it7: rs.Iter = ends$searches_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(text2), front, back); const _556: [rs.usize, rs.usize | undefined] = it7.sizeHint(); const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it7, f, "SplitAsciiWhitespace"), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_556[0], f), (f: rs.Formatter) => rs.fmtOption(_556[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0]), "|", rs.fmtSpec({ debugHex: "x" }, args66[0]), "|", args66[1]])); + put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0]), "|", rs.fmtSpec({ debugHex: "x" }, args66[0]), "|", args66[1]]).v); } export function ends$searches_str_Lines(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index e11ee9479..edff7a0cb 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -34,9 +34,9 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const meters: Wrap.Wrap = new Wrap.Wrap({ _0: at(3) as rs.u64 }, at(4)); const shape: Wrap.Wrap = Wrap.new$shapes_Shape({ tag: "Rect", corner: Wrap.intoInner$shapes_Point(point), width: at(5) as rs.u16, height: 3 } as Shape.Shape); const args2: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Point(point, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_u8(byte, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Shape(shape, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(Wrap.double$u8(byte)))); rs.byteVecPush(out, Wrap.get$u8(byte)); rs.byteVecPush(out, Wrap.get$fmt_Pair(Wrap.get$generics_Wrap_fmt_Pair(nested))._0); @@ -50,7 +50,7 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const _119: Wrap.Wrap = Wrap.new$fmt_Pair({ _0: at(1), _1: 0 }); const _116: boolean = Wrap.eq$cmp_PartialEq_fmt_Pair(mapped, _119); const args6: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_fmt_Pair(mapped, f), (f: rs.Formatter) => rs.fmtBool(_116, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1]])); + put(out, rs.fmtFormat([args6[0], " ", args6[1]]).v); const iter: rs.Iter> = rs.iterSlice(copy$array_generics_Either_u8_shapes_Point([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either])); while (true) { const _140: Either.Either | rs.Done = iter.next(); @@ -62,7 +62,7 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const _153: rs.u8 | undefined = Either.left$u8_shapes_Point(either); const _156: Point.Point | undefined = Either.left$shapes_Point_u8(flipped); const args8: rs.Fmt[] = [(f: rs.Formatter) => Either.fmt$fmt_Debug_u8_shapes_Point(either, f), (f: rs.Formatter) => Either.fmt$fmt_Debug_shapes_Point_u8(flipped, f), (f: rs.Formatter) => rs.fmtOption(_153, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_156, f, (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]])); + put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]]).v); } const list: Wrap.Wrap> = new Wrap.Wrap(new rs.Vec(), 1); const _171: rs.u16 = at(10) as rs.u16; @@ -73,11 +73,11 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const err: Wrap.Wrap> = new Wrap.Wrap(rs.Err({ tag: "Dot" } as Shape.Shape), 2); const _193: rs.u8 = option_unwrapOr$1fr498u(Wrap.get$Option_u8(none), some.count); const args10: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rs.Formatter) => rs.u8Debug(_193, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]]).v); const tagged: Tagged.Tagged, rs.i16> = new Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rs.i16Sub(at(8) as rs.i16, 100)), rs.vecFrom([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rs.i16)].slice())); const _237: Wrap.Wrap | undefined = Tagged.first$generics_Either_u8_u16_i16(tagged); const args12: rs.Fmt[] = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rs.Formatter) => rs.fmtOption(_237, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + put(out, rs.fmtFormat([args12[0], " ", args12[1]]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(tagged.inner.value))); rs.byteVecPush(out, option_unwrapOr$1fr498u(Either.left$u8_u16(tagged.key), 0)); } @@ -194,7 +194,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const _91: boolean = Runs.eq$cmp_PartialEq_u8(runs, before); const _95: rs.u8 | undefined = Run.first$u8(run); const args2: rs.Fmt[] = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(runs, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(before, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(taken), f, rs.u8Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u8(run, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(fixed, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(copy, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(swapped, f), (f: rs.Formatter) => rs.usizeDisplay(_88, f), (f: rs.Formatter) => rs.fmtBool(_91, f), (f: rs.Formatter) => rs.fmtOption(_95, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9], " ", args2[10]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9], " ", args2[10]]).v); const data3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { return _22 as rs.u16; }), undefined, 2, true); @@ -240,7 +240,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const _207: boolean = Runs.eq$cmp_PartialEq_u16(runs2, before2); const _211: rs.u16 | undefined = Run.first$u16(run2); const args4: rs.Fmt[] = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(runs2, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(before2, f), (f: rs.Formatter) => rs.fmtList(taken2.items, f, rs.u16Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u16(run2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(fixed2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(copy2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(swapped2, f), (f: rs.Formatter) => rs.usizeDisplay(_204, f), (f: rs.Formatter) => rs.fmtBool(_207, f), (f: rs.Formatter) => rs.fmtOption(_211, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], " ", args4[7], " ", args4[8], " ", args4[9], " ", args4[10]])); + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], " ", args4[7], " ", args4[8], " ", args4[9], " ", args4[10]]).v); const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const tick: (a0: rs.u8) => Ticked.Ticked = (id: rs.u8): Ticked.Ticked => { return new Ticked.Ticked(id, rs.arcClone(log)); diff --git a/ts/fixtures/lang/shapes/expected/shapes.ts b/ts/fixtures/lang/shapes/expected/shapes.ts index a5d211c5c..938636452 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.ts @@ -594,7 +594,7 @@ export function order(data: rs.ByteSlice, out: rs.ByteVec): void { const _82: rs.ByteSlice = rs.byteSliceRange(_83, rs.usizeDiv(rs.min(mark(out, 15), len), 2), _85); const _103: rs.usize = sum; const args2: rs.Fmt[] = [(f: rs.Formatter) => Shape.fmt$fmt_Debug(rect, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(line, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(pair, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(read, f), (f: rs.Formatter) => Moved.fmt$fmt_Debug(updated, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(taken, f), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.usizeDisplay(_63, f), (f: rs.Formatter) => rs.usizeDisplay(_103, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_82), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]).v)); const _125: rs.usize = mark(out, 16); const _127: rs.usize = out.length; rs.byteVecPush(out, _125 & 0xff); @@ -1399,7 +1399,7 @@ export function patterns(data: rs.ByteSlice, out: rs.ByteVec): void { const a2: rs.u8 = (parsed as { ok: true; value: rs.u8 }).value; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rs.u8 }).value, (parsed as { ok: true; value: rs.u8 }).value, early(a2)))); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(parsed, f, rs.u8Debug, (value: Void.Void, f: rs.Formatter) => Void.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); payloads(data.data, data.start, data.length, out); known(data.data, data.start, data.length, out); rematched(data, out); @@ -1489,12 +1489,12 @@ export function payloads(_dataData: Uint8Array, _dataStart: number, dataLen: num replaced = { ok: true, value: 66 }; rs.byteVecPush(out, old); } - let named: rs.Result = rs.Ok(""); + const named: rs.Result = rs.Ok(rs.stringNew()); if (named.ok) { - named = { ok: true, value: named.value + "r" }; + rs.stringPush(named.value, 114); } if (named.ok) { - _86 = rs.stringLen(named.value) & 0xff; + _86 = named.value.len & 0xff; } else { _86 = named.error; } @@ -2316,12 +2316,12 @@ export function library(data: rs.ByteSlice, out: rs.ByteVec): void { } else { rs.byteVecPush(out, 4); } - const _46: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); + const _46: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_46.ok) { - const s: string = _46.value; + const s: rs.String = _46.value; rs.byteVecPush(out, 1); - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.stringLen(s) as rs.u32))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(s.len as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } else { rs.byteVecPush(out, 0); } diff --git a/ts/fixtures/lang/shares/expected/harness.ts b/ts/fixtures/lang/shares/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/shares/expected/harness.ts +++ b/ts/fixtures/lang/shares/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/shares/expected/shares.ts b/ts/fixtures/lang/shares/expected/shares.ts index 04f5e7bf0..20e577cd7 100644 --- a/ts/fixtures/lang/shares/expected/shares.ts +++ b/ts/fixtures/lang/shares/expected/shares.ts @@ -167,7 +167,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putBytes(borrowed.value, out); const owned: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteCowIntoOwned(rs.byteSliceToByteVec(data2)))); putBytes(owned.value, out); - const s: rs.Arc = new rs.Arc(text(data2)); + const s: rs.Arc = new rs.Arc(text(data2).v); const twin: rs.Arc = rs.arcClone(s); const ofStr: rs.Arc = rs.arcStrBytes(s); counts$slice_u8(ofStr, out); @@ -177,7 +177,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { ofTwin[Symbol.dispose](); counts$slice_u8(ofStr, out); putBytes(ofStr.value, out); - const s2: rs.Arc = new rs.Arc(text(data2)); + const s2: rs.Arc = new rs.Arc(text(data2).v); rs.arcStrBytes(rs.arcClone(s2))[Symbol.dispose](); const _121: rs.Place | undefined = rs.arcGetMutPlace(s2); if (_121 !== undefined) { @@ -192,7 +192,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const same2: rs.Arc = rs.arcClone(n); rs.byteVecPush(out, same2 === n ? 1 : 0); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(same2.value).reverse()), undefined, true); - const arcOfStr: rs.Arc = rs.arcStrBytes(new rs.Arc(text(data2))); + const arcOfStr: rs.Arc = rs.arcStrBytes(new rs.Arc(text(data2).v)); putBytes(arcOfStr.value, out); const v: rs.ByteVec = rs.byteSliceToByteVec(fromVec.value); rs.byteVecPush(v, 238); @@ -242,9 +242,9 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.u64Eq(hash$sync_Arc_slice_u8(arc), hash$Rc_slice_u8(a)) ? 1 : 0); const _285: rs.Arc = new rs.Arc(rs.byteSliceFrom(new Uint8Array(0))); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arc.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_285.value), f, rs.u8Debug)]; - const _281: string = rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]]); + const _281: rs.String = rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]]); _285[Symbol.dispose](); - put(out, _281); + put(out, _281.v); arc[Symbol.dispose](); b2[Symbol.dispose](); a[Symbol.dispose](); @@ -369,7 +369,7 @@ export function wides(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.cmpArc(rs.cmpSlice(rs.cmp))(collected, fromRef) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$Rc_slice_u16(collected), hash$slice_u16(collected.value)) ? 1 : 0); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected.value), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(fromVec.value), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1]]).v); let shared: rs.Arc> = rs.arcClone(fromRef); counts$slice_u16(fromRef, out); if (rs.u8Rem(kind, 2) === 0) { @@ -563,23 +563,24 @@ export function drops(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** `Rc` and `Arc`, each way, read, counted, and written. */ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = text(data); - const fromRef: rs.Arc = new rs.Arc(s); - const fromString: rs.Arc = new rs.Arc(s); - const fromBox: rs.Arc = new rs.Arc(s); - let source: string = s; - const fromMut: rs.Arc = new rs.Arc(source); - source = rs.strToAsciiUppercase(source); - const borrowed: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s))); - const owned: rs.Arc = new rs.Arc(rs.strCowStr(s)); - const into: rs.Arc = new rs.Arc(s); + const s: rs.String = text(data); + const fromRef: rs.Arc = new rs.Arc(s.v); + const fromString: rs.Arc = new rs.Arc(rs.stringClone(s).v); + const fromBox: rs.Arc = new rs.Arc(rs.stringClone(s).v); + const source: rs.String = rs.stringClone(s); + const fromMut: rs.Arc = new rs.Arc(source.v); + const _21: rs.Place = source; + _21.v = rs.strToAsciiUppercase(_21.v); + const borrowed: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s.v))); + const owned: rs.Arc = new rs.Arc(rs.strCowStr(rs.stringClone(s))); + const into: rs.Arc = new rs.Arc(rs.stringClone(s).v); const empty: rs.Arc = new rs.Arc(""); const arcEmpty: rs.Arc = new rs.Arc(""); put(out, fromRef.value); put(out, fromString.value); put(out, fromBox.value); put(out, fromMut.value); - put(out, source); + put(out, source.v); put(out, borrowed.value); put(out, owned.value); put(out, into.value); @@ -587,11 +588,11 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, arcEmpty.value); rs.byteVecPush(out, rs.eqArc(rs.same, true)(fromRef, into) ? 1 : 0); rs.byteVecPush(out, rs.cmpArc(rs.cmpStr)(fromRef, empty) & 0xff); - rs.byteVecPush(out, rs.u64Eq(hash$Rc_str(fromRef), hash$str(s)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$Rc_str(fromRef), hash$str(s.v)) ? 1 : 0); rs.byteVecPush(out, rs.stringLen(fromRef.value) & 0xff); rs.byteVecPush(out, rs.iterCount(rs.strChars(fromRef.value)) & 0xff); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, fromRef.value), (f: rs.Formatter) => rs.fmtStr(fromString.value, f), (f: rs.Formatter) => rs.fmtStr(empty.value, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]]).v); const twin: rs.Arc = rs.arcClone(fromRef); counts$str(twin, out); rs.byteVecPush(out, twin === fromRef ? 1 : 0); @@ -604,12 +605,12 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } else { let _137: rs.Arc = rs.arcClone(twin); - const _135: rs.Place = rs.arcMakeMutPlace(rs.place(() => _137, (value2) => _137 = value2), undefined, rs.drop); + const _135: rs.Place = rs.arcMakeMutPlace(rs.place(() => _137, (value) => _137 = value), undefined, rs.drop); _135.v = rs.strToAsciiLowercase(_135.v); _137[Symbol.dispose](); } let shared: rs.Arc = twin; - const _141: rs.Place = rs.arcMakeMutPlace(rs.place(() => shared, (value3) => shared = value3), undefined, rs.drop); + const _141: rs.Place = rs.arcMakeMutPlace(rs.place(() => shared, (value2) => shared = value2), undefined, rs.drop); _141.v = rs.strToAsciiUppercase(_141.v); counts$str(shared, out); counts$str(fromRef, out); @@ -617,12 +618,12 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, shared.value); put(out, fromRef.value); let arc: rs.Arc = rs.arcClone(fromString); - const _159: rs.Place = rs.arcMakeMutPlace(rs.place(() => arc, (value4) => arc = value4), undefined, rs.drop); + const _159: rs.Place = rs.arcMakeMutPlace(rs.place(() => arc, (value3) => arc = value3), undefined, rs.drop); _159.v = rs.strToAsciiUppercase(_159.v); put(out, arc.value); put(out, fromString.value); - put(out, arc.value); - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtPad(f, fromBox.value))); + put(out, rs.stringFrom(arc.value).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtPad(f, fromBox.value)).v); arc[Symbol.dispose](); shared[Symbol.dispose](); mine[Symbol.dispose](); @@ -687,15 +688,15 @@ export function generics(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void */ export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); - const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data2, 2), text), undefined, 12, true); - const _19: rs.Iter> = rs.iterMap(rs.iterSlice(words.items), (w: string): rs.Arc => { - return new rs.Arc(w); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data2, 2), text), undefined, 12, true); + const _19: rs.Iter> = rs.iterMap(rs.iterSlice(words.items), (w: rs.String): rs.Arc => { + return new rs.Arc(w.v); }); const interned: rs.HashSet> = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashArc(rs.hashStr), rs.eqArc(rs.same, true))) as rs.HashSet>, _19, rs.drop, undefined, 117440512); rs.byteVecPush(out, rs.hashLen(interned) & 0xff); for (const _30 of words.items) { - rs.byteVecPush(out, rs.hashContains(interned, new rs.Arc(_30)) ? 1 : 0); - rs.byteVecPush(out, option_mapOr$00xrvtw(rs.hashKey(interned, new rs.Arc(_30)), 0, (k: rs.Arc): rs.u8 => { + rs.byteVecPush(out, rs.hashContains(interned, new rs.Arc(_30.v)) ? 1 : 0); + rs.byteVecPush(out, option_mapOr$00xrvtw(rs.hashKey(interned, new rs.Arc(_30.v)), 0, (k: rs.Arc): rs.u8 => { return k.strong & 0xff; })); } @@ -726,7 +727,7 @@ export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true).items)); putWides(fromIter.value, out); putWides(fromIter.value, out); - const text_: rs.Arc = new rs.Arc(rs.strsJoin(words.items, "")); + const text_: rs.Arc = new rs.Arc(rs.strsJoin(words.items, "").v); put(out, text_.value); put(out, text_.value); let slot: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); diff --git a/ts/fixtures/lang/singles/expected/singles.ts b/ts/fixtures/lang/singles/expected/singles.ts index c8bcdb6ad..5e91bbc10 100644 --- a/ts/fixtures/lang/singles/expected/singles.ts +++ b/ts/fixtures/lang/singles/expected/singles.ts @@ -54,7 +54,7 @@ export function putSecs(out: rs.ByteVec, d: rs.Result rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1]]).v); } } @@ -398,13 +398,13 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])]).v); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0])])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f))); + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f)).v); } else if (_13 === 1) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args6[0]), " ", rs.fmtSpec({ precision: 120 }, args6[1]), " ", rs.fmtSpec({ precision: 160 }, args6[2])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args6[0]), " ", rs.fmtSpec({ precision: 120 }, args6[1]), " ", rs.fmtSpec({ precision: 160 }, args6[2])]).v); } else if (_13 === 2) { const _72: [rs.f32, rs.ByteSlice] = take(_6[1]); const b: rs.f32 = _72[0]; @@ -414,7 +414,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _78: rs.Vec = rs.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); const part = { level: a, history: _78 }; const args8: rs.Fmt[] = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])]).v); } else { let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rs.i32 = 0; @@ -422,7 +422,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void while (iterStart++ < iterEnd) { const x: rs.f32 = rs.f32FromBits(step(rs.place(() => state, (value) => state = value))); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]]).v); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 64; @@ -433,7 +433,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const r2: rs.u32 = step(rs.place(() => state, (value2) => state = value2)); const x2: rs.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rs.u32Shl(1, rs.u32Add(rs.u32Rem(r2, 16), 1)))); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + put(out, rs.fmtFormat([args12[0], " ", args12[1]]).v); } } } @@ -453,14 +453,14 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { one(_6.value, out); } } else if (_4 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(data)) { const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); rs.idx(_21, _22); - s = s + String.fromCodePoint(_21.data[_21.start + _22] as rs.char); + rs.stringPush(s, _21.data[_21.start + _22] as rs.char); } - one(s, out); + one(s.v, out); } else { let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rs.i32 = 0; @@ -470,9 +470,9 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const half: rs.f64 = ((x as rs.f64) + (rs.f32NextUp(x) as rs.f64)) / 2.0; const p: rs.usize = rs.u32Add(rs.u32Rem(step(rs.place(() => state, (value2) => state = value2)), 30), 8) as rs.usize; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; - one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args2[1]) }, args2[0])]), out); + one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args2[1]) }, args2[0])]).v, out); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f64LowerExp(half, f)]; - one(rs.fmtFormat([args4[0]]), out); + one(rs.fmtFormat([args4[0]]).v, out); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 16; @@ -483,19 +483,19 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const r: rs.u32 = step(rs.place(() => state, (value3) => state = value3)); const len: rs.usize = rs.u32Add(rs.u32Rem(r, 20), 1) as rs.usize; const point: rs.usize = rs.usizeRem(r >>> 8 as rs.usize, rs.usizeAdd(len, 1)); - let s2: string = ""; + const s2: rs.String = rs.stringNew(); let iterStart3: rs.usize = 0; const iterEnd3: rs.usize = len; while ((_108 = iterStart3++) < iterEnd3) { if (_108 === point) { - s2 = s2 + "."; + rs.stringPush(s2, 46); } const _117: rs.char = rs.u8Add(48, rs.u32Rem(step(rs.place(() => state, (value4) => state = value4)), 10) & 0xff) as rs.char; - s2 = s2 + String.fromCodePoint(_117); + rs.stringPush(s2, _117); } const _133: rs.i64 = rs.i64Sub(rs.u32Rem(r >>> 16, 100) as rs.i64, 50); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_133, f)]; - one(rs.fmtFormat([args6[0], "e", args6[1]]), out); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_133, f)]; + one(rs.fmtFormat([args6[0], "e", args6[1]]).v, out); } } } @@ -508,11 +508,11 @@ export function one(s: string, out: rs.ByteVec): void { const v: rs.f32 = _4.value; putF32(out, v); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Debug(v, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); } else { const e: rs.ParseFloatError = _4.error; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1]])); + put(out, rs.fmtFormat([args4[0], "|", args4[1]]).v); } rs.byteVecPush(out, rs.f32FromStr(s).ok ? 1 : 0); } diff --git a/ts/fixtures/lang/statics/expected/statics.ts b/ts/fixtures/lang/statics/expected/statics.ts index 7af8a195b..1803e1587 100644 --- a/ts/fixtures/lang/statics/expected/statics.ts +++ b/ts/fixtures/lang/statics/expected/statics.ts @@ -9,7 +9,7 @@ import * as Dropped from "./statics.Dropped.ts"; import * as Lock from "./statics.Lock.ts"; import type * as Node from "./statics.Node.ts"; import type * as Raw from "./statics.Raw.ts"; -import { withBorrow$03hv9ge, take$1ni7uux, take$1snv7rd } from "./std/thread/local.ts"; +import { withBorrow$15t368r, take$1o1xmz7, take$1snv7rd } from "./std/thread/local.ts"; export const COUNT: rs.Atomic = /* @__PURE__ */ new rs.Atomic({ hi: 0xffffffff, lo: 0xfffffffd } as rs.u64); @@ -338,17 +338,17 @@ export function onces(data: rs.ByteSlice, out: rs.ByteVec): void { owned[Symbol.dispose](); } -export const SHOWN: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(shown); +export const SHOWN: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(shown); -export function shown(): string { - const args2: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; +export function shown(): rs.String { + const args2: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; return rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args2[0])]); } -export const FORCING: rs.LocalKey> | undefined>> = /* @__PURE__ */ new rs.LocalKey(FORCING$init, false); +export const FORCING: rs.LocalKey> | undefined>> = /* @__PURE__ */ new rs.LocalKey(FORCING$init, false); -export function FORCING$init(): rs.RefCell> | undefined> { - return new rs.RefCell(undefined as rs.Arc> | undefined); +export function FORCING$init(): rs.RefCell> | undefined> { + return new rs.RefCell(undefined as rs.Arc> | undefined); } /** @@ -357,7 +357,7 @@ export function FORCING$init(): rs.RefCell> | undefin * forces neither; then its value, padded and pretty as its own `Debug` writes it. */ export function lazies(data: rs.ByteSlice, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; for (const _5 of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(_5, 6); if (_10 === 0) { @@ -365,70 +365,70 @@ export function lazies(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u8Add(rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0), 10); }); const args2: rs.Fmt[] = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; - const before: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|"]); + const before: rs.String = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|"]); const forced: rs.u8 = rs.atomicLoad(FORCED, 0); cell.force(); rs.atomicSwap(FORCED, 0, 0); const args5: rs.Fmt[] = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; - const _34: string = rs.fmtFormat([args5[0], " ", rs.fmtSpec({ alternate: true }, args5[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args5[0]), "|"]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34)]; + const _34: rs.String = rs.fmtFormat([args5[0], " ", rs.fmtSpec({ alternate: true }, args5[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args5[0]), "|"]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before.v), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34.v)]; text = rs.fmtFormat([args6[0], args6[1], args6[2]]); } else if (_10 === 1) { const cell2: rs.LazyCell = new rs.LazyCell((): undefined => {}); const args8: rs.Fmt[] = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; - const before2: string = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args8[0]), "|"]); + const before2: rs.String = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args8[0]), "|"]); cell2.force(); const args11: rs.Fmt[] = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; - const _67: string = rs.fmtFormat([args11[0], " ", rs.fmtSpec({ alternate: true }, args11[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args11[0]), "|"]); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before2), (f: rs.Formatter) => rs.fmtPad(f, _67)]; + const _67: rs.String = rs.fmtFormat([args11[0], " ", rs.fmtSpec({ alternate: true }, args11[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args11[0]), "|"]); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before2.v), (f: rs.Formatter) => rs.fmtPad(f, _67.v)]; text = rs.fmtFormat([args12[0], args12[1]]); } else if (_10 === 2) { const lock: rs.LazyLock = new rs.LazyLock((): rs.u8 | undefined => { return undefined; }); const args14: rs.Fmt[] = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - const before3: string = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args14[0]), "|"]); + const before3: rs.String = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args14[0]), "|"]); lock.force(); const args17: rs.Fmt[] = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - const _98: string = rs.fmtFormat([args17[0], " ", rs.fmtSpec({ alternate: true }, args17[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args17[0]), "|"]); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before3), (f: rs.Formatter) => rs.fmtPad(f, _98)]; + const _98: rs.String = rs.fmtFormat([args17[0], " ", rs.fmtSpec({ alternate: true }, args17[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args17[0]), "|"]); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before3.v), (f: rs.Formatter) => rs.fmtPad(f, _98.v)]; text = rs.fmtFormat([args18[0], args18[1]]); } else if (_10 === 3) { const lock2: rs.LazyLock> = new rs.LazyLock((): rs.Vec => { return rs.vecFrom(["a", "bc"]); }); const args20: rs.Fmt[] = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; - const before4: string = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args20[0]), "|"]); + const before4: rs.String = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args20[0]), "|"]); lock2.force().items.length; const args23: rs.Fmt[] = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; - const _130: string = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args23[0]), "|"]); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before4), (f: rs.Formatter) => rs.fmtPad(f, _130)]; + const _130: rs.String = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args23[0]), "|"]); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before4.v), (f: rs.Formatter) => rs.fmtPad(f, _130.v)]; text = rs.fmtFormat([args24[0], args24[1]]); } else if (_10 === 4) { - const _148: string = SHOWN.force(); - const args27: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; - const _151: string = rs.fmtFormat([args27[0], " ", rs.fmtSpec({ alternate: true }, args27[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args27[0]), "|"]); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _148), (f: rs.Formatter) => rs.fmtPad(f, _151)]; + const _148: rs.String = SHOWN.force(); + const args27: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + const _151: rs.String = rs.fmtFormat([args27[0], " ", rs.fmtSpec({ alternate: true }, args27[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args27[0]), "|"]); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _148.v), (f: rs.Formatter) => rs.fmtPad(f, _151.v)]; text = rs.fmtFormat([args28[0], " ", args28[1]]); } else { - const cell3: rs.Arc> = new rs.Arc(new rs.LazyCell((): string => { - return withBorrow$03hv9ge(FORCING, (me: rs.Arc> | undefined): string => { + const cell3: rs.Arc> = new rs.Arc(new rs.LazyCell((): rs.String => { + return withBorrow$15t368r(FORCING, (me: rs.Arc> | undefined): rs.String => { const part = rs.optionUnwrap(me); - const args34: rs.Fmt[] = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", rs.fmtStr)]; + const args34: rs.Fmt[] = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; return rs.fmtFormat([args34[0], " ", rs.fmtSpec({ alternate: true }, args34[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args34[0]), "|"]); }); })); rs.localKeyRefCellSet(FORCING, rs.arcClone(cell3), rs.drop); - const _175: string = cell3.value.force(); - const args31: rs.Fmt[] = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", rs.fmtStr)]; - const _179: string = rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args31[0]), "|"]); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _175), (f: rs.Formatter) => rs.fmtPad(f, _179)]; - const text2: string = rs.fmtFormat([args32[0], " ", args32[1]]); - rs.drop(take$1ni7uux(FORCING)); + const _175: rs.String = cell3.value.force(); + const args31: rs.Fmt[] = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + const _179: rs.String = rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args31[0]), "|"]); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _175.v), (f: rs.Formatter) => rs.fmtPad(f, _179.v)]; + const text2: rs.String = rs.fmtFormat([args32[0], " ", args32[1]]); + rs.drop(take$1o1xmz7(FORCING)); text = text2; cell3[Symbol.dispose](); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } } @@ -500,7 +500,7 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { } export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyCell, out: rs.ByteVec): void { - const _18: (a0: rs.LazyCell) => string = (l: rs.LazyCell): string => { + const _18: (a0: rs.LazyCell) => rs.String = (l: rs.LazyCell): rs.String => { const args2: rs.Fmt[] = [(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; return rs.fmtFormat([args2[0], "|"]); }; @@ -523,17 +523,17 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: const _28: rs.LazyCell = a; _103 = false; const old: rs.LazyCell = rs.replaceIn(_28, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old).v)); rs.lazyDrop(old, rs.drop); } else if (_20 === 2) { b = rs.replaceIn(a, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b).v)); rs.byteVecPush(out, b.force()._0); } else if (_20 === 3) { const _52: rs.Cell> = rs.cellIn(a); _103 = false; const old2: rs.LazyCell = rs.cellReplace(_52, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2).v)); rs.lazyDrop(old2, rs.drop); } else if (_20 === 4) { const _62: rs.Cell> = rs.cellIn(a); @@ -556,9 +556,9 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.refMutRelease(_78); a = held.value[1]; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); rs.byteVecPush(out, a.force()._0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); if (_103) { rs.lazyDrop(b, rs.drop); } @@ -567,7 +567,7 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: } export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyLock, out: rs.ByteVec): void { - const _18: (a0: rs.LazyLock) => string = (l: rs.LazyLock): string => { + const _18: (a0: rs.LazyLock) => rs.String = (l: rs.LazyLock): rs.String => { const args2: rs.Fmt[] = [(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; return rs.fmtFormat([args2[0], "|"]); }; @@ -590,17 +590,17 @@ export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: const _28: rs.LazyLock = a; _103 = false; const old: rs.LazyLock = rs.replaceIn(_28, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old).v)); rs.lazyDrop(old, rs.drop); } else if (_20 === 2) { b = rs.replaceIn(a, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b).v)); rs.byteVecPush(out, b.force()._0); } else if (_20 === 3) { const _52: rs.Cell> = rs.cellIn(a); _103 = false; const old2: rs.LazyLock = rs.cellReplace(_52, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2).v)); rs.lazyDrop(old2, rs.drop); } else if (_20 === 4) { const _62: rs.Cell> = rs.cellIn(a); @@ -623,9 +623,9 @@ export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.refMutRelease(_78); a = held.value[1]; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); rs.byteVecPush(out, a.force()._0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); if (_103) { rs.lazyDrop(b, rs.drop); } diff --git a/ts/fixtures/lang/statics/expected/std/thread/local.ts b/ts/fixtures/lang/statics/expected/std/thread/local.ts index 7be29cc62..1a052c859 100644 --- a/ts/fixtures/lang/statics/expected/std/thread/local.ts +++ b/ts/fixtures/lang/statics/expected/std/thread/local.ts @@ -2,19 +2,19 @@ import * as rs from "../../rs.ts"; -export function withBorrow$03hv9ge(self: rs.LocalKey> | undefined>>, f: (a0: rs.Arc> | undefined) => string): string { +export function withBorrow$15t368r(self: rs.LocalKey> | undefined>>, f: (a0: rs.Arc> | undefined) => rs.String): rs.String { const captured = f; - return ((cell: rs.RefCell> | undefined>): string => { - const _32: (a0: rs.Arc> | undefined) => string = captured; - const _7: rs.RefCell> | undefined> = rs.refCellBorrow(cell); - const _02: string = _32(_7.value); + return ((cell: rs.RefCell> | undefined>): rs.String => { + const _32: (a0: rs.Arc> | undefined) => rs.String = captured; + const _7: rs.RefCell> | undefined> = rs.refCellBorrow(cell); + const _02: rs.String = _32(_7.value); rs.refRelease(_7); return _02; })(self.get()); } -export function take$1ni7uux(self: rs.LocalKey> | undefined>>): rs.Arc> | undefined { - return ((a0: rs.RefCell> | undefined>): rs.Arc> | undefined => { +export function take$1o1xmz7(self: rs.LocalKey> | undefined>>): rs.Arc> | undefined { + return ((a0: rs.RefCell> | undefined>): rs.Arc> | undefined => { return rs.refCellReplace(a0, undefined); })(self.get()); } diff --git a/ts/fixtures/lang/strs/expected/harness.ts b/ts/fixtures/lang/strs/expected/harness.ts index 78fad7cd8..a4d32784d 100644 --- a/ts/fixtures/lang/strs/expected/harness.ts +++ b/ts/fixtures/lang/strs/expected/harness.ts @@ -44,8 +44,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -57,7 +57,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/strs/expected/strs.Counted.ts b/ts/fixtures/lang/strs/expected/strs.Counted.ts index 4d6dfb4f9..0a88b4bd7 100644 --- a/ts/fixtures/lang/strs/expected/strs.Counted.ts +++ b/ts/fixtures/lang/strs/expected/strs.Counted.ts @@ -8,13 +8,13 @@ export interface Counted { nexts: rs.Cell; } -export function next$iter_Iterator_String(self: Counted): string | rs.Done { +export function next$iter_Iterator_String(self: Counted): rs.String | rs.Done { rs.cellSet(self.nexts, rs.u8Add(self.nexts.v, 1)); - const _8: [string, rs.Slice] | undefined = rs.sliceSplitFirst(self.items as rs.Slice); + const _8: [rs.String, rs.Slice] | undefined = rs.sliceSplitFirst(self.items as rs.Slice); if (_8 !== undefined) { - const val: [string, rs.Slice] = _8; - (self.items as rs.Slice) = val[1]; - return val[0]; + const val: [rs.String, rs.Slice] = _8; + (self.items as rs.Slice) = val[1]; + return rs.stringClone(val[0]); } return rs.DONE; } diff --git a/ts/fixtures/lang/strs/expected/strs.Named.ts b/ts/fixtures/lang/strs/expected/strs.Named.ts index 029969cd5..bcb0e2dad 100644 --- a/ts/fixtures/lang/strs/expected/strs.Named.ts +++ b/ts/fixtures/lang/strs/expected/strs.Named.ts @@ -3,11 +3,11 @@ import * as rs from "./rs.ts"; export interface Named { - name: string; + name: rs.String; } export function add(self: Named, c: rs.char): void { - self.name = self.name + String.fromCodePoint(c); + rs.stringPush(self.name, c); } //# sourceMappingURL=strs.Named.ts.map diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 22f0347c0..527a6f503 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -52,7 +52,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let part5!: string | undefined; let item!: [rs.usize, string] | undefined; let _260!: rs.char; - const s: string = text(data); + const s: rs.String = text(data); const _7: rs.usize = rs.u8Rem(rs.u8Div(kind, 8), 16) as rs.usize; if (!(_7 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _7); @@ -61,7 +61,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { b0: { const _13: rs.u8 = rs.u8Rem(kind, 8); if (_13 === 0) { - const it: rs.Iter = rs.strChars(s); + const it: rs.Iter = rs.strChars(s.v); let i: rs.usize = 0; while (true) { if (!fromBack(data, i)) { @@ -73,8 +73,8 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (!(c === undefined)) { i = rs.usizeAdd(i, 1); } else { - rs.byteVecPush(out, rs.iterCount(rs.strChars(s)) & 0xff); - const iter: rs.Iter = rs.iterRev(rs.strChars(s)); + rs.byteVecPush(out, rs.iterCount(rs.strChars(s.v)) & 0xff); + const iter: rs.Iter = rs.iterRev(rs.strChars(s.v)); while (true) { const _41: rs.char | rs.Done = iter.next(); if (_41 === rs.DONE) { @@ -82,14 +82,14 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, rs.isAsciiDigit(_41) ? 1 : 0); } - rs.byteVecPush(out, s.length === 0 ? 1 : 0); - rs.byteVecPush(out, s.length === 0 ? 1 : 0); + rs.byteVecPush(out, s.len === 0 ? 1 : 0); + rs.byteVecPush(out, s.v.length === 0 ? 1 : 0); break b0; } } } if (_13 === 1) { - const parts: rs.Iter = rs.strSplit(s, String.fromCodePoint(sep)); + const parts: rs.Iter = rs.strSplit(s.v, String.fromCodePoint(sep)); let i2: rs.usize = 0; while (true) { if (!fromBack(data, i2)) { @@ -104,8 +104,8 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { i2 = rs.usizeAdd(i2, 1); } else { rs.byteVecPush(out, i2 & 0xff); - put(out, option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, String.fromCodePoint(sep)).next()), "none")); - const parts2: rs.Iter = rs.strSplitTerminator(s, String.fromCodePoint(sep)); + put(out, option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, String.fromCodePoint(sep)).next()), "none")); + const parts2: rs.Iter = rs.strSplitTerminator(s.v, String.fromCodePoint(sep)); let i3: rs.usize = 0; while (true) { if (!fromBack(data, i3)) { @@ -126,7 +126,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } if (_13 === 2) { const seen: rs.Vec = new rs.Vec(); - const parts3: rs.Iter = rs.strSplit(s, (c9: rs.char): boolean => { + const parts3: rs.Iter = rs.strSplit(s.v, (c9: rs.char): boolean => { seen.items.push(c9); if (!(c9 === sep)) { return rs.isAsciiDigit(c9); @@ -150,12 +150,12 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } if (_13 === 3) { - put(out, rs.strTrimStartMatches(s, String.fromCodePoint(sep))); - put(out, rs.strTrimEndMatches(s, String.fromCodePoint(sep))); - put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s, String.fromCodePoint(sep)), String.fromCodePoint(sep))); - rs.byteVecPush(out, rs.strStartsWith(s, String.fromCodePoint(sep)) ? 1 : 0); - putOffset(out, rs.strRfind(s, String.fromCodePoint(sep))); - const _143: [string, string] | undefined = rs.strRsplitOnce(s, String.fromCodePoint(sep)); + put(out, rs.strTrimStartMatches(s.v, String.fromCodePoint(sep))); + put(out, rs.strTrimEndMatches(s.v, String.fromCodePoint(sep))); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s.v, String.fromCodePoint(sep)), String.fromCodePoint(sep))); + rs.byteVecPush(out, rs.strStartsWith(s.v, String.fromCodePoint(sep)) ? 1 : 0); + putOffset(out, rs.strRfind(s.v, String.fromCodePoint(sep))); + const _143: [string, string] | undefined = rs.strRsplitOnce(s.v, String.fromCodePoint(sep)); if (_143 === undefined) { rs.byteVecPush(out, 253); } else { @@ -164,28 +164,28 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } else if (_13 === 4) { const seen2: rs.Vec = new rs.Vec(); - put(out, rs.strTrimStartMatches(s, (c5: rs.char): boolean => { + put(out, rs.strTrimStartMatches(s.v, (c5: rs.char): boolean => { seen2.items.push(c5); return c5 === sep; })); putSeen(out, rs.sliceFrom(seen2.items)); - put(out, rs.strTrimEndMatches(s, (c6: rs.char): boolean => { + put(out, rs.strTrimEndMatches(s.v, (c6: rs.char): boolean => { seen2.items.push(c6); return c6 !== sep; })); putSeen(out, rs.sliceFrom(seen2.items)); - rs.byteVecPush(out, rs.strStartsWith(s, (c7: rs.char): boolean => { + rs.byteVecPush(out, rs.strStartsWith(s.v, (c7: rs.char): boolean => { return rs.isAsciiDigit(c7); }) ? 1 : 0); - put(out, rs.strTrimStartMatches(s, digit)); - putOffset(out, rs.strRfind(s, (c8: rs.char): boolean => { + put(out, rs.strTrimStartMatches(s.v, digit)); + putOffset(out, rs.strRfind(s.v, (c8: rs.char): boolean => { seen2.items.push(c8); return c8 === sep; })); putSeen(out, rs.sliceFrom(seen2.items)); } else { if (_13 === 5) { - const found2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s, String.fromCodePoint(sep)); + const found2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s.v, String.fromCodePoint(sep)); let i5: rs.usize = 0; while (true) { if (!fromBack(data, i5)) { @@ -200,7 +200,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, matched); i5 = rs.usizeAdd(i5, 1); } else { - for (const _214 of rs.iterToVec(rs.iterMap(rs.strMatchIndices(s, "/"), (_2: [rs.usize, string]): rs.usize => { + for (const _214 of rs.iterToVec(rs.iterMap(rs.strMatchIndices(s.v, "/"), (_2: [rs.usize, string]): rs.usize => { return _2[0]; }), "next", 4).items) { putOffset(out, _214); @@ -210,16 +210,16 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } if (_13 === 6) { - const parts4: rs.Vec = unescape(s); + const parts4: rs.Vec = unescape(s.v); for (const _226 of parts4.items) { - put(out, _226); + put(out, _226.v); } - put(out, escape(rs.sliceFrom(parts4.items))); + put(out, escape(rs.sliceFrom(parts4.items)).v); } else { - let built: string = ""; - const named: Named.Named = { name: "" }; - const each: rs.Vec = rs.vecFrom(["", ""]); - const iter4: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.strChars(s)); + let built: rs.String = rs.stringNew(); + const named: Named.Named = { name: rs.stringNew() }; + const each: rs.Vec = rs.vecFrom([rs.stringNew(), rs.stringNew()]); + const iter4: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.strChars(s.v)); while (true) { const _251: [rs.usize, rs.char] | rs.Done = iter4.next(); if (_251 === rs.DONE) { @@ -227,37 +227,36 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } const i6: rs.usize = _251[0]; const c3: rs.char = _251[1]; - built = built + String.fromCodePoint(c3); + rs.stringPush(built, c3); if (!(rs.usizeRem(i6, 2) === 0)) { _260 = sep; } else { _260 = c3; } - named.name = named.name + String.fromCodePoint(_260); + rs.stringPush(named.name, _260); Named.add(named, c3); - const at2 = rs.idx(each.items, rs.usizeRem(i6, 2)); - each.items[at2] = each.items[at2] + String.fromCodePoint(c3); + rs.stringPush(each.items[rs.idx(each.items, rs.usizeRem(i6, 2))], c3); const _271: rs.char | undefined = rs.charFromU32(rs.u32Add(c3 as rs.u32, 1)); if (_271 !== undefined) { - built = built + String.fromCodePoint(_271); + rs.stringPush(built, _271); } } - named.name = named.name + "􏿿"; - put(out, built); - put(out, named.name); - put(out, each.items[rs.idx(each.items, 0)]); - put(out, each.items[rs.idx(each.items, 1)]); - const before: string = built; - const len: rs.usize = rs.stringLen(built); - const empty: boolean = built.length === 0; - built = built + String.fromCodePoint(sep); - put(out, before); + rs.stringPush(named.name, 1114111); + put(out, built.v); + put(out, named.name.v); + put(out, each.items[rs.idx(each.items, 0)].v); + put(out, each.items[rs.idx(each.items, 1)].v); + const before: rs.String = rs.stringClone(built); + const len: rs.usize = built.len; + const empty: boolean = built.len === 0; + rs.stringPush(built, sep); + put(out, before.v); rs.byteVecPush(out, len & 0xff); rs.byteVecPush(out, empty ? 1 : 0); const taken2 = built; - built = ""; - put(out, taken2); - rs.byteVecPush(out, built.length === 0 ? 1 : 0); + built = rs.stringNew(); + put(out, taken2.v); + rs.byteVecPush(out, built.len === 0 ? 1 : 0); } } } @@ -267,15 +266,15 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * Up to three chars of `s`, from the char the kind's high bits pick: empty a quarter of * the time, and otherwise found at least once unless the text is shorter. */ -export function pattern(kind: rs.u8, s: string): string { - let p: string = ""; +export function pattern(kind: rs.u8, s: string): rs.String { + const p: rs.String = rs.stringNew(); const iter: rs.Iter = rs.iterTake(rs.iterSkip(rs.strChars(s), rs.u8Div(kind, 32) as rs.usize), rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize); while (true) { const _17: rs.char | rs.Done = iter.next(); if (_17 === rs.DONE) { return p; } - p = p + String.fromCodePoint(_17); + rs.stringPush(p, _17); } } @@ -286,13 +285,13 @@ export function pattern(kind: rs.u8, s: string): string { export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _219!: [rs.usize, rs.usize]; let sliced!: string; - const s: string = text(data); - const p: string = pattern(kind, s); + const s: rs.String = text(data); + const p: rs.String = pattern(kind, s.v); b0: { const _8: rs.u8 = rs.u8Rem(kind, 8); if (_8 === 0) { let n: rs.i32 = 0; - const iter: rs.Iter = rs.strSplit(s, p); + const iter: rs.Iter = rs.strSplit(s.v, p.v); while (true) { const _18: string | rs.Done = iter.next(); if (_18 === rs.DONE) { @@ -302,10 +301,10 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { n = rs.i32Add(n, 1); } rs.byteVecPush(out, n & 0xff); - put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s, p)), "none")); + put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s.v, p.v)), "none")); } else { if (_8 === 1) { - const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s, p); + const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s.v, p.v); while (true) { const _42: [rs.usize, string] | rs.Done = iter2.next(); if (_42 === rs.DONE) { @@ -314,26 +313,26 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const at: rs.usize = _42[0]; putOffset(out, at); put(out, _42[1]); - put(out, rs.strSlice(s, 0, at)); + put(out, rs.strSlice(s.v, 0, at)); const part6 = rs.usizeAdd(at, rs.stringLen(_42[1])); - put(out, rs.strSlice(s, part6)); + put(out, rs.strSlice(s.v, part6)); const part7 = rs.usizeAdd(at, rs.stringLen(_42[1])); - put(out, rs.strSlice(s, at, part7)); + put(out, rs.strSlice(s.v, at, part7)); } } if (_8 === 2) { - put(out, rs.strTrimStartMatches(s, p)); - put(out, rs.strTrimEndMatches(s, p)); - put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s, p), p)); - rs.byteVecPush(out, rs.strStartsWith(s, p) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, p) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, p) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, "/") ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, (c: rs.char): boolean => { + put(out, rs.strTrimStartMatches(s.v, p.v)); + put(out, rs.strTrimEndMatches(s.v, p.v)); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s.v, p.v), p.v)); + rs.byteVecPush(out, rs.strStartsWith(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, (c: rs.char): boolean => { return rs.isAsciiDigit(c); }) ? 1 : 0); - putOffset(out, rs.strRfind(s, p)); - const _123: [string, string] | undefined = rs.strRsplitOnce(s, p); + putOffset(out, rs.strRfind(s.v, p.v)); + const _123: [string, string] | undefined = rs.strRsplitOnce(s.v, p.v); if (_123 === undefined) { rs.byteVecPush(out, 253); } else { @@ -342,7 +341,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } else { if (_8 === 3) { - const iter3: rs.Iter = rs.iterSuccessors(s, (path: string): string | undefined => { + const iter3: rs.Iter = rs.iterSuccessors(s.v, (path: string): string | undefined => { const _73: string = path; return then$0havnzo(!(path.length === 0), (): string => { return option_mapOr$19xt0tb(rs.strRfind(_73, "/"), "", (slash: rs.usize): string => { @@ -360,30 +359,30 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } if (_8 === 4) { const keep: rs.usize = rs.usizeAdd(rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize, 1); - put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { - return rs.strSlice(s, 0, _2[0]); + put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { + return rs.strSlice(s.v, 0, _2[0]); }), "none")); - const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s, "/"), rs.usizeSub(keep, 1)), rs.stringLen(s), (_22: [rs.usize, string]): rs.usize => { + const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), s.len, (_22: [rs.usize, string]): rs.usize => { return rs.usizeAdd(_22[0], 1); }); - put(out, rs.strSlice(s, part5)); + put(out, rs.strSlice(s.v, part5)); } else if (_8 === 5) { - const parts: rs.Vec = rs.iterToVec(rs.strSplit(s, "/"), "next", 8); + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s.v, "/"), "next", 8); const _186: rs.Slice = rs.sliceFrom(parts.items); - const _188: string = p; - put(out, rs.strsJoin(rs.sliceItems(_186), _188)); - const _199: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): string => { - return part3; + const _188: string = p.v; + put(out, rs.strsJoin(rs.sliceItems(_186), _188).v); + const _199: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): rs.String => { + return rs.stringFrom(part3); }), undefined, 12, true).items); - const _201: string = p; - put(out, rs.strsJoin(rs.sliceItems(_199), _201)); - put(out, rs.strsJoin(["a", "", s], "/")); + const _201: string = p.v; + put(out, rs.strsJoin(rs.sliceItems(_199), _201).v); + put(out, rs.strsJoin(["a", "", s.v], "/").v); } else { const at2: (a0: rs.u8) => rs.usize = (b2: rs.u8): rs.usize => { if ((kind & 32) === 0) { - return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(rs.stringLen(s), 2)); + return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(s.len, 2)); } - return rs.usizeSaturatingSub(rs.usizeAdd(rs.stringLen(s), 1), rs.usizeRem(b2 as rs.usize, 4)); + return rs.usizeSaturatingSub(rs.usizeAdd(s.len, 1), rs.usizeRem(b2 as rs.usize, 4)); }; if (!(data.length >= 2)) { _219 = [0, 0] as [rs.usize, rs.usize]; @@ -394,13 +393,13 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.usize = _219[1]; const _233: rs.u8 = rs.u8Rem(rs.u8Div(kind, 8), 4); if (_233 === 0) { - sliced = rs.strSlice(s, a, b); + sliced = rs.strSlice(s.v, a, b); } else if (_233 === 1) { - sliced = rs.strSlice(s, a); + sliced = rs.strSlice(s.v, a); } else if (_233 === 2) { - sliced = rs.strSlice(s, 0, b); + sliced = rs.strSlice(s.v, 0, b); } else { - sliced = rs.strSlice(s, 0); + sliced = rs.strSlice(s.v, 0); } put(out, sliced); } @@ -415,10 +414,10 @@ export function digit(c: rs.char): boolean { } /** `/` separates parts, and `\` escapes a `/` or `\` within one. */ -export function unescape(path: string): rs.Vec { +export function unescape(path: string): rs.Vec { if (!(path.length === 0)) { - const parts: rs.Vec = new rs.Vec(); - let part: string = ""; + const parts: rs.Vec = new rs.Vec(); + let part: rs.String = rs.stringNew(); const chars: rs.Iter = rs.strChars(path); while (true) { const _7: rs.char | rs.Done = chars.next(); @@ -426,21 +425,21 @@ export function unescape(path: string): rs.Vec { const ch: rs.char = _7; if (ch === 47) { const taken = part; - part = ""; + part = rs.stringNew(); parts.items.push(taken); } else if (ch === 92) { const _14: rs.char | rs.Done = chars.next(); if (_14 === rs.DONE) { - part = part + "\\"; + rs.stringPush(part, 92); } else if (_14 === 47 || _14 === 92) { - part = part + String.fromCodePoint(_14); + rs.stringPush(part, _14); } else { const next2: rs.char = _14; - part = part + "\\"; - part = part + String.fromCodePoint(next2); + rs.stringPush(part, 92); + rs.stringPush(part, next2); } } else { - part = part + String.fromCodePoint(ch); + rs.stringPush(part, ch); } } else { break; @@ -452,19 +451,19 @@ export function unescape(path: string): rs.Vec { return new rs.Vec(); } -export function escape(parts: rs.Slice): string { +export function escape(parts: rs.Slice): rs.String { let _23!: boolean; - let path: string = ""; - const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(parts))); + const path: rs.String = rs.stringNew(); + const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(parts))); l1: while (true) { - const _7: [rs.usize, string] | rs.Done = iter.next(); + const _7: [rs.usize, rs.String] | rs.Done = iter.next(); if (_7 === rs.DONE) { return path; } if (_7[0] > 0) { - path = path + "/"; + rs.stringPush(path, 47); } - const iter2: rs.Iter = rs.strChars(_7[1]); + const iter2: rs.Iter = rs.strChars(_7[1].v); while (true) { const _19: rs.char | rs.Done = iter2.next(); if (_19 === rs.DONE) { @@ -477,9 +476,9 @@ export function escape(parts: rs.Slice): string { _23 = false; } if (_23) { - path = path + "\\"; + rs.stringPush(path, 92); } - path = path + String.fromCodePoint(ch); + rs.stringPush(path, ch); } } } @@ -511,15 +510,15 @@ export function offset(s: string, b: rs.u8): rs.usize { } /** `String::retain` by a function behind a `&mut`, behind two, and boxed behind one. */ -export function retainBy(s: rs.Place, f: rs.Place<(a0: rs.char) => boolean>, how: rs.u8): void { +export function retainBy(s: rs.String, f: rs.Place<(a0: rs.char) => boolean>, how: rs.u8): void { const _4: rs.u8 = rs.u8Rem(how, 3); if (_4 === 0) { - s.v = rs.stringRetain(s.v, f.v); + rs.stringRetain(s, f.v); } else if (_4 === 1) { let _7: rs.Place<(a0: rs.char) => boolean> = f; - s.v = rs.stringRetain(s.v, rs.place(() => _7, (value) => _7 = value).v.v); + rs.stringRetain(s, rs.place(() => _7, (value) => _7 = value).v.v); } else { - s.v = rs.stringRetain(s.v, f.v); + rs.stringRetain(s, f.v); } } @@ -528,29 +527,25 @@ export function odd(c: rs.char): boolean { } /** One edit of `s` by `op`, taking offsets and text from `a` and `b`, through a `&mut`. */ -export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs.ByteVec): void { +export function edit(s: rs.String, op: rs.u8, a: rs.u8, b: rs.u8, out: rs.ByteVec): void { let capacity!: rs.usize; - const piece: string = text(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, rs.u8Rem(a, 4) as rs.usize)); + const piece: rs.String = text(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, rs.u8Rem(a, 4) as rs.usize)); const _17: [rs.usize, rs.usize] = [offset(s.v, a), offset(s.v, b)]; const i: rs.usize = _17[0]; const j: rs.usize = _17[1]; const _24: rs.u8 = rs.u8Rem(op, 14); if (_24 === 0) { - s.v = s.v + piece; + rs.stringPushStr(s, piece.v); } else if (_24 === 1) { const _28: rs.u8 = rs.u8Rem(b, 4); if (_28 === 0) { - s.v = s.v + piece; + rs.stringPushStr(s, piece.v); } else if (_28 === 1) { - const taken2 = s.v; - s.v = ""; - s.v = taken2 + piece; + Object.assign(s, rs.stringAdd(rs.replaceIn(s, rs.stringNew()), piece.v)); } else if (_28 === 2) { - const taken = s.v; - s.v = ""; - s.v = taken + "" + piece + piece; + Object.assign(s, rs.stringAdd(rs.stringAdd(rs.stringAdd(rs.replaceIn(s, rs.stringNew()), ""), piece.v), piece.v)); } else { - s.v = rs.stringWithCapacity(a as rs.usize) + s.v + ""; + Object.assign(s, rs.stringAdd(rs.stringAdd(rs.stringWithCapacity(a as rs.usize), s.v), "")); } } else if (_24 === 2) { if (!(rs.u8Rem(a, 4) === 0)) { @@ -558,32 +553,28 @@ export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs if (!(_59 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _59); } - s.v = s.v + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_59]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_59]); } else { - s.v = ""; + rs.stringClear(s); } } else if (_24 === 3) { - s.v = rs.stringTruncate(s.v, i); + rs.stringTruncate(s, i); } else if (_24 === 4) { - const edit3 = rs.stringPop(s.v); - s.v = edit3[0]; - putChar(out, edit3[1]); + putChar(out, rs.stringPop(s)); } else if (_24 === 5) { - const edit2 = rs.stringRemove(s.v, i); - s.v = edit2[0]; - putChar(out, edit2[1]); + putChar(out, rs.stringRemove(s, i)); } else if (_24 === 6) { const _68: rs.usize = rs.u8Rem(b, 16) as rs.usize; if (!(_68 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _68); } - s.v = rs.stringInsertStr(s.v, i, String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_68])); + rs.stringInsertStr(s, i, String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_68])); } else if (_24 === 7) { - s.v = rs.stringInsertStr(s.v, i, piece); + rs.stringInsertStr(s, i, piece.v); } else if (_24 === 8) { if (!(rs.u8Rem(b, 2) === 1)) { const seen: rs.Vec = new rs.Vec(); - s.v = rs.stringRetain(s.v, (c: rs.char): boolean => { + rs.stringRetain(s, (c: rs.char): boolean => { seen.items.push(c); return rs.u32Rem(c as rs.u32, 3) !== rs.u8Rem(a, 3) as rs.u32; }); @@ -593,55 +584,48 @@ export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs retainBy(s, rs.place(() => f, (value) => f = value), a); } } else if (_24 === 9) { - const edit = rs.stringSplitOff(s.v, i); - s.v = edit[0]; - put(out, edit[1]); + put(out, rs.stringSplitOff(s, i).v); } else if (_24 === 10) { const _91: rs.u8 = rs.u8Rem(b, 7); if (_91 === 0) { - const _93: rs.Range = new rs.Range(i, j); - s.v = rs.stringReplaceRange(s.v, _93, piece); + rs.stringReplaceRange(s, new rs.Range(i, j), piece.v); } else if (_91 === 1) { - const _96: rs.RangeFrom = new rs.RangeFrom(i, rs.usizeStep); - s.v = rs.stringReplaceRange(s.v, _96, piece); + rs.stringReplaceRange(s, new rs.RangeFrom(i, rs.usizeStep), piece.v); } else if (_91 === 2) { - const _99: { end: rs.usize } = { end: j }; - s.v = rs.stringReplaceRange(s.v, _99, piece); + rs.stringReplaceRange(s, { end: j }, piece.v); } else if (_91 === 3) { - s.v = rs.stringReplaceRange(s.v, undefined, piece); + rs.stringReplaceRange(s, undefined, piece.v); } else if (_91 === 4) { - const _104: rs.RangeInclusive = new rs.RangeInclusive(i, j, rs.usizeStep); - s.v = rs.stringReplaceRange(s.v, _104, piece); + rs.stringReplaceRange(s, new rs.RangeInclusive(i, j, rs.usizeStep), piece.v); } else if (_91 === 5) { - const _107: { end: rs.usize; inclusive: true } = { end: j, inclusive: true }; - s.v = rs.stringReplaceRange(s.v, _107, piece); + rs.stringReplaceRange(s, { end: j, inclusive: true }, piece.v); } else { - const _110: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: i } as rs.RangeBound, { tag: "Included", _0: j } as rs.RangeBound]; - s.v = rs.stringReplaceRange(s.v, _110, piece); + rs.stringReplaceRange(s, [{ tag: "Excluded", _0: i } as rs.RangeBound, { tag: "Included", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], piece.v); } } else if (_24 === 11) { const _115: rs.u8 = rs.u8Rem(b, 5); if (_115 === 0) { - s.v = rs.stringExtendFromWithin(s.v, new rs.Range(i, j)); + rs.stringExtendFromWithin(s, new rs.Range(i, j)); } else if (_115 === 1) { - s.v = rs.stringExtendFromWithin(s.v, new rs.RangeFrom(i, rs.usizeStep)); + rs.stringExtendFromWithin(s, new rs.RangeFrom(i, rs.usizeStep)); } else if (_115 === 2) { - s.v = rs.stringExtendFromWithin(s.v, { end: j, inclusive: true }); + rs.stringExtendFromWithin(s, { end: j, inclusive: true }); } else if (_115 === 3) { - s.v = rs.stringExtendFromWithin(s.v, [{ tag: "Included", _0: i } as rs.RangeBound, { tag: "Excluded", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); + rs.stringExtendFromWithin(s, [{ tag: "Included", _0: i } as rs.RangeBound, { tag: "Excluded", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); } else { - s.v = rs.stringExtendFromWithin(s.v, undefined); + rs.stringExtendFromWithin(s, undefined); } } else if (_24 === 12) { const _123: rs.u8 = rs.u8Rem(a, 4); if (_123 === 0) { - rs.stringReserve(s.v, rs.usizeSub(4294967295, b as rs.usize)); + rs.stringReserve(s, rs.usizeSub(4294967295, b as rs.usize)); } else if (_123 === 1) { - const _128: rs.usize = rs.usizeAdd(rs.usizeAdd(rs.usizeSub(2147483647, rs.stringLen(s.v)), 1), rs.u8Rem(b, 2) as rs.usize); - rs.stringReserve(s.v, _128); + rs.stringReserveExact(s, rs.usizeAdd(rs.usizeAdd(rs.usizeSub(2147483647, s.len), 1), rs.u8Rem(b, 2) as rs.usize)); } else { - rs.stringReserve(s.v, a as rs.usize); - rs.stringReserve(s.v, b as rs.usize); + rs.stringReserve(s, a as rs.usize); + rs.stringReserveExact(s, b as rs.usize); + rs.stringShrinkTo(s, a as rs.usize); + rs.stringShrinkTo(s, 0); } } else { if (rs.u8Rem(a, 4) === 0) { @@ -649,9 +633,9 @@ export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs } else { capacity = a as rs.usize; } - let fresh: string = rs.stringWithCapacity(capacity); - fresh = fresh + s.v; - s.v = fresh; + const fresh: rs.String = rs.stringWithCapacity(capacity); + rs.stringPushStr(fresh, s.v); + Object.assign(s, fresh); } } @@ -666,7 +650,7 @@ export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, data rs.panic("mid > len"); } const head: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); - let s: string = text(head); + let s: rs.String = text(head); const named: Named.Named = { name: text(head) }; const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid), 3); while (true) { @@ -681,52 +665,34 @@ export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, data const b: rs.u8 = _25[2]; const _39: rs.u8 = rs.u8Div(op, 64); if (_39 === 0) { - edit(rs.place(() => named.name, (value10) => named.name = value10), op, a, b, out); + edit(named.name, op, a, b, out); } else if (_39 === 1) { const _42: rs.u8 = rs.u8Rem(op, 8); if (_42 === 0) { - const _44: rs.Place = rs.place(() => s, (value9) => s = value9); - _44.v = _44.v + "é/"; + rs.stringPushStr(s, "é/"); } else if (_42 === 1) { - const _46: rs.Place = rs.place(() => s, (value8) => s = value8); - const _47: rs.usize = offset(s, a); - _46.v = rs.stringTruncate(_46.v, _47); + rs.stringTruncate(s, offset(s.v, a)); } else if (_42 === 2) { - const _51: rs.Place = rs.place(() => s, (value7) => s = value7); - const edit4 = rs.stringPop(_51.v); - _51.v = edit4[0]; - putChar(out, edit4[1]); + putChar(out, rs.stringPop(s)); } else if (_42 === 3) { - const _52: rs.Place = rs.place(() => s, (value6) => s = value6); - const _53: rs.usize = offset(s, a); - _52.v = rs.stringInsertStr(_52.v, _53, "😀"); + rs.stringInsertStr(s, offset(s.v, a), "😀"); } else if (_42 === 4) { - const _60: rs.Place = rs.place(() => s, (value5) => s = value5); - const _61: rs.usize = offset(s, a); - const edit3 = rs.stringSplitOff(_60.v, _61); - _60.v = edit3[0]; - put(out, edit3[1]); + put(out, rs.stringSplitOff(s, offset(s.v, a)).v); } else if (_42 === 5) { - const _66: rs.Place = rs.place(() => s, (value4) => s = value4); - const edit2 = rs.stringRemove(_66.v, 0); - _66.v = edit2[0]; - putChar(out, edit2[1]); + putChar(out, rs.stringRemove(s, 0)); } else if (_42 === 6) { - const _70: rs.Place = rs.place(() => s, (value3) => s = value3); - const edit_ = rs.stringSplitOff(_70.v, 1); - _70.v = edit_[0]; - put(out, edit_[1]); + put(out, rs.stringSplitOff(s, 1).v); } else { - s = ""; + rs.stringClear(s); } } else { - edit(rs.place(() => s, (value) => s = value), op, a, b, out); + edit(s, op, a, b, out); } - put(out, s); - put(out, named.name); + put(out, s.v); + put(out, named.name.v); } - s = s + "😀" + named.name; - put(out, s); + s = rs.stringAdd(rs.stringAdd(s, "😀"), named.name.v); + put(out, s.v); } /** @@ -735,7 +701,7 @@ export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, data * alphabet of signs, digits, and the letters of `true` and `false`. */ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - let one!: string | undefined; + let one!: rs.String | undefined; let all!: rs.Vec; const radix: rs.u32 = rs.u32Add(2, rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 35)); const _13: rs.u8 = rs.u8Rem(rs.u8Div(kind, 14), 3); @@ -744,20 +710,20 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_13 === 1) { one = text(data); } else { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(data)) { const _29: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)); const _30: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)).length); rs.idx(_29, _30); - s = s + String.fromCodePoint(_29.data[_29.start + _30] as rs.char); + rs.stringPush(s, _29.data[_29.start + _30] as rs.char); } one = s; } - const _39: string | undefined = one; + const _39: rs.String | undefined = one; if (_39 === undefined) { all = rs.vecFrom(["true", "false", "True", "FALSE", "", " true", "true ", "t", "truefalse", "a", "é", "ࠀ", "😀", "􏿿", "ab", "a😀", "😀a", "éé", "0", "+0", "-0", "000", "1", "+1", "-1", "+", "-", "--1", "+-1", "1_0", "0x1", "127", "128", "-128", "-129", "255", "256", "32767", "32768", "-32768", "-32769", "65535", "65536", "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "170141183460469231731687303715884105727", "170141183460469231731687303715884105728", "-170141183460469231731687303715884105728", "-170141183460469231731687303715884105729", "340282366920938463463374607431768211455", "340282366920938463463374607431768211456"].slice()); } else { - all = rs.vecFrom([_39]); + all = rs.vecFrom([_39.v]); } for (const _49 of all.items) { const _53: rs.u8 = rs.u8Rem(kind, 14); @@ -772,11 +738,11 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed.ok) { const arg26 = parsed.value; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg26, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); } else { const part13 = new rs.ParseBoolError(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(part13, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(part13, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args4[1]), "|", rs.fmtSpec({ alternate: true }, args4[1])])); + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args4[1]), "|", rs.fmtSpec({ alternate: true }, args4[1])]).v); } } parse$1yfzdza(_49); @@ -791,11 +757,11 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed2.ok) { const arg25 = parsed2.value; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(arg25, f)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([args6[0]]).v); } else { const e: rs.ParseCharError = parsed2.error; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseCharErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseCharErrorDebug(e, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[1])])); + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[1])]).v); } } rs.charFromStr(_49); @@ -811,28 +777,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed3.ok) { const arg23 = parsed3.value; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(arg23, f)]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([args10[0]]).v); } else { const e2: rs.ParseIntError = parsed3.error; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rs.fmtSpec({ alternate: true }, args12[1])])); + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rs.fmtSpec({ alternate: true }, args12[1])]).v); } } const _139: rs.Result = parse$1y4njjc(_49); if (!_139.ok) { const part12 = _139.error.kind; const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part12)]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([args14[0]]).v); } const _195: rs.Result = nonzero_fromStrRadix$1i96daa(_49, radix2); if (_195.ok) { const arg24 = _195.value; const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg24, f)]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([args16[0]]).v); } else { const e4: rs.ParseIntError = _195.error; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f)]; - put(out, rs.fmtFormat([args18[0], "|", args18[1]])); + put(out, rs.fmtFormat([args18[0], "|", args18[1]]).v); } } else if (_53 === 3) { const radix3: rs.u32 = radix; @@ -846,28 +812,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed4.ok) { const arg21 = parsed4.value; const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Debug(arg21, f)]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([args20[0]]).v); } else { const e5: rs.ParseIntError = parsed4.error; const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f)]; - put(out, rs.fmtFormat([args22[0], "|", args22[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rs.fmtSpec({ alternate: true }, args22[1])])); + put(out, rs.fmtFormat([args22[0], "|", args22[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rs.fmtSpec({ alternate: true }, args22[1])]).v); } } const _226: rs.Result = parse$13tnb7e(_49); if (!_226.ok) { const part11 = _226.error.kind; const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part11)]; - put(out, rs.fmtFormat([args24[0]])); + put(out, rs.fmtFormat([args24[0]]).v); } const _282: rs.Result = nonzero_fromStrRadix$0yk2yqd(_49, radix3); if (_282.ok) { const arg22 = _282.value; const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg22, f)]; - put(out, rs.fmtFormat([args26[0]])); + put(out, rs.fmtFormat([args26[0]]).v); } else { const e7: rs.ParseIntError = _282.error; const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f)]; - put(out, rs.fmtFormat([args28[0], "|", args28[1]])); + put(out, rs.fmtFormat([args28[0], "|", args28[1]]).v); } } else if (_53 === 4) { const radix4: rs.u32 = radix; @@ -881,28 +847,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed5.ok) { const arg19 = parsed5.value; const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(arg19, f)]; - put(out, rs.fmtFormat([args30[0]])); + put(out, rs.fmtFormat([args30[0]]).v); } else { const e8: rs.ParseIntError = parsed5.error; const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f)]; - put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rs.fmtSpec({ alternate: true }, args32[1])])); + put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rs.fmtSpec({ alternate: true }, args32[1])]).v); } } const _313: rs.Result = parse$04z9euf(_49); if (!_313.ok) { const part10 = _313.error.kind; const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part10)]; - put(out, rs.fmtFormat([args34[0]])); + put(out, rs.fmtFormat([args34[0]]).v); } const _369: rs.Result = nonzero_fromStrRadix$1y934te(_49, radix4); if (_369.ok) { const arg20 = _369.value; const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg20, f)]; - put(out, rs.fmtFormat([args36[0]])); + put(out, rs.fmtFormat([args36[0]]).v); } else { const e10: rs.ParseIntError = _369.error; const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f)]; - put(out, rs.fmtFormat([args38[0], "|", args38[1]])); + put(out, rs.fmtFormat([args38[0], "|", args38[1]]).v); } } else if (_53 === 5) { const radix5: rs.u32 = radix; @@ -916,28 +882,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed6.ok) { const arg17 = parsed6.value; const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(arg17, f)]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([args40[0]]).v); } else { const e11: rs.ParseIntError = parsed6.error; const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f)]; - put(out, rs.fmtFormat([args42[0], "|", args42[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rs.fmtSpec({ alternate: true }, args42[1])])); + put(out, rs.fmtFormat([args42[0], "|", args42[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rs.fmtSpec({ alternate: true }, args42[1])]).v); } } const _400: rs.Result = parse$1fob3ck(_49); if (!_400.ok) { const part9 = _400.error.kind; const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part9)]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([args44[0]]).v); } const _456: rs.Result = nonzero_fromStrRadix$11u1rq7(_49, radix5); if (_456.ok) { const arg18 = _456.value; const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg18, f)]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([args46[0]]).v); } else { const e13: rs.ParseIntError = _456.error; const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f)]; - put(out, rs.fmtFormat([args48[0], "|", args48[1]])); + put(out, rs.fmtFormat([args48[0], "|", args48[1]]).v); } } else if (_53 === 6) { const radix6: rs.u32 = radix; @@ -951,28 +917,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed7.ok) { const arg15 = parsed7.value; const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(arg15, f)]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([args50[0]]).v); } else { const e14: rs.ParseIntError = parsed7.error; const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f)]; - put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rs.fmtSpec({ alternate: true }, args52[1])])); + put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rs.fmtSpec({ alternate: true }, args52[1])]).v); } } const _487: rs.Result = parse$0j8ztlu(_49); if (!_487.ok) { const part8 = _487.error.kind; const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part8)]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([args54[0]]).v); } const _543: rs.Result = nonzero_fromStrRadix$1ejhcoz(_49, radix6); if (_543.ok) { const arg16 = _543.value; const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg16, f)]; - put(out, rs.fmtFormat([args56[0]])); + put(out, rs.fmtFormat([args56[0]]).v); } else { const e16: rs.ParseIntError = _543.error; const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f)]; - put(out, rs.fmtFormat([args58[0], "|", args58[1]])); + put(out, rs.fmtFormat([args58[0], "|", args58[1]]).v); } } else if (_53 === 7) { const radix7: rs.u32 = radix; @@ -986,28 +952,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed8.ok) { const arg13 = parsed8.value; const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(arg13, f)]; - put(out, rs.fmtFormat([args60[0]])); + put(out, rs.fmtFormat([args60[0]]).v); } else { const e17: rs.ParseIntError = parsed8.error; const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f)]; - put(out, rs.fmtFormat([args62[0], "|", args62[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rs.fmtSpec({ alternate: true }, args62[1])])); + put(out, rs.fmtFormat([args62[0], "|", args62[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rs.fmtSpec({ alternate: true }, args62[1])]).v); } } const _574: rs.Result = parse$1acldxi(_49); if (!_574.ok) { const part7 = _574.error.kind; const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part7)]; - put(out, rs.fmtFormat([args64[0]])); + put(out, rs.fmtFormat([args64[0]]).v); } const _630: rs.Result = nonzero_fromStrRadix$1dc88z1(_49, radix7); if (_630.ok) { const arg14 = _630.value; const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg14, f)]; - put(out, rs.fmtFormat([args66[0]])); + put(out, rs.fmtFormat([args66[0]]).v); } else { const e19: rs.ParseIntError = _630.error; const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f)]; - put(out, rs.fmtFormat([args68[0], "|", args68[1]])); + put(out, rs.fmtFormat([args68[0], "|", args68[1]]).v); } } else if (_53 === 8) { const radix8: rs.u32 = radix; @@ -1021,28 +987,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed9.ok) { const arg11 = parsed9.value; const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Debug(arg11, f)]; - put(out, rs.fmtFormat([args70[0]])); + put(out, rs.fmtFormat([args70[0]]).v); } else { const e20: rs.ParseIntError = parsed9.error; const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f)]; - put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rs.fmtSpec({ alternate: true }, args72[1])])); + put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rs.fmtSpec({ alternate: true }, args72[1])]).v); } } const _661: rs.Result = parse$0jsh5gh(_49); if (!_661.ok) { const part6 = _661.error.kind; const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part6)]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([args74[0]]).v); } const _717: rs.Result = nonzero_fromStrRadix$011a32r(_49, radix8); if (_717.ok) { const arg12 = _717.value; const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg12, f)]; - put(out, rs.fmtFormat([args76[0]])); + put(out, rs.fmtFormat([args76[0]]).v); } else { const e22: rs.ParseIntError = _717.error; const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f)]; - put(out, rs.fmtFormat([args78[0], "|", args78[1]])); + put(out, rs.fmtFormat([args78[0], "|", args78[1]]).v); } } else if (_53 === 9) { const radix9: rs.u32 = radix; @@ -1056,28 +1022,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed10.ok) { const arg9 = parsed10.value; const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Debug(arg9, f)]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([args80[0]]).v); } else { const e23: rs.ParseIntError = parsed10.error; const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f)]; - put(out, rs.fmtFormat([args82[0], "|", args82[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rs.fmtSpec({ alternate: true }, args82[1])])); + put(out, rs.fmtFormat([args82[0], "|", args82[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rs.fmtSpec({ alternate: true }, args82[1])]).v); } } const _748: rs.Result = parse$0wntisu(_49); if (!_748.ok) { const part5 = _748.error.kind; const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part5)]; - put(out, rs.fmtFormat([args84[0]])); + put(out, rs.fmtFormat([args84[0]]).v); } const _804: rs.Result = nonzero_fromStrRadix$1u0zwz8(_49, radix9); if (_804.ok) { const arg10 = _804.value; const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg10, f)]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([args86[0]]).v); } else { const e25: rs.ParseIntError = _804.error; const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f)]; - put(out, rs.fmtFormat([args88[0], "|", args88[1]])); + put(out, rs.fmtFormat([args88[0], "|", args88[1]]).v); } } else if (_53 === 10) { const radix10: rs.u32 = radix; @@ -1091,28 +1057,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed11.ok) { const arg7 = parsed11.value; const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Debug(arg7, f)]; - put(out, rs.fmtFormat([args90[0]])); + put(out, rs.fmtFormat([args90[0]]).v); } else { const e26: rs.ParseIntError = parsed11.error; const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f)]; - put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rs.fmtSpec({ alternate: true }, args92[1])])); + put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rs.fmtSpec({ alternate: true }, args92[1])]).v); } } const _835: rs.Result = parse$18h4mna(_49); if (!_835.ok) { const part4 = _835.error.kind; const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part4)]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([args94[0]]).v); } const _891: rs.Result = nonzero_fromStrRadix$1m6epfo(_49, radix10); if (_891.ok) { const arg8 = _891.value; const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg8, f)]; - put(out, rs.fmtFormat([args96[0]])); + put(out, rs.fmtFormat([args96[0]]).v); } else { const e28: rs.ParseIntError = _891.error; const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f)]; - put(out, rs.fmtFormat([args98[0], "|", args98[1]])); + put(out, rs.fmtFormat([args98[0], "|", args98[1]]).v); } } else if (_53 === 11) { const radix11: rs.u32 = radix; @@ -1126,28 +1092,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed12.ok) { const arg5 = parsed12.value; const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Debug(arg5, f)]; - put(out, rs.fmtFormat([args100[0]])); + put(out, rs.fmtFormat([args100[0]]).v); } else { const e29: rs.ParseIntError = parsed12.error; const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f)]; - put(out, rs.fmtFormat([args102[0], "|", args102[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rs.fmtSpec({ alternate: true }, args102[1])])); + put(out, rs.fmtFormat([args102[0], "|", args102[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rs.fmtSpec({ alternate: true }, args102[1])]).v); } } const _922: rs.Result = parse$1gh8p0t(_49); if (!_922.ok) { const part3 = _922.error.kind; const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part3)]; - put(out, rs.fmtFormat([args104[0]])); + put(out, rs.fmtFormat([args104[0]]).v); } const _978: rs.Result = nonzero_fromStrRadix$15i0o2z(_49, radix11); if (_978.ok) { const arg6 = _978.value; const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg6, f)]; - put(out, rs.fmtFormat([args106[0]])); + put(out, rs.fmtFormat([args106[0]]).v); } else { const e31: rs.ParseIntError = _978.error; const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f)]; - put(out, rs.fmtFormat([args108[0], "|", args108[1]])); + put(out, rs.fmtFormat([args108[0], "|", args108[1]]).v); } } else if (_53 === 12) { const radix12: rs.u32 = radix; @@ -1161,28 +1127,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed13.ok) { const arg3 = parsed13.value; const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Debug(arg3, f)]; - put(out, rs.fmtFormat([args110[0]])); + put(out, rs.fmtFormat([args110[0]]).v); } else { const e32: rs.ParseIntError = parsed13.error; const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f)]; - put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rs.fmtSpec({ alternate: true }, args112[1])])); + put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rs.fmtSpec({ alternate: true }, args112[1])]).v); } } const _1009: rs.Result = parse$1d17hvd(_49); if (!_1009.ok) { const part2 = _1009.error.kind; const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part2)]; - put(out, rs.fmtFormat([args114[0]])); + put(out, rs.fmtFormat([args114[0]]).v); } const _1065: rs.Result = nonzero_fromStrRadix$09x3avk(_49, radix12); if (_1065.ok) { const arg4 = _1065.value; const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg4, f)]; - put(out, rs.fmtFormat([args116[0]])); + put(out, rs.fmtFormat([args116[0]]).v); } else { const e34: rs.ParseIntError = _1065.error; const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f)]; - put(out, rs.fmtFormat([args118[0], "|", args118[1]])); + put(out, rs.fmtFormat([args118[0], "|", args118[1]]).v); } } else { const radix13: rs.u32 = radix; @@ -1196,28 +1162,28 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (parsed14.ok) { const arg = parsed14.value; const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDebug(arg, f)]; - put(out, rs.fmtFormat([args120[0]])); + put(out, rs.fmtFormat([args120[0]]).v); } else { const e35: rs.ParseIntError = parsed14.error; const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f)]; - put(out, rs.fmtFormat([args122[0], "|", args122[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rs.fmtSpec({ alternate: true }, args122[1])])); + put(out, rs.fmtFormat([args122[0], "|", args122[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rs.fmtSpec({ alternate: true }, args122[1])]).v); } } const _1096: rs.Result = parse$09069e1(_49); if (!_1096.ok) { const part = _1096.error.kind; const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part)]; - put(out, rs.fmtFormat([args124[0]])); + put(out, rs.fmtFormat([args124[0]]).v); } const _1152: rs.Result = nonzero_fromStrRadix$1jg523s(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]; - put(out, rs.fmtFormat([args126[0]])); + put(out, rs.fmtFormat([args126[0]]).v); } else { const e37: rs.ParseIntError = _1152.error; const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f)]; - put(out, rs.fmtFormat([args128[0], "|", args128[1]])); + put(out, rs.fmtFormat([args128[0], "|", args128[1]]).v); } } } @@ -1228,95 +1194,103 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * picks, from text of chars of every UTF-8 width and its parts between `/`s. */ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = text(data); - const chars: rs.Vec = rs.iterToVec(rs.strChars(s), "next", 4); - const parts: rs.Vec = rs.iterToVec(rs.strSplit(s, "/"), "next", 8); + const s: rs.String = text(data); + const chars: rs.Vec = rs.iterToVec(rs.strChars(s.v), "next", 4); + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s.v, "/"), "next", 8); const nexts: rs.Cell = new rs.Cell(0); const named: Named.Named = { name: text(rs.byteSliceRange(data, 0, rs.usizeDiv(data.length, 2))) }; const _21: rs.u8 = rs.u8Rem(kind, 4); if (_21 === 0) { - put(out, rs.stringExtendChars("", rs.strChars(s))); - put(out, rs.stringExtendChars("", rs.iterFilter(rs.iterRev(rs.strChars(s)), (c: rs.char): boolean => { + const _27: rs.Iter = rs.strChars(s.v); + put(out, rs.stringExtendChars(rs.stringNew(), _27).v); + const _34: rs.Iter = rs.iterFilter(rs.iterRev(rs.strChars(s.v)), (c: rs.char): boolean => { return !rs.isAsciiDigit(c); - }))); - put(out, rs.stringExtendChars("", rs.iterSlice(chars.items))); - put(out, rs.stringExtendChars("", rs.iterSkip(rs.iterSlice(chars.items), 1))); + }); + put(out, rs.stringExtendChars(rs.stringNew(), _34).v); + const _43: rs.Iter = rs.iterSlice(chars.items); + put(out, rs.stringExtendChars(rs.stringNew(), _43).v); + const _50: rs.Iter = rs.iterSkip(rs.iterSlice(chars.items), 1); + put(out, rs.stringExtendChars(rs.stringNew(), _50).v); rs.iterEmpty(); - put(out, rs.stringExtendChars("", rs.iterEmpty() as rs.Iter)); - put(out, rs.stringExtendChars("", rs.iterOption(rs.charFromU32(kind as rs.u32)))); - put(out, rs.stringExtendChars("", rs.iterFrom({ items: rs.sliceFrom(chars.items), nexts }, Counted.next$iter_Iterator_char))); + put(out, rs.stringExtendChars(rs.stringNew(), rs.iterEmpty() as rs.Iter).v); + const _64: rs.Iter = rs.iterOption(rs.charFromU32(kind as rs.u32)); + put(out, rs.stringExtendChars(rs.stringNew(), _64).v); + const counted: Counted.Counted = { items: rs.sliceFrom(chars.items), nexts }; + put(out, rs.stringExtendChars(rs.stringNew(), rs.iterFrom(counted, Counted.next$iter_Iterator_char)).v); } else if (_21 === 1) { - put(out, rs.stringExtend("", rs.iterSlice(parts.items))); - put(out, rs.stringExtend("", rs.iterRev(rs.strSplit(s, "/")))); - put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(parts.items), (p3: string): string => { - return p3; - }))); - put(out, rs.stringFromStrings(rs.iterFilter(rs.iterMap(rs.strSplit(s, "/"), (p4: string): string => { + const _79: rs.Iter = rs.iterSlice(parts.items); + put(out, rs.stringExtend(rs.stringNew(), _79).v); + const _87: rs.Iter = rs.iterRev(rs.strSplit(s.v, "/")); + put(out, rs.stringExtend(rs.stringNew(), _87).v); + put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(parts.items), (p3: string): rs.String => { + return rs.stringFrom(p3); + })).v); + put(out, rs.stringFromStrings(rs.iterFilter(rs.iterMap(rs.strSplit(s.v, "/"), (p4: string): rs.String => { const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, p4)]; return rs.fmtFormat([args4[0], args4[0]]); - }), (p5: string): boolean => { - return !(p5.length === 0); - }))); + }), (p5: rs.String): boolean => { + return !(p5.len === 0); + })).v); rs.iterEmpty(); - put(out, rs.stringFromStrings(rs.iterEmpty() as rs.Iter)); - put(out, rs.strCowStr(rs.stringExtendChars("", rs.iterRev(rs.strChars(s))))); - put(out, rs.stringExtend("", rs.iterSlice(parts.items))); - const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p6: string): string => { - return p6; + put(out, rs.stringFromStrings(rs.iterEmpty() as rs.Iter).v); + const _114: rs.Iter = rs.iterRev(rs.strChars(s.v)); + put(out, rs.strCowStr(rs.stringExtendChars(rs.stringNew(), _114))); + const _122: rs.Iter = rs.iterSlice(parts.items); + put(out, rs.stringExtend(rs.stringNew(), _122).v); + const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p6: string): rs.String => { + return rs.stringFrom(p6); }), undefined, 12, true); - put(out, rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.iterSlice(owned.items), (p7: string): rs.StrCow => { - return new rs.Borrowed(p7); - }), rs.strCowStr))); - put(out, rs.stringFromStrings(rs.iterFrom({ items: rs.sliceFrom(owned.items), nexts }, Counted.next$iter_Iterator_String))); + put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(owned.items), (p7: rs.String): rs.StrCow => { + return new rs.Borrowed(p7.v); + })).v); + put(out, rs.stringFromStrings(rs.iterFrom({ items: rs.sliceFrom(owned.items), nexts }, Counted.next$iter_Iterator_String)).v); } else if (_21 === 2) { - let t: string = "é"; + const t: rs.String = rs.stringFrom("é"); const _153: rs.Slice = rs.sliceFrom(chars.items); - extendChars(rs.place(() => t, (value) => t = value), _153, kind); - const _157: rs.Iter = rs.iterRev(rs.strChars(s)); - t = rs.stringExtendChars(t, _157); - named.name = rs.stringExtendChars(named.name, rs.iterSlice(chars.items)); + extendChars(t, _153, kind); + const _157: rs.Iter = rs.iterRev(rs.strChars(s.v)); + rs.stringExtendChars(t, _157); + rs.stringExtendChars(named.name, rs.iterSlice(chars.items)); rs.iterEmpty(); - named.name = rs.stringExtendChars(named.name, rs.iterEmpty() as rs.Iter); + rs.stringExtendChars(named.name, rs.iterEmpty() as rs.Iter); const counted3: Counted.Counted = { items: rs.sliceFrom(chars.items), nexts }; - t = rs.stringExtendChars(t, rs.iterFrom(counted3, Counted.next$iter_Iterator_char)); - put(out, t); + rs.stringExtendChars(t, rs.iterFrom(counted3, Counted.next$iter_Iterator_char)); + put(out, t.v); } else { - let t2: string = ""; - const _179: rs.Iter = rs.strSplit(s, "/"); - t2 = rs.stringExtend(t2, _179); - const _184: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p: string): string => { + const t2: rs.String = rs.stringNew(); + const _179: rs.Iter = rs.strSplit(s.v, "/"); + rs.stringExtend(t2, _179); + const _184: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p: string): rs.String => { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, p)]; return rs.fmtFormat([args2[0], "é"]); }); - t2 = rs.stringExtend(t2, _184); + rs.stringExtend(t2, _184); const _190: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); - named.name = rs.stringExtend(named.name, _190); + rs.stringExtend(named.name, _190); const _197: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p2: string): rs.StrCow => { - return p2; + return rs.stringFrom(p2); }); - named.name = rs.stringExtend(named.name, rs.iterMap(_197, rs.strCowStr)); + rs.stringExtend(named.name, _197); rs.iterEmpty(); - named.name = rs.stringExtend(named.name, rs.iterEmpty() as rs.Iter); + rs.stringExtend(named.name, rs.iterEmpty() as rs.Iter); const counted4: Counted.Counted = { items: rs.sliceFrom(parts.items), nexts }; - t2 = rs.stringExtend(t2, rs.iterFrom(counted4, Counted.next$iter_Iterator_ref_str)); - put(out, t2); + rs.stringExtend(t2, rs.iterFrom(counted4, Counted.next$iter_Iterator_ref_str)); + put(out, t2.v); } - put(out, named.name); + put(out, named.name.v); rs.byteVecPush(out, nexts.v); } -export function extendChars(t: rs.Place, chars: rs.Slice, kind: rs.u8): void { +export function extendChars(t: rs.String, chars: rs.Slice, kind: rs.u8): void { const _4: rs.u8 = rs.u8Rem(rs.u8Div(kind, 4), 3); if (_4 === 0) { - const _8: rs.Iter = rs.iterSlice(rs.sliceItems(chars)); - t.v = rs.stringExtendChars(t.v, _8); + rs.stringExtendChars(t, rs.iterSlice(rs.sliceItems(chars))); } else if (_4 === 1) { - const _9: rs.Iter = rs.iterFilter(rs.iterSlice(rs.sliceItems(chars)), (c: rs.char): boolean => { + rs.stringExtendChars(t, rs.iterFilter(rs.iterSlice(rs.sliceItems(chars)), (c: rs.char): boolean => { return rs.isAsciiDigit(c); - }); - t.v = rs.stringExtendChars(t.v, _9); + })); } else { - t.v = rs.stringExtendChars(t.v, rs.iterOption(128512)); + rs.stringExtendChars(t, rs.iterOption(128512)); } } @@ -1324,7 +1298,7 @@ export function extendChars(t: rs.Place, chars: rs.Slice, kind: * `String::drain` of `s` by the range `form` picks, between offsets from `a` and `b`, * read from either end by `steps`' bits, then dropped, forgotten, or read to its end. */ -export function drainBy(s: rs.Place, form: rs.u8, a: rs.u8, b: rs.u8, steps: rs.u8, out: rs.ByteVec): void { +export function drainBy(s: rs.String, form: rs.u8, a: rs.u8, b: rs.u8, steps: rs.u8, out: rs.ByteVec): void { let drain!: rs.Iter; let _35!: rs.u8; let c!: rs.char | undefined; @@ -1375,7 +1349,8 @@ export function drainBy(s: rs.Place, form: rs.u8, a: rs.u8, b: rs.u8, st _71 = false; } else if (_49 === 2) { _71 = false; - put(out, rs.stringExtendChars("", drain, true)); + const _57: rs.Iter = drain; + put(out, rs.stringExtendChars(rs.stringNew(), _57, true).v); } else { put(out, rs.stringDrainAsStr(drain)); _71 = false; @@ -1407,7 +1382,7 @@ export function drains(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat rs.panic("mid > len"); } const head: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); - let s: string = text(head); + const s: rs.String = text(head); const named: Named.Named = { name: text(head) }; const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid), 4); while (true) { @@ -1423,26 +1398,27 @@ export function drains(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const steps: rs.u8 = _26[3]; const _44: rs.u8 = rs.u8Rem(rs.u8Div(form, 32), 4); if (_44 === 0) { - drainBy(rs.place(() => named.name, (value6) => named.name = value6), form, a, b, steps, out); + drainBy(named.name, form, a, b, steps, out); } else if (_44 === 1) { const _49: rs.u8 = rs.u8Rem(form, 4); if (_49 === 0) { - const _56: { end: rs.usize } = { end: offset(s, a) }; - put(out, rs.stringExtendChars("", rs.stringDrain(rs.place(() => s, (value5) => s = value5), _56), true)); + const _56: { end: rs.usize } = { end: offset(s.v, a) }; + const _54: rs.Iter = rs.stringDrain(s, _56); + put(out, rs.stringExtendChars(rs.stringNew(), _54, true).v); } else if (_49 === 1) { - const _64: rs.RangeFrom = new rs.RangeFrom(offset(s, a), rs.usizeStep); - rs.byteVecPush(out, rs.ownedCount(rs.stringDrain(rs.place(() => s, (value4) => s = value4), _64)) & 0xff); + const _64: rs.RangeFrom = new rs.RangeFrom(offset(s.v, a), rs.usizeStep); + rs.byteVecPush(out, rs.ownedCount(rs.stringDrain(s, _64)) & 0xff); } else if (_49 === 2) { - putChar(out, rs.ownedLast(rs.stringDrain(rs.place(() => s, (value3) => s = value3), undefined))); + putChar(out, rs.ownedLast(rs.stringDrain(s, undefined))); } else { - const _73: rs.Range = new rs.Range(offset(s, a), offset(s, b)); - rs.drop(rs.stringDrain(rs.place(() => s, (value2) => s = value2), _73)); + const _73: rs.Range = new rs.Range(offset(s.v, a), offset(s.v, b)); + rs.drop(rs.stringDrain(s, _73)); } } else { - drainBy(rs.place(() => s, (value) => s = value), form, a, b, steps, out); + drainBy(s, form, a, b, steps, out); } - put(out, s); - put(out, named.name); + put(out, s.v); + put(out, named.name.v); } } @@ -1465,10 +1441,8 @@ export function hinted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = _7[0]; const m: rs.u32 = _7[1]; const sub: rs.usize = rs.usizeDiv(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0) as rs.usize, rs.sliceFrom([0, 5, 8, 9, 2147483645, 2147483648, 4294967295]).length); - let t: string = "aé"; - const _25: rs.Place = rs.place(() => t, (value) => t = value); - const _26: string = text(option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 2), rs.byteSliceFrom(Uint8Array.of()))); - _25.v = _25.v + _26; + let t: rs.String = rs.stringFrom("aé"); + rs.stringPushStr(t, text(option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 2), rs.byteSliceFrom(Uint8Array.of()))).v); const calls: rs.Cell = new rs.Cell(0); const f: (a0: rs.u32) => rs.char = (_2: rs.u32): rs.char => { rs.cellSet(calls, rs.usizeAdd(calls.v, 1)); @@ -1484,83 +1458,62 @@ export function hinted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; const _38: rs.u8 = rs.u8Rem(kind, 10); if (_38 === 0) { - const _40: rs.Place = rs.place(() => t, (value13) => t = value13); - const _41: rs.Iter = rs.iterMap(new rs.Range(0, n), f); - _40.v = rs.stringExtendChars(_40.v, _41); + rs.stringExtendChars(t, rs.iterMap(new rs.Range(0, n), f)); } else if (_38 === 1) { - t = rs.stringExtendChars("", rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f)); + const _44: rs.Iter = rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f); + t = rs.stringExtendChars(rs.stringNew(), _44); } else if (_38 === 2) { - const _48: rs.Place = rs.place(() => t, (value12) => t = value12); - const _49: rs.Iter = rs.iterSkip(rs.iterMap(new rs.Range(0, rs.u64Or(rs.u64Shl(n as rs.u64, 8), m as rs.u64), rs.u64Step), (i4: rs.u64): rs.char => { + rs.stringExtendChars(t, rs.iterSkip(rs.iterMap(new rs.Range(0, rs.u64Or(rs.u64Shl(n as rs.u64, 8), m as rs.u64), rs.u64Step), (i4: rs.u64): rs.char => { return f(rs.u64Low(i4)); - }), m as rs.usize); - _48.v = rs.stringExtendChars(_48.v, _49); + }), m as rs.usize)); } else if (_38 === 3) { - const _61: rs.Place = rs.place(() => t, (value11) => t = value11); - const _62: rs.Iter = rs.iterTake(rs.iterMap(new rs.Range(0, n), f), m as rs.usize, undefined, true); - _61.v = rs.stringExtendChars(_61.v, _62); + rs.stringExtendChars(t, rs.iterTake(rs.iterMap(new rs.Range(0, n), f), m as rs.usize, undefined, true)); } else if (_38 === 4) { - const _66: rs.Place = rs.place(() => t, (value10) => t = value10); + const _66: rs.String = t; const _69: rs.Range = new rs.Range(0, n); if (!(n === 4294967295)) { _70 = 1; } else { _70 = rs.usizeAdd(1, rs.usizeRem(m as rs.usize, 2)); } - const _67: rs.Iter = rs.iterMap(rs.iterStepBy(_69, _70, undefined, 4294967295), f); - _66.v = rs.stringExtendChars(_66.v, _67); + rs.stringExtendChars(_66, rs.iterMap(rs.iterStepBy(_69, _70, undefined, 4294967295), f)); } else if (_38 === 5) { if (rs.u32Rem(m, 2) === 0) { - const _78: rs.Place = rs.place(() => t, (value9) => t = value9); - const _79: rs.Iter = rs.iterChain(rs.iterMap(new rs.Range(0, n), f), rs.iterMap(new rs.Range(0, m), f)); - _78.v = rs.stringExtendChars(_78.v, _79); + rs.stringExtendChars(t, rs.iterChain(rs.iterMap(new rs.Range(0, n), f), rs.iterMap(new rs.Range(0, m), f))); } else { - const _84: rs.Place = rs.place(() => t, (value8) => t = value8); - const _85: rs.Iter = rs.iterMap(rs.iterZip(new rs.Range(0, n), new rs.Range(0, m), [false, false]), (_211: [rs.u32, rs.u32]): rs.char => { + rs.stringExtendChars(t, rs.iterMap(rs.iterZip(new rs.Range(0, n), new rs.Range(0, m), [false, false]), (_211: [rs.u32, rs.u32]): rs.char => { return f(_211[0]); - }); - _84.v = rs.stringExtendChars(_84.v, _85); + })); } } else if (_38 === 6) { - const _91: rs.Place = rs.place(() => t, (value7) => t = value7); - const _92: rs.Iter = rs.iterFlatMap(new rs.Range(0, n), (i2: rs.u32): rs.char[] => { + rs.stringExtendChars(t, rs.iterFlatMap(new rs.Range(0, n), (i2: rs.u32): rs.char[] => { return [f(i2), f(i2)]; - }, (value: rs.char[]) => rs.iterSlice(value), true, 2); - _91.v = rs.stringExtendChars(_91.v, _92); + }, (value: rs.char[]) => rs.iterSlice(value), true, 2)); } else if (_38 === 7) { - const _96: rs.Place = rs.place(() => t, (value6) => t = value6); - const _97: rs.Iter = rs.iterChain(rs.iterChain(rs.iterChain(rs.iterChain(rs.iterMap(new rs.Range(0, rs.u32SaturatingSub(n, 5)), f), rs.iterOnce(120)), rs.iterOption(121)), rs.strChars("é😀")), rs.iterSlice([122])); - _96.v = rs.stringExtendChars(_96.v, _97); + rs.stringExtendChars(t, rs.iterChain(rs.iterChain(rs.iterChain(rs.iterChain(rs.iterMap(new rs.Range(0, rs.u32SaturatingSub(n, 5)), f), rs.iterOnce(120)), rs.iterOption(121)), rs.strChars("é😀")), rs.iterSlice([122]))); } else if (_38 === 8) { const _112: rs.usize = rs.usizeRem(sub, 3); if (_112 === 0) { - const _114: rs.Place = rs.place(() => t, (value5) => t = value5); - const _115: rs.Iter = rs.iterMap(new rs.Range({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_210: rs.u64): rs.char => { + rs.stringExtendChars(t, rs.iterMap(new rs.Range({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_210: rs.u64): rs.char => { return f(0); - }); - _114.v = rs.stringExtendChars(_114.v, _115); + })); } else if (_112 === 1) { - const _128: rs.Place = rs.place(() => t, (value4) => t = value4); - const _129: rs.Iter = rs.iterMap(new rs.Range(rs.i128Neg(rs.i128Shl(1, 100)), rs.i128Add(rs.i128Neg(rs.i128Shl(1, 100)), n as rs.i128), rs.i128Step), (_27: rs.i128): rs.char => { + rs.stringExtendChars(t, rs.iterMap(new rs.Range(rs.i128Neg(rs.i128Shl(1, 100)), rs.i128Add(rs.i128Neg(rs.i128Shl(1, 100)), n as rs.i128), rs.i128Step), (_27: rs.i128): rs.char => { return f(0); - }); - _128.v = rs.stringExtendChars(_128.v, _129); + })); } else { - const _146: rs.Place = rs.place(() => t, (value3) => t = value3); - const _147: rs.Iter = rs.iterMap(new rs.RangeInclusive({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_24: rs.u64): rs.char => { + rs.stringExtendChars(t, rs.iterMap(new rs.RangeInclusive({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_24: rs.u64): rs.char => { return f(0); - }); - _146.v = rs.stringExtendChars(_146.v, _147); + })); } } else { const chars: rs.Peekable = rs.iterPeekable(rs.iterFuse(rs.iterRev(rs.iterMap(rs.iterEnumerate(rs.iterMap(new rs.Range(0, n), f)), (_23: [rs.usize, rs.char]): rs.char => { return _23[1]; })), true)); putChar(out, rs.peekablePeek(chars)); - const _172: rs.Place = rs.place(() => t, (value2) => t = value2); - _172.v = rs.stringExtendChars(_172.v, chars); + rs.stringExtendChars(t, chars); } - put(out, t); + put(out, t.v); } /** A part a checked read gives, or 0xfe if it gave none. */ @@ -1625,7 +1578,7 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.usize = _10[0]; const b: rs.usize = _10[1]; const s: string = text; - let string: string = text; + const string: rs.String = rs.stringFrom(text); const _20: rs.u8 = rs.u8Rem(kind, 16); if (_20 === 0) { putPart(out, rs.strGet(s, a, b)); @@ -1637,7 +1590,7 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putPart(out, rs.strGet(s, bounds22[0], bounds22[1])); const bounds23 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(s)); putPart(out, rs.strGet(s, bounds23[0], bounds23[1])); - const _41: string = string; + const _41: string = string.v; const bounds24 = rs.sliceGetBounds(exhausted(a, b), rs.stringLen(_41)); putPart(out, rs.strGet(_41, bounds24[0], bounds24[1])); } else if (_20 === 2) { @@ -1657,11 +1610,11 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, rs.strSlice(s, bounds16[0], bounds16[1])); } else if (_20 === 5) { const _70: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const bounds15 = rs.strInclusive(string, _70); - put(out, rs.strSlice(string, bounds15[0], bounds15[1])); + const bounds15 = rs.strInclusive(string.v, _70); + put(out, rs.strSlice(string.v, bounds15[0], bounds15[1])); } else if (_20 === 6) { - const bounds14 = rs.strInclusive(string, { end: b, inclusive: true }); - put(out, rs.strSlice(string, bounds14[0], bounds14[1])); + const bounds14 = rs.strInclusive(string.v, { end: b, inclusive: true }); + put(out, rs.strSlice(string.v, bounds14[0], bounds14[1])); } else if (_20 === 7) { const bounds13 = rs.strInclusive(s, exhausted(a, b)); put(out, rs.strSlice(s, bounds13[0], bounds13[1])); @@ -1669,60 +1622,55 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const bounds12 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); put(out, rs.strSlice(s, bounds12[0], bounds12[1])); } else if (_20 === 9) { - const bounds11 = rs.boundsRange([{ tag: "Included", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(string)); - put(out, rs.strSlice(string, bounds11[0], bounds11[1])); + const bounds11 = rs.boundsRange([{ tag: "Included", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(string.v)); + put(out, rs.strSlice(string.v, bounds11[0], bounds11[1])); } else if (_20 === 10) { - const _89: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const s7 = rs.place(() => string, (value6) => string = value6); - const bounds7 = rs.sliceGetBounds(_89, rs.stringLen(s7.v)); - putUpper(out, rs.strGetMut(s7, bounds7[0], bounds7[1])); - const s8 = rs.place(() => string, (value7) => string = value7); - const bounds8 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(s8.v)); - putUpper(out, rs.strGetMut(s8, bounds8[0], bounds8[1])); - const _99: rs.RangeInclusive = exhausted(a, b); - const s9 = rs.place(() => string, (value8) => string = value8); - const bounds9 = rs.sliceGetBounds(_99, rs.stringLen(s9.v)); - putUpper(out, rs.strGetMut(s9, bounds9[0], bounds9[1])); - const s10 = rs.place(() => string, (value9) => string = value9); - const bounds10 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s10.v)); - putUpper(out, rs.strGetMut(s10, bounds10[0], bounds10[1])); - put(out, string); + const _87: rs.Place = string; + const bounds7 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), rs.stringLen(_87.v)); + putUpper(out, rs.strGetMut(_87, bounds7[0], bounds7[1])); + const _92: rs.Place = string; + const bounds8 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(_92.v)); + putUpper(out, rs.strGetMut(_92, bounds8[0], bounds8[1])); + const _97: rs.Place = string; + const bounds9 = rs.sliceGetBounds(exhausted(a, b), rs.stringLen(_97.v)); + putUpper(out, rs.strGetMut(_97, bounds9[0], bounds9[1])); + const _102: rs.Place = string; + const bounds10 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(_102.v)); + putUpper(out, rs.strGetMut(_102, bounds10[0], bounds10[1])); + put(out, string.v); } else if (_20 === 11) { const _113: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const s6 = rs.place(() => string, (value5) => string = value5); - const bounds6 = rs.strInclusive(s6.v, _113); - const _111: rs.Place = rs.strPart(s6, bounds6[0], bounds6[1]); + const bounds6 = rs.strInclusive(string.v, _113); + const _111: rs.Place = rs.strPart(string, bounds6[0], bounds6[1]); _111.v = rs.strToAsciiUppercase(_111.v); - put(out, string); + put(out, string.v); } else if (_20 === 12) { - const s5 = rs.place(() => string, (value4) => string = value4); - const bounds5 = rs.strInclusive(s5.v, { end: b, inclusive: true }); - const _118: rs.Place = rs.strPart(s5, bounds5[0], bounds5[1]); + const _119: rs.Place = string; + const bounds5 = rs.strInclusive(_119.v, { end: b, inclusive: true }); + const _118: rs.Place = rs.strPart(_119, bounds5[0], bounds5[1]); _118.v = rs.strToAsciiUppercase(_118.v); - put(out, string); + put(out, string.v); } else if (_20 === 13) { const _128: rs.RangeInclusive = exhausted(a, b); - const s4 = rs.place(() => string, (value3) => string = value3); - const bounds4 = rs.strInclusive(s4.v, _128); - const _126: rs.Place = rs.strPart(s4, bounds4[0], bounds4[1]); + const bounds4 = rs.strInclusive(string.v, _128); + const _126: rs.Place = rs.strPart(string, bounds4[0], bounds4[1]); _126.v = rs.strToAsciiUppercase(_126.v); - put(out, string); + put(out, string.v); } else if (_20 === 14) { - const s3 = rs.place(() => string, (value2) => string = value2); - const bounds3 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s3.v)); - const _133: rs.Place = rs.strPart(s3, bounds3[0], bounds3[1]); + const _134: rs.Place = string; + const bounds3 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(_134.v)); + const _133: rs.Place = rs.strPart(_134, bounds3[0], bounds3[1]); _133.v = rs.strToAsciiUppercase(_133.v); - put(out, string); + put(out, string.v); } else { - const s2 = rs.place(() => string, (value) => string = value); - const bounds = rs.strInclusive(s2.v, { end: b, inclusive: true }); - const part: rs.Place = rs.strPart(s2, bounds[0], bounds[1]); + const bounds = rs.strInclusive(string.v, { end: b, inclusive: true }); + const part: rs.Place = rs.strPart(string, bounds[0], bounds[1]); const last: rs.usize = rs.usizeSaturatingSub(rs.stringLen(part.v), 1); const _150: rs.RangeInclusive = new rs.RangeInclusive(rs.min(a, last), last, rs.usizeStep); const bounds2 = rs.strInclusive(part.v, _150); const _149: rs.Place = rs.strPart(part, bounds2[0], bounds2[1]); _149.v = rs.strToAsciiUppercase(_149.v); - put(out, string); + put(out, string.v); } } @@ -1848,12 +1796,12 @@ export function walk$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter, pu */ export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])]).v); walk$str_EscapeDebug(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); } } @@ -1863,12 +1811,12 @@ export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): */ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])]).v); walk$str_EscapeDefault(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); } } @@ -1878,12 +1826,12 @@ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter) */ export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])]).v); walk$str_EscapeUnicode(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); } } @@ -1893,57 +1841,58 @@ export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter) * and each iterator's size hints as it goes. */ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_2, 32) as rs.usize; if (!(_54 < 32)) { rs.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); } return [931, 931, 962, 65, 97, 453, 66560, 223, 304, 912, 64259, 46, 39, 58, 769, 837, 173, 119143, 32, 49, 20013, 128512, 233, 34, 92, 10, 9, 0, 127, 57344, 65279, 1114111][_54]; - })); - const words: rs.Vec = rs.iterToVec(rs.strSplit(s, " "), "next", 8); + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _5); + const words: rs.Vec = rs.iterToVec(rs.strSplit(s.v, " "), "next", 8); const _11: rs.u8 = rs.u8Rem(kind, 5); if (_11 === 0) { - put(out, rs.strToLowercase(s)); - put(out, rs.strToUppercase(s)); - const lower: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a08: string): string => { + put(out, rs.strToLowercase(s.v).v); + put(out, rs.strToUppercase(s.v).v); + const lower: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a08: string): rs.String => { return rs.strToLowercase(a08); }), undefined, 12, true); - const upper: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a09: string): string => { + const upper: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a09: string): rs.String => { return rs.strToUppercase(a09); }), undefined, 12, true); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lower.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(upper.items, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lower.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(upper.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([args2[0], "|", args2[1]]).v); } else if (_11 === 1) { - escaped$str_EscapeDebug(out, rs.strEscapeDebug(s)); - const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a07: string): rs.Iter => { + escaped$str_EscapeDebug(out, rs.strEscapeDebug(s.v)); + const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a07: string): rs.Iter => { return rs.strEscapeDebug(a07); - }), (e2: rs.Iter): string => { + }), (e2: rs.Iter): rs.String => { return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e2, f)); }), undefined, 12, true); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1]]).v); } else if (_11 === 2) { - escaped$str_EscapeDefault(out, rs.strEscapeDefault(s)); + escaped$str_EscapeDefault(out, rs.strEscapeDefault(s.v)); const part2 = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a06: string): rs.Iter => { return rs.strEscapeDefault(a06); - }), (e: rs.Iter): string => { + }), (e: rs.Iter): rs.String => { return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e, f)); }), undefined, 12, true); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([args6[0]]).v); } else if (_11 === 3) { - escaped$str_EscapeUnicode(out, rs.strEscapeUnicode(s)); + escaped$str_EscapeUnicode(out, rs.strEscapeUnicode(s.v)); const part = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a04: string): rs.Iter => { return rs.strEscapeUnicode(a04); }), (a05: rs.Iter): rs.usize => { return rs.iterCount(a05); }), undefined, 4, true); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([args8[0]]).v); } else { - const it: rs.Iter = rs.strEncodeUtf16(s); + const it: rs.Iter = rs.strEncodeUtf16(s.v); const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16"))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args10[0])])); + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args10[0])]).v); walk$str_EncodeUtf16(out, it.clone(), (out2: rs.ByteVec, u: rs.u16): undefined => { rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(u))); }); @@ -1953,25 +1902,26 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (a02: rs.Iter): rs.usize => { return rs.iterCount(a02); }), undefined, 4, true); - const _164: boolean = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { + const _150: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { return rs.resultUnwrap(a03, rs.fmtDecodeUtf16ErrorDebug); - })) === s; + }); + const _164: boolean = rs.eqStr(rs.stringExtendChars(rs.stringNew(), _150), s); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(each4.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_164, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2]])); + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2]]).v); } } /** What a `String` from UTF-16 is, or its error's `Display`, padded or not, and `Debug`. */ -export function putUtf16(out: rs.ByteVec, r: rs.Result): void { +export function putUtf16(out: rs.ByteVec, r: rs.Result): void { if (r.ok) { const part = r.value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part, f)]; - put(out, rs.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part.v, f)]; + put(out, rs.fmtFormat([args2[0]]).v); } else { const e: rs.FromUtf16Error = r.error; - const _24: rs.usize = rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f))); + const _24: rs.usize = rs.fmtToString((f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f)).len; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args4[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", args4[2]])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args4[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", args4[2]]).v); } } @@ -1999,11 +1949,11 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putUtf16(out, rs.stringFromUtf16(rs.sliceFrom(units.items))); const part3 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part3, f)]; - put(out, rs.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part3.v, f)]; + put(out, rs.fmtFormat([args2[0]]).v); const part4 = rs.stringFromUtf16(rs.sliceFrom(units.items)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part4, f, rs.fmtStr, rs.fmtFromUtf16ErrorDebug)]; - put(out, rs.fmtFormat([args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part4, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), rs.fmtFromUtf16ErrorDebug)]; + put(out, rs.fmtFormat([args4[0]]).v); const le: rs.ByteVec = rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(units.items), (u: rs.u16): Uint8Array => { return rs.u16ToBeBytes(u).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -2019,44 +1969,44 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putUtf16(out, rs.stringFromUtf16le(_79[0])); putUtf16(out, rs.stringFromUtf16be(_79[1])); - const _96: string = rs.stringFromUtf16leLossy(_79[0]); - const _98: string = rs.stringFromUtf16beLossy(_79[1]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_96, f), (f: rs.Formatter) => rs.fmtStr(_98, f)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1]])); + const _96: rs.String = rs.stringFromUtf16leLossy(_79[0]); + const _98: rs.String = rs.stringFromUtf16beLossy(_79[1]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_96.v, f), (f: rs.Formatter) => rs.fmtStr(_98.v, f)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1]]).v); } - const lossy: Array<(a0: rs.ByteSlice) => string> = [(a03: rs.ByteSlice): string => { + const lossy: Array<(a0: rs.ByteSlice) => rs.String> = [(a03: rs.ByteSlice): rs.String => { return rs.stringFromUtf16leLossy(a03); - }, (a04: rs.ByteSlice): string => { + }, (a04: rs.ByteSlice): rs.String => { return rs.stringFromUtf16beLossy(a04); }]; - const iter2: rs.Iter<[(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => string]> = rs.iterZip(rs.iterSlice([(a0: rs.ByteSlice): rs.Result => { + const iter2: rs.Iter<[(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => rs.String]> = rs.iterZip(rs.iterSlice([(a0: rs.ByteSlice): rs.Result => { return rs.stringFromUtf16le(a0); - }, (a02: rs.ByteSlice): rs.Result => { + }, (a02: rs.ByteSlice): rs.Result => { return rs.stringFromUtf16be(a02); }]), rs.iterSlice(lossy), "index"); while (true) { - const _114: [(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => string] | rs.Done = iter2.next(); + const _114: [(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => rs.String] | rs.Done = iter2.next(); if (_114 === rs.DONE) { break; } - const decode2: (a0: rs.ByteSlice) => rs.Result = _114[0]; - const lossy2: (a0: rs.ByteSlice) => string = _114[1]; + const decode2: (a0: rs.ByteSlice) => rs.Result = _114[0]; + const lossy2: (a0: rs.ByteSlice) => rs.String = _114[1]; putUtf16(out, decode2(data)); - put(out, lossy2(data)); + put(out, lossy2(data).v); } const parts: rs.Vec> = rs.iterToVec(rs.sliceSplit(rs.sliceFrom(units.items), (_22: rs.u16): boolean => { return _22 === 0; }), "next", 8); - const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (a05: rs.Slice): string => { + const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (a05: rs.Slice): rs.String => { return rs.stringFromUtf16Lossy(a05); }), undefined, 12, true); - const ok: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(parts.items), (a06: rs.Slice): rs.Result => { + const ok: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(parts.items), (a06: rs.Slice): rs.Result => { return rs.stringFromUtf16(a06); - }), (r: rs.Result): boolean => { + }), (r: rs.Result): boolean => { return r.ok; }), undefined, 1, true); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]]).v); } //# sourceMappingURL=strs.ts.map diff --git a/ts/fixtures/lang/tuples/expected/tuples.ts b/ts/fixtures/lang/tuples/expected/tuples.ts index 9a7e2b1ea..a23f3066c 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.ts @@ -77,9 +77,10 @@ export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(rs.tupleExtendOne([new rs.Vec()] as [rs.Vec], _5, (c, items) => rs.iterExtend(c, items, undefined, 2, true))[0].items), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(rs.tupleExtendOne([""] as [string], rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.char] => { + const _14: rs.Iter<[rs.char]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.char] => { return [_24 as rs.char] as [rs.char]; - }), (c2, items2) => rs.stringExtendChars(c2, items2))[0]), undefined, true); + }); + rs.iterExtendBytes(out, rs.strBytes(rs.tupleExtendOne([rs.stringNew()] as [rs.String], _14, (c2, items2) => rs.stringExtendChars(c2, items2))[0].v), undefined, true); const _22: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): [rs.u8] => { return [_26] as [rs.u8]; }); @@ -105,7 +106,7 @@ export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { }); rs.tupleExtendOne(t, _48, (c8, items7) => rs.iterExtendBytes(c8, items7, undefined, true)); rs.iterExtendBytes(out, rs.byteVecIntoIter(t[0]), undefined, true); - const t2: [string] = ["ab"]; + const t2: [rs.String] = [rs.stringFrom("ab")]; const _56: rs.Iter<[string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): [string] => { const _84: rs.usize = rs.u8Rem(_214, 3) as rs.usize; if (!(_84 < 3)) { @@ -114,7 +115,7 @@ export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { return [["x", "", "yz"][_84]] as [string]; }); rs.tupleExtendOne(t2, _56, (c9, items8) => rs.stringExtend(c9, items8)); - rs.iterExtendBytes(out, rs.strBytes(t2[0]), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(t2[0].v), undefined, true); const _65: rs.Iter<[[rs.u8, rs.u8]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): [[rs.u8, rs.u8]] => { const b9: rs.u8 = _215; return [[b9, b9] as [rs.u8, rs.u8]] as [[rs.u8, rs.u8]]; @@ -140,11 +141,11 @@ export function pairs(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2; return [b ^ 90, b as rs.char] as [rs.u8, rs.char]; }); - const _5: [rs.ByteVec, string] = rs.tupleExtend([new rs.ByteVec(), ""] as [rs.ByteVec, string], _6, [rs.byteVecPart(), rs.STRING_CHARS_PART]); + const _5: [rs.ByteVec, rs.String] = rs.tupleExtend([new rs.ByteVec(), rs.stringNew()] as [rs.ByteVec, rs.String], _6, [rs.byteVecPart(), rs.STRING_CHARS_PART]); const v: rs.ByteVec = _5[0]; - const s: string = _5[1]; + const s: rs.String = _5[1]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); const _16: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): [rs.u8, rs.u8] => { const b2: rs.u8 = _25; return [b2, rs.u8Rem(b2, 8)] as [rs.u8, rs.u8]; @@ -190,15 +191,15 @@ export function triples(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2; return [b, ((b as rs.u16) << 8) & 0xffff, rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char] as [rs.u8, rs.u16, rs.char]; }); - const _6: [rs.ByteVec, rs.VecDeque, string] = rs.tupleExtend([new rs.ByteVec(), rs.dequeNew(2) as rs.VecDeque, ""] as [rs.ByteVec, rs.VecDeque, string], _7, [rs.byteVecPart(), rs.dequePart(), rs.STRING_CHARS_PART]); + const _6: [rs.ByteVec, rs.VecDeque, rs.String] = rs.tupleExtend([new rs.ByteVec(), rs.dequeNew(2) as rs.VecDeque, rs.stringNew()] as [rs.ByteVec, rs.VecDeque, rs.String], _7, [rs.byteVecPart(), rs.dequePart(), rs.STRING_CHARS_PART]); const v: rs.ByteVec = _6[0]; const q: rs.VecDeque = _6[1]; - const s: string = _6[2]; + const s: rs.String = _6[2]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(q), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); const _22: rs.Iter<[[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8] => { const b2: rs.u8 = _24; return [[rs.u8Rem(b2, 8), b2] as [rs.u8, rs.u8], [rs.u8Rem(b2, 5), b2 as rs.u16] as [rs.u8, rs.u16], b2] as [[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8]; @@ -216,12 +217,12 @@ export function triples(data: rs.ByteSlice, out: rs.ByteVec): void { const b3: rs.u8 = _26; return [b3, [b3 as rs.char, rs.u16Add(b3 as rs.u16, 1)] as [rs.char, rs.u16]] as [rs.u8, [rs.char, rs.u16]]; }); - const _34: [rs.ByteVec, [string, rs.Vec]] = rs.tupleExtend([new rs.ByteVec(), ["", new rs.Vec()]] as [rs.ByteVec, [string, rs.Vec]], _35, [rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART, rs.vecPart(2)])]); + const _34: [rs.ByteVec, [rs.String, rs.Vec]] = rs.tupleExtend([new rs.ByteVec(), [rs.stringNew(), new rs.Vec()]] as [rs.ByteVec, [rs.String, rs.Vec]], _35, [rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART, rs.vecPart(2)])]); const v2: rs.ByteVec = _34[0]; - const s2: string = _34[1][0]; + const s2: rs.String = _34[1][0]; const w: rs.Vec = _34[1][1]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s2.v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n2: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n2).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -255,11 +256,11 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { const _28: [rs.u8, [rs.char]] = [b ^ 51, [rs.u8Add(65, rs.u8Rem(b, 26)) as rs.char] as [rs.char]]; return [b, _12, _152, _5[_8], _162, b, _172, _202, _222, _262, undefined, _28] as [rs.u8, rs.u16, rs.char, string, rs.u8, rs.u8, [rs.u8, rs.u8], rs.u8, [rs.u8, rs.u16], rs.u8, undefined, [rs.u8, [rs.char]]]; }); - const _15: [rs.ByteVec, rs.Vec, string, string, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [string]]] = rs.tupleExtend([new rs.ByteVec(), new rs.Vec(), "", "", rs.dequeNew(1, true) as rs.VecDeque, rs.heapNew() as rs.BinaryHeap, rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet, rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.btreeNew(rs.cmp) as rs.BTreeSet, undefined, [new rs.ByteVec(), [""]]] as [rs.ByteVec, rs.Vec, string, string, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [string]]], _16, [rs.byteVecPart(), rs.vecPart(2), rs.STRING_CHARS_PART, rs.STRING_PART, rs.dequePart(), rs.heapPart(rs.le, 1), rs.hashPart(undefined, undefined, 469762048), rs.hashKeysPart(undefined, 469762048), rs.btreePart(), rs.btreeKeysPart(), rs.UNIT_PART, rs.tuplePart([rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART])])]); + const _15: [rs.ByteVec, rs.Vec, rs.String, rs.String, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [rs.String]]] = rs.tupleExtend([new rs.ByteVec(), new rs.Vec(), rs.stringNew(), rs.stringNew(), rs.dequeNew(1, true) as rs.VecDeque, rs.heapNew() as rs.BinaryHeap, rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet, rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.btreeNew(rs.cmp) as rs.BTreeSet, undefined, [new rs.ByteVec(), [rs.stringNew()]]] as [rs.ByteVec, rs.Vec, rs.String, rs.String, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [rs.String]]], _16, [rs.byteVecPart(), rs.vecPart(2), rs.STRING_CHARS_PART, rs.STRING_PART, rs.dequePart(), rs.heapPart(rs.le, 1), rs.hashPart(undefined, undefined, 469762048), rs.hashKeysPart(undefined, 469762048), rs.btreePart(), rs.btreeKeysPart(), rs.UNIT_PART, rs.tuplePart([rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART])])]); const bytes: rs.ByteVec = _15[0]; const wide: rs.Vec = _15[1]; - const chars: string = _15[2]; - const texts: string = _15[3]; + const chars: rs.String = _15[2]; + const texts: rs.String = _15[3]; const q: rs.VecDeque = _15[4]; const heap: rs.BinaryHeap = _15[5]; const map: rs.HashMap = _15[6]; @@ -267,13 +268,13 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { const tree: rs.BTreeMap = _15[8]; const keys: rs.BTreeSet = _15[9]; const v: rs.ByteVec = _15[11][0]; - const s: string = _15[11][1][0]; + const s: rs.String = _15[11][1][0]; rs.iterExtendBytes(out, rs.byteVecIntoIter(bytes), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(wide.items), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(chars), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(texts), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(chars.v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(texts.v), undefined, true); rs.iterExtendBytes(out, rs.dequeIntoIter(q), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(heap)), undefined, true); entries(map, out); @@ -286,7 +287,7 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); rs.iterExtendBytes(out, rs.btreeKeys(keys), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); } /** @@ -294,19 +295,19 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { * and a map or set keeps an equal key already there. */ export function extended(data: rs.ByteSlice, out: rs.ByteVec): void { - const t: [rs.ByteVec, string, rs.BTreeMap, rs.VecDeque, rs.HashSet] = [rs.byteVecFrom(Uint8Array.of(9, 8)), "pre", rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterSlice([[3, 30] as [rs.u8, rs.u16]]), true, undefined, undefined, undefined, 4, true), rs.dequeFromArray([1], 2) as rs.VecDeque, rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const t: [rs.ByteVec, rs.String, rs.BTreeMap, rs.VecDeque, rs.HashSet] = [rs.byteVecFrom(Uint8Array.of(9, 8)), rs.stringFrom("pre"), rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterSlice([[3, 30] as [rs.u8, rs.u16]]), true, undefined, undefined, undefined, 4, true), rs.dequeFromArray([1], 2) as rs.VecDeque, rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rs.Iter<[rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8] => { const b: rs.u8 = _2; return [b, b as rs.char, [rs.u8Rem(b, 8), b as rs.u16] as [rs.u8, rs.u16], b as rs.u16, rs.u8Rem(b, 16)] as [rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8]; }); rs.tupleExtend(t, _16, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.btreePart(), rs.dequePart(), rs.hashKeysPart(undefined, 469762048)]); const v: rs.ByteVec = t[0]; - const s: string = t[1]; + const s: rs.String = t[1]; const tree: rs.BTreeMap = t[2]; const q: rs.VecDeque = t[3]; const set: rs.HashSet = t[4]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(tree), (_22: [rs.u8, rs.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -330,7 +331,7 @@ export function borrowed(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2; return { x: b, y: ((b as rs.u16) << 2) & 0xffff }; }), undefined, 4, true); - const t: [rs.ByteVec, rs.Vec, rs.HashMap, string] = [new rs.ByteVec(), new rs.Vec(), rs.hashNew() as rs.HashMap, ""]; + const t: [rs.ByteVec, rs.Vec, rs.HashMap, rs.String] = [new rs.ByteVec(), new rs.Vec(), rs.hashNew() as rs.HashMap, rs.stringNew()]; const marks: rs.char[] = [122, 233]; const _10: rs.Iter<[rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]> = rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterSlice(points.items), [false, false]), (_23: [rs.u8, Spot.Spot]): [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char] => { const _54: [rs.u8, rs.u8] = [_23[0], _23[0]]; @@ -352,13 +353,13 @@ export function borrowed(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.ByteVec = t[0]; const copied: rs.Vec = t[1]; const map: rs.HashMap = t[2]; - const s: string = t[3]; + const s: rs.String = t[3]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterChain(rs.iterSlice(copied.items), rs.iterSlice(ones[0].items)), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); entries(map, out); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(points.items), (p3: Spot.Spot): rs.u8 => { return p3.x; }), undefined, true); @@ -455,12 +456,12 @@ export function panicked(data: rs.ByteSlice, out: rs.ByteVec): void { return [b, b as rs.char, b as rs.u16] as [rs.u8, rs.char, rs.u16]; } }); - const _12: [rs.ByteVec, string, rs.Vec] = rs.tupleExtend([new rs.ByteVec(), "", new rs.Vec()] as [rs.ByteVec, string, rs.Vec], _13, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.vecPart(2)]); + const _12: [rs.ByteVec, rs.String, rs.Vec] = rs.tupleExtend([new rs.ByteVec(), rs.stringNew(), new rs.Vec()] as [rs.ByteVec, rs.String, rs.Vec], _13, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.vecPart(2)]); const v: rs.ByteVec = _12[0]; - const s: string = _12[1]; + const s: rs.String = _12[1]; const w: rs.Vec = _12[2]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -497,8 +498,8 @@ export function reserved(data: rs.ByteSlice, out: rs.ByteVec): void { const _43: rs.Iter<[undefined, rs.char]> = rs.iterMap(items, (_2: rs.u32): [undefined, rs.char] => { return [undefined, 97] as [undefined, rs.char]; }); - const _42: [rs.Vec, string] = rs.tupleExtend([new rs.Vec(), ""] as [rs.Vec, string], _43, [rs.vecPart(0), rs.STRING_CHARS_PART]); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_42[0].items.length & 0xff, rs.stringLen(_42[1]) & 0xff)), undefined, true); + const _42: [rs.Vec, rs.String] = rs.tupleExtend([new rs.Vec(), rs.stringNew()] as [rs.Vec, rs.String], _43, [rs.vecPart(0), rs.STRING_CHARS_PART]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_42[0].items.length & 0xff, _42[1].len & 0xff)), undefined, true); } else if (_4 === 4) { const _55: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(items, (i2: rs.u32): [rs.u8, rs.u16] => { return [i2 & 0xff, i2 & 0xffff] as [rs.u8, rs.u16]; @@ -517,18 +518,18 @@ export function reserved(data: rs.ByteSlice, out: rs.ByteVec): void { /** `collect` of `Result`s and `Option`s of pairs, into one of a tuple, which std's docs show. */ export function shunted(data: rs.ByteSlice, out: rs.ByteVec): void { - const parsed: rs.Result<[rs.ByteVec, string], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result<[rs.u8, rs.char], rs.u8> => { + const parsed: rs.Result<[rs.ByteVec, rs.String], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result<[rs.u8, rs.char], rs.u8> => { const b: rs.u8 = _2; if (!(b === 0)) { return rs.Ok([b, b as rs.char] as [rs.u8, rs.char]); } return rs.Err(b); - }), (values: rs.Iter<[rs.u8, rs.char]>) => rs.tupleExtend([new rs.ByteVec(), ""] as [rs.ByteVec, string], values, [rs.byteVecPart(), rs.STRING_CHARS_PART])); + }), (values: rs.Iter<[rs.u8, rs.char]>) => rs.tupleExtend([new rs.ByteVec(), rs.stringNew()] as [rs.ByteVec, rs.String], values, [rs.byteVecPart(), rs.STRING_CHARS_PART])); if (parsed.ok) { const v: rs.ByteVec = parsed.value[0]; - const s: string = parsed.value[1]; + const s: rs.String = parsed.value[1]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); } else { rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } @@ -644,21 +645,21 @@ export function own(data: rs.ByteSlice, out: rs.ByteVec): void { const b11: rs.u8 = _211; return [b11, b11 as rs.char, ~b11 & 0xff] as [rs.u8, rs.char, rs.u8]; }); - const _62: [Tally.Tally, string, Tally.Tally] = rs.tupleExtend([Tally.default$Default(), "", Tally.default$Default()] as [Tally.Tally, string, Tally.Tally], _63, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART, rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); + const _62: [Tally.Tally, rs.String, Tally.Tally] = rs.tupleExtend([Tally.default$Default(), rs.stringNew(), Tally.default$Default()] as [Tally.Tally, rs.String, Tally.Tally], _63, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART, rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); const a: Tally.Tally = _62[0]; - const s: string = _62[1]; + const s: rs.String = _62[1]; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a.sum, _62[2].sum)), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); calls(out); const _81: rs.Iter<[rs.char, rs.char, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_212: rs.u8): [rs.char, rs.char, rs.u8] => { const b12: rs.u8 = _212; return [b12 as rs.char, rs.u8Add(97, rs.u8Rem(b12, 26)) as rs.char, b12] as [rs.char, rs.char, rs.u8]; }); - const _80: [string, Last.Last, Tally.Tally] = rs.tupleExtend(["", Last.default$Default(), Tally.default$Default()] as [string, Last.Last, Tally.Tally], _81, [rs.STRING_CHARS_PART, rs.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rs.Place, a1: rs.char | undefined) => undefined, true), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); - const s2: string = _80[0]; + const _80: [rs.String, Last.Last, Tally.Tally] = rs.tupleExtend([rs.stringNew(), Last.default$Default(), Tally.default$Default()] as [rs.String, Last.Last, Tally.Tally], _81, [rs.STRING_CHARS_PART, rs.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rs.Place, a1: rs.char | undefined) => undefined, true), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); + const s2: rs.String = _80[0]; const last: Last.Last = _80[1]; const t4: Tally.Tally = _80[2]; - rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s2.v), undefined, true); Last.put(last, out); rs.byteVecPush(out, t4.sum); calls(out); @@ -796,13 +797,13 @@ export function ownPanicked(data: rs.ByteSlice, out: rs.ByteVec): void { const _25: rs.Iter<[rs.u8, rs.u8, rs.char]> = rs.iterMap(items, (b3: rs.u8): [rs.u8, rs.u8, rs.char] => { return [b3, b3, b3 as rs.char] as [rs.u8, rs.u8, rs.char]; }); - const _24: [rs.ByteVec, Tally.Tally, string] = rs.tupleExtend([new rs.ByteVec(), Tally.default$Default(), ""] as [rs.ByteVec, Tally.Tally, string], _25, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART]); + const _24: [rs.ByteVec, Tally.Tally, rs.String] = rs.tupleExtend([new rs.ByteVec(), Tally.default$Default(), rs.stringNew()] as [rs.ByteVec, Tally.Tally, rs.String], _25, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART]); const v: rs.ByteVec = _24[0]; const t: Tally.Tally = _24[1]; - const s: string = _24[2]; + const s: rs.String = _24[2]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); rs.byteVecPush(out, t.sum); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); } else { const _35: rs.Iter<[rs.u8]> = rs.iterMap(items, (b2: rs.u8): [rs.u8] => { return [b2] as [rs.u8]; diff --git a/ts/fixtures/lang/utf8/expected/utf8.ts b/ts/fixtures/lang/utf8/expected/utf8.ts index 8c7b601fc..8454e64e4 100644 --- a/ts/fixtures/lang/utf8/expected/utf8.ts +++ b/ts/fixtures/lang/utf8/expected/utf8.ts @@ -32,7 +32,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_14.ok) { const s: string = _14.value; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([args2[0]]).v); rs.byteVecPush(out, rs.stringLen(s) & 0xff); } else { const e: rs.Utf8Error = _14.error; @@ -41,7 +41,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return n & 0xff; })); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1])]).v); } } const _57: rs.Result = rs.strFromUtf8(rs.byteVecSlice(bytes)); @@ -70,17 +70,17 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, _20 ? 1 : 0); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(text)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(text), f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + put(out, rs.fmtFormat([args2[0], "|", args2[1]]).v); rs.byteVecPush(out, rs.stringLen(rs.strCowStr(text)) & 0xff); - const owned: string = rs.strCowStr(text); - put(out, owned); - put(out, rs.strFromUtf8Unchecked(rs.stringAsBytes(owned))); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); - put(out, rs.strFromUtf8Unchecked(rs.byteVecSlice(rs.stringIntoBytes(owned)))); + const owned: rs.String = rs.strCowIntoOwned(text); + put(out, owned.v); + put(out, rs.strFromUtf8Unchecked(rs.stringAsBytes(owned.v))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(rs.stringClone(owned)))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.strToBytes(owned.v))); + put(out, rs.stringFromUtf8Unchecked(rs.stringIntoBytes(owned)).v); const chunks: rs.Iter = rs.byteSliceUtf8Chunks(rest); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])]).v); let last: rs.Utf8Chunk | undefined = undefined; while (true) { const _79: rs.Utf8Chunk | rs.Done = chunks.next(); @@ -90,9 +90,9 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, chunk.invalid); rs.byteVecPush(out, chunk.invalid.length & 0xff); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ChunkDebug(chunk, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])]).v); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([args8[0]]).v); rs.byteVecPush(out, rs.iterCount(chunks.clone()) & 0xff); rs.byteVecPush(out, lossy_eq$1kzzmg3(chunk, chunk) ? 1 : 0); const _134: rs.Utf8Chunk | undefined = last; @@ -104,11 +104,11 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([args10[0]]).v); } - const _152: rs.Result = rs.stringFromUtf8(bytes); + const _152: rs.Result = rs.stringFromUtf8(bytes); if (_152.ok) { - put(out, _152.value); + put(out, _152.value.v); } else { const e: rs.FromUtf8Error = _152.error; rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); @@ -118,7 +118,7 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return n & 0xff; })); const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(u, f)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([args12[0]]).v); put(out, rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteVecSlice(e.bytes)))); rs.byteVecPush(out, string_eq$1enuhj8(rs.fromUtf8ErrorClone(e), e) ? 1 : 0); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.ts b/ts/fixtures/lang/wrappers/expected/wrappers.ts index 2a08d8cd1..9423a00f2 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.ts @@ -461,7 +461,7 @@ export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, d); rs.byteVecPush(out, i2 & 0xff); } - put(out, "held"); + put(out, rs.stringFrom("held").v); } else if (_21 === 3) { const n: rs.u64 | undefined = rs.nonZero(a); if (n === undefined) { @@ -473,7 +473,7 @@ export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _519: rs.u64 = option_unwrapOr$15hbiwd(rs.nonZero(b), n2); const _516: boolean = rs.u64Eq(n2, _519); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(n2, f), (f: rs.Formatter) => rs.u64Debug(n2, f), (f: rs.Formatter) => rs.fmtBool(_516, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])); + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]).v); rs.byteVecPush(out, rs.u64Gt(n2, { _0: 1 }._0) ? 1 : 0); rs.byteVecPush(out, rs.cmp(n2, { _0: 1000 }._0) & 0xff); } diff --git a/ts/fixtures/lang/wraps/expected/wraps.ts b/ts/fixtures/lang/wraps/expected/wraps.ts index 049d40cea..7e80c93b0 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.ts @@ -369,7 +369,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.u8[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u8WrappingAdd, 0); @@ -394,7 +394,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u8(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u8(x7), hashed$num_Wrapping_u8(a)) ? 1 : 0); @@ -552,7 +552,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.u16[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u16WrappingAdd, 0); @@ -577,7 +577,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u16(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u16(x7), hashed$num_Wrapping_u16(a)) ? 1 : 0); @@ -735,7 +735,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.u32[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u32WrappingAdd, 0); @@ -760,7 +760,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u32(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u32(x7), hashed$num_Wrapping_u32(a)) ? 1 : 0); @@ -918,7 +918,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.u64[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u64WrappingAdd, 0); @@ -943,7 +943,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u64(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u64(x7), hashed$num_Wrapping_u64(a)) ? 1 : 0); @@ -1101,7 +1101,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.u128[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u128WrappingAdd, 0); @@ -1126,7 +1126,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u128(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u128(x7), hashed$num_Wrapping_u128(a)) ? 1 : 0); @@ -1284,7 +1284,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.usize[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.usizeWrappingAdd, 0); @@ -1309,7 +1309,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_usize(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_usize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_usize(x7), hashed$num_Wrapping_usize(a)) ? 1 : 0); @@ -1469,7 +1469,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.i8[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i8WrappingAdd, 0); @@ -1494,7 +1494,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i8(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i8(x7), hashed$num_Wrapping_i8(a)) ? 1 : 0); @@ -1654,7 +1654,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.i16[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i16WrappingAdd, 0); @@ -1679,7 +1679,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i16(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i16(x7), hashed$num_Wrapping_i16(a)) ? 1 : 0); @@ -1839,7 +1839,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.i32[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i32WrappingAdd, 0); @@ -1864,7 +1864,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i32(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i32(x7), hashed$num_Wrapping_i32(a)) ? 1 : 0); @@ -2024,7 +2024,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.i64[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i64WrappingAdd, 0); @@ -2049,7 +2049,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i64(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i64(x7), hashed$num_Wrapping_i64(a)) ? 1 : 0); @@ -2209,7 +2209,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.i128[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i128WrappingAdd, 0); @@ -2234,7 +2234,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i128(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i128(x7), hashed$num_Wrapping_i128(a)) ? 1 : 0); @@ -2394,7 +2394,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]).v)); } else if (_31 === 21) { const all: rs.isize[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.isizeWrappingAdd, 0); @@ -2419,7 +2419,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_isize(); const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_isize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_isize(x7), hashed$num_Wrapping_isize(a)) ? 1 : 0); diff --git a/ts/fixtures/lang/zeros/expected/core/option.ts b/ts/fixtures/lang/zeros/expected/core/option.ts index 9210f934d..a3b1eba38 100644 --- a/ts/fixtures/lang/zeros/expected/core/option.ts +++ b/ts/fixtures/lang/zeros/expected/core/option.ts @@ -18,7 +18,7 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function unwrapOrDefault$1b97y1a(self: Tagged.Tagged | undefined): Tagged.Tagged { +export function unwrapOrDefault$0348bav(self: Tagged.Tagged | undefined): Tagged.Tagged { if (self === undefined) { return Tagged.default$Default_String(); } diff --git a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts index 9c715e053..5e14b17d7 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts @@ -2,14 +2,14 @@ import * as rs from "./rs.ts"; -export function clone$Clone_String(self: Tagged): Tagged { +export function clone$Clone_String(self: Tagged): Tagged { const _2: rs.u8 = self.n; self.of; self.pin; return { n: _2, of: undefined, pin: undefined, unit: undefined }; } -export function fmt$fmt_Debug_String(self: Tagged, f: rs.Formatter): rs.Result { +export function fmt$fmt_Debug_String(self: Tagged, f: rs.Formatter): rs.Result { const _3: string = "Tagged"; const _4: string = "n"; const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.n, f); @@ -35,7 +35,7 @@ export function fmt$fmt_Debug_u8(self: Tagged, f: rs.Formatter): rs.Resul return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); } -export function default$Default_String(): Tagged { +export function default$Default_String(): Tagged { const _1: rs.u8 = 0; undefined; undefined; @@ -51,7 +51,7 @@ export function default$Default_u8(): Tagged { return { n: _1, of: undefined, pin: undefined, unit: undefined }; } -export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged): boolean { +export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged): boolean { if (self.n === other.n) { if (true) { if (true) { @@ -62,7 +62,7 @@ export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged, other: Tagged): rs.Ordering | undefined { +export function partialCmp$cmp_PartialOrd_String(self: Tagged, other: Tagged): rs.Ordering | undefined { const cmp: rs.Ordering | undefined = rs.cmp(self.n, other.n); if (cmp !== undefined) { if (cmp === 0) { @@ -84,7 +84,7 @@ export function partialCmp$cmp_PartialOrd_String(self: Tagged, other: Ta return cmp; } -export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): rs.Ordering { +export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): rs.Ordering { const cmp: rs.Ordering = rs.cmp(self.n, other.n); if (cmp === 0) { const cmp2: rs.Ordering = rs.cmpNothing(self.of, other.of); @@ -100,7 +100,7 @@ export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): return cmp; } -export function hash$Hash_String_hash_DefaultHasher(self: Tagged, state: rs.Hasher): void { +export function hash$Hash_String_hash_DefaultHasher(self: Tagged, state: rs.Hasher): void { rs.hash8(self.n, state); rs.hashNothing(self.of, state); rs.hashNothing(self.pin, state); diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index 1159e0323..07daeeb1b 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { drop$zeros_Lock_u32, drop$zeros_Lock_zeros_Loud } from "./lib.ts"; import { thenSome$1n1oy1h } from "./core/bool.ts"; -import { unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1b97y1a as option_unwrapOrDefault$1b97y1a, map$1b6tbot as option_map$1b6tbot, map$12cu62z as option_map$12cu62z, map$0ul65ro as option_map$0ul65ro, map$0w716ia as option_map$0w716ia } from "./core/option.ts"; +import { unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0348bav as option_unwrapOrDefault$0348bav, map$1b6tbot as option_map$1b6tbot, map$12cu62z as option_map$12cu62z, map$0ul65ro as option_map$0ul65ro, map$0w716ia as option_map$0w716ia } from "./core/option.ts"; import * as Both from "./zeros.Both.ts"; import * as Defaulted from "./zeros.Defaulted.ts"; import * as Holds from "./zeros.Holds.ts"; @@ -31,7 +31,7 @@ export function pair(): Pair.Pair { return { _0: {}, _1: undefined }; } -export function none$String(): string[] { +export function none$String(): rs.String[] { return []; } @@ -81,7 +81,7 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, {}) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); const _40: One.One = One.clone$Clone("Only" as One.One); const args2: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rs.Formatter) => One.fmt$fmt_Debug(_40, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1]]).v), undefined, true); } else if (_8 === 1) { rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): Uint8Array => { return Uint8Array.of(); @@ -100,12 +100,12 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, One.eq$cmp_PartialEq(_72(1), one()) ? 1 : 0); } else if (_8 === 2) { const _87: Unit.Unit = unit(); - const _89: string[] = none$String(); + const _89: rs.String[] = none$String(); const _91: Unit.Unit[] = units(); const _93: One.One = one(); const _95: [undefined, Unit.Unit, Uint8Array] = tuple(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(_89, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_91, f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]])), undefined, true); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(_89, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(_91, f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]]).v), undefined, true); } else if (_8 === 3) { const _108: (a0: rs.u8) => rs.u8 = adder(); adder(); @@ -229,7 +229,7 @@ export function hash$zeros_Names(value: Names.Names): rs.u64 { } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$zeros_Tagged_String(value: Tagged.Tagged): rs.u64 { +export function hash$zeros_Tagged_String(value: Tagged.Tagged): rs.u64 { const h: rs.Hasher = rs.hasher(); Tagged.hash$Hash_String_hash_DefaultHasher(value, h); return rs.hashFinish(h); @@ -266,41 +266,41 @@ export function digest$zeros_Names(value: Names.Names, out: rs.ByteVec): void { } /** [`hash`] of `value`, little-endian. */ -export function digest$zeros_Tagged_String(value: Tagged.Tagged, out: rs.ByteVec): void { +export function digest$zeros_Tagged_String(value: Tagged.Tagged, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$zeros_Tagged_String(value)).reverse())); } /** The impls `#[derive]` calls on `PhantomData`, `PhantomPinned`, and `()` fields. */ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const tags: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tagged.Tagged => { + const tags: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tagged.Tagged => { const n: rs.u8 = _2; Tagged.default$Default_String(); return { n, of: undefined, pin: undefined, unit: undefined }; }), undefined, 1, true); const _7: rs.u8 = rs.u8Rem(kind, 4); if (_7 === 0) { - const _11: Tagged.Tagged | undefined = rs.sliceFirst(rs.sliceFrom(tags.items)); - const t: Tagged.Tagged = option_unwrapOrDefault$1b97y1a(_11 === undefined ? undefined : Tagged.clone$Clone_String(_11)); + const _11: Tagged.Tagged | undefined = rs.sliceFirst(rs.sliceFrom(tags.items)); + const t: Tagged.Tagged = option_unwrapOrDefault$0348bav(_11 === undefined ? undefined : Tagged.clone$Clone_String(_11)); const _15: rs.u8 = t.n; Tagged.default$Default_u8(); const copied: Tagged.Tagged = { n: _15, of: undefined, pin: undefined, unit: undefined }; const again: Tagged.Tagged = copied; const _27: Names.Names = Names.default$Default(); const args2: rs.Fmt[] = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_String(t, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(copied, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(again, f), (f: rs.Formatter) => Names.fmt$fmt_Debug(_27, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3])])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3])]).v), undefined, true); const _38: Rest.Rest = Rest.clone$Clone(Rest.default$Default()); const args4: rs.Fmt[] = [(f: rs.Formatter) => Rest.fmt$fmt_Debug(_38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"])]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[2]), "|"])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[2]), "|"]).v), undefined, true); rs.byteVecPush(out, rs.iterCount(rs.iterEmpty() as rs.Iter) & 0xff); } else if (_7 === 1) { - const sorted: rs.Vec> = rs.vecFrom(tags.items.map(Tagged.clone$Clone_String)); + const sorted: rs.Vec> = rs.vecFrom(tags.items.map(Tagged.clone$Clone_String)); rs.sliceSort(rs.sliceFrom(sorted.items), rs.cmpLt(Tagged.partialCmp$cmp_PartialOrd_String), 1, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (t3: Tagged.Tagged): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (t3: Tagged.Tagged): rs.u8 => { return t3.n; }), undefined, true); - const iter: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(tags.items), 2); + const iter: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(tags.items), 2); while (true) { - const _76: rs.Slice> | rs.Done = iter.next(); + const _76: rs.Slice> | rs.Done = iter.next(); if (_76 === rs.DONE) { break; } @@ -308,8 +308,8 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_76, 1); const part = _76.data[_76.start]; const part2 = _76.data[_76.start + 1]; - const a: Tagged.Tagged = part; - const b: Tagged.Tagged = part2; + const a: Tagged.Tagged = part; + const b: Tagged.Tagged = part2; rs.byteVecPush(out, (Tagged.cmp$cmp_Ord_String(a, b) & 0xff) | (((Tagged.eq$cmp_PartialEq_String(a, b) ? 1 : 0) << 2) & 0xff) | (((Tagged.partialCmp$cmp_PartialOrd_String(a, b) === Tagged.cmp$cmp_Ord_String(a, b) as rs.Ordering | undefined ? 1 : 0) << 3) & 0xff)); rs.byteVecPush(out, Tagged.cmp$cmp_Ord_String(a, b) === 0 === rs.u64Eq(hash$zeros_Tagged_String(a), hash$zeros_Tagged_String(b)) ? 1 : 0); } @@ -332,7 +332,7 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, Names.eq$cmp_PartialEq(_168, _176) ? 1 : 0); const _183: Names.Names = Names.default$Default(); rs.byteVecPush(out, Names.cmp$cmp_Ord(_168, _183) === 0 ? 1 : 0); - rs.byteVecPush(out, rs.iterAll(rs.iterSlice(tags.items), (t2: Tagged.Tagged): boolean => { + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(tags.items), (t2: Tagged.Tagged): boolean => { return Tagged.eq$cmp_PartialEq_String(Tagged.clone$Clone_String(t2), t2); }) ? 1 : 0); Rest.default$Default(); diff --git a/ts/fixtures/model/expected/harness.ts b/ts/fixtures/model/expected/harness.ts index 55a953d95..3a2a5e273 100644 --- a/ts/fixtures/model/expected/harness.ts +++ b/ts/fixtures/model/expected/harness.ts @@ -88,8 +88,8 @@ export function putU128(out: rs.ByteVec, value: rs.u128): void { } /** Text callers see, such as a `Debug` or `Display`, ended by a zero byte. */ -export function putText(out: rs.ByteVec, text: string): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); +export function putText(out: rs.ByteVec, text: rs.String): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); rs.byteVecPush(out, 0); } diff --git a/ts/fixtures/names/expected/lib.ts b/ts/fixtures/names/expected/lib.ts index 9897fe3ac..0a59428fc 100644 --- a/ts/fixtures/names/expected/lib.ts +++ b/ts/fixtures/names/expected/lib.ts @@ -25,7 +25,7 @@ export function run(data: rs.ByteSlice): rs.ByteVec { rs.byteVecPush(out, _15); const part = Wrap.new$wrap_Pair(pair); const args2: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)]; - const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([args2[0]])); + const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([args2[0]]).v); rs.byteVecExtendFromSlice(out, _22); if (!(first === 0)) { shape = "Line" as shapes_Shape.Shape; diff --git a/ts/fixtures/reject/census.txt b/ts/fixtures/reject/census.txt index 6e4576b9a..d0e340d7c 100644 --- a/ts/fixtures/reject/census.txt +++ b/ts/fixtures/reject/census.txt @@ -15,14 +15,6 @@ fixtures/reject/src/alloc.rs:vec_pointer+1:10: a raw pointer to `std::vec::Vec`, which would drop with the last clone of what it makes, which is not supported fixtures/reject/src/buffers.rs:shared+1:2: a coercion to `std::sync::Arc<[u8]>` fixtures/reject/src/buffers.rs:spare+1:4: `Vec::spare_capacity_mut` of other than bytes, whose room past its length no JS array holds, which is not supported yet diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 96445c56c..ad36c07b2 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -19,14 +19,6 @@ fixtures/reject/src/alloc.rs:vec_pointer+1:10: a raw pointer to `std::vec::Vec`, which would drop with the last clone of what it makes, which is not supported fixtures/reject/src/buffers.rs:shared+1:2: a coercion to `std::sync::Arc<[u8]>` fixtures/reject/src/buffers.rs:spare+1:4: `Vec::spare_capacity_mut` of other than bytes, whose room past its length no JS array holds, which is not supported yet diff --git a/ts/fixtures/stock/caller.ts b/ts/fixtures/stock/caller.ts index 98ee5b707..cb2f3ceb4 100644 --- a/ts/fixtures/stock/caller.ts +++ b/ts/fixtures/stock/caller.ts @@ -2,7 +2,8 @@ // `buf::far`'s reads past where a vector shares its storage, which only these reach, as // each allocates 128 MiB, `buf::reclaims` after each pick of the handles to drop, each of `hashlink`'s iterators read through every pick of steps from // either end, each `buf::chains` chain copied by each pick of a length, split at either -// end and between, and every pair of steps over `hashlink`'s maps of what drops. +// end and between, every pair of steps over `hashlink`'s maps of what drops, and each +// `Bytes` of a `String` by each room and way taken back. import { cases as named, op, run } from "./harness.ts"; @@ -38,4 +39,9 @@ const reclaims = [0, 3, 200].flatMap((cap) => Array.from({ length: 8 * 4 * 2 }, (_, i) => Uint8Array.of(op("buf::reclaims"), cap, i % 8, [0, 3, 40, 255][Math.floor(i / 8) % 4], i < 32 ? 0 : 5)), ); -export const cases: Uint8Array[] = [...far, ...reclaims, ...linked, ...chains, ...nested]; +/** `buf::strings` of no room, of exactly its text, and of more, each way taken back, with a clone held or not. */ +const strings = [0, 4, 23].flatMap((cap) => + Array.from({ length: 2 * 2 * 3 }, (_, i) => Uint8Array.of(op("buf::strings"), cap, 4, 0x61, 0xc3, 0xa9, 0x62, i % 2 === 0 ? 0 : 6, Math.floor(i / 2) % 2, Math.floor(i / 4))), +); + +export const cases: Uint8Array[] = [...far, ...reclaims, ...linked, ...chains, ...nested, ...strings]; diff --git a/ts/fixtures/stock/expected/buf.Ops.ts b/ts/fixtures/stock/expected/buf.Ops.ts index 6914f8578..48635a8e6 100644 --- a/ts/fixtures/stock/expected/buf.Ops.ts +++ b/ts/fixtures/stock/expected/buf.Ops.ts @@ -3,7 +3,6 @@ import * as rs from "./rs.ts"; import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; -/** The bytes of a case's input, taken from the front. */ export interface Ops { _0Data: Uint8Array; _0Start: number; diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index 3a424c66d..c96769988 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { drop$Option_bytes_Bytes as lib_drop$Option_bytes_Bytes, drop$bytes_buf_Chain_buf_Provided_bytes_Bytes as lib_drop$bytes_buf_Chain_buf_Provided_bytes_Bytes, drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8, drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces, drop$bytes_buf_Take_bytes_Bytes as lib_drop$bytes_buf_Take_bytes_Bytes, of$buf_Counted, of$buf_Pieces, of$buf_Provided, of$bytes_Bytes, of$bytes_BytesMut, of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8, of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, of$bytes_buf_Take_bytes_Bytes, of$bytes_buf_Take_ref_slice_u8, of$ref_slice_u8, ofPlace$bytes_Bytes, ofPlace$ref_slice_u8, out$i64, out$u128, out$u16, out$u8 } from "./lib.ts"; +import { drop$Option_bytes_Bytes as lib_drop$Option_bytes_Bytes, drop$Result_bytes_BytesMut_bytes_Bytes as lib_drop$Result_bytes_BytesMut_bytes_Bytes, drop$bytes_buf_Chain_buf_Provided_bytes_Bytes as lib_drop$bytes_buf_Chain_buf_Provided_bytes_Bytes, drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8, drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces, drop$bytes_buf_Take_bytes_Bytes as lib_drop$bytes_buf_Take_bytes_Bytes, of$buf_Counted, of$buf_Pieces, of$buf_Provided, of$bytes_Bytes, of$bytes_BytesMut, of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8, of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, of$bytes_buf_Take_bytes_Bytes, of$bytes_buf_Take_ref_slice_u8, of$ref_slice_u8, ofPlace$bytes_Bytes, ofPlace$ref_slice_u8, out$i64, out$u128, out$u16, out$u8 } from "./lib.ts"; import * as buf_Counted from "./buf.Counted.ts"; import * as Fixed from "./buf.Fixed.ts"; import type * as Leased from "./buf.Leased.ts"; @@ -16,6 +16,7 @@ import * as Chain from "./bytes/buf/chain.Chain.ts"; import * as Take from "./bytes/buf/take.Take.ts"; import * as UninitSlice from "./bytes/buf/uninit_slice.UninitSlice.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; +import { then$0abhnvu } from "./core/bool.ts"; import { clone$1i3gmk3 as option_clone$1i3gmk3 } from "./core/option.ts"; import { map$1rpus2m as result_map$1rpus2m, map$1cosroz as result_map$1cosroz, map$1k6isgs as result_map$1k6isgs } from "./core/result.ts"; @@ -322,16 +323,16 @@ export function bytesMut(data: rs.ByteSlice, out: rs.ByteVec): void { const _403: rs.usize = buf.length; const _406: rs.usize = buf.cap; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(buf), f), (f: rs.Formatter) => rs.usizeDisplay(_403, f), (f: rs.Formatter) => rs.usizeDisplay(_406, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]).v)); for (const piece6 of pieces.items) { const _430: rs.usize = piece6.cap; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(piece6), f), (f: rs.Formatter) => rs.usizeDisplay(_430, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]).v)); } for (const bytes3 of frozen.items) { const _452: boolean = rs.bytesIsUnique(bytes3); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(bytes3, f), (f: rs.Formatter) => rs.fmtBool(_452, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]).v)); } const vec2: rs.ByteVec = rs.bytesMutToByteVec(buf); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(vec2.data.length as rs.u32).reverse())); @@ -3217,7 +3218,7 @@ export function chunkWrite(chunk: rs.ByteSlice, op: rs.u8, n: rs.u8, out: rs.Byt } } const args2: rs.Fmt[] = [(f: rs.Formatter) => UninitSlice.fmt$fmt_Debug(chunk, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); return 0; } return k; @@ -3947,7 +3948,7 @@ export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, const _68: boolean = rs.bytesIsUnique(bytes); const _70: rs.ByteSlice = part; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(_70, f), (f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.fmtBool(_65, f), (f: rs.Formatter) => rs.fmtBool(_68, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]).v)); rs.bytesDrop(part); rs.bytesDrop(bytes); } @@ -4263,4 +4264,52 @@ export function chained$dyn_bytes_Buf(at: rs.usize[], buf: Buf.Buf, pick: rs.u8, return readAll$dyn_bytes_Buf(buf, ops, out); } +/** + * The bytes of a case's input, taken from the front. + * A `Bytes` of a `String`, which takes its storage, of the room its first bytes pick past + * its text: whether it is the one handle of it, and the room a `BytesMut` or a `Vec` taken + * back of it holds, with a clone of it held or not. + */ +export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: [rs.usize, rs.usize]; + const ops: Ops.Ops = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; + const s: rs.String = rs.stringWithCapacity(rs.usizeRem(Ops.byte(ops) as rs.usize, 24)); + const n: rs.usize = rs.usizeRem(Ops.byte(ops) as rs.usize, 12); + const _17: string = rs.strCowStr(rs.stringFromUtf8Lossy(Ops.take(ops, n))); + rs.stringPushStr(s, _17); + const _24: rs.usize = rs.usizeRem(Ops.byte(ops) as rs.usize, 7); + rs.stringReserve(s, _24); + const bytes: rs.ByteSlice = rs.bytesFromVec(rs.stringIntoBytes(s)); + rs.byteVecPush(out, rs.bytesIsUnique(bytes) ? 1 : 0); + const held: rs.ByteSlice | undefined = then$0abhnvu(rs.u8Rem(Ops.byte(ops), 2) === 1, (): rs.ByteSlice => { + return rs.bytesClone(bytes); + }); + const _46: rs.u8 = rs.u8Rem(Ops.byte(ops), 3); + if (_46 === 0) { + const m: rs.BytesMut = rs.bytesMutFromBytes(bytes); + _45 = [m.length, m.cap] as [rs.usize, rs.usize]; + m[Symbol.dispose](); + } else if (_46 === 1) { + const _56: rs.Result = rs.bytesTryIntoMut(bytes); + if (_56.ok) { + const m2: rs.BytesMut = _56.value; + _45 = [m2.length, m2.cap] as [rs.usize, rs.usize]; + m2[Symbol.dispose](); + } else { + _45 = [4294967295, 0] as [rs.usize, rs.usize]; + } + if (!_56.ok) { + lib_drop$Result_bytes_BytesMut_bytes_Bytes(_56); + } + } else { + const v: rs.ByteVec = rs.bytesToByteVec(bytes); + _45 = [v.length, v.data.length] as [rs.usize, rs.usize]; + } + const len: rs.usize = _45[0]; + const cap: rs.usize = _45[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(cap as rs.u32).reverse())); + lib_drop$Option_bytes_Bytes(held); +} + //# sourceMappingURL=buf.ts.map diff --git a/ts/fixtures/stock/expected/core/bool.ts b/ts/fixtures/stock/expected/core/bool.ts new file mode 100644 index 000000000..d4fdee6c9 --- /dev/null +++ b/ts/fixtures/stock/expected/core/bool.ts @@ -0,0 +1,12 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; + +export function then$0abhnvu(self: boolean, f: () => rs.ByteSlice): rs.ByteSlice | undefined { + if (!self) { + return undefined; + } + return f(); +} + +//# sourceMappingURL=bool.ts.map diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index a35ff3742..18c3a1c94 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { bytesMut, far, reclaims, reads, dyns, late, vecSpares, chunks, writes, edits, chains } from "./buf.ts"; +import { bytesMut, far, reclaims, reads, dyns, late, vecSpares, chunks, writes, edits, chains, strings } from "./buf.ts"; import * as Owner from "./harness.Owner.ts"; import { map as maps_map, table, capacity, linked, linkedIters, nested, ownHasher, ownFromIter, equal, defaultHasher } from "./maps.ts"; @@ -38,7 +38,7 @@ export function cases(): rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => u reclaims(a013.data, a013.start, a013.length, a113); }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::vec_spares", vecSpares as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::chunks", (a014: rs.ByteSlice, a114: rs.ByteVec): undefined => { chunks(a014.data, a014.start, a014.length, a114); - }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::strings", strings as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); } /** Run one case. */ @@ -146,7 +146,7 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o rs.byteVecClear(source); rs.byteVecPush(source, 0); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(copied, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]).v)); const iter: rs.Iter = rs.iterSlice(made, rs.bytesDrop); while (true) { const _44: rs.ByteSlice | rs.Done = iter.next(); @@ -156,7 +156,7 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o const bytes: rs.ByteSlice = _44; const _56: rs.usize = bytes.length; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.usizeDisplay(_56, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]).v)); rs.bytesDrop(bytes); } rs.drop(iter); diff --git a/ts/fixtures/stock/expected/lib.ts b/ts/fixtures/stock/expected/lib.ts index b6c1611a6..24485f1c2 100644 --- a/ts/fixtures/stock/expected/lib.ts +++ b/ts/fixtures/stock/expected/lib.ts @@ -81,6 +81,14 @@ export function drop$Option_tuple2_u16_maps_Logged(_1: [rs.u16, Logged.Logged] | } } +export function drop$Result_bytes_BytesMut_bytes_Bytes(_1: rs.Result): void { + if (_1.ok) { + _1.value[Symbol.dispose](); + } else { + rs.bytesDrop(_1.error); + } +} + export function drop$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes(_1: Chain.Chain): void { rs.drop(_1.a); rs.bytesDrop(_1.b); diff --git a/ts/fixtures/stock/expected/maps.ts b/ts/fixtures/stock/expected/maps.ts index 122ea0fa2..72e03017f 100644 --- a/ts/fixtures/stock/expected/maps.ts +++ b/ts/fixtures/stock/expected/maps.ts @@ -33,7 +33,7 @@ export function put(out: rs.ByteVec, n: rs.usize): void { export function map(data: rs.ByteSlice, out: rs.ByteVec): void { const own: rs.HashMap = rs.hashNew() as rs.HashMap; const pairs: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; - const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512) as rs.HashSet; + const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512, rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashSet; const iter: rs.Iter = rs.byteSliceChunks(data, 2); while (true) { const _12: rs.ByteSlice | rs.Done = iter.next(); @@ -83,15 +83,15 @@ export function map(data: rs.ByteSlice, out: rs.ByteVec): void { }); } else if (_35 === 6) { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(key, f)]; - const _88: string = rs.fmtFormat([args2[0]]); + const _88: rs.String = rs.fmtFormat([args2[0]]); rs.byteVecPush(out, rs.hashAdd(set, _88) ? 1 : 0); const part = rs.u16Add(key, 1); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(part, f)]; - const _102: string = rs.fmtFormat([args4[0]]); + const _102: rs.String = rs.fmtFormat([args4[0]]); rs.byteVecPush(out, rs.hashContains(set, _102) ? 1 : 0); } else if (_35 === 7) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(key, f)]; - const _117: string = rs.fmtFormat([args6[0]]); + const _117: rs.String = rs.fmtFormat([args6[0]]); rs.byteVecPush(out, rs.hashDelete(set, _117) ? 1 : 0); } else if (_35 === 8) { put(out, option_mapOr$0o00yzv(rs.hashRemoveEntry(own, key), 256, (_26: [rs.u16, rs.u32]): rs.usize => { @@ -125,9 +125,9 @@ export function map(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, b))); put(out, v2 as rs.usize); } - const set2: rs.Vec = rs.iterToVec(rs.hashKeys(set), "next", 12); + const set2: rs.Vec = rs.iterToVec(rs.hashKeys(set), "next", 12); rs.sliceSort(rs.sliceFrom(set2.items), rs.cmpLt(rs.cmpStr), 12, true); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strsJoin(set2.items, ","))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strsJoin(set2.items, ",").v)); } /** diff --git a/ts/fixtures/stock/src/buf.rs b/ts/fixtures/stock/src/buf.rs index aad61cffb..bc205474b 100644 --- a/ts/fixtures/stock/src/buf.rs +++ b/ts/fixtures/stock/src/buf.rs @@ -981,6 +981,37 @@ fn chained(at: [usize; 2], buf: &mut B, pick: &u8, ops: &[u8], } /// The bytes of a case's input, taken from the front. +/// A `Bytes` of a `String`, which takes its storage, of the room its first bytes pick past +/// its text: whether it is the one handle of it, and the room a `BytesMut` or a `Vec` taken +/// back of it holds, with a clone of it held or not. +pub fn strings(data: &[u8], out: &mut Vec) { + let mut ops = Ops(data); + let mut s = String::with_capacity(ops.byte() as usize % 24); + let n = ops.byte() as usize % 12; + s.push_str(&String::from_utf8_lossy(ops.take(n))); + s.reserve(ops.byte() as usize % 7); + let bytes = Bytes::from(s); + out.push(bytes.is_unique() as u8); + let held = (ops.byte() % 2 == 1).then(|| bytes.clone()); + let (len, cap) = match ops.byte() % 3 { + 0 => { + let m = BytesMut::from(bytes); + (m.len(), m.capacity()) + } + 1 => match bytes.try_into_mut() { + Ok(m) => (m.len(), m.capacity()), + Err(_) => (usize::MAX, 0), + }, + _ => { + let v: Vec = bytes.into(); + (v.len(), v.capacity()) + } + }; + out.extend_from_slice(&(len as u32).to_le_bytes()); + out.extend_from_slice(&(cap as u32).to_le_bytes()); + drop(held); +} + struct Ops<'a>(&'a [u8]); impl<'a> Ops<'a> { diff --git a/ts/fixtures/stock/src/harness.rs b/ts/fixtures/stock/src/harness.rs index 4cbf079b3..97b824240 100644 --- a/ts/fixtures/stock/src/harness.rs +++ b/ts/fixtures/stock/src/harness.rs @@ -36,6 +36,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("buf::reclaims", crate::buf::reclaims), ("buf::vec_spares", crate::buf::vec_spares), ("buf::chunks", crate::buf::chunks), + ("buf::strings", crate::buf::strings), ] } diff --git a/ts/fixtures/task/expected/closures.ts b/ts/fixtures/task/expected/closures.ts index 2c968068c..bb37e638d 100644 --- a/ts/fixtures/task/expected/closures.ts +++ b/ts/fixtures/task/expected/closures.ts @@ -280,7 +280,7 @@ export class closuresFuture { const _91: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(arg5[0], f), (f: rs.Formatter) => rs.u32Debug(arg5[1], f), (f: rs.Formatter) => rs.u32Debug(arg5[2], f)], f); const arg6 = this.#count; const args2: rs.Fmt[] = [_87, _88, _89, _90, _91, (f: rs.Formatter) => rs.u32Display(arg6, f)]; - const _74: string = rs.fmtFormat(["seen ", args2[0], " first ", args2[1], " second ", args2[2], " reads ", args2[3], " tallied ", args2[4], " count ", args2[5]]); + const _74: string = rs.fmtFormat(["seen ", args2[0], " first ", args2[1], " second ", args2[2], " reads ", args2[3], " tallied ", args2[4], " count ", args2[5]]).v; Guard.note(this.#guard, _74); const captured2 = Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)); this.#awaitee$3 = new callOnceFuture$closures_closures_closure0_closure2(rs.closure(rs.byMove((rx: Consumer.Consumer): rs.Future => { @@ -301,7 +301,7 @@ export class closuresFuture { rs.drop(this.#awaitee$3); const arg7 = this.#third; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg7, f)]; - const _115: string = rs.fmtFormat(["third ", args4[0]]); + const _115: string = rs.fmtFormat(["third ", args4[0]]).v; Guard.note(this.#guard, _115); this.#lent = Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)); this.#peek = (value3: rs.u64): rs.Future => { @@ -416,7 +416,7 @@ export class closuresFuture { const _249: rs.Fmt = (f: rs.Formatter) => rs.u64Display(arg8, f); const arg9 = this.#fifth; const args6: rs.Fmt[] = [_249, (f: rs.Formatter) => rs.u64Display(arg9, f)]; - const _240: string = rs.fmtFormat(["fourth ", args6[0], " fifth ", args6[1]]); + const _240: string = rs.fmtFormat(["fourth ", args6[0], " fifth ", args6[1]]).v; Guard.note(this.#guard, _240); const captured5 = Guard.new(rs.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); this.#awaitee$3 = new callOnceFuture$boxed_Box_closures_closures_closure0_closure7(rs.closure(rs.byMove((rx2: Consumer.Consumer): rs.Future => { @@ -481,7 +481,7 @@ export class closuresFuture { }))()); const arg10 = this.#sixth; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg10, f), (f: rs.Formatter) => rs.u32Display(seventh, f)]; - const _319: string = rs.fmtFormat(["sixth ", args8[0], " seventh ", args8[1]]); + const _319: string = rs.fmtFormat(["sixth ", args8[0], " seventh ", args8[1]]).v; Guard.note(this.#guard, _319); const _360: rs.u64 = rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(option_unwrapOr$15hbiwd(this.#first, 0), option_unwrapOr$15hbiwd(this.#second, 0)), this.#third), this.#fourth), this.#fifth), this.#sixth); this.#saved$4 = false; @@ -594,7 +594,7 @@ export class closuresFuture$closure2_closure0 { rs.drop(this.#awaitee); const _27: Guard.Guard = this.#owned; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - Guard.note(_27, rs.fmtFormat(["once ", args2[0]])); + Guard.note(_27, rs.fmtFormat(["once ", args2[0]]).v); const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; @@ -635,7 +635,7 @@ export class closuresFuture$closure2_closure0_once { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - const _17: string = rs.fmtFormat(["once ", args2[0]]); + const _17: string = rs.fmtFormat(["once ", args2[0]]).v; Guard.note(this.#owned, _17); const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#owned[Symbol.dispose](); @@ -665,7 +665,7 @@ export class closuresFuture$closure3_closure0 { const value: rs.u64 = this.#value; const _17: Guard.Guard = this.#lent; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - Guard.note(_17, rs.fmtFormat(["peek ", args2[0]])); + Guard.note(_17, rs.fmtFormat(["peek ", args2[0]]).v); const _0: rs.Poll = rs.u64Add(value, 1); this.#state = 1; return _0; @@ -738,7 +738,7 @@ export class closuresFuture$closure6_closure0 { const value: rs.u64 = this.#value; const _16: Guard.Guard = this.#last; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - Guard.note(_16, rs.fmtFormat(["last ", args2[0]])); + Guard.note(_16, rs.fmtFormat(["last ", args2[0]]).v); this.#state = 1; return value; } @@ -766,7 +766,7 @@ export class closuresFuture$closure6_closure0_once { if (this.#state === 0) { const value: rs.u64 = this.#value; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - const _6: string = rs.fmtFormat(["last ", args2[0]]); + const _6: string = rs.fmtFormat(["last ", args2[0]]).v; Guard.note(this.#last, _6); this.#last[Symbol.dispose](); this.#state = 1; @@ -805,7 +805,7 @@ export class closuresFuture$closure7_closure0 { rs.drop(this.#awaitee); const _27: Guard.Guard = this.#boxed; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - Guard.note(_27, rs.fmtFormat(["boxed ", args2[0]])); + Guard.note(_27, rs.fmtFormat(["boxed ", args2[0]]).v); const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; @@ -846,7 +846,7 @@ export class closuresFuture$closure7_closure0_once { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - const _17: string = rs.fmtFormat(["boxed ", args2[0]]); + const _17: string = rs.fmtFormat(["boxed ", args2[0]]).v; Guard.note(this.#boxed, _17); const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#boxed[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops.Key.ts b/ts/fixtures/task/expected/drops.Key.ts index 12d9010ca..5c41fdb13 100644 --- a/ts/fixtures/task/expected/drops.Key.ts +++ b/ts/fixtures/task/expected/drops.Key.ts @@ -29,7 +29,7 @@ function new_(id: rs.u32, log: Log.Log): Key { export function drop$ops_Drop(self: Key): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["k", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["k", args2[0], " drop"]); Log.note(self.log, _4); self.id = 4294967295; } @@ -50,7 +50,7 @@ export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void if (self.counted) { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _6: string = rs.fmtFormat(["k", args2[0], " hashed"]); + const _6: rs.String = rs.fmtFormat(["k", args2[0], " hashed"]); Log.note(self.log, _6); } rs.hash32(self.id, state); @@ -59,7 +59,7 @@ export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void export function clone$Clone(self: Key): Key { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["k", args2[0], " cloned"]); + const _4: rs.String = rs.fmtFormat(["k", args2[0], " cloned"]); Log.note(self.log, _4); return new Key(self.id, Log.clone$Clone(self.log), self.counted); } diff --git a/ts/fixtures/task/expected/drops.Wrap.ts b/ts/fixtures/task/expected/drops.Wrap.ts index 2f78b4528..adb66c845 100644 --- a/ts/fixtures/task/expected/drops.Wrap.ts +++ b/ts/fixtures/task/expected/drops.Wrap.ts @@ -23,42 +23,42 @@ export class Wrap { export function drop$ops_Drop_Vec_drops_Wrap_drops_Held(self: Wrap>>): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Held(self: Wrap): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Pair_drops_Held(self: Wrap>): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_model_Guard(self: Wrap): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_sync_Arc_drops_Held(self: Wrap>): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_u32(self: Wrap): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index d6b819aee..f58966507 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -294,7 +294,7 @@ export class heldFuture { const _54: boolean = Held.isSome(this.#wrap.inner.value); const arg = this.#id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_51, f), (f: rs.Formatter) => rs.fmtBool(_54, f)]; - const _46: string = rs.fmtFormat(["g", args2[0], " held ", args2[1], " ", args2[2]]); + const _46: rs.String = rs.fmtFormat(["g", args2[0], " held ", args2[1], " ", args2[2]]); Log.note(this.#log, _46); lib_drop$drops_Wrap_sync_Arc_drops_Held(this.#wrap); rs.dropVec(this.#held, lib_drop$drops_Held); @@ -354,7 +354,7 @@ export function ordered(log: Log.Log, id: rs.u32): void { const _86: Guard.Guard = rs.entryRemove(_72, rs.drop); const part3 = Guard.id(_86); const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _80: string = rs.fmtFormat(["occupied ", args6[0]]); + const _80: rs.String = rs.fmtFormat(["occupied ", args6[0]]); _86[Symbol.dispose](); Log.note(log, _80); } @@ -394,7 +394,7 @@ export function ordered(log: Log.Log, id: rs.u32): void { const _192: Key.Key = key(11); const part6 = rs.btreeDelete(set, _192, rs.drop); const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; - const _185: string = rs.fmtFormat(["gone ", args14[0]]); + const _185: rs.String = rs.fmtFormat(["gone ", args14[0]]); _192[Symbol.dispose](); Log.note(log, _185); const _201: Key.Key = key(12); @@ -574,7 +574,7 @@ export function hashed(log: Log.Log, id: rs.u32): void { const _183: Key.Key = key(11); const part3 = rs.hashDelete(set, _183, rs.drop); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - const _176: string = rs.fmtFormat(["gone ", args8[0]]); + const _176: rs.String = rs.fmtFormat(["gone ", args8[0]]); _183[Symbol.dispose](); Log.note(log, _176); const _192: Key.Key = key(12); @@ -911,7 +911,7 @@ export function elements(log: Log.Log, id: rs.u32): void { }), rs.drop, rs.None); const part5 = _151 !== rs.None; const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; - const _145: string = rs.fmtFormat(["uncalled ", args12[0]]); + const _145: rs.String = rs.fmtFormat(["uncalled ", args12[0]]); rs.drop(_151); Log.note(log, _145); v.items.push(undefined as Guard.Guard | undefined); @@ -1081,7 +1081,7 @@ export function elements(log: Log.Log, id: rs.u32): void { }); }); const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - const _458: string = rs.fmtFormat(["get ", args36[0]]); + const _458: rs.String = rs.fmtFormat(["get ", args36[0]]); rs.drop(_466); Log.note(log, _458); const _477: Key.Key | undefined = key(10); @@ -1096,7 +1096,7 @@ export function elements(log: Log.Log, id: rs.u32): void { const _493: Key.Key | undefined | rs.None = rs.btreeKey(sorted, _496, true, rs.None); const _491: boolean = _493 !== rs.None; const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_487, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtBool(_491, f)]; - const _483: string = rs.fmtFormat(["take ", args38[0], " ", args38[1]]); + const _483: rs.String = rs.fmtFormat(["take ", args38[0], " ", args38[1]]); rs.drop(_493); rs.drop(_496); Log.note(log, _483); @@ -1236,7 +1236,7 @@ export function arcs(log: Log.Log, id: rs.u32): void { const _176: Guard.Guard | undefined = rs.arcIntoInner(shared); const part10 = _176 !== undefined; const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part10, f)]; - const _170: string = rs.fmtFormat(["into_inner ", args8[0]]); + const _170: rs.String = rs.fmtFormat(["into_inner ", args8[0]]); rs.drop(_176); Log.note(log, _170); const inner: Guard.Guard | undefined = rs.arcIntoInner(clone); @@ -1244,7 +1244,7 @@ export function arcs(log: Log.Log, id: rs.u32): void { const _194: rs.Arc | undefined = rs.weakUpgrade(weak); const _192: boolean = _194 !== undefined; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_188, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_192, f)]; - const _184: string = rs.fmtFormat(["into_inner ", args10[0], " ", args10[1]]); + const _184: rs.String = rs.fmtFormat(["into_inner ", args10[0], " ", args10[1]]); rs.drop(_194); Log.note(log, _184); rs.drop(inner); @@ -1355,10 +1355,10 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { return Key.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const ids: (a0: rs.Slice) => string = (v13: rs.Slice): string => { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(v13)), (k: Key.Key): string => { + const ids: (a0: rs.Slice) => rs.String = (v13: rs.Slice): rs.String => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(v13)), (k: Key.Key): rs.String => { const _43: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_43, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_43, f), 0); }), undefined, 12, true).items, ","); }; const _8: rs.u8 = rs.u8Rem(arg, 9); @@ -1378,14 +1378,14 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, rs.drop); const part24 = rs.sliceFrom(v.items); const part25 = ids(part24); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25.v)]; Log.note(log, rs.fmtFormat(["retained ", args2[0]])); rs.vecRetain(v, (k7: Key.Key): boolean => { return k7.id !== rs.u32Add(id, 3); }, rs.drop); const part26 = rs.sliceFrom(v.items); const part27 = ids(part26); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part27)]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part27.v)]; Log.note(log, rs.fmtFormat(["retained ", args4[0]])); rs.dropVec(v); } else if (_8 === 1) { @@ -1404,21 +1404,21 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecDedupBy(v3, Key.eq$cmp_PartialEq, rs.drop); const part18 = rs.sliceFrom(v3.items); const part19 = ids(part18); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part19)]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part19.v)]; Log.note(log, rs.fmtFormat(["deduped ", args6[0]])); rs.vecDedupByKey(v3, (k5: Key.Key): rs.u32 => { return rs.u32Div(k5.id, 2); }, rs.same, rs.drop); const part20 = rs.sliceFrom(v3.items); const part21 = ids(part20); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21)]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21.v)]; Log.note(log, rs.fmtFormat(["deduped ", args8[0]])); rs.vecDedupBy(v3, (a: Key.Key, b: Key.Key): boolean => { return a.id > b.id; }, rs.drop); const part22 = rs.sliceFrom(v3.items); const part23 = ids(part22); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23)]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23.v)]; Log.note(log, rs.fmtFormat(["deduped ", args10[0]])); rs.dropVec(v3); } else if (_8 === 2) { @@ -1433,7 +1433,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecSwapRemove(v5, 0)[Symbol.dispose](); const part16 = rs.sliceFrom(v5.items); const part17 = ids(part16); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part17)]; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part17.v)]; Log.note(log, rs.fmtFormat(["swapped ", args12[0]])); rs.vecSwapRemove(v5, 3)[Symbol.dispose](); rs.dropVec(v5); @@ -1447,8 +1447,8 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _209: rs.Vec = rs.vecFrom(v7.items.map(Key.clone$Clone)); const part14 = rs.sliceFrom(_209.items); const part15 = ids(part14); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15)]; - const _200: string = rs.fmtFormat(["cloned ", args14[0]]); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15.v)]; + const _200: rs.String = rs.fmtFormat(["cloned ", args14[0]]); rs.dropVec(_209); Log.note(log, _200); rs.dropVec(v7); @@ -1469,17 +1469,17 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecInsert(v9, 1, _244); const part8 = rs.sliceFrom(v9.items); const part9 = ids(part8); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part9)]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part9.v)]; Log.note(log, rs.fmtFormat(["inserted ", args16[0]])); rs.vecRemove(v9, 0)[Symbol.dispose](); const part10 = rs.sliceFrom(v9.items); const part11 = ids(part10); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11)]; + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11.v)]; Log.note(log, rs.fmtFormat(["removed ", args18[0]])); rs.vecTruncate(v9, 1, rs.drop); const part12 = rs.sliceFrom(v9.items); const part13 = ids(part12); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part13)]; + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part13.v)]; Log.note(log, rs.fmtFormat(["truncated ", args20[0]])); rs.vecTruncate(v9, 0, rs.drop); rs.dropVec(v9); @@ -1519,7 +1519,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _377: Key.Key = Key.clone$Clone(boxed); const part5 = rs.u32Sub(_377.id, id); const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - const _371: string = rs.fmtFormat(["boxed ", args26[0]]); + const _371: rs.String = rs.fmtFormat(["boxed ", args26[0]]); _377[Symbol.dispose](); Log.note(log, _371); boxed[Symbol.dispose](); @@ -1527,25 +1527,25 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _392: Key.Key = rs.ordMax(key(1), key(2), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part = rs.u32Sub(_392.id, id); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - const _386: string = rs.fmtFormat(["max ", args28[0]]); + const _386: rs.String = rs.fmtFormat(["max ", args28[0]]); _392[Symbol.dispose](); Log.note(log, _386); const _412: Key.Key = rs.ordMin(key(5), key(4), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part2 = rs.u32Sub(_412.id, id); const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - const _406: string = rs.fmtFormat(["min ", args30[0]]); + const _406: rs.String = rs.fmtFormat(["min ", args30[0]]); _412[Symbol.dispose](); Log.note(log, _406); const _432: Key.Key = rs.ordClamp(key(2), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part3 = rs.u32Sub(_432.id, id); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _426: string = rs.fmtFormat(["clamped ", args32[0]]); + const _426: rs.String = rs.fmtFormat(["clamped ", args32[0]]); _432[Symbol.dispose](); Log.note(log, _426); const _455: Key.Key = rs.ordClamp(key(0), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part4 = rs.u32Sub(_455.id, id); const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - const _449: string = rs.fmtFormat(["clamped ", args34[0]]); + const _449: rs.String = rs.fmtFormat(["clamped ", args34[0]]); _455[Symbol.dispose](); Log.note(log, _449); } diff --git a/ts/fixtures/task/expected/drops/called.ts b/ts/fixtures/task/expected/drops/called.ts index a7ec4cf94..6224e27d4 100644 --- a/ts/fixtures/task/expected/drops/called.ts +++ b/ts/fixtures/task/expected/drops/called.ts @@ -279,7 +279,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_280, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_283[0], f), (f: rs.Formatter) => rs.fmtOption(_283[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_286[0], f), (f: rs.Formatter) => rs.fmtOption(_286[1], f, rs.usizeDebug)], f)]; Log.note(log, rs.fmtFormat(["first ", args28[0], " ", args28[1], " ", args28[2]])); rs.drop(it5); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); rs.dropVec(made); } else if (_17 === 6) { const _303: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); @@ -376,7 +376,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured9[Symbol.dispose](); })); - Log.note(log, "made"); + Log.note(log, rs.stringFrom("made")); const _425: rs.u32 = lazy.force(); const _427: rs.u32 = lazy.force(); const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_425, f), (f: rs.Formatter) => rs.u32Display(_427, f)]; @@ -390,7 +390,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured10[Symbol.dispose](); })), undefined, rs.drop); - Log.note(log, "unused"); + Log.note(log, rs.stringFrom("unused")); const captured11 = guard(22); const lazy2: rs.LazyCell = new rs.LazyCell(rs.once(rs.closure((): rs.u32 => { return Guard.id(captured11); @@ -425,7 +425,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _137: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell2); const _1110: boolean = !_137.ok; const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8.v, f), (f: rs.Formatter) => rs.u32Display(_95, f), (f: rs.Formatter) => rs.fmtBool(_1110, f)]; - const _511: string = rs.fmtFormat(["replace ", args64[0], " ", args64[1], " ", args64[2]]); + const _511: rs.String = rs.fmtFormat(["replace ", args64[0], " ", args64[1], " ", args64[2]]); lib_drop$Result_cell_Ref_u32_cell_BorrowError(_137); Log.note(log, _511); n8.v = rs.u32Add(n8.v, 1); @@ -433,7 +433,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, true); const _484: rs.RefCell = rs.refCellBorrow(cell2); const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(old, f), (f: rs.Formatter) => rs.u32Display(_484.value, f)]; - const _480: string = rs.fmtFormat(["replaced ", args46[0], " ", args46[1]]); + const _480: rs.String = rs.fmtFormat(["replaced ", args46[0], " ", args46[1]]); rs.refRelease(_484); Log.note(log, _480); const _494: [Guard.Guard, Guard.Guard] = [guard(22), guard(23)]; @@ -539,8 +539,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { const _142: rs.u32 = Guard.id(g2); const _173: rs.u32 = Guard.id(captured2); - const _205: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_142, f), (f: rs.Formatter) => rs.u32Display(_173, f), (f: rs.Formatter) => rs.fmtPad(f, _205)]; + const _205: rs.String = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_142, f), (f: rs.Formatter) => rs.u32Display(_173, f), (f: rs.Formatter) => rs.fmtPad(f, _205.v)]; rs.panicFmt(["try_fold of g", args60[0], " with g", args60[1], " after\n", args60[2]]); } else { const _04: rs.u32 | undefined = rs.u32Add(n4, Guard.id(g2)); diff --git a/ts/fixtures/task/expected/drops/flattened.ts b/ts/fixtures/task/expected/drops/flattened.ts index e0c3ecb1c..625e08c65 100644 --- a/ts/fixtures/task/expected/drops/flattened.ts +++ b/ts/fixtures/task/expected/drops/flattened.ts @@ -113,7 +113,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _026; }); const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part56, f)]; - const _147: string = rs.fmtFormat(["all ", args18[0]]); + const _147: rs.String = rs.fmtFormat(["all ", args18[0]]); rs.drop(_153); Log.note(log, _147); const _168: rs.Iter = firsts(log, id, 60); @@ -123,7 +123,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _027; }); const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part57, f, rs.usizeDebug)]; - const _162: string = rs.fmtFormat(["position ", args20[0]]); + const _162: rs.String = rs.fmtFormat(["position ", args20[0]]); rs.drop(_168); Log.note(log, _162); } else if (_6 === 3) { diff --git a/ts/fixtures/task/expected/drops/folds.Pile.ts b/ts/fixtures/task/expected/drops/folds.Pile.ts index ef293336e..63c0e8ea0 100644 --- a/ts/fixtures/task/expected/drops/folds.Pile.ts +++ b/ts/fixtures/task/expected/drops/folds.Pile.ts @@ -35,7 +35,7 @@ export function sizeHint$iter_Iterator(self: Pile): [rs.usize, rs.usize | undefi export function nth$iter_Iterator(self: Pile, n: rs.usize): Guard.Guard | undefined { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f)]; - const _5: string = rs.fmtFormat(["pile nth ", args2[0]]); + const _5: rs.String = rs.fmtFormat(["pile nth ", args2[0]]); Log.note(self.log, _5); let iterStart: rs.usize = 0; const iterEnd: rs.usize = n; @@ -51,14 +51,16 @@ export function nth$iter_Iterator(self: Pile, n: rs.usize): Guard.Guard | undefi } export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: Guard.Guard) => rs.u32 | undefined): rs.u32 | undefined { - Log.note(self.log, "pile fold"); + const _6: rs.String = rs.stringFrom("pile fold"); + Log.note(self.log, _6); let acc: rs.u32 | undefined = init; while (self.held.items.length > 1) { const part = rs.optionUnwrap(rs.vecPop(self.held)); acc = f(acc, part); } rs.drop(f); - Log.note(self.log, "pile folded"); + const _23: rs.String = rs.stringFrom("pile folded"); + Log.note(self.log, _23); self[Symbol.dispose](); return acc; } @@ -66,7 +68,7 @@ export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Opt export function count$iter_Iterator(self: Pile): rs.usize { const part = self.held.items.length; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - const _4: string = rs.fmtFormat(["pile count ", args2[0]]); + const _4: rs.String = rs.fmtFormat(["pile count ", args2[0]]); Log.note(self.log, _4); const _0: rs.usize = self.held.items.length; self[Symbol.dispose](); @@ -74,7 +76,8 @@ export function count$iter_Iterator(self: Pile): rs.usize { } export function last$iter_Iterator(self: Pile): Guard.Guard | undefined { - Log.note(self.log, "pile last"); + const _4: rs.String = rs.stringFrom("pile last"); + Log.note(self.log, _4); const _0: Guard.Guard | undefined = then$1xpp3sz(!(self.held.items.length === 0), (): Guard.Guard => { return rs.vecRemove(self.held, 0); }); @@ -90,7 +93,7 @@ export function nextBack$iter_DoubleEndedIterator(self: Pile): Guard.Guard | und export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rs.usize): Guard.Guard | undefined { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f)]; - const _5: string = rs.fmtFormat(["pile nth_back ", args2[0]]); + const _5: rs.String = rs.fmtFormat(["pile nth_back ", args2[0]]); Log.note(self.log, _5); let iterStart: rs.usize = 0; const iterEnd: rs.usize = n; @@ -106,14 +109,16 @@ export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rs.usize): Guard } export function rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: Guard.Guard) => rs.u32 | undefined): rs.u32 | undefined { - Log.note(self.log, "pile rfold"); + const _6: rs.String = rs.stringFrom("pile rfold"); + Log.note(self.log, _6); let acc: rs.u32 | undefined = init; while (self.held.items.length > 1) { const part = rs.vecRemove(self.held, 0); acc = f(acc, part); } rs.drop(f); - Log.note(self.log, "pile rfolded"); + const _22: rs.String = rs.stringFrom("pile rfolded"); + Log.note(self.log, _22); self[Symbol.dispose](); return acc; } diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index c73aa0931..b8058d3d8 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -1661,8 +1661,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { const _145: rs.u32 = Guard.id(g2); const _172: rs.u32 = Guard.id(captured2); - const _202: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_145, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202)]; + const _202: rs.String = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_145, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202.v)]; rs.panicFmt(["try_rfold of g", args56[0], " with g", args56[1], " after\n", args56[2]]); } else { const _04: rs.u32 | undefined = rs.u32Add(n13, Guard.id(g2)); diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index c9931b0a8..3a09f3476 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -33,14 +33,14 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _24: Log.Log = Log.clone$Clone(log); const _23: Listed.Listed = new Listed.Listed(id, _24, n); const args2: rs.Fmt[] = [(f: rs.Formatter) => Listed.fmt$fmt_Debug(_23, f)]; - const _19: string = rs.fmtFormat(["listed ", args2[0]]); + const _19: rs.String = rs.fmtFormat(["listed ", args2[0]]); _23[Symbol.dispose](); Log.note(log, _19); } const _36: Log.Log = Log.clone$Clone(log); const _35: Listed.Listed = new Listed.Listed(id, _36, 2); const args4: rs.Fmt[] = [(f: rs.Formatter) => Listed.fmt$fmt_Debug(_35, f)]; - const _31: string = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, args4[0])]); + const _31: rs.String = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, args4[0])]); _35[Symbol.dispose](); Log.note(log, _31); } else if (_8 === 1) { @@ -80,22 +80,22 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, rs.u32Debug)]; Log.note(log, rs.fmtFormat(["deque ", args12[0]])); rs.drop(it); - let s: string = "abcdef"; + const s: rs.String = rs.stringFrom("abcdef"); const _180: Spent.Spent = new Spent.Spent(guard(12), 1, 3); - const s4 = rs.place(() => s, (value2) => s = value2); - const part18 = rs.stringExtendChars("", rs.stringDrain(s4, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s4.v)), rs.drop)), true); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18)]; + const _178: rs.Iter = rs.stringDrain(s, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop)); + const part18 = rs.stringExtendChars(rs.stringNew(), _178, true); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18.v)]; Log.note(log, rs.fmtFormat(["text ", args14[0]])); const _190: Spent.Spent = new Spent.Spent(guard(13), 0, 1); - s = rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop), "xy"); + rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop), "xy"); const _197: Spent.Spent = new Spent.Spent(guard(14), 2, 4); - s = rs.stringExtendFromWithin(s, rs.dropAfter(_197, (range16) => rs.boundsChecked(rs.boundsOf(range16, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop)); + rs.stringExtendFromWithin(s, rs.dropAfter(_197, (range16) => rs.boundsChecked(rs.boundsOf(range16, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop)); const bytes: Uint8Array = Uint8Array.of(1, 2, 3, 4); const _203: rs.ByteSlice = rs.byteSliceFrom(bytes); const bounds = rs.dropAfter(new Spent.Spent(guard(15), 0, 2), (range17) => rs.boundsRange(rs.boundsOf(range17, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), _203.length), rs.drop); rs.byteSliceCopyWithin(_203, bounds[0], bounds[1], 2); - [s, rs.byteSliceFrom(bytes)] as [string, rs.ByteSlice]; - const _217: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s); + [s, rs.byteSliceFrom(bytes)] as [rs.String, rs.ByteSlice]; + const _217: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s.v); const arg2 = rs.byteSliceFrom(bytes); const args16: rs.Fmt[] = [_217, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; Log.note(log, rs.fmtFormat(["edited ", args16[0], " ", args16[1]])); @@ -172,7 +172,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _421: Key.Key | undefined = rs.iterToOption(keys.next()); const part6 = _421 === undefined; const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; - const _415: string = rs.fmtFormat(["done ", args32[0]]); + const _415: rs.String = rs.fmtFormat(["done ", args32[0]]); rs.drop(_421); Log.note(log, _415); rs.iterForEach(rs.hashValues(map3(2), rs.drop, rs.drop), (g8: Guard.Guard): undefined => { @@ -232,7 +232,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.iterForEach(_551, rs.closure((g2: Guard.Guard): undefined => { const part = Guard.id(captured3); const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - const _49: string = rs.fmtFormat(["each ", args50[0]]); + const _49: string = rs.fmtFormat(["each ", args50[0]]).v; Guard.note(g2, _49); g2[Symbol.dispose](); }, (): void => { @@ -252,7 +252,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const h: rs.u32 = _311[1]; const _155: rs.u32 = Guard.id(captured5); const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(h, f), (f: rs.Formatter) => rs.u32Display(_155, f)]; - const _87: string = rs.fmtFormat(["fold ", args52[0], " ", args52[1]]); + const _87: string = rs.fmtFormat(["fold ", args52[0], " ", args52[1]]).v; Guard.note(g4, _87); const _04: rs.i32 = rs.i32Add(n7, 1); g4[Symbol.dispose](); @@ -276,7 +276,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.iterForEach(_581, rs.closure((g5: Guard.Guard): undefined => { const part3 = Guard.id(captured7); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _413: string = rs.fmtFormat([args56[0]]); + const _413: string = rs.fmtFormat([args56[0]]).v; Guard.note(g5, _413); g5[Symbol.dispose](); }, (): void => { @@ -319,7 +319,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured9[Symbol.dispose](); }); rs.iterForEach(rs.iterMap(new rs.Range(17, 19), guard), count); - Log.note(log, "lent"); + Log.note(log, rs.stringFrom("lent")); rs.drop(count); kept[Symbol.dispose](); } else if (_8 === 7) { @@ -344,16 +344,15 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(rs.dropAfter(new Spent.Spent(guard(10), 1, 4), (range4) => rs.vecDrain(v3, rs.boundsOf(range4, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop)); rs.dropVec(v3); } else { - let s2: string = "é"; + const s2: rs.String = rs.stringFrom("é"); const bomb: Bomb.Bomb = new Bomb.Bomb(1, 2); const _636: rs.u8 = rs.u8Rem(rs.u8Div(arg, 10), 3); if (_636 === 0) { - const s3 = rs.place(() => s2, (value) => s2 = value); - rs.drop(rs.stringDrain(s3, rs.dropAfter(bomb, (range3) => rs.boundsChecked(rs.boundsOf(range3, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s3.v)), rs.drop))); + rs.drop(rs.stringDrain(s2, rs.dropAfter(bomb, (range3) => rs.boundsChecked(rs.boundsOf(range3, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), s2.len), rs.drop))); } else if (_636 === 1) { - s2 = rs.stringReplaceRange(s2, rs.dropAfter(bomb, (range2) => rs.boundsChecked(rs.boundsOf(range2, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s2)), rs.drop), "x"); + rs.stringReplaceRange(s2, rs.dropAfter(bomb, (range2) => rs.boundsChecked(rs.boundsOf(range2, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), s2.len), rs.drop), "x"); } else { - s2 = rs.stringExtendFromWithin(s2, rs.dropAfter(bomb, (range) => rs.boundsChecked(rs.boundsOf(range, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s2)), rs.drop)); + rs.stringExtendFromWithin(s2, rs.dropAfter(bomb, (range) => rs.boundsChecked(rs.boundsOf(range, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), s2.len), rs.drop)); } } } diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index d930f6de5..3f9689676 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -487,7 +487,7 @@ export function drained(log: Log.Log, id: rs.u32): void { return _05; }); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - const _63: string = rs.fmtFormat(["set ", args4[0]]); + const _63: rs.String = rs.fmtFormat(["set ", args4[0]]); rs.drop(_70); Log.note(log, _63); const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; @@ -514,7 +514,7 @@ export function drained(log: Log.Log, id: rs.u32): void { return _07; }); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_113, f), (f: rs.Formatter) => rs.u32Display(_116, f)]; - const _109: string = rs.fmtFormat(["queue ", args8[0], " ", args8[1]]); + const _109: rs.String = rs.fmtFormat(["queue ", args8[0], " ", args8[1]]); rs.drop(_119); Log.note(log, _109); const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; @@ -525,7 +525,7 @@ export function drained(log: Log.Log, id: rs.u32): void { const _145: [Key.Key, Guard.Guard] | undefined = rs.iterToOption(entries.next()); const part3 = _145 !== undefined; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - const _139: string = rs.fmtFormat(["entry ", args10[0]]); + const _139: rs.String = rs.fmtFormat(["entry ", args10[0]]); lib_drop$Option_tuple2_drops_Key_model_Guard(_145); Log.note(log, _139); const map2: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; diff --git a/ts/fixtures/task/expected/drops/lists.ts b/ts/fixtures/task/expected/drops/lists.ts index 555c2d3e7..488de2fa2 100644 --- a/ts/fixtures/task/expected/drops/lists.ts +++ b/ts/fixtures/task/expected/drops/lists.ts @@ -6,10 +6,10 @@ import * as Key from "../drops.Key.ts"; import * as Log from "../log.Log.ts"; /** The ids of a list's keys, front to back, apart from `id`. */ -export function ids(id: rs.u32, l: rs.LinkedList): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.listIter(l), (k: Key.Key): string => { +export function ids(id: rs.u32, l: rs.LinkedList): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.listIter(l), (k: Key.Key): rs.String => { const _4: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_4, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_4, f), 0); }), undefined, 12, true).items, ","); } @@ -38,10 +38,10 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _33: Key.Key = key(0); rs.listPushFront(l, _33); rs.drop(rs.listPopBack(l)); - Log.note(log, "popped back"); + Log.note(log, rs.stringFrom("popped back")); rs.drop(rs.listPopFront(l)); const part11 = ids(id, l); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11.v)]; Log.note(log, rs.fmtFormat(["left ", args2[0]])); rs.listDrop(l, rs.drop); } else if (_8 === 1) { @@ -55,7 +55,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.listDrop(l2, rs.drop); l2 = _81; const part10 = ids(id, l2); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part10)]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part10.v)]; Log.note(log, rs.fmtFormat(["replaced ", args6[0]])); rs.listDrop(l2, rs.drop); } else if (_8 === 2) { @@ -79,14 +79,14 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const back: rs.LinkedList = rs.listSplitOff(l3, 3); const none: rs.LinkedList = rs.listSplitOff(l3, 3); const all: rs.LinkedList = rs.listSplitOff(l3, 0); - const _157: string = ids(id, l3); - const _160: string = ids(id, back); - const _163: string = ids(id, none); - const _166: string = ids(id, all); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _157), (f: rs.Formatter) => rs.fmtPad(f, _160), (f: rs.Formatter) => rs.fmtPad(f, _163), (f: rs.Formatter) => rs.fmtPad(f, _166)]; + const _157: rs.String = ids(id, l3); + const _160: rs.String = ids(id, back); + const _163: rs.String = ids(id, none); + const _166: rs.String = ids(id, all); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _157.v), (f: rs.Formatter) => rs.fmtPad(f, _160.v), (f: rs.Formatter) => rs.fmtPad(f, _163.v), (f: rs.Formatter) => rs.fmtPad(f, _166.v)]; Log.note(log, rs.fmtFormat(["split ", args12[0], " ", args12[1], " ", args12[2], " ", args12[3]])); rs.listDrop(all, rs.drop); - Log.note(log, "front dropped"); + Log.note(log, rs.stringFrom("front dropped")); rs.listDrop(back, rs.drop); rs.listDrop(none, rs.drop); rs.listDrop(l3, rs.drop); @@ -94,9 +94,9 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const l4: rs.LinkedList = keys(rs.sliceFrom([1, 2])); const other: rs.LinkedList = keys(rs.sliceFrom([3, 4])); rs.listAppend(l4, other); - const _199: string = ids(id, l4); + const _199: rs.String = ids(id, l4); const _202: rs.usize = other.n; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _199), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _199.v), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; Log.note(log, rs.fmtFormat(["appended ", args14[0], " ", args14[1]])); const _211: Key.Key = key(5); rs.listPushBack(other, _211); @@ -105,9 +105,9 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.listExtend(l4, rs.iterSlice(_219, rs.drop), "fold"); const empty: rs.LinkedList = rs.listNew() as rs.LinkedList; rs.listAppend(empty, l4); - const _236: string = ids(id, empty); + const _236: rs.String = ids(id, empty); const _239: rs.usize = l4.n; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _236), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _236.v), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; Log.note(log, rs.fmtFormat(["moved ", args16[0], " ", args16[1]])); rs.listDrop(empty, rs.drop); rs.listDrop(l4, rs.drop); @@ -116,12 +116,12 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const source: rs.LinkedList = keys(rs.sliceFrom([5, 6])); rs.listCloneFrom(l5, source, Key.clone$Clone, rs.drop); const part5 = ids(id, l5); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5)]; + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5.v)]; Log.note(log, rs.fmtFormat(["cloned ", args18[0]])); const longer: rs.LinkedList = keys(rs.sliceFrom([7, 8, 9])); rs.listCloneFrom(l5, longer, Key.clone$Clone, rs.drop); const part6 = ids(id, l5); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part6)]; + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part6.v)]; Log.note(log, rs.fmtFormat(["cloned ", args20[0]])); rs.listDrop(longer, rs.drop); rs.listDrop(source, rs.drop); @@ -132,8 +132,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { return rs.u32Rem(rs.u32Sub(k2.id, id), 2) === 0; }), "next", 12); const _307: rs.usize = taken.items.length; - const _310: string = ids(id, l6); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310)]; + const _310: rs.String = ids(id, l6); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310.v)]; Log.note(log, rs.fmtFormat(["taken ", args22[0], " left ", args22[1]])); rs.dropVec(taken); const first: Key.Key | undefined = rs.iterToOption(rs.listExtractIf(l6, (k3: Key.Key): boolean => { @@ -142,8 +142,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _330: rs.u32 | undefined = option_map$0bmexgo(first, (k4: Key.Key): rs.u32 => { return rs.u32Sub(k4.id, id); }); - const _336: string = ids(id, l6); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336)]; + const _336: rs.String = ids(id, l6); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336.v)]; Log.note(log, rs.fmtFormat(["first ", args24[0], " left ", args24[1]])); const captured = key(9); const it2: rs.Iter = rs.listExtractIf(l6, rs.closure((k5: Key.Key): boolean => { @@ -154,12 +154,12 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _357: Key.Key | undefined = rs.iterToOption(it2.next()); const part3 = _357 === undefined; const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - const _351: string = rs.fmtFormat(["none ", args26[0]]); + const _351: rs.String = rs.fmtFormat(["none ", args26[0]]); rs.drop(_357); Log.note(log, _351); rs.drop(it2); const part4 = ids(id, l6); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4.v)]; Log.note(log, rs.fmtFormat(["kept ", args28[0]])); rs.drop(first); rs.listDrop(l6, rs.drop); diff --git a/ts/fixtures/task/expected/drops/objects.ts b/ts/fixtures/task/expected/drops/objects.ts index 27fbf5182..6675cf7ce 100644 --- a/ts/fixtures/task/expected/drops/objects.ts +++ b/ts/fixtures/task/expected/drops/objects.ts @@ -131,7 +131,7 @@ export function shared(log: Log.Log, id: rs.u32): void { const _122: rs.Arc | undefined = rs.weakUpgrade(weak); const part4 = _122 === undefined; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; - const _116: string = rs.fmtFormat(["gone ", args10[0]]); + const _116: rs.String = rs.fmtFormat(["gone ", args10[0]]); rs.drop(_122); Log.note(log, _116); const _132: rs.Arc> = new rs.Arc(new sharedFuture$closure1(guard(6))); @@ -229,7 +229,7 @@ export function anys(log: Log.Log, id: rs.u32): void { const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u32, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f))]; Log.note(log, rs.fmtFormat(["typed ", args10[0]])); lib_drop$Option_sync_Arc_tuple2_model_Guard_model_Guard(typed); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); b[Symbol.dispose](); const _149: Any.Any = slot; const part5 = (_149 instanceof of$drops_Held ? _149.v : _149 instanceof ofPlace$drops_Held ? _149.v.v : undefined) !== undefined; @@ -380,7 +380,7 @@ export function fns(log: Log.Log, id: rs.u32): void { const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part12, f)]; Log.note(log, rs.fmtFormat(["up ", args24[0]])); again[Symbol.dispose](); - Log.note(log, "gone"); + Log.note(log, rs.stringFrom("gone")); const _257: [Guard.Guard, Guard.Guard] = [guard(13), guard(14)]; const n: Guard.Guard = _257[0]; const o: Guard.Guard = _257[1]; @@ -400,7 +400,7 @@ export function fns(log: Log.Log, id: rs.u32): void { })); const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; Log.note(log, rs.fmtFormat(["run ", args28[0]])); - Log.note(log, "ran"); + Log.note(log, rs.stringFrom("ran")); const _296: [Guard.Guard, Guard.Guard] = [guard(15), guard(16)]; const p: Guard.Guard = _296[0]; const captured15 = _296[1]; diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index 8a678c2d0..f82c5040e 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -20,7 +20,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _17: rs.Result = rs.onceSet(cell, _19); const part13 = _17.ok; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part13, f)]; - const _11: string = rs.fmtFormat(["set ", args2[0]]); + const _11: rs.String = rs.fmtFormat(["set ", args2[0]]); lib_drop$Result_unit_model_Guard(_17); Log.note(log, _11); const _28: Guard.Guard = guard(2); @@ -113,7 +113,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _198: Guard.Guard | undefined = rs.onceTake(cell3); const part9 = _198 === undefined; const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part9, f)]; - const _192: string = rs.fmtFormat(["empty ", args18[0]]); + const _192: rs.String = rs.fmtFormat(["empty ", args18[0]]); rs.drop(_198); Log.note(log, _192); const _206: Guard.Guard = guard(22); @@ -170,14 +170,14 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _315: rs.Result = rs.onceSet(cell5, undefined as Guard.Guard | undefined, rs.None); const part = _315.ok; const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - const _309: string = rs.fmtFormat(["none ", args26[0]]); + const _309: rs.String = rs.fmtFormat(["none ", args26[0]]); lib_drop$Result_unit_Option_model_Guard(_315); Log.note(log, _309); const _332: Guard.Guard | undefined = guard(71); const _330: rs.Result = rs.onceSet(cell5, _332, rs.None); const part2 = !_330.ok; const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; - const _324: string = rs.fmtFormat(["full ", args28[0]]); + const _324: rs.String = rs.fmtFormat(["full ", args28[0]]); lib_drop$Result_unit_Option_model_Guard(_330); Log.note(log, _324); const unit: rs.OnceLock = new rs.OnceLock(rs.None); diff --git a/ts/fixtures/task/expected/drops/orders.Ranked.ts b/ts/fixtures/task/expected/drops/orders.Ranked.ts index 040b52238..903b71dc7 100644 --- a/ts/fixtures/task/expected/drops/orders.Ranked.ts +++ b/ts/fixtures/task/expected/drops/orders.Ranked.ts @@ -27,7 +27,7 @@ export class Ranked { export function drop$ops_Drop(self: Ranked): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["k", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["k", args2[0], " drop"]); Log.note(self.log, _4); } @@ -36,7 +36,7 @@ export function eq$cmp_PartialEq(self: Ranked, other: Ranked): boolean { const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["eq ", args2[0], " ", args2[1]]); + const _5: rs.String = rs.fmtFormat(["eq ", args2[0], " ", args2[1]]); Log.note(self.log, _5); return rs.u8Rem(self.rank, 3) === rs.u8Rem(other.rank, 3); } @@ -46,7 +46,7 @@ export function partialCmp$cmp_PartialOrd(self: Ranked, other: Ranked): rs.Order const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["partial_cmp ", args2[0], " ", args2[1]]); + const _5: rs.String = rs.fmtFormat(["partial_cmp ", args2[0], " ", args2[1]]); Log.note(self.log, _5); return rs.cmp(rs.u8Div(self.rank, 2), rs.u8Div(other.rank, 2)); } @@ -56,7 +56,7 @@ export function cmp$cmp_Ord(self: Ranked, other: Ranked): rs.Ordering { const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["cmp ", args2[0], " ", args2[1]]); + const _5: rs.String = rs.fmtFormat(["cmp ", args2[0], " ", args2[1]]); Log.note(self.log, _5); if (self.rank !== 99) { if (other.rank !== 99) { diff --git a/ts/fixtures/task/expected/drops/orders.ts b/ts/fixtures/task/expected/drops/orders.ts index 8e8a5ee99..3d3fe4f78 100644 --- a/ts/fixtures/task/expected/drops/orders.ts +++ b/ts/fixtures/task/expected/drops/orders.ts @@ -26,14 +26,14 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { return entry(_23[0], _23[1]); }), undefined, 20, true); }; - const setIds: (a0: rs.BTreeSet) => string = (s: rs.BTreeSet): string => { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeKeys(s), (k: Ranked.Ranked): string => { + const setIds: (a0: rs.BTreeSet) => rs.String = (s: rs.BTreeSet): rs.String => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeKeys(s), (k: Ranked.Ranked): rs.String => { const _48: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_48, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_48, f), 0); }), undefined, 12, true).items, ","); }; - const mapIds: (a0: rs.BTreeMap) => string = (m: rs.BTreeMap): string => { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): string => { + const mapIds: (a0: rs.BTreeMap) => rs.String = (m: rs.BTreeMap): rs.String => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): rs.String => { const _97: rs.u32 = rs.u32Sub(_26[0].id, id); const _144: rs.u32 = rs.u32Sub(Guard.id(_26[1]), id); const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_97, f), (f: rs.Formatter) => rs.u32Display(_144, f)]; @@ -50,7 +50,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _24: rs.Iter = rs.vecIntoIter(keys(part29), rs.drop); const set: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_24, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part31 = setIds(set); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part31)]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part31.v)]; Log.note(log, rs.fmtFormat(["set ", args2[0]])); rs.btreeDrop(set, rs.drop); const _46: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of())), rs.drop); @@ -58,8 +58,8 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _53: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of(7))), rs.drop); const one: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_53, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const _65: rs.usize = rs.btreeLen(none); - const _68: string = setIds(one); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68)]; + const _68: rs.String = setIds(one); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68.v)]; Log.note(log, rs.fmtFormat(["small ", args4[0], " ", args4[1]])); rs.btreeDrop(one, rs.drop); rs.btreeDrop(none, rs.drop); @@ -68,19 +68,19 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _78: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part26), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const map: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_78, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part28 = mapIds(map); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part28)]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part28.v)]; Log.note(log, rs.fmtFormat(["map ", args6[0]])); rs.btreeDrop(map, rs.drop, rs.drop); } else if (_21 === 2) { const _99: Ranked.Ranked[] = [key(1, 4), key(2, 2), key(3, 4), key(4, 1), key(5, 2)]; const set2: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice(_99, rs.drop), "fold", 12, true).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part23 = setIds(set2); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23)]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23.v)]; Log.note(log, rs.fmtFormat(["set ", args8[0]])); const _130: [Ranked.Ranked, Guard.Guard][] = [entry(1, 4), entry(2, 2), entry(3, 4), entry(4, 1), entry(5, 2)]; const map2: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(rs.iterSlice(_130, lib_drop$tuple2_drops_orders_Ranked_model_Guard), "fold", 20, true).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part25 = mapIds(map2); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25)]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25.v)]; Log.note(log, rs.fmtFormat(["map ", args10[0]])); rs.btreeDrop(map2, rs.drop, rs.drop); rs.btreeDrop(set2, rs.drop); @@ -89,7 +89,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _161: rs.Iter = rs.vecIntoIter(keys(part16), rs.drop); const set3: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_161, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part18 = setIds(set3); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18)]; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18.v)]; Log.note(log, rs.fmtFormat(["set ", args12[0]])); rs.iterForEach(rs.btreeKeys(set3, rs.drop), (a0: Ranked.Ranked): undefined => { a0[Symbol.dispose](); @@ -98,7 +98,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _184: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part19), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const map3: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_184, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part21 = mapIds(map3); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21)]; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21.v)]; Log.note(log, rs.fmtFormat(["map ", args14[0]])); rs.iterForEach(rs.btreeIter(map3, rs.drop, rs.drop), (a02: [Ranked.Ranked, Guard.Guard]): undefined => { lib_drop$tuple2_drops_orders_Ranked_model_Guard(a02); @@ -110,14 +110,14 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { return [new rs.Cell({ _0: r }), Guard.new(rs.u32Add(id, n9), Log.clone$Clone(log))] as [rs.Cell, Guard.Guard]; }); const map4: rs.BTreeMap, Guard.Guard> = rs.btreeCollect(rs.btreeNew(rs.cellBy(Rank.cmp$cmp_Ord)) as rs.BTreeMap, Guard.Guard>, rs.iterToVec(_207, undefined, 12, true).items, 12, false, rs.cellBy(Rank.eq$cmp_PartialEq), undefined, rs.drop); - const part15 = rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(map4), (_219: [rs.Cell, Guard.Guard]): string => { + const part15 = rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(map4), (_219: [rs.Cell, Guard.Guard]): rs.String => { const _912: Rank.Rank = _219[0].v; const _1111: rs.u32 = rs.u32Sub(Guard.id(_219[1]), id); const arg2 = _912._0; const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; return rs.fmtFormat([args36[0], ":", args36[1]]); }), undefined, 12, true).items, ","); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15)]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15.v)]; Log.note(log, rs.fmtFormat(["cells ", args16[0]])); rs.btreeDrop(map4, undefined, rs.drop); } else if (_21 === 5) { diff --git a/ts/fixtures/task/expected/drops/released.ts b/ts/fixtures/task/expected/drops/released.ts index 5d66cda7e..89a4abd82 100644 --- a/ts/fixtures/task/expected/drops/released.ts +++ b/ts/fixtures/task/expected/drops/released.ts @@ -36,7 +36,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { _252 = true; const part27 = Guard.id(captured26); const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part27, f)]; - const _626: string = rs.fmtFormat(["reduce ", args64[0]]); + const _626: string = rs.fmtFormat(["reduce ", args64[0]]).v; Guard.note(y4, _626); if (!(Guard.id(x4) < Guard.id(y4))) { _262 = false; @@ -228,7 +228,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part16 = rs.iterIsSortedBy(rs.iterMap(_235, rs.closure((g6: Guard.Guard): rs.u32 => { const part15 = Guard.id(captured15); const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part15, f)]; - const _517: string = rs.fmtFormat(["key ", args62[0]]); + const _517: string = rs.fmtFormat(["key ", args62[0]]).v; Guard.note(g6, _517); const _013: rs.u32 = Guard.id(g6); g6[Symbol.dispose](); @@ -327,7 +327,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.entryAndModify(_404, rs.closure((g4: Guard.Guard): undefined => { const part12 = Guard.id(captured13); const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part12, f)]; - Guard.note(g4, rs.fmtFormat(["modified ", args58[0]])); + Guard.note(g4, rs.fmtFormat(["modified ", args58[0]]).v); captured13[Symbol.dispose](); }, (): void => { captured13[Symbol.dispose](); @@ -337,7 +337,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part14 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_409, rs.closure((g5: Guard.Guard): undefined => { const part13 = Guard.id(captured14); const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; - Guard.note(g5, rs.fmtFormat([args60[0]])); + Guard.note(g5, rs.fmtFormat([args60[0]]).v); captured14[Symbol.dispose](); }, (): void => { captured14[Symbol.dispose](); @@ -405,7 +405,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.entryAndModify(_538, rs.closure((g2: Guard.Guard): undefined => { const part5 = Guard.id(captured7); const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - Guard.note(g2, rs.fmtFormat(["modified ", args54[0]])); + Guard.note(g2, rs.fmtFormat(["modified ", args54[0]]).v); captured7[Symbol.dispose](); }, (): void => { captured7[Symbol.dispose](); @@ -415,7 +415,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part7 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_543, rs.closure((g3: Guard.Guard): undefined => { const part6 = Guard.id(captured8); const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Guard.note(g3, rs.fmtFormat([args56[0]])); + Guard.note(g3, rs.fmtFormat([args56[0]]).v); captured8[Symbol.dispose](); }, (): void => { captured8[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/searched.ts b/ts/fixtures/task/expected/drops/searched.ts index 515eb47cc..010cfa361 100644 --- a/ts/fixtures/task/expected/drops/searched.ts +++ b/ts/fixtures/task/expected/drops/searched.ts @@ -224,7 +224,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured73[Symbol.dispose](); }); const _173: string = "+"; - const _171: string = rs.dropAfter(_172, () => rs.strReplace(text, _172, _173)); + const _171: rs.String = rs.dropAfter(_172, () => rs.strReplace(text, _172, _173, false)); const captured74 = (c71: rs.char): boolean => { if (!(c71 === 44)) { return c71 === 59; @@ -241,8 +241,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured75[Symbol.dispose](); }); const _176: string = "+"; - const part19 = [_171, rs.dropAfter(_175, () => rs.strReplace(text, _175, _176, 2))] as [string, string]; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0], f), (f: rs.Formatter) => rs.fmtStr(part19[1], f)], f)]; + const part19 = [_171, rs.dropAfter(_175, () => rs.strReplacen(text, _175, _176, 2))] as [rs.String, rs.String]; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0].v, f), (f: rs.Formatter) => rs.fmtStr(part19[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["replace ", args14[0]])); } else if (_8 === 1) { const a2: Guard.Guard = guard(1); @@ -468,7 +468,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["indices ", args30[0]])); } else if (_8 === 2) { const a3: Guard.Guard = guard(1); - let s: string = text; + const s: rs.String = rs.stringFrom(text); const captured27 = a3; const captured28 = (c29: rs.char): boolean => { if (!(c29 === 44)) { @@ -478,14 +478,14 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }; const _378: (a0: rs.char) => boolean = rs.closure((c30: rs.char): boolean => { const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(c30, f)]; - Guard.note(captured27, rs.fmtFormat(["retain ", args138[0]])); + Guard.note(captured27, rs.fmtFormat(["retain ", args138[0]]).v); return !captured28(c30); }, (): void => { captured27[Symbol.dispose](); }); - s = rs.stringRetain(s, _378); + rs.stringRetain(s, _378); rs.drop(_378); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v)]; Log.note(log, rs.fmtFormat(["retained ", args32[0]])); const b3: Guard.Guard = guard(2); let captured29: rs.i32 = 0; @@ -499,24 +499,24 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured30[Symbol.dispose](); }); - s = rs.stringRetain(s, everyOther); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; + rs.stringRetain(s, everyOther); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v)]; Log.note(log, rs.fmtFormat(["every other ", args34[0]])); - s = rs.stringRetain(s, everyOther); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; + rs.stringRetain(s, everyOther); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v)]; Log.note(log, rs.fmtFormat(["every other ", args36[0]])); rs.drop(everyOther); const c3: Guard.Guard = guard(3); - let empty: string = ""; + const empty: rs.String = rs.stringNew(); const captured31 = c3; const _427: (a0: rs.char) => boolean = rs.closure((_24: rs.char): boolean => { return Guard.id(captured31) > 0; }, (): void => { captured31[Symbol.dispose](); }); - empty = rs.stringRetain(empty, _427); + rs.stringRetain(empty, _427); rs.drop(_427); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(empty, f)]; + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(empty.v, f)]; Log.note(log, rs.fmtFormat(["empty ", args38[0]])); } else if (_8 === 3) { const a4: Guard.Guard = guard(1); @@ -544,8 +544,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["ends ", args42[0], " ", args42[1]])); const once2: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f3), rs.strRsplitOnce(text, f3)]; const trimmed2: [string, string, string] = [rs.strTrimMatches(",a,", f3), rs.strTrimStartMatches(",a,", f3), rs.strTrimEndMatches(",a,", f3)]; - const replaced2: [string, string] = [rs.strReplace(text, f3, "+"), rs.strReplace(text, f3, "+", 2)]; - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0], f), (f: rs.Formatter) => rs.fmtStr(replaced2[1], f)], f)]; + const replaced2: [rs.String, rs.String] = [rs.strReplace(text, f3, "+", false), rs.strReplacen(text, f3, "+", 2)]; + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced2[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["once ", args44[0], " ", args44[1], " ", args44[2]])); const split2: rs.Iter = rs.strSplit(text, rs.lent(f3)); const _526: string | undefined = rs.iterToOption(split2.next()); @@ -581,7 +581,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(spaced.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_659, f)]; Log.note(log, rs.fmtFormat(["spaced ", args58[0], " ", args58[1]])); rs.drop(f3); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } else if (_8 === 4) { const a5: Guard.Guard = guard(1); let captured22: rs.i32 = 0; @@ -614,10 +614,10 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["ends ", args62[0], " ", args62[1], " ", args62[2]])); const once3: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f4), rs.strRsplitOnce(text, f4)]; const trimmed3: [string, string] = [rs.strTrimMatches(",,a,,", f4), rs.strTrimStartMatches(",,a", f4)]; - const replaced3: [string, string] = [rs.strReplace(text, f4, "+"), rs.strReplace(text, f4, "+", 2)]; + const replaced3: [rs.String, rs.String] = [rs.strReplace(text, f4, "+", false), rs.strReplacen(text, f4, "+", 2)]; const end: string = rs.strTrimEndMatches(",a,,", f4); const _755: boolean = f4(120); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0], f), (f: rs.Formatter) => rs.fmtStr(replaced3[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced3[1].v, f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; Log.note(log, rs.fmtFormat(["once ", args64[0], " ", args64[1], " ", args64[2], " ", args64[3], " ", args64[4]])); const split3: rs.Iter = rs.strSplit(text, rs.lent(f4)); const _778: string | undefined = rs.iterToOption(split3.next()); @@ -650,7 +650,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(parts2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_905, f)]; Log.note(log, rs.fmtFormat(["lent ", args76[0], " ", args76[1]])); rs.drop(f4); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } else if (_8 === 5) { if (!(id < 4294967295)) { p = (a0: rs.char): boolean => { @@ -666,8 +666,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["contains ", args78[0], " ", args78[1], " ", args78[2]])); const once4: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, p), rs.strRsplitOnce(text, p)]; const trimmed4: [string, string, string] = [rs.strTrimMatches(",a,", p), rs.strTrimStartMatches(",a,", p), rs.strTrimEndMatches(",a,", p)]; - const replaced4: [string, string] = [rs.strReplace(text, p, "+"), rs.strReplace(text, p, "+", 2)]; - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0], f), (f: rs.Formatter) => rs.fmtStr(replaced4[1], f)], f)]; + const replaced4: [rs.String, rs.String] = [rs.strReplace(text, p, "+", false), rs.strReplacen(text, p, "+", 2)]; + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced4[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["once ", args80[0], " ", args80[1], " ", args80[2]])); const split4: rs.Iter = rs.strSplit(text, p); const _998: string | undefined = rs.iterToOption(split4.next()); @@ -735,8 +735,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _1178: string = "+"; const once5: [[string, string] | undefined, [string, string] | undefined] = [rs.dropAfter(_1145, () => rs.strSplitOnce(text, _1145)), rs.dropAfter(_1149, () => rs.strRsplitOnce(text, _1149))]; const trimmed5: [string, string, string] = [rs.dropAfter(_1155, () => rs.strTrimMatches(_1154, _1155)), rs.dropAfter(_1160, () => rs.strTrimStartMatches(_1159, _1160)), rs.dropAfter(_1165, () => rs.strTrimEndMatches(_1164, _1165))]; - const replaced5: [string, string] = [rs.dropAfter(_1170, () => rs.strReplace(text, _1170, _1173)), rs.dropAfter(_1175, () => rs.strReplace(text, _1175, _1178, 2))]; - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0], f), (f: rs.Formatter) => rs.fmtStr(replaced5[1], f)], f)]; + const replaced5: [rs.String, rs.String] = [rs.dropAfter(_1170, () => rs.strReplace(text, _1170, _1173, false)), rs.dropAfter(_1175, () => rs.strReplacen(text, _1175, _1178, 2))]; + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced5[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["once ", args94[0], " ", args94[1], " ", args94[2]])); const split5: rs.Iter = rs.strSplit(text, boxed(15)); const _1203: string | undefined = rs.iterToOption(split5.next()); @@ -817,10 +817,10 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["ends ", args110[0], " ", args110[1], " ", args110[2]])); const once6: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, rs.place(() => b4, (value11) => b4 = value11).v), rs.strRsplitOnce(text, rs.place(() => b4, (value12) => b4 = value12).v)]; const trimmed6: [string, string] = [rs.strTrimMatches(",,a,,", rs.place(() => b4, (value13) => b4 = value13).v), rs.strTrimStartMatches(",,a", rs.place(() => b4, (value14) => b4 = value14).v)]; - const replaced6: [string, string] = [rs.strReplace(text, rs.place(() => b4, (value15) => b4 = value15).v, "+"), rs.strReplace(text, rs.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; + const replaced6: [rs.String, rs.String] = [rs.strReplace(text, rs.place(() => b4, (value15) => b4 = value15).v, "+", false), rs.strReplacen(text, rs.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; const end2: string = rs.strTrimEndMatches(",a,,", rs.place(() => b4, (value17) => b4 = value17).v); const _1430: boolean = b4(120); - const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0], f), (f: rs.Formatter) => rs.fmtStr(replaced6[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; + const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced6[1].v, f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; Log.note(log, rs.fmtFormat(["once ", args112[0], " ", args112[1], " ", args112[2], " ", args112[3], " ", args112[4]])); const split7: rs.Iter = rs.strSplit(text, rs.lent(rs.place(() => b4, (value18) => b4 = value18).v)); const _1453: string | undefined = rs.iterToOption(split7.next()); @@ -848,7 +848,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last7, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices6[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices6[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_1559, f)]; Log.note(log, rs.fmtFormat(["indices ", args122[0], " ", args122[1], " ", args122[2]])); rs.drop(b4); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } else { const _1578: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(1), guard(2), guard(3)]; const a7: Guard.Guard = _1578[0]; @@ -896,8 +896,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured5[Symbol.dispose](); }); const _1597: string = "+"; - const replaced7: string = rs.dropAfter(_1595, () => rs.strReplace(text, _1595, _1597, 2)); - const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7)]; + const replaced7: rs.String = rs.dropAfter(_1595, () => rs.strReplacen(text, _1595, _1597, 2)); + const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7.v)]; Log.note(log, rs.fmtFormat(["contains ", args124[0], " ", args124[1], " ", args124[2]])); const d3: Guard.Guard = guard(4); const captured6 = (c10: rs.char): boolean => { @@ -1010,7 +1010,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1736, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(parts4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1739, f, rs.usizeDebug)]; Log.note(log, rs.fmtFormat(["shared ", args136[0], " ", args136[1], " ", args136[2]])); rs.drop(shared); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } } diff --git a/ts/fixtures/task/expected/futures.ts b/ts/fixtures/task/expected/futures.ts index b81588340..f80b43ed2 100644 --- a/ts/fixtures/task/expected/futures.ts +++ b/ts/fixtures/task/expected/futures.ts @@ -106,7 +106,7 @@ export class helpersFuture { const _422: boolean = isReady$1wybfmi(polled); const _45: boolean = isPending$0mrvg1b(polled); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_392, f), (f: rs.Formatter) => rs.fmtBool(_422, f), (f: rs.Formatter) => rs.fmtBool(_45, f)]; - Guard.note(captured4, rs.fmtFormat(["pending ", args2[0], " ready ", args2[1], " pending ", args2[2]])); + Guard.note(captured4, rs.fmtFormat(["pending ", args2[0], " ready ", args2[1], " pending ", args2[2]]).v); if (polled !== rs.Pending) { if (polled !== undefined) { if (rs.u64Rem(polled, 2) === 0) { @@ -273,7 +273,7 @@ export class wakersFuture { put$unit(rs.DANGLING_UNIT, undefined); const arg = this.#checks; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(arg, f, rs.fmtBool)]; - const _88: string = rs.fmtFormat(["wakers ", args2[0]]); + const _88: string = rs.fmtFormat(["wakers ", args2[0]]).v; Guard.note(this.#guard, _88); lib_drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker([this.#a, this.#b, this.#other, this.#plain] as [rs.Waker, rs.Waker, rs.Waker, rs.Waker]); this.#last = undefined as [rs.Place, rs.WakerVTable] | undefined; @@ -306,7 +306,7 @@ export class wakersFuture { const _183: boolean = rs.willWake(lent, waker); const _222: boolean = polling(waker); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(same, f), (f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(inner[0], f), (f: rs.Formatter) => rs.fmtBool(inner[1], f)], f), (f: rs.Formatter) => rs.fmtBool(_222, f)]; - const _85: string = rs.fmtFormat(["same ", args4[0], " clone ", args4[1], " lent ", args4[2], " inner ", args4[3], " after ", args4[4]]); + const _85: string = rs.fmtFormat(["same ", args4[0], " clone ", args4[1], " lent ", args4[2], " inner ", args4[3], " after ", args4[4]]).v; Guard.note(this.#guard, _85); const _04: rs.Poll = this.#next.poll(cx); clone[Symbol.dispose](); @@ -521,7 +521,7 @@ export class boxedFuture { this.#first = option_unwrapOr$15hbiwd(result, 0); const arg = this.#first; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; - const _17: string = rs.fmtFormat(["first ", args2[0]]); + const _17: string = rs.fmtFormat(["first ", args2[0]]).v; Guard.note(this.#guard, _17); const _28: [rs.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; this.#id = _28[0]; @@ -581,7 +581,7 @@ export class boxedFuture { this.#saved = rs.u64Add(this.#saved, _81); const arg2 = this.#saved; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg2, f)]; - const _92: string = rs.fmtFormat(["lent ", args4[0]]); + const _92: string = rs.fmtFormat(["lent ", args4[0]]).v; Guard.note(this.#guard, _92); this.#saved$5 = false; this.#lend[Symbol.dispose](); @@ -642,7 +642,7 @@ export class boxedFuture { this.#moved = rs.u64Add(this.#moved, result8); const arg3 = this.#moved; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg3, f)]; - const _183: string = rs.fmtFormat(["moved ", args6[0]]); + const _183: string = rs.fmtFormat(["moved ", args6[0]]).v; Guard.note(this.#guard, _183); const _197: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 700), Log.clone$Clone(this.#log))]; const block: Guard.Guard = _197[0]; @@ -709,7 +709,7 @@ export class boxedFuture { const total: rs.u64 = _248; this.#awaitee$6[Symbol.dispose](); const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(total, f)]; - const _258: string = rs.fmtFormat(["boxed ", args8[0]]); + const _258: string = rs.fmtFormat(["boxed ", args8[0]]).v; Guard.note(this.#guard, _258); this.#pinned[Symbol.dispose](); this.#saved$2 = false; @@ -761,7 +761,7 @@ export class boxedFuture$closure2 { rs.drop(this.#awaitee); const value: rs.u64 = option_unwrapOr$15hbiwd(result, 0); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - const _17: string = rs.fmtFormat(["block ", args2[0]]); + const _17: string = rs.fmtFormat(["block ", args2[0]]).v; Guard.note(this.#block, _17); const _30: rs.u64 = rs.u64Add(value, 1); this.#rx[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 0e283b983..3cd30872f 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -8,9 +8,9 @@ export function clone$Clone(self: Log): Log { /** A shared, append-only list of events. */ export class Log { - _0: rs.Arc>>; + _0: rs.Arc>>; - constructor(_0: rs.Arc>>) { + constructor(_0: rs.Arc>>) { this._0 = _0; } @@ -24,23 +24,23 @@ function new_(): Log { } /** Append one event. */ -export function note(self: Log, event: string): void { - const _6: rs.Mutex> = rs.mutexLock(self._0.value); +export function note(self: Log, event: rs.String): void { + const _6: rs.Mutex> = rs.mutexLock(self._0.value); _6.value.items.push(event); rs.mutexUnlock(_6); } /** Every event so far, one per line. */ export function text(self: Log): rs.ByteVec { - const events: rs.Mutex> = rs.mutexLock(self._0.value); + const events: rs.Mutex> = rs.mutexLock(self._0.value); const out: rs.ByteVec = new rs.ByteVec(); - const iter: rs.Iter = rs.iterSlice(events.value.items); + const iter: rs.Iter = rs.iterSlice(events.value.items); while (true) { - const _13: string | rs.Done = iter.next(); + const _13: rs.String | rs.Done = iter.next(); if (_13 === rs.DONE) { break; } - const _19: rs.ByteSlice = rs.stringAsBytes(_13); + const _19: rs.ByteSlice = rs.stringAsBytes(_13.v); rs.byteVecExtendFromSlice(out, _19); rs.byteVecPush(out, 10); } diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index 0929ac995..c0dca21d2 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -46,7 +46,7 @@ export function log(self: Guard): Log.Log { export function note(self: Guard, event: string): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, event)]; - const _5: string = rs.fmtFormat(["g", args2[0], " ", args2[1]]); + const _5: rs.String = rs.fmtFormat(["g", args2[0], " ", args2[1]]); Log.note(self.log, _5); } @@ -66,7 +66,7 @@ export function unbox(self: Guard, event: string): rs.u32 { export function drop$ops_Drop(self: Guard): void { const arg = self.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["g", args2[0], " drop"]); + const _4: rs.String = rs.fmtFormat(["g", args2[0], " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index b237513e6..5f56a1fcc 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -87,7 +87,7 @@ export class sumFuture { } else { const arg = this.#guard.id; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.u64Display(value, f)]; - const _32: string = rs.fmtFormat(["g", args4[0], " got ", args4[1]]); + const _32: rs.String = rs.fmtFormat(["g", args4[0], " got ", args4[1]]); Log.note(this.#inner.log, _32); this.#total = rs.u64Add(this.#total, value); bb0 = 4; @@ -225,7 +225,7 @@ export class watchFuture { rs.drop(this.#pinned); const arg = this.#first; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(arg, f, rs.u64Debug)]; - const _22: string = rs.fmtFormat(["first ", args2[0]]); + const _22: string = rs.fmtFormat(["first ", args2[0]]).v; Guard.note(this.#guard, _22); this.#saved$2 = false; this.#pending = Pending.new$model_Watch(new Watch.Watch(this.#rx, 1)); @@ -247,7 +247,7 @@ export class watchFuture { if (result2 !== undefined) { value = result2; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - const _50: string = rs.fmtFormat(["watched ", args4[0]]); + const _50: string = rs.fmtFormat(["watched ", args4[0]]).v; Guard.note(this.#guard, _50); this.#total = rs.u64Add(this.#total, value); const _62: Watch.Watch = Pending.derefMut$ops_DerefMut_model_Watch(this.#pending); @@ -281,7 +281,7 @@ export class watchFuture { rs.drop(this.#awaitee$4); const arg2 = this.#watch.index; const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg2, f), (f: rs.Formatter) => rs.fmtResult(sent, f, rs.usizeDebug, (value: Closed.Closed, f: rs.Formatter) => Closed.fmt$fmt_Debug(value, f))]; - const _92: string = rs.fmtFormat(["watched to ", args6[0], " of ", args6[1]]); + const _92: string = rs.fmtFormat(["watched to ", args6[0], " of ", args6[1]]).v; Guard.note(this.#guard, _92); const _109: rs.u64 = this.#total; this.#watch[Symbol.dispose](); @@ -397,7 +397,7 @@ export class frontFuture { case 23: const arg = this.#listing; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(arg, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]; - const _32: string = rs.fmtFormat(["listing ", args2[0]]); + const _32: string = rs.fmtFormat(["listing ", args2[0]]).v; Guard.note(this.#guard, _32); this.#awaitee$2 = wait$model_front_closure0_closure0_usize((waiter: Waiter.Waiter): rs.Poll => { while (true) { @@ -434,7 +434,7 @@ export class frontFuture { const _69: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(closed, f); const arg2 = this.#inFlight; const args4: rs.Fmt[] = [_69, (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u64Debug)]; - const _60: string = rs.fmtFormat(["closed with ", args4[0], " in flight ", args4[1]]); + const _60: string = rs.fmtFormat(["closed with ", args4[0], " in flight ", args4[1]]).v; Guard.note(this.#guard, _60); const _79: rs.u64 = rs.iterSum(rs.iterSlice(this.#inFlight.items), rs.u64Add, 0); this.#guard[Symbol.dispose](); @@ -693,7 +693,7 @@ export class blocksFuture { this.#slots[result2] = this.#saved; const arg = this.#waited; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; - const _76: string = rs.fmtFormat(["slot after ", args2[0]]); + const _76: string = rs.fmtFormat(["slot after ", args2[0]]).v; Guard.note(this.#slots[0], _76); this.#tally = { n: this.#guard.id }; const seen: rs.Future = new blocksFuture$closure1(copy$model_Tally(this.#tally)); @@ -712,7 +712,7 @@ export class blocksFuture { rs.drop(this.#awaitee$3); const arg2 = this.#saved$2; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_98, f)]; - const _91: string = rs.fmtFormat(["tally ", args4[0], " then ", args4[1]]); + const _91: string = rs.fmtFormat(["tally ", args4[0], " then ", args4[1]]).v; Guard.note(this.#saved, _91); this.#mark = { n: 1 }; this.#awaitee$3 = new blocksFuture$closure2(this.#mark); @@ -729,7 +729,7 @@ export class blocksFuture { const _135: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg3, f); const arg4 = this.#mark.n; const args6: rs.Fmt[] = [_135, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - const _126: string = rs.fmtFormat(["mark ", args6[0], " ", args6[1]]); + const _126: string = rs.fmtFormat(["mark ", args6[0], " ", args6[1]]).v; Guard.note(this.#guard, _126); this.#count = this.#guard.id; this.#awaitee$3 = new blocksFuture$closure3(rs.place(() => this.#count, (value) => this.#count = value)); @@ -746,7 +746,7 @@ export class blocksFuture { const _161: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg5, f); const arg6 = this.#count; const args8: rs.Fmt[] = [_161, (f: rs.Formatter) => rs.u32Display(arg6, f)]; - const _152: string = rs.fmtFormat(["count ", args8[0], " ", args8[1]]); + const _152: string = rs.fmtFormat(["count ", args8[0], " ", args8[1]]).v; Guard.note(this.#guard, _152); this.#nested = new Inner.Inner(new Outer.Outer(undefined, Guard.new(rs.u32Add(this.#guard.id, 800), Log.clone$Clone(this.#guard.log)))); const third: Guard.Guard = Guard.new(rs.u32Add(this.#guard.id, 400), Log.clone$Clone(this.#guard.log)); @@ -768,7 +768,7 @@ export class blocksFuture { rs.drop(this.#awaitee$3); const arg7 = this.#looped; const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg7, f)]; - const _197: string = rs.fmtFormat(["looped ", args10[0]]); + const _197: string = rs.fmtFormat(["looped ", args10[0]]).v; Guard.note(this.#saved, _197); if (this.#moves) { this.#saved$3 = false; @@ -1140,7 +1140,7 @@ export function temporaries(log: Log.Log, id: rs.u32): void { const _11: Guard.Guard = guard(1000); const arg = _11.id; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _7: string = rs.fmtFormat(["temporary ", args2[0]]); + const _7: rs.String = rs.fmtFormat(["temporary ", args2[0]]); _11[Symbol.dispose](); Log.note(log, _7); const _19: Guard.Guard | undefined = guard(1010); @@ -1160,7 +1160,7 @@ export function temporaries(log: Log.Log, id: rs.u32): void { const _39: Guard.Guard = guard(1030); const arg2 = _39.id; const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.i32Display(matched, f)]; - const _35: string = rs.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); + const _35: rs.String = rs.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); _39[Symbol.dispose](); Log.note(log, _35); const part = first([guard(1040), guard(1050)] as [Guard.Guard, Guard.Guard]); diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 9e0238929..3005a91dd 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -16,7 +16,7 @@ import { drop as dispose, dropAll, partPlace, type Pending } from "./rs/task.ts" import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./rs/alloc.ts"; import { AtIndex } from "./rs/collections.ts"; import { escapeDebug } from "./rs/char.ts"; -import { strFromUtf8Unchecked } from "./rs/str.ts"; +import { byteSliceUtf8Chunks, String as RsString, strFromUtf8Unchecked, stringClone, stringCloneFrom, stringFrom, stringLen, stringNew, stringOf, stringPush, stringPushStr, stringWithCapacity } from "./rs/str.ts"; export * from "./rs/alloc.ts"; export * from "./rs/ascii.ts"; export * from "./rs/bytes.ts"; @@ -68,7 +68,7 @@ export function resumeUnwind(): never { * to format, as std's does. A hook formats it as it runs, as std formats it once panicking. */ export function panicFmt(message: Arguments, at?: Location | string): never { - throw new Panic(Panic.hooked?.(message, at) ?? fmtWriteString("", message).s); + throw new Panic(Panic.hooked?.(message, at) ?? fmtFormatText(message)); } /** A `match` without arms, on a value Rust proved can't exist, such as a `(Void, u8)`. */ @@ -2546,7 +2546,7 @@ export type Cow = Vec | Borrowed>; /** `Cow<[u8]>`: the `Vec` it owns, or the bytes it borrows. */ export type ByteCow = ByteVec | ByteSlice; /** `Cow`: the `String` it owns, or the `str` it borrows. */ -export type StrCow = string | Borrowed; +export type StrCow = RsString | Borrowed; /** `Deref` of a `Cow<[T]>`: its slice. */ export function cowSlice(c: Cow): Slice { @@ -2631,25 +2631,58 @@ export function hashCow(hash: (value: B, s: S) => void): (value: B | Borro return (value, s) => hash(cowDeref(value), s); } -/** `Deref` of a `Cow`, and its `into_owned`: its text. */ +/** `Deref` of a `Cow`: its text. */ export function strCowStr(c: StrCow): string { - return c instanceof Borrowed ? c.slice : c; + return c instanceof Borrowed ? c.slice : c.v; +} + +/** `Cow::into_owned` of a `Cow`: the `String` it owns, or one of the text it borrows. */ +export function strCowIntoOwned(c: StrCow): RsString { + return c instanceof Borrowed ? stringFrom(c.slice) : c; } -/** `Clone` of a `Cow`: a borrow of the same text, or its text. */ +/** `Clone` of a `Cow`: a borrow of the same text, or a clone of its `String`. */ export function strCowClone(c: StrCow): StrCow { - return c instanceof Borrowed ? new Borrowed(c.slice) : c; + return c instanceof Borrowed ? new Borrowed(c.slice) : stringClone(c); +} + +/** `clone_from` of a `Cow`: an owned one's `String`, of an owned one's, as `String`'s clones into it, and else `src`'s clone. */ +export function strCowCloneFrom(c: StrCow, src: StrCow): StrCow { + if (c instanceof Borrowed || src instanceof Borrowed) return strCowClone(src); + c.v = ""; + c.len = 0 as usize; + stringPushStr(c, src.v, src.len); + return c; +} + +/** `strCowCloneFrom` as a `CloneFrom`. */ +export function strCowCloneFromFn(): CloneFrom { + return strCowCloneFrom; +} + +/** `stringCloneFrom` as a `CloneFrom`. */ +export function stringCloneFromFn(): CloneFrom { + return stringCloneFrom; } /** - * `+` of two `Cow`s, and `+=`: the right one if the left is empty, the left if the - * right is, and else the text they join, owned. + * `+` of two `Cow`s, and `+=`: the right one if the left is empty, and else the left, + * which owns room for both if it borrowed, once it pushed the right's text. */ export function strCowAdd(a: StrCow, b: StrCow): StrCow { const left = strCowStr(a); if (left === "") return b; const right = strCowStr(b); - return right === "" ? a : left + right; + if (right === "") return a; + const len = b instanceof Borrowed ? stringLen(right) : b.len; + if (!(a instanceof Borrowed)) { + stringPushStr(a, right, len); + return a; + } + const owned = stringWithCapacity((stringLen(left) + len) as usize); + stringPushStr(owned, left); + stringPushStr(owned, right, len); + return owned; } // Strings @@ -2718,38 +2751,53 @@ export function strFromUtf8(bytes: ByteSlice): Result { } } -/** `String::from_utf8_lossy`: the text of valid UTF-8, borrowed, or else with each invalid sequence replaced by U+FFFD, owned. */ +/** + * `String::from_utf8_lossy`: the text of valid UTF-8, borrowed, or else with each invalid + * sequence replaced by U+FFFD, owned, with room for a byte of each and grown by each push. + */ export function stringFromUtf8Lossy(bytes: ByteSlice): StrCow { const v = byteSliceView(bytes); try { return new Borrowed(decoder.decode(v)); } catch { - return strFromUtf8Unchecked(bytes); + const s = stringWithCapacity(bytes.length as usize); + for (const chunk of byteSliceUtf8Chunks(bytes)) { + stringPushStr(s, chunk.valid); + if (chunk.invalid.length > 0) stringPushStr(s, "\ufffd", 3 as usize); + } + return s; } } -/** `String::from_utf8`. */ -export function stringFromUtf8(bytes: ByteVec): Result { +/** `String::from_utf8`: its text, with the room `bytes` had. */ +export function stringFromUtf8(bytes: ByteVec): Result { try { - return Ok(decoder.decode(byteVecView(bytes))); + return Ok(stringOf(decoder.decode(byteVecView(bytes)), bytes.length as usize, bytes.data.length as usize)); } catch { return Err(new FromUtf8Error(bytes)); } } +/** `String::from_utf8_unchecked` of UTF-8, which keeps the room `bytes` had. */ +export function stringFromUtf8Unchecked(bytes: ByteVec): RsString { + return stringOf(strFromUtf8Unchecked(byteVecSlice(bytes)), bytes.length as usize, bytes.data.length as usize); +} + /** `str::as_bytes`: its UTF-8 bytes. */ export function stringAsBytes(s: string): ByteSlice { return byteSliceFrom(encoder.encode(s)); } -/** `String::into_bytes`: its UTF-8 bytes. */ -export function stringIntoBytes(s: string): ByteVec { - return byteVecFrom(encoder.encode(s)); +/** `String::into_bytes`: its UTF-8 bytes, with its room. */ +export function stringIntoBytes(s: RsString): ByteVec { + const v = new ByteVec(s.cap); + v.length = encoder.encodeInto(s.v, v.data).written; + return v; } -/** `str::len`: its length in UTF-8 bytes. */ -export function stringLen(s: string): number { - return encoder.encode(s).length; +/** `<[u8]>::to_vec` of a `str`'s bytes, with room for exactly them. */ +export function strToBytes(s: string): ByteVec { + return byteVecFrom(encoder.encode(s)); } /** `char::from_u32`: `n`, unless it is a surrogate or past the last char. */ @@ -2825,20 +2873,32 @@ export interface Write { writeChar(c: char): FmtResult; } +/** `impl fmt::Write for String`: each `write_str` a `push_str`, and each `write_char` a `push`. */ class StringWriter implements Write { - s = ""; + readonly s: RsString; + + constructor(s: RsString) { + this.s = s; + } writeStr(s: string): FmtResult { - this.s += s; + stringPushStr(this.s, s); return OK; } writeChar(c: char): FmtResult { - this.s += String.fromCodePoint(c); + stringPush(this.s, c); return OK; } } +/** The text `args` writes, before any value failed to, as a panic's message. */ +export function fmtFormatText(args: Arguments): string { + const s = stringNew(); + write(new StringWriter(s), args); + return s.v; +} + /** Indents each line it writes, for `{:#?}`'s nesting. */ class PadAdapter implements Write { private onNewline = true; @@ -2914,12 +2974,9 @@ export function fmtWriteFmt(f: Formatter, args: Arguments): FmtResult { return write(f.out, args); } -/** `write!` into a `String`, `s`: `s` with what was written, even before an error, and the result. */ -export function fmtWriteString(s: string, args: Arguments): { s: string; result: FmtResult } { - const out = new StringWriter(); - out.s = s; - const result = write(out, args); - return { s: out.s, result }; +/** `write!` into a `String`, which keeps what was written before an error. */ +export function fmtWriteString(s: RsString, args: Arguments): FmtResult { + return write(new StringWriter(s), args); } /** `Formatter::alternate`: whether the spec has `#`. */ @@ -3237,20 +3294,47 @@ function closePretty(f: Formatter, close: string): FmtResult { // `Debug` and `Display` of what std defines them for. A string's `Display` is `fmtPad`. -/** `format!`, from `alloc::fmt::format`. */ -export function fmtFormat(args: Arguments): string { - const out = new StringWriter(); - if (!write(out, args).ok) { +/** + * `format!`, from `alloc::fmt::format`: room for `Arguments::estimated_capacity`, which + * each write grows. + */ +export function fmtFormat(args: Arguments): RsString { + const s = stringWithCapacity(estimate(args) as usize); + if (!write(new StringWriter(s), args).ok) { panic("a formatting trait implementation returned an error when the underlying stream did not: Error", "format", true); } - return out.s; + return s; } -/** `ToString::to_string` of a `Display` value. */ -export function fmtToString(value: Fmt): string { - const out = new StringWriter(); - if (!value({ out, spec: {} }).ok) panic("a Display implementation returned an error unexpectedly: Error", "to_string", true); - return out.s; +/** + * `Arguments::estimated_capacity`: the text's bytes if it has no placeholder, none if one + * comes first and the text is under 16 bytes, and else twice the text's bytes. + */ +function estimate(args: Arguments): number { + let len = 0; + let placeholders = false; + let first = false; + for (const part of args) { + if (typeof part === "string") len += stringLen(part); + else { + first ||= len === 0; + placeholders = true; + } + } + if (!placeholders) return len; + return first && len < 16 ? 0 : len * 2; +} + +/** + * `ToString::to_string` of a `Display` value. std's room for a signed integer is `size` + * digits, and its sign if negative; for other primitives, given a `size` of 0, exactly its + * bytes; and else what each write grows from none. + */ +export function fmtToString(value: Fmt, size?: number): RsString { + const s = stringNew(); + if (!value({ out: new StringWriter(s), spec: {} }).ok) panic("a Display implementation returned an error unexpectedly: Error", "to_string", true); + if (size !== undefined) s.cap = (size === 0 ? s.len : size + (s.v.startsWith("-") ? 1 : 0)) as usize; + return s; } /** A placeholder with options, which replace the defaults its value is written with. */ diff --git a/ts/runtime/rs/char.ts b/ts/runtime/rs/char.ts index cc35ae7a6..87b0c48a4 100644 --- a/ts/runtime/rs/char.ts +++ b/ts/runtime/rs/char.ts @@ -7,7 +7,7 @@ import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtPad, fmtUnit, fmtWriteFmt, OK, Ok, type Place, panic, type Result, Slice } from "../rs.ts"; import { type char, type u8, type u16, u16Debug, u16LowerHex, type u32, type usize } from "./int.ts"; import { type Clones, DONE, type Done, Iter, iterFlatMap, iterHeld, type SizeHint } from "./iter.ts"; -import { strChars } from "./str.ts"; +import { type String as RsString, strChars, stringCased } from "./str.ts"; import { drop as dispose } from "./task.ts"; import { ALPHABETIC, CASE_IGNORABLE, LOWERCASE, NUMERIC, TITLECASE, TO_LOWERCASE, TO_LOWERCASE_MULTI, TO_UPPERCASE, TO_UPPERCASE_MULTI, UNPRINTABLE, UPPERCASE } from "./unicode.ts"; import type { Location } from "./location.ts"; @@ -151,7 +151,7 @@ const toLowercase = /* @__PURE__ */ new CaseMap(TO_LOWERCASE, TO_LOWERCASE_MULTI const toUppercase = /* @__PURE__ */ new CaseMap(TO_UPPERCASE, TO_UPPERCASE_MULTI); /** `str::to_lowercase`: each char's, but a capital sigma's at the end of a word, which is final. */ -export function strToLowercase(s: string): string { +export function strToLowercase(s: string): RsString { let out = ""; for (let i = 0; i < s.length; ) { const c = s.codePointAt(i) as char; @@ -160,7 +160,7 @@ export function strToLowercase(s: string): string { else out += String.fromCodePoint(...toLowercase.map(c)); i = end; } - return out; + return stringCased(s, out); } /** @@ -188,14 +188,14 @@ function isLowSurrogate(u: number): boolean { } /** `str::to_uppercase`: each char's. */ -export function strToUppercase(s: string): string { +export function strToUppercase(s: string): RsString { let out = ""; for (let i = 0; i < s.length; ) { const c = s.codePointAt(i) as char; out += String.fromCodePoint(...toUppercase.map(c)); i += c > 0xffff ? 2 : 1; } - return out; + return stringCased(s, out); } /** The chars a case map or an escape still has, from either end, exactly sized. */ diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index 93b77cf1d..f45d44266 100644 --- a/ts/runtime/rs/collections.ts +++ b/ts/runtime/rs/collections.ts @@ -15,10 +15,11 @@ // A function that may drop a key, value, or item std's would, rather than return or keep // it, takes what drops each that does, as `k`, `v`, or `f`, and drops it where std's does. -import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; +import { Borrowed, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; import type { Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; +import type { String as RsString } from "./str.ts"; import { type Clones, DONE, @@ -68,7 +69,9 @@ export function cmp(a: T, b: T): Ordering { * `Ord::cmp` of two strings, by code point as Rust's UTF-8 bytes sort. JS's `<` compares * UTF-16 units, which puts a character past U+FFFF, a surrogate pair, below U+E000. */ -export function cmpStr(a: string, b: string): Ordering { +export function cmpStr(x: string | RsString, y: string | RsString): Ordering { + const a = typeof x === "string" ? x : x.v; + const b = typeof y === "string" ? y : y.v; if (a === b) return 0; const n = Math.min(a.length, b.length); for (let i = 0; i < n; i++) { @@ -308,6 +311,16 @@ export function same(a: T, b: T): boolean { return a === b; } +/** `PartialEq::eq` of text of any form, a `str`, a `String`, or a `Cow`: their text. */ +export function eqStr(a: string | RsString | Borrowed, b: string | RsString | Borrowed): boolean { + return textOf(a) === textOf(b); +} + +/** The text of a `str`, a `String`, or a `Cow`. */ +function textOf(s: string | RsString | Borrowed): string { + return typeof s === "string" ? s : s instanceof Borrowed ? s.slice : s.v; +} + /** `PartialEq::eq` of tuples, from each field's. */ export function eqTuple(fields: readonly ((a: never, b: never) => boolean)[]): (a: T, b: T) => boolean { return (a, b) => { @@ -2365,9 +2378,10 @@ export function btreeRangeKeys(m: BTreeMap, r: NoInfer /** * What a range of keys `K` is bounded by: a key, or for an array's or a `Vec`'s, a `Slice`, - * which `cmpSlice` orders alike. + * which `cmpSlice` orders alike, or for a `String`'s or a `Cow`'s, a `str`, which + * `cmpStr` orders alike. */ -type Key = K | (K extends (infer E)[] ? Slice : never); +type Key = K | (K extends (infer E)[] ? Slice : never) | (K extends RsString | Borrowed ? string : never); /** * The items of `m` within `r`, checked as std checks it: by `eq` and `gt`, or by `m`'s diff --git a/ts/runtime/rs/float.ts b/ts/runtime/rs/float.ts index 60e5c3f55..627fe1607 100644 --- a/ts/runtime/rs/float.ts +++ b/ts/runtime/rs/float.ts @@ -313,7 +313,7 @@ function mulAddExact(a: number, b: number, c: number): number { /** `clamp`, which panics with both bounds' `Debug` unless `min <= max`. */ function clamp(x: number, min: number, max: number, debug: (x: number, f: Formatter) => FmtResult, key: string): number { if (!(min <= max)) { - const text = (v: number) => fmtToString((f) => debug(v, f)); + const text = (v: number) => fmtToString((f) => debug(v, f)).v; panic(`min > max, or either was NaN. min = ${text(min)}, max = ${text(max)}`, key, true); } return x < min ? min : x > max ? max : x; diff --git a/ts/runtime/rs/hash.ts b/ts/runtime/rs/hash.ts index 5762270f8..e25674d8f 100644 --- a/ts/runtime/rs/hash.ts +++ b/ts/runtime/rs/hash.ts @@ -26,6 +26,7 @@ import { u128Cast, } from "./int.ts"; import type { LinkedList } from "./collections.ts"; +import type { String as RsString } from "./str.ts"; import type { Arc } from "./task.ts"; /** What `Hash` writes into, by `Hasher`'s methods: `DefaultHasher`, a hash collection's own, or the crate's. */ @@ -679,9 +680,9 @@ export function hashWrite(bytes: ByteSlice, s: Hasher): void { s.write(bytes.data, bytes.start, bytes.length); } -/** `Hash::hash` of a string. */ -export function hashStr(str: string, s: Hasher): void { - s.str(str); +/** `Hash::hash` of a `str` or a `String`, which hash the same. */ +export function hashStr(str: string | RsString, s: Hasher): void { + s.str(typeof str === "string" ? str : str.v); } /** `Hash::hash` of what holds nothing, as `()` and `PhantomData`: nothing written. */ diff --git a/ts/runtime/rs/hook.ts b/ts/runtime/rs/hook.ts index 5473a709b..f61b49a79 100644 --- a/ts/runtime/rs/hook.ts +++ b/ts/runtime/rs/hook.ts @@ -1,7 +1,8 @@ // `std::panic`'s hook, for rust2-ts output: only a program that sets one reaches this // module, so a bundler drops all of it from one that doesn't. `rs.ts` re-exports all of it. -import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtWriteString, Panic, panic } from "../rs.ts"; +import { type String as RsString, stringFrom } from "./str.ts"; +import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtFormatText, Panic, panic } from "../rs.ts"; import { fmtLocationDisplay, type Location } from "./location.ts"; import { drop } from "./task.ts"; @@ -49,7 +50,7 @@ function run(message: string | Arguments | undefined, at: Location | string | un if (location === undefined) throw new Error(`rust2-ts: a panic its hook can't locate: ${literal ?? "a formatted message"}`); hooking = true; try { - const text = typeof message === "object" ? fmtWriteString("", message).s : message; + const text = typeof message === "object" ? fmtFormatText(message) : message; hook({ text, owned: owned ?? literal === undefined, payload, location }); return text; } finally { @@ -97,8 +98,9 @@ export function panicAny(payload: object, at?: Location): never { * `PanicHookInfo::payload`: what `panic_any` was given, or else the text, as a `str` or a * `String` object, whose classes translation makes. */ -export function hookPayload(info: PanicHookInfo, str: new (text: string) => object, string: new (text: string) => object): object { - return info.payload ?? new (info.owned ? string : str)(info.text ?? ""); +export function hookPayload(info: PanicHookInfo, str: new (text: string) => object, string: new (text: RsString) => object): object { + if (info.payload !== undefined) return info.payload; + return info.owned ? new string(stringFrom(info.text ?? "")) : new str(info.text ?? ""); } /** `PanicHookInfo`'s `Display`: where it panicked, then any text, as the default hook's first lines. */ diff --git a/ts/runtime/rs/str.ts b/ts/runtime/rs/str.ts index 1cd860f7a..c4184117c 100644 --- a/ts/runtime/rs/str.ts +++ b/ts/runtime/rs/str.ts @@ -7,7 +7,13 @@ // surrogate pair. import { + Borrowed, ByteSlice, + capReserve, + capReserveExact, + capShrink, + capTryReserve, + capTryReserveExact, type Slice, byteSliceView, Err, @@ -29,8 +35,6 @@ import { panicFmt, type Result, type StrCow, - strCowStr, - stringLen, utf8Check, } from "../rs.ts"; import { CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; @@ -1114,18 +1118,6 @@ export function strFind(s: string, p: Pattern): usize | undefined { return m.nextMatch() ? (utf8Len(s, 0, m.start) as usize) : undefined; } -/** `str::replace`, and `replacen` of the first `n` matches. */ -export function strReplace(s: string, p: Pattern, to: string, n = Infinity): string { - const m = new Searcher(s, p); - let out = ""; - let last = 0; - for (let i = 0; i < n && m.nextMatch(); i++) { - out += s.slice(last, m.start) + to; - last = m.end; - } - return out + s.slice(last); -} - /** `str::rfind`: the last match's offset in UTF-8 bytes. */ export function strRfind(s: string, p: Pattern): usize | undefined { const m = new Searcher(s, p); @@ -1268,35 +1260,207 @@ export function fmtUtf8ChunkDebug(chunk: Utf8Chunk, f: Formatter): FmtResult { ]); } -// `String`'s edits, each giving the edited string, which the caller writes where the -// `&mut String` points, and what the edit returns beside it. +// `String`: a JS string, as a `str` is, and the length in UTF-8 bytes and the capacity std's +// would hold. Each step grows it as `RawVec` grows a `Vec`'s, so a `capacity` read gives +// std's. A `&mut String` is the object, edited in place, and so is a `&mut str` of it, as +// no write through one changes its length. + +/** `alloc::string::String`: its text, `v`, its length in UTF-8 bytes, and its capacity. */ +class RsString implements Place { + v: string; + len: usize; + cap: usize; + + constructor(v: string, len: usize, cap: usize) { + this.v = v; + this.len = len; + this.cap = cap; + } +} + +export { RsString as String }; /** `isize::MAX` on wasm32, past which std refuses a capacity. */ const ISIZE_MAX = 0x7fffffff; +/** `str::len`: its length in UTF-8 bytes. */ +export function stringLen(s: string): usize { + return utf8Len(s, 0, s.length) as usize; +} + +/** `String::new`, which holds nothing. */ +export function stringNew(): RsString { + return new RsString("", 0 as usize, 0 as usize); +} + +/** A `String` of `text` with room for exactly its bytes, as `str::to_owned` makes one. */ +export function stringFrom(text: string): RsString { + const len = stringLen(text); + return new RsString(text, len, len); +} + +/** A `String` of `text`, `len` bytes long, with room for `cap`. */ +export function stringOf(text: string, len: usize, cap: usize): RsString { + return new RsString(text, len, cap); +} + +/** `String::with_capacity`, which panics past what it may hold. */ +export function stringWithCapacity(capacity: usize): RsString { + return new RsString("", 0 as usize, capReserveExact(0, 0, capacity, 1) as usize); +} + +/** `String::reserve`: room for `additional` more bytes, at least doubled if it grows. */ +export function stringReserve(s: RsString, additional: usize): void { + s.cap = capReserve(s.len, s.cap, additional, 1) as usize; +} + +/** `String::reserve_exact`: room for exactly `additional` more bytes if it grows. */ +export function stringReserveExact(s: RsString, additional: usize): void { + s.cap = capReserveExact(s.len, s.cap, additional, 1) as usize; +} + +/** `String::try_reserve`: `reserve`'s room, or the error where it panics. */ +export function stringTryReserve(s: RsString, additional: usize): Result { + return reserved(s, capTryReserve(s.len, s.cap, additional, 1)); +} + +/** `String::try_reserve_exact`. */ +export function stringTryReserveExact(s: RsString, additional: usize): Result { + return reserved(s, capTryReserveExact(s.len, s.cap, additional, 1)); +} + +/** `s` with room for `cap`, or the error of an overflow, `undefined`. */ +function reserved(s: RsString, cap: number | undefined): Result { + if (cap === undefined) return CAPACITY_OVERFLOW; + s.cap = cap as usize; + return OK; +} + +/** `String::shrink_to`, and `shrink_to_fit`, of 0. */ +export function stringShrinkTo(s: RsString, min: usize): void { + s.cap = capShrink(s.len, s.cap, min) as usize; +} + +/** `String::push_str` of `text`, `len` bytes long. */ +export function stringPushStr(s: RsString, text: string, len: usize = stringLen(text)): void { + stringReserve(s, len); + s.v += text; + s.len = (s.len + len) as usize; +} + +/** `String::push`. */ +export function stringPush(s: RsString, c: char): void { + stringPushStr(s, globalThis.String.fromCodePoint(c), charLen(c) as usize); +} + +/** `String + &str`, and `+=`: `s`, once it pushed `text`. */ +export function stringAdd(s: RsString, text: string): RsString { + stringPushStr(s, text); + return s; +} + +/** Push each char of `text` in turn, as std's `push` of each grows `s`. */ +export function stringPushChars(s: RsString, text: string): void { + let { len, cap } = s; + for (let i = 0; i < text.length; i++) { + const u = text.charCodeAt(i); + // A pair's high half is two bytes, and its low half the other two. + const n = u < 0x80 ? 1 : u < 0x800 ? 2 : u >= 0xd800 && u <= 0xdbff ? 4 : u >= 0xdc00 && u <= 0xdfff ? 0 : 3; + if (n > cap - len) cap = capReserve(len, cap, n, 1); + len += n; + } + s.v += text; + s.len = len as usize; + s.cap = cap as usize; +} + +/** `Clone` of a `String`: its text, with room for exactly its bytes. */ +export function stringClone(s: RsString): RsString { + return new RsString(s.v, s.len, s.len); +} + +/** `clone_from` of `src` into `s`, as `Vec`'s clears it and extends it by `src`'s bytes. */ +export function stringCloneFrom(s: RsString, src: RsString): RsString { + s.v = ""; + s.len = 0 as usize; + stringPushStr(s, src.v, src.len); + return s; +} + +/** `String::clear`, which keeps its room. */ +export function stringClear(s: RsString): void { + s.v = ""; + s.len = 0 as usize; +} + /** - * `concat` and `join` of strings by `sep`, which panic as std's do where the bytes they - * reserve pass `usize::MAX` or what a `String` may hold. + * `concat` and `join` of strings or `String`s by `sep`: a `String` with room for exactly + * their bytes, as std's reserves them, which panics as std's does where they pass + * `usize::MAX` or what a `String` may hold. */ -export function strsJoin(parts: readonly string[], sep: string): string { +export function strsJoin(parts: readonly (string | RsString)[], sep: string): RsString { const seps = Math.max(parts.length - 1, 0); - let units = sep.length * seps; - for (const part of parts) units += part.length; - // A code unit is one to three bytes, so only a long result needs its bytes counted, each - // distinct part once, as such a result mostly repeats a few. - if (units * 3 > ISIZE_MAX) { - const counted = new Map(); - const count = (s: string): number => { - let n = counted.get(s); - if (n === undefined) counted.set(s, (n = stringLen(s))); - return n; - }; - let len = count(sep) * seps; - for (const part of parts) len += count(part); - if (len > 0xffffffff) panic("attempt to join into collection with len > usize::MAX", "join_len", true); - if (len > ISIZE_MAX) panic("capacity overflow", "capacity"); - } - return parts.join(sep); + // Each distinct text's bytes counted once, as a long result mostly repeats a few. + const counted = new Map(); + const count = (s: string): number => { + let n = counted.get(s); + if (n === undefined) counted.set(s, (n = stringLen(s))); + return n; + }; + let len = count(sep) * seps; + const texts: string[] = []; + for (const part of parts) { + if (typeof part === "string") { + len += count(part); + texts.push(part); + } else { + len += part.len; + texts.push(part.v); + } + } + if (len > 0xffffffff) panic("attempt to join into collection with len > usize::MAX", "join_len", true); + if (len > ISIZE_MAX) panic("capacity overflow", "capacity"); + return new RsString(texts.join(sep), len as usize, len as usize); +} + +/** + * `str::replace` of a pattern, `utf8` if a `char`, `&str`, or `&String`: room for `s`'s + * bytes if what replaces each match is no shorter, and else none, which each push grows. + * One ASCII byte for another is a copy, with room for exactly its bytes. + */ +export function strReplace(s: string, p: Pattern, to: string, utf8: boolean): RsString { + const len = stringLen(s); + if (utf8 && typeof p === "string" && p.length === 1 && p.charCodeAt(0) < 0x80 && to.length === 1 && to.charCodeAt(0) < 0x80) { + return new RsString(s.replaceAll(p, to), len, len); + } + const toLen = stringLen(to); + const fits = utf8 && typeof p === "string" && stringLen(p) <= toLen; + return replaced(new RsString("", 0 as usize, fits ? len : (0 as usize)), s, p, to, toLen, Infinity); +} + +/** `str::replacen`: room for 32 bytes, which each push of the first `n` matches grows. */ +export function strReplacen(s: string, p: Pattern, to: string, n: usize): RsString { + return replaced(new RsString("", 0 as usize, 32 as usize), s, p, to, stringLen(to), n); +} + +/** `out`, once it pushed the text of `s` between its first `n` matches of `p`, and `to` for each. */ +function replaced(out: RsString, s: string, p: Pattern, to: string, toLen: usize, n: number): RsString { + const m = new Searcher(s, p); + let last = 0; + for (let i = 0; i < n && m.nextMatch(); i++) { + stringPushStr(out, s.slice(last, m.start)); + stringPushStr(out, to, toLen); + last = m.end; + } + stringPushStr(out, s.slice(last)); + return out; +} + +/** `str::to_lowercase` and `to_uppercase` of `s` to `text`: room for `s`'s bytes, which each char's push grows. */ +export function stringCased(s: string, text: string): RsString { + const out = new RsString("", 0 as usize, stringLen(s)); + stringPushChars(out, text); + return out; } /** `String::FromUtf16Error`: `{ kind }`, its private `FromUtf16ErrorKind`'s name. */ @@ -1317,33 +1481,51 @@ function fromUtf16Units(len: number, unit: (i: number) => number, lossy: boolean for (let i = 0; i < len; i++) { const u = unit(i); if (u < 0xd800 || u > 0xdfff) { - s += String.fromCharCode(u); + s += globalThis.String.fromCharCode(u); continue; } const next = i + 1 < len ? unit(i + 1) : 0; if (u <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) { - s += String.fromCharCode(u, next); + s += globalThis.String.fromCharCode(u, next); i++; - } else if (lossy) s += "\ufffd"; + } else if (lossy) s += "�"; else return undefined; } return s; } -/** The text of `len` units, `unit(i)` the `i`th, or a `LoneSurrogate` error, as `String::from_utf16` reads them. */ -function fromUtf16(len: number, unit: (i: number) => number): Result { - const s = fromUtf16Units(len, unit, false); - return s === undefined ? Err(new FromUtf16Error("LoneSurrogate")) : Ok(s); +/** + * The `String` of `len` units, `unit(i)` the `i`th, or a `LoneSurrogate` error, as + * `String::from_utf16` reads them: room for a byte a unit, which each char's push grows. + */ +function fromUtf16(len: number, unit: (i: number) => number): Result { + const text = fromUtf16Units(len, unit, false); + if (text === undefined) return Err(new FromUtf16Error("LoneSurrogate")); + const s = stringWithCapacity(len as usize); + stringPushChars(s, text); + return Ok(s); +} + +/** + * The `String` of `len` units, `unit(i)` the `i`th, U+FFFD for each surrogate without its + * pair, as `String::from_utf16_lossy` collects them: room for half a char a unit, which + * each char's push grows. + */ +function fromUtf16Lossy(len: number, unit: (i: number) => number): RsString { + const s = stringNew(); + stringReserve(s, Math.ceil(len / 2) as usize); + stringPushChars(s, fromUtf16Units(len, unit, true) as string); + return s; } /** `String::from_utf16`. */ -export function stringFromUtf16(v: Slice): Result { +export function stringFromUtf16(v: Slice): Result { return fromUtf16(v.length, (i) => v.data[v.start + i]); } /** `String::from_utf16_lossy`: U+FFFD for each surrogate without its pair. */ -export function stringFromUtf16Lossy(v: Slice): string { - return fromUtf16Units(v.length, (i) => v.data[v.start + i], true) as string; +export function stringFromUtf16Lossy(v: Slice): RsString { + return fromUtf16Lossy(v.length, (i) => v.data[v.start + i]); } /** The `i`th unit of `v`'s bytes, little-endian unless `big`. */ @@ -1353,23 +1535,29 @@ function byteUnit(v: ByteSlice, big: boolean): (i: number) => number { } /** `String::from_utf16le`, an `OddBytes` error of an odd number of bytes. */ -export function stringFromUtf16le(v: ByteSlice): Result { +export function stringFromUtf16le(v: ByteSlice): Result { return v.length % 2 === 1 ? Err(new FromUtf16Error("OddBytes")) : fromUtf16(v.length / 2, byteUnit(v, false)); } /** `String::from_utf16be`, an `OddBytes` error of an odd number of bytes. */ -export function stringFromUtf16be(v: ByteSlice): Result { +export function stringFromUtf16be(v: ByteSlice): Result { return v.length % 2 === 1 ? Err(new FromUtf16Error("OddBytes")) : fromUtf16(v.length / 2, byteUnit(v, true)); } -/** `String::from_utf16le_lossy`, and U+FFFD for an odd byte at the end. */ -export function stringFromUtf16leLossy(v: ByteSlice): string { - return (fromUtf16Units(v.length >>> 1, byteUnit(v, false), true) as string) + (v.length % 2 === 1 ? "\ufffd" : ""); +/** `String::from_utf16le_lossy`, and U+FFFD pushed for an odd byte at the end. */ +export function stringFromUtf16leLossy(v: ByteSlice): RsString { + return oddByte(fromUtf16Lossy(v.length >>> 1, byteUnit(v, false)), v); +} + +/** `String::from_utf16be_lossy`, and U+FFFD pushed for an odd byte at the end. */ +export function stringFromUtf16beLossy(v: ByteSlice): RsString { + return oddByte(fromUtf16Lossy(v.length >>> 1, byteUnit(v, true)), v); } -/** `String::from_utf16be_lossy`, and U+FFFD for an odd byte at the end. */ -export function stringFromUtf16beLossy(v: ByteSlice): string { - return (fromUtf16Units(v.length >>> 1, byteUnit(v, true), true) as string) + (v.length % 2 === 1 ? "\ufffd" : ""); +/** `s`, and U+FFFD pushed if `v` has an odd byte at the end. */ +function oddByte(s: RsString, v: ByteSlice): RsString { + if (v.length % 2 === 1) stringPushStr(s, "�", 3 as usize); + return s; } /** `Debug` of `FromUtf16Error`. */ @@ -1382,23 +1570,7 @@ export function fmtFromUtf16ErrorDisplay(e: FromUtf16Error, f: Formatter): FmtRe return fmtPad(f, e.kind === "LoneSurrogate" ? "invalid utf-16: lone surrogate found" : "invalid utf-16: odd number of bytes"); } -/** `String::with_capacity`: the empty string, which keeps no capacity. */ -export function stringWithCapacity(capacity: usize): string { - if (capacity > ISIZE_MAX) panic("capacity overflow", "capacity"); - return ""; -} - -/** `String::reserve` and `reserve_exact`, which panic as std's do past `isize::MAX`. */ -export function stringReserve(s: string, additional: usize): void { - if (!stringTryReserve(s, additional).ok) panic("capacity overflow", "capacity"); -} - -/** `String::try_reserve` and `try_reserve_exact`: the error where `reserve` panics. */ -export function stringTryReserve(s: string, additional: usize): Result { - // A code unit is at most three bytes, so only a large `additional` needs the length. - const over = additional > ISIZE_MAX - 3 * s.length && additional > ISIZE_MAX - utf8Len(s, 0, s.length); - return over ? CAPACITY_OVERFLOW : OK; -} +// `String`'s edits, in place. /** The code unit where byte `i` of `s` starts a char, or panic with `message`. */ function boundary(s: string, i: number, message: string, at?: Location): number { @@ -1407,127 +1579,163 @@ function boundary(s: string, i: number, message: string, at?: Location): number return pos; } -/** `String::truncate`: `s` to `len` bytes, or as it is if no longer. */ -export function stringTruncate(s: string, len: usize, at?: Location): string { - const pos = unitAt(s, 0, 0, len); - if (pos >= 0) return s.slice(0, pos); - if (len > utf8Len(s, 0, s.length)) return s; - panic("assertion failed: self.is_char_boundary(new_len)", at); +/** `String::truncate`: to `len` bytes, unless already no longer. */ +export function stringTruncate(s: RsString, len: usize, at?: Location): void { + if (len > s.len) return; + s.v = s.v.slice(0, boundary(s.v, len, "assertion failed: self.is_char_boundary(new_len)", at)); + s.len = len; } -/** `String::insert_str`, and `insert` of a char's text. */ -export function stringInsertStr(s: string, i: usize, text: string, at?: Location): string { - const pos = boundary(s, i, "assertion failed: self.is_char_boundary(idx)", at); - return s.slice(0, pos) + text + s.slice(pos); +/** `String::insert_str`, and `insert` of a char's text: room for its bytes reserved. */ +export function stringInsertStr(s: RsString, i: usize, text: string, at?: Location): void { + const pos = boundary(s.v, i, "assertion failed: self.is_char_boundary(idx)", at); + const len = stringLen(text); + stringReserve(s, len); + s.v = s.v.slice(0, pos) + text + s.v.slice(pos); + s.len = (s.len + len) as usize; } /** `String::retain`: the chars `f` keeps, calling it on each in order. */ -export function stringRetain(s: string, f: (c: char) => boolean): string { +export function stringRetain(s: RsString, f: (c: char) => boolean): void { let kept = ""; - for (const ch of s) if (f(ch.codePointAt(0) as char)) kept += ch; - return kept; -} - -/** `String::replace_range`. */ -export function stringReplaceRange(s: string, r: Bounds, text: string, at?: Location): string { - const [start, end] = boundsRange(r, utf8Len(s, 0, s.length), at); - const from = boundary(s, start, "start of range should be a character boundary", at); - const to = boundary(s, end, "end of range should be a character boundary", at); - return s.slice(0, from) + text + s.slice(to); -} - -/** `String::extend_from_within`. */ -export function stringExtendFromWithin(s: string, r: Bounds, at?: Location): string { - const [start, end] = boundsRange(r, utf8Len(s, 0, s.length), at); - const from = boundary(s, start, "assertion failed: self.is_char_boundary(start)", at); - const to = boundary(s, end, "assertion failed: self.is_char_boundary(end)", at); - return s + s.slice(from, to); -} - -/** `String::pop`: the rest, and the last char if any. */ -export function stringPop(s: string): [string, char | undefined] { - if (s.length === 0) return [s, undefined]; - const pos = before(s, s.length); - return [s.slice(0, pos), s.codePointAt(pos) as char]; -} - -/** `String::remove`: the rest, and the char at byte `i`. */ -export function stringRemove(s: string, i: usize, at?: Location): [string, char] { - const pos = unitAt(s, 0, 0, i); - if (pos < 0) sliceFailed(s, i, utf8Len(s, 0, s.length), at); - if (pos === s.length) panic("cannot remove a char from the end of a string", at); - const c = s.codePointAt(pos) as number; - return [s.slice(0, pos) + s.slice(pos + (c > 0xffff ? 2 : 1)), c as char]; -} - -/** `String::split_off`: what comes before byte `i`, and after it. */ -export function stringSplitOff(s: string, i: usize, at?: Location): [string, string] { - const pos = boundary(s, i, "assertion failed: self.is_char_boundary(at)", at); - return [s.slice(0, pos), s.slice(pos)]; + for (const ch of s.v) if (f(ch.codePointAt(0) as char)) kept += ch; + s.v = kept; + s.len = stringLen(kept); +} + +/** `String::replace_range`: room reserved for what `text` adds. */ +export function stringReplaceRange(s: RsString, r: Bounds, text: string, at?: Location): void { + const [start, end] = boundsRange(r, s.len, at); + const from = boundary(s.v, start, "start of range should be a character boundary", at); + const to = boundary(s.v, end, "end of range should be a character boundary", at); + const len = stringLen(text); + if (len > end - start) stringReserve(s, (len - (end - start)) as usize); + s.v = s.v.slice(0, from) + text + s.v.slice(to); + s.len = (s.len - (end - start) + len) as usize; +} + +/** `String::extend_from_within`: room reserved for the bytes it copies. */ +export function stringExtendFromWithin(s: RsString, r: Bounds, at?: Location): void { + const [start, end] = boundsRange(r, s.len, at); + const from = boundary(s.v, start, "assertion failed: self.is_char_boundary(start)", at); + const to = boundary(s.v, end, "assertion failed: self.is_char_boundary(end)", at); + stringPushStr(s, s.v.slice(from, to), (end - start) as usize); +} + +/** `String::pop`: the last char, if any. */ +export function stringPop(s: RsString): char | undefined { + if (s.len === 0) return undefined; + const pos = before(s.v, s.v.length); + const c = s.v.codePointAt(pos) as char; + s.v = s.v.slice(0, pos); + s.len = (s.len - charLen(c)) as usize; + return c; +} + +/** `String::remove`: the char at byte `i`. */ +export function stringRemove(s: RsString, i: usize, at?: Location): char { + const pos = unitAt(s.v, 0, 0, i); + if (pos < 0) sliceFailed(s.v, i, s.len, at); + if (pos === s.v.length) panic("cannot remove a char from the end of a string", at); + const c = s.v.codePointAt(pos) as char; + s.v = s.v.slice(0, pos) + s.v.slice(pos + (c > 0xffff ? 2 : 1)); + s.len = (s.len - charLen(c)) as usize; + return c; +} + +/** `String::split_off`: what comes after byte `i`, with room for exactly its bytes. */ +export function stringSplitOff(s: RsString, i: usize, at?: Location): RsString { + const pos = boundary(s.v, i, "assertion failed: self.is_char_boundary(at)", at); + const len = (s.len - i) as usize; + const rest = new RsString(s.v.slice(pos), len, len); + s.v = s.v.slice(0, pos); + s.len = i; + return rest; } // `String` from and into iterators. Each reads the iterator by `for_each`, as std's does, // which `drops` makes its own `fold`. /** - * `Extend` and `Extend<&char>` of `s`, and `collect` of chars from `""`: `s` and each - * char, once it reserved the iterator's lower bound, which panics past `isize::MAX`. + * `Extend` and `Extend<&char>` of `s`, and `collect` of chars from `String::new`: each + * char pushed, once it reserved the iterator's lower bound. */ -export function stringExtendChars(s: string, it: Iter, drops = false): string { - stringReserve(s, it.sizeHint()[0]); - iterForEach( - it, - (c) => { - s += String.fromCodePoint(c); - }, - drops, - ); +export function stringExtendChars(s: RsString, it: Iter, drops = false): RsString { + stringReserve(s, it.sizeHint()[0] as usize); + iterForEach(it, (c) => stringPush(s, c), drops); return s; } /** `String` as a tuple's part, of chars, which reserves as `stringReserve`. */ -export const STRING_CHARS_PART: Part = { +export const STRING_CHARS_PART: Part = { reserve: stringReserve, - one: (s, c) => s + String.fromCodePoint(c), + one: (s, c) => (stringPush(s, c), s), }; /** `String` as a tuple's part, of strings, which never reserves. */ -export const STRING_PART: Part = { one: (s, text) => s + text }; +export const STRING_PART: Part = { one: (s, text) => (pushText(s, text), s) }; /** `String` as a tuple's part, of `Cow`s, which never reserves. */ -export const STRING_COW_PART: Part = { one: (s, c) => s + strCowStr(c) }; - -/** `Extend` of `s` by strings, `&str`, `String`, or `Cow`, and `collect` of `&str`s from `""`. */ -export function stringExtend(s: string, it: Iter, drops = false): string { - iterForEach( - it, - (text) => { - s += text; - }, - drops, - ); +export const STRING_COW_PART: Part = { one: (s, c) => (pushText(s, strCowText(c)), s) }; + +/** `push_str` of a `str` or a `String`'s text. */ +function pushText(s: RsString, text: string | RsString): void { + if (typeof text === "string") stringPushStr(s, text); + else stringPushStr(s, text.v, text.len); +} + +/** A `Cow`'s text, or the `String` it owns. */ +function strCowText(c: StrCow): string | RsString { + return c instanceof Borrowed ? c.slice : c; +} + +/** + * `Extend` of `s` by `&str`, `Box`, `String`, or `Cow`, each pushed, and `collect` + * of `&str`s and `Box`s from `String::new`. + */ +export function stringExtend(s: RsString, it: Iter, drops = false): RsString { + iterForEach(it, (text) => pushText(s, text instanceof Borrowed ? text.slice : text), drops); return s; } -/** `collect` of owned strings, a `String` or `Cow`: the first by `next`, then the rest extend it. */ -export function stringFromStrings(it: Iter, drops = false): string { +/** `Extend<&str>` of an array's strings, and `from_iter` of one: room reserved for all of them, then each pushed. */ +export function stringExtendArray(s: RsString, it: Iter): RsString { + const texts: string[] = []; + const lens: usize[] = []; + let len = 0; + iterForEach(it, (text) => { + const n = stringLen(text); + texts.push(text); + lens.push(n); + len += n; + }); + // std's sum saturates, so a reserve past `usize::MAX` panics as one of it does. + stringReserve(s, Math.min(len, 0xffffffff) as usize); + texts.forEach((text, i) => stringPushStr(s, text, lens[i])); + return s; +} + +/** + * `collect` of `String`s or `Cow`s: the first, owned, by `next`, which the rest extend, + * as std's keeps the first's room. + */ +export function stringFromStrings(it: Iter, drops = false): RsString { const first = it.next(); - if (first !== DONE) return stringExtend(first, it, drops); + if (first !== DONE) return stringExtend(first instanceof Borrowed ? stringFrom(first.slice) : first, it, drops); if (drops) dispose(it); - return ""; + return stringNew(); } /** - * `String::drain`: the chars within the byte range `r` of the string at `s`, which leaves - * the string without them as it drops, and as it was if it never does, as `mem::forget` - * leaves it. + * `String::drain`: the chars within the byte range `r` of `s`, which leaves `s` without them + * as it drops, and as it was if it never does, as `mem::forget` leaves it. */ -export function stringDrain(s: Place, r: Bounds, at?: Location): Iter { +export function stringDrain(s: RsString, r: Bounds, at?: Location): Iter { const text = s.v; - const [start, end] = boundsRange(r, utf8Len(text, 0, text.length), at); + const [start, end] = boundsRange(r, s.len, at); const from = boundary(text, start, "assertion failed: self.is_char_boundary(start)", at); const to = boundary(text, end, "assertion failed: self.is_char_boundary(end)", at); - return new StringDrain(s, text, from, to); + return new StringDrain(s, text, from, to, end - start); } /** `Drain::as_str`: the chars `drain` has yet to yield. */ @@ -1541,20 +1749,23 @@ export function fmtStringDrain(drain: Iter, f: Formatter): FmtResult { } class StringDrain extends Chars implements Disposable { - readonly #s: Place; + readonly #s: RsString; readonly #text: string; readonly #from: number; readonly #to: number; + readonly #bytes: number; - constructor(s: Place, text: string, from: number, to: number) { + constructor(s: RsString, text: string, from: number, to: number, bytes: number) { super(text.slice(from, to)); this.#s = s; this.#text = text; this.#from = from; this.#to = to; + this.#bytes = bytes; } [Symbol.dispose](): void { this.#s.v = this.#text.slice(0, this.#from) + this.#text.slice(this.#to); + this.#s.len = (this.#s.len - this.#bytes) as usize; } } diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index fee306796..72f82ec52 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -142,7 +142,10 @@ pub fn call<'tcx>( { return Err(args); } + // A `String` against text of any form, as `eqStr` reads each. + let text = library::owned_string(tcx, t) || library::owned_string(tcx, peel(b, rhs)); let eq = match name { + _ if text => Expr::Rs("eqStr".into()), "eq" => eq_fn(b, t, span), _ => not_ne_fn(b, t, span), }; @@ -155,7 +158,10 @@ pub fn call<'tcx>( } ("Borrow", "borrow", ..) | ("BorrowMut", "borrow_mut", ..) if let Some(t) = self_ty => { let by = library::targ(call.args, 1); + let text = library::owned_string(b.t.tcx, peel(b, t)) && !library::owned_string(b.t.tcx, peel(b, by)); let value = match (same_key(b, t, by), arc_of(b, peel(b, t))) { + // A `String`'s `str` is its text. + (true, _) if text => args.pop().map(|v| v.member("v")), (true, _) => args.pop(), (false, Some(inner)) if same_key(b, inner, by) => args.pop().map(|v| v.member("value")), _ => return Err(args), @@ -245,11 +251,12 @@ pub fn call<'tcx>( } } } - // A slice or an array finds an `rs.Vec` key, which the runtime reads alike, as its type. + // A slice or an array finds an `rs.Vec` key, and a `str` an `rs.String` or an + // `rs.StrCow` key, which the runtime reads alike, as its type. if let Some(by) = by && !matches!(name, "range" | "range_mut") && let Some(at) = args.get_mut(1) - && other_shape(b, arg(coll, 0), by) + && (other_shape(b, arg(coll, 0), by) || text_key(b, arg(coll, 0), by)) { let key = b.t.ty(arg(coll, 0), span); *at = as_type(std::mem::replace(at, Expr::undefined()), key); @@ -393,12 +400,21 @@ fn lookup_ty<'tcx>(b: &Body<'_, '_, 'tcx>, std: Std, call: &Call<'tcx>, owner: & } /// Whether a key of type `by` is a JS value that hashes, compares, and orders as one of -/// type `key` does: the same type through references and boxes, or a string either way. +/// type `key` does: the same type through references and boxes, or text either way, a JS +/// string or an `rs.String`, which the runtime's string functions take both of. fn same_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { let tcx = b.t.tcx; let (key, by) = (peel(b, key), peel(b, by)); - tcx.erase_and_anonymize_regions(key) == tcx.erase_and_anonymize_regions(by) - || (library::string(tcx, key) && library::string(tcx, by)) + let text = |ty| library::string(tcx, ty) || library::owned_string(tcx, ty); + tcx.erase_and_anonymize_regions(key) == tcx.erase_and_anonymize_regions(by) || (text(key) && text(by)) +} + +/// Whether a key of type `by` is a JS string that finds a `key` that is a `String` or a +/// `Cow`, an object. +fn text_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { + let tcx = b.t.tcx; + let key = peel(b, key); + (library::owned_string(tcx, key) || library::cow_str(tcx, key)) && library::string(tcx, peel(b, by)) } /// Whether a key of type `by` is a slice or an array that finds a `key` that is a `Vec`, @@ -1066,8 +1082,8 @@ fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span }; let mut values = vec![hash_fn(b, key, hasher, span), eq_fn(b, key, span)]; // A fieldless enum is a JS string, and a bound value may be any primitive, which its - // own `Eq` may tell apart where JS can't, and an owned `Cow` is a string its - // borrowed one equals, as is the `Some` of an `Option` of one, and a `Reverse`, a + // own `Eq` may tell apart where JS can't, and a `String` and an owned `Cow` are + // objects a `str` equals, as is the `Some` of an `Option` of one, and a `Reverse`, a // `Wrapping`, or a `Saturating` of one. let mut held = peeled; while let Some(inner) = option_of(b, held) @@ -1077,6 +1093,7 @@ fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span held = peel(b, inner); } if library::cow_str(b.t.tcx, held) + || library::owned_string(b.t.tcx, held) || matches!(held.kind(), ty::Adt(adt, _) if fieldless(*adt) || b.t.bound_drops(adt.did()).is_some()) { values.push(Expr::lit("true")); @@ -2436,7 +2453,7 @@ fn default<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Opti .then(|| b.fn_value(default, args, span).call(Vec::new())); }; Some(match std { - Std::String => Expr::Str(String::new()), + Std::String => Expr::rs("stringNew", Vec::new()), Std::Vec if super::byte(arg(coll, 0)) => Expr::New(Box::new(Expr::Rs("ByteVec".into())), Vec::new()), Std::Vec => library::vec_new(false), Std::VecDeque => deque_new(b, coll, span), @@ -2727,6 +2744,7 @@ fn std_key<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { ty::Adt(..) if b.t.std_of(ty).is_some_and(Std::record) => true, ty::Adt(..) => { library::string(b.t.tcx, ty) + || library::owned_string(b.t.tcx, ty) || matches!( b.t.std_of(ty), Some(Std::Ordering | Std::Duration | Std::Location | Std::TryReserveError) @@ -2974,7 +2992,7 @@ pub fn cmp_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, partial: bool, spa // `None` for a NaN: only `PartialOrd`, since a float is no `Ord`. _ if partial && let Some(float) = super::float::Float::of(ty) => Expr::rs_of(float.name(), "partialCmp"), ty::Str => Expr::Rs("cmpStr".into()), - ty::Adt(..) if library::string(tcx, ty) => Expr::Rs("cmpStr".into()), + ty::Adt(..) if library::string(tcx, ty) || library::owned_string(tcx, ty) => Expr::Rs("cmpStr".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rs("cmp".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationCmp".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationCmp".into()), @@ -3055,6 +3073,7 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr ty::Adt(..) if library::string(tcx, ty) || matches!(b.t.std_of(ty), Some(Std::Ordering | Std::ErrorKind)) => { Expr::Rs("same".into()) } + ty::Adt(..) if library::owned_string(tcx, ty) => Expr::Rs("eqStr".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationEq".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationEq".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::TryReserveError) => Expr::Rs("tryReserveErrorEq".into()), @@ -3073,6 +3092,8 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr eq => Expr::rs("eqOption", [eq].into_iter().chain(b.t.none_arg(inner)).collect()), }, ty::Adt(..) if let Some(inner) = reverse_of(b, ty).or_else(|| overflowing_of(b, ty)) => eq_fn(b, inner, span), + // An owned `Cow` derefs to its `rs.String`, which `eqStr` reads. + ty::Adt(..) if library::cow_str(tcx, ty) => Expr::Rs("eqStr".into()), ty::Adt(..) if let Some(borrowed) = cow_of(b, ty) => Expr::rs("cowBy", vec![eq_fn(b, borrowed, span)]), ty::Adt(..) if let Some(bound) = range_of(b, ty) => Expr::rs("rangeEq", vec![eq_fn(b, bound, span)]), // A slice compares its elements by `!=`, as a deque does each of its halves. @@ -3286,7 +3307,7 @@ fn hash_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, hasher: Ty<'tcx>, spa .into(), ), ty::Str => Expr::Rs("hashStr".into()), - ty::Adt(..) if library::string(tcx, ty) => Expr::Rs("hashStr".into()), + ty::Adt(..) if library::string(tcx, ty) || library::owned_string(tcx, ty) => Expr::Rs("hashStr".into()), // Its derived `Hash` writes its `i8` discriminant. ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rs("hashI8".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationHash".into()), diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 01a0228b8..d7fbb75e3 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -204,12 +204,8 @@ impl<'tcx> Body<'_, '_, 'tcx> { if !matches!(std, Some(Std::String | Std::Formatter)) && !self.t.translated(write_str, wargs) { return None; } - // A JS string can't change in place, so the place the `&mut` is gets a longer one. if std == Some(Std::String) { - let read = receiver.member("v"); - let (value, result) = self.string_write(name, read.clone(), arg, literal, out); - out.push(StmtKind::Expr(read.assign(value)).at(None)); - return Some(result); + return Some(self.string_write(name, receiver, arg, literal, out)); } // The crate's impl writes this method itself. if self.t.translated(def_id, wargs) { @@ -263,27 +259,18 @@ impl<'tcx> Body<'_, '_, 'tcx> { Some(self.call_def(write_str, wargs, vec![receiver, text], span, out)) } - /// `fmt::Write`'s `name` of a `String` whose value `read` reads, writing `arg`, a - /// `fmt::Arguments` whose only piece is `literal` if it is one: the longer string and - /// what the call returns. What a placeholder wrote before an error stays written. - pub fn string_write( - &mut self, - name: &str, - read: Expr, - arg: Expr, - literal: Option, - out: &mut Vec, - ) -> (Expr, Expr) { - let ok = Expr::Rs("OK".into()); - match (name, literal) { - ("write_char", _) => (read.binary("+", library::char_text(arg)), ok), - ("write_fmt", Some(s)) => (read.binary("+", Expr::Str(s)), ok), - ("write_fmt", None) => { - let written = self.spill(Expr::rs("fmtWriteString", vec![read, arg]), "written", out); - (written.clone().member("s"), written.member("result")) - } - _ => (read.binary("+", arg), ok), - } + /// `fmt::Write`'s `name` of the `String` `s`, writing `arg`, a `fmt::Arguments` whose only + /// piece is `literal` if it is one, in place: what the call returns. What a placeholder + /// wrote before an error stays written. + pub fn string_write(&mut self, name: &str, s: Expr, arg: Expr, literal: Option, out: &mut Vec) -> Expr { + let pushed = match (name, literal) { + ("write_char", _) => Expr::rs("stringPush", vec![s, arg]), + ("write_fmt", Some(text)) => Expr::rs("stringPushStr", vec![s, Expr::Str(text)]), + ("write_fmt", None) => return Expr::rs("fmtWriteString", vec![s, arg]), + _ => Expr::rs("stringPushStr", vec![s, arg]), + }; + out.push(StmtKind::Expr(pushed).at(None)); + Expr::Rs("OK".into()) } } @@ -480,8 +467,8 @@ pub fn std_impl<'tcx>( e } ty::Adt(adt, args) => match (Std::of(tcx, adt.did())?, tr) { - (Std::String, Trait::Display) => Expr::rs("fmtPad", vec![f, value]), - (Std::String, Trait::Debug) => rs("str", vec![value, f]), + (Std::String, Trait::Display) => Expr::rs("fmtPad", vec![f, value.member("v")]), + (Std::String, Trait::Debug) => rs("str", vec![value.member("v"), f]), // A `NonZero`, a `Wrapping`, and a `Saturating` write their integer, by each trait. (Std::Box | Std::NonZero | Std::Wrapping | Std::Saturating, _) => { b.fmt_call(tr, args.type_at(0), value, f, span) diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 0f9bdd8cb..c69694909 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1098,6 +1098,14 @@ pub fn call<'tcx>( }; let iter = iter_of(b.t, source)?; let items = into_iter(b, source, value, span)?; + // Text of an array of `&str`s, which std's reserves for at once. + if str_array(source) && library::textual(b.t.tcx, targ(0)?) { + let s = Expr::rs("stringExtendArray", vec![Expr::rs("stringNew", vec![]), items]); + return Some(match b.t.std_of(targ(0)?) { + Some(Std::Box) => s.member("v"), + _ => s, + }); + } let trusted = implements(b.t, iter, "TrustedLen"); return collect(b, targ(0)?, targ(1)?, items, iter, trusted, span); } @@ -2146,18 +2154,21 @@ fn collect<'tcx>( } }) } - // From chars or text, as `extend` of an empty one, but for an owned string's, which - // the rest extend once `next` gives it. A `Cow` and a `Box` own the `String` - // std's collects. + // From chars or text, as `extend` of `String::new`, but for an owned string's, which + // the rest extend once `next` gives it. A `Cow` owns the `String` std's collects, + // and a `Box` is its text. Std::String | Std::Cow | Std::Box if std == Std::String || args.types().next().is_some_and(|t| t.is_str()) => { - match b.t.std_of(item) { + let s = match b.t.std_of(item) { Some(Std::String | Std::Cow) => { let drops = iter_drops(b, from, span); - let texts = texts(b.t, iter, item); - Some(Expr::rs("stringFromStrings", tail(vec![texts], vec![drops]))) + Expr::rs("stringFromStrings", tail(vec![iter], vec![drops])) } - _ => string_extend(b, Expr::Str(String::new()), iter, item, from, span), - } + _ => string_extend(b, Expr::rs("stringNew", vec![]), iter, item, from, span)?, + }; + Some(match std { + Std::Box => s.member("v"), + _ => s, + }) } _ => super::collections::collect(b, ty, iter, from, trusted, span), } @@ -2188,6 +2199,11 @@ fn shunt<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>, item: Ty<'tcx>, from: Ty< sig.inputs().first()?.tuple_fields().first().copied() } +/// Whether `ty` is an array of `&str`s, whose bytes `String`'s `Extend` reserves at once. +pub(super) fn str_array(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Array(elem, _) if elem.is_ref() && elem.peel_refs().is_str()) +} + /// `s` extended by `items`, an iterator of type `iter` of `item`s, as `String`'s `Extend` /// reads it, by `for_each`: of chars, through any `&`, or of text, a `&str`, `String`, /// `Box`, or `Cow`. @@ -2205,15 +2221,7 @@ pub(super) fn string_extend<'tcx>( "stringExtendChars" }; let drops = iter_drops(b, iter, span); - Some(Expr::rs(extend, tail(vec![s, texts(b.t, items, item)], vec![drops]))) -} - -/// `items`, an iterator of `item`s, as one of the strings they are: a `Cow`'s text. -fn texts<'tcx>(t: &Translator<'_, 'tcx>, items: Expr, item: Ty<'tcx>) -> Expr { - match library::cow_str(t.tcx, item.peel_refs()) { - true => Expr::rs("iterMap", vec![items, Expr::Rs("strCowStr".into())]), - false => items, - } + Some(Expr::rs(extend, tail(vec![s, items], vec![drops]))) } /// Whether a `String` extends by `item`s of text, a `&str`, `String`, `Box`, or diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 1f2551563..0007b977f 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -485,38 +485,45 @@ pub fn empty_default(tcx: TyCtxt<'_>, ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Adt(adt, _) if empty_iter(tcx, adt.did()) || list_iter(tcx, adt.did())) } -/// Whether a `ty`'s value is a JS string: a `str`, a `String`, or a `Box`. +/// Whether a `ty`'s value is a JS string: a `str` or a `Box`. pub fn string<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { match ty.kind() { ty::Str => true, - ty::Adt(adt, args) => match Std::of(tcx, adt.did()) { - Some(Std::String) => true, - Some(Std::Box) => args.type_at(0).is_str(), - _ => false, - }, + ty::Adt(adt, args) => Std::of(tcx, adt.did()) == Some(Std::Box) && args.type_at(0).is_str(), _ => false, } } +/// Whether `ty` is a `String`: an `rs.String`, whose text is its `v`. +pub fn owned_string<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { + matches!(ty.kind(), ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::String)) +} + /// Whether `ty` is a `Cow`: an `rs.StrCow`, the string it owns or the `rs.Borrowed` /// one it borrows. pub fn cow_str<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { cow_borrowed(tcx, ty).is_some_and(|t| t.is_str()) } -/// Whether `ty` is text: a JS string, or a `Cow`, which [`text`] reads as one. +/// Whether `ty` is text: a JS string, a `String`, or a `Cow`, which [`text`] reads as one. pub fn textual<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { - string(tcx, ty) || cow_str(tcx, ty) + string(tcx, ty) || owned_string(tcx, ty) || cow_str(tcx, ty) } -/// `value`, of type `ty`, as the JS string it is or, for a `Cow`, derefs to. +/// `value`, of type `ty`, as the JS string it is or, for a `String` or a `Cow`, derefs to. pub fn text<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, value: Expr) -> Expr { - match cow_str(tcx, ty) { - true => Expr::rs("strCowStr", vec![value]), - false => value, + match () { + _ if cow_str(tcx, ty) => Expr::rs("strCowStr", vec![value]), + _ if owned_string(tcx, ty) => value.member("v"), + _ => value, } } +/// A `String` of `text`, a JS string, with room for exactly its bytes, as `to_owned` makes one. +pub fn string_from(text: Expr) -> Expr { + Expr::rs("stringFrom", vec![text]) +} + /// What a value of `ty` is in JS if `ty` wraps one value it is represented as: `Reverse`'s, /// `NonZero`'s, `Wrapping`'s, `Saturating`'s, and `AssertUnwindSafe`'s `T`, which /// differ only in their order, range, arithmetic, and unwind safety, a pattern type's base, @@ -1570,32 +1577,31 @@ fn mapping<'tcx>( if to == from || some { return Some(value); } - // One between strings keeps the text, and a `&mut str` is the `rs.Place` of its text. - if string(tcx, to) && string(tcx, from.peel_refs()) { - return Some(b.t.pointee_value(targ(gargs, 1), value)); - } - // A `Cow` borrows the text a reference does and owns a `String`, and gives up - // its text. - if cow_str(tcx, to) && string(tcx, from.peel_refs()) { - let owned = rustc_abi::VariantIdx::from_u32((!targ(gargs, 1).is_ref()).into()); - return Some(cow_made( - tcx.types.str_, - owned, - b.t.pointee_value(targ(gargs, 1), value), - )); - } - if string(tcx, to) && cow_str(tcx, from) { - return Some(text(tcx, from, value)); + // Text into text: a `&mut str` is the `rs.Place` of its text, as a `String` is. + let (raw, peeled) = (targ(gargs, 1), from); + if textual(tcx, to) && textual(tcx, peeled) { + let value = b.t.pointee_value(targ(gargs, 1), value); + return Some(match () { + // A `String` the `Cow` owns, or one it borrows, or a clone of one. + _ if owned_string(tcx, to) && cow_str(tcx, raw) => Expr::rs("strCowIntoOwned", vec![value]), + _ if owned_string(tcx, to) && owned_string(tcx, peeled) => Expr::rs("stringClone", vec![value]), + _ if owned_string(tcx, to) => string_from(text(tcx, peeled, value)), + // A `Cow` owns a `String` and borrows what a reference does. + _ if cow_str(tcx, to) && !raw.is_ref() && owned_string(tcx, raw) => { + cow_made(tcx.types.str_, rustc_abi::VariantIdx::from_u32(1), value) + } + _ if cow_str(tcx, to) => cow_made(tcx.types.str_, rustc_abi::FIRST_VARIANT, text(tcx, peeled, value)), + // A `Box` is its text, a `String`'s once it shrinks to fit. + _ => text(tcx, peeled, value), + }); } - // A `Vec` of a `String`'s or a `&str`'s UTF-8. - if b.t.std_of(to) == Some(Std::Vec) && string(tcx, from.peel_refs()) { - if !from.is_ref() { - b.t.string_bytes(); - } - return Some(Expr::rs( - "stringIntoBytes", - vec![b.t.pointee_value(targ(gargs, 1), value)], - )); + // A `Vec` of a `String`'s UTF-8, with its capacity, or of a `&str`'s. + if b.t.std_of(to) == Some(Std::Vec) && textual(tcx, peeled) { + let value = b.t.pointee_value(targ(gargs, 1), value); + return Some(match !raw.is_ref() && owned_string(tcx, raw) { + true => Expr::rs("stringIntoBytes", vec![value]), + false => Expr::rs("strToBytes", vec![text(tcx, peeled, value)]), + }); } // A `Vec` is owned, and a reference to a slice, an array, or a `Vec` borrows its slice. if let Some(elem) = cow_slice(tcx, to) { @@ -1852,6 +1858,7 @@ fn mapping<'tcx>( Expr::rs("byteVecFrom", vec![Expr::rs("byteVecView", vec![value])]) } ty::Adt(..) if string(tcx, ty) => value, + ty::Adt(..) if owned_string(tcx, ty) => Expr::rs("stringClone", vec![value]), ty::Adt(..) if cow_str(tcx, ty) => Expr::rs("strCowClone", vec![value]), ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) => { return Some(vec_clone(b, value.member("items"), args.type_at(0), span)); @@ -2693,6 +2700,8 @@ fn mapping<'tcx>( match ty.kind() { ty::Adt(adt, vargs) => match Std::of(tcx, adt.did()) { Some(Std::Vec) => vec_view(v, vargs.type_at(0)), + // A `String` is the place of its text, as a `&mut str` of it is. + Some(Std::String) if name == "deref" => v.member("v"), Some(Std::String | Std::Box | Std::ManuallyDrop | Std::AssertUnwindSafe) => v, Some(Std::Cow) if let Some(borrowed) = cow_borrowed(tcx, ty) => cow_deref(v, borrowed), // The greatest element of a heap, which `DerefMut` marks to sift once lent. @@ -2714,19 +2723,15 @@ fn mapping<'tcx>( // Strings. // A `Box`'s bytes are their own, as `as_bytes` gives them. - ("String" | "str", "as_bytes") | ("str", "into_boxed_bytes") => Expr::rs("stringAsBytes", args), + ("String", "as_bytes") => Expr::rs("stringAsBytes", vec![args.pop()?.member("v")]), + ("str", "as_bytes" | "into_boxed_bytes") => Expr::rs("stringAsBytes", args), ("String", "from_utf8") => Expr::rs("stringFromUtf8", args), - ("String", "into_bytes") => { - b.t.string_bytes(); - Expr::rs("stringIntoBytes", args) - } + // Its bytes, with its capacity, as the vector it is. + ("String", "into_bytes") => Expr::rs("stringIntoBytes", args), ("String", "from_utf8_lossy") => Expr::rs("stringFromUtf8Lossy", args), // UTF-8 by their contract, which the lossy decoder reads as the text. ("converts" | "str", "from_utf8_unchecked") => Expr::rs("strFromUtf8Unchecked", args), - ("String", "from_utf8_unchecked") => Expr::rs( - "strFromUtf8Unchecked", - vec![Expr::rs("byteVecSlice", vec![args.pop()?])], - ), + ("String", "from_utf8_unchecked") => Expr::rs("stringFromUtf8Unchecked", args), ("FromUtf8Error", "as_bytes") => Expr::rs("byteVecSlice", vec![args.pop()?.member("bytes")]), ("FromUtf8Error", "into_bytes") => args.pop()?.member("bytes"), ("FromUtf8Error", "utf8_error") => args.pop()?.member("error"), @@ -2741,15 +2746,16 @@ fn mapping<'tcx>( ("converts" | "str", "from_utf8") => Expr::rs("strFromUtf8", args), ("Utf8Error", "valid_up_to") => args.pop()?.member("validUpTo"), ("Utf8Error", "error_len") => args.pop()?.member("errorLen"), - ("String" | "str", "len") => Expr::rs("stringLen", args), - // A `Box` is its text, as a `String` is. - ("String", "as_str" | "into_boxed_str") | ("str", "into_string") => args.pop()?, - ("String", "new") => Expr::Str(String::new()), - // `String + &str`, which pushes onto the moved text as `+=` does. - ("Add", "add") if string(tcx, targ(gargs, 0)) => { - let text = args.pop()?; - args.pop()?.binary("+", text) - } + ("String", "len") => args.pop()?.member("len"), + ("String", "capacity") => args.pop()?.member("cap"), + ("str", "len") => Expr::rs("stringLen", args), + // A `Box` is its text, as a `String`'s is once it shrinks to fit, and a `String` + // of one has room for exactly its bytes. + ("String", "as_str" | "into_boxed_str") => args.pop()?.member("v"), + ("str", "into_string") => string_from(args.pop()?), + ("String", "new") => Expr::rs("stringNew", vec![]), + // `String + &str`, which pushes onto the moved `String` as `+=` does. + ("Add", "add") if owned_string(tcx, targ(gargs, 0)) => Expr::rs("stringAdd", args), ("Add", "add") if cow_str(tcx, targ(gargs, 0)) => { let rhs = str_cow(tcx, targ(gargs, 1), args.pop()?); Expr::rs("strCowAdd", vec![args.pop()?, rhs]) @@ -2763,7 +2769,7 @@ fn mapping<'tcx>( true => s, false => b.spill(s, "s", out), }; - let len = Expr::rs("stringLen", vec![s.clone().member("v")]); + let len = s.clone().member("len"); return Some(Expr::rs("stringDrain", vec![s, ranged.within(len)])); } ("Drain", "as_str") => Expr::rs("stringDrainAsStr", args), @@ -2774,7 +2780,8 @@ fn mapping<'tcx>( } // A `char`'s steps through its chars by `&mut`, which no body of std's may. ("str", "parse") | ("FromStr", "from_str") if targ(gargs, 0).is_char() => Expr::rs("charFromStr", args), - ("String" | "str", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("String", "is_empty") => args.pop()?.member("len").binary("===", Expr::lit("0")), + ("str", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), ("str", "chars") => Expr::rs("strChars", args), ("str", "bytes") => Expr::rs("strBytes", args), ("str", "is_char_boundary") => Expr::rs("strIsCharBoundary", args), @@ -2790,12 +2797,18 @@ fn mapping<'tcx>( let [s, n, p] = <[Expr; 3]>::try_from(args).ok()?; Expr::rs_of("str", &name).call(vec![s, n, pattern(b.t, targ(gargs, 0), p)?]) } - // `replacen`'s count follows what replaces each match. + // `replacen`'s count follows what replaces each match. std's `replace` reserves by + // the pattern's length if it is a `char`, a `&str`, or a `&String`. ("str", "replace" | "replacen") => { + let p = targ(gargs, 0); let mut args = args.into_iter(); - let (s, p) = (args.next()?, args.next()?); - let rest = args.collect::>(); - Expr::rs("strReplace", [vec![s, pattern(b.t, targ(gargs, 0), p)?], rest].concat()) + let (s, pat) = (args.next()?, args.next()?); + let mut values = [vec![s, pattern(b.t, p, pat)?], args.collect()].concat(); + if name == "replace" { + let utf8 = p.is_char() || matches!(p.kind(), ty::Ref(_, t, _) if t.is_str() || owned_string(tcx, *t)); + values.push(Expr::lit(utf8.to_string())); + } + Expr::rs(if name == "replace" { "strReplace" } else { "strReplacen" }, values) } // Searches by whitespace, as std's are by `char::is_whitespace`. ("char", "is_whitespace") => Expr::rs("charIsWhitespace", args), @@ -2857,11 +2870,18 @@ fn mapping<'tcx>( ) | ("slice", "escape_ascii" | "make_ascii_uppercase" | "make_ascii_lowercase") => { let of = if owner == "slice" { "byteSlice" } else { "str" }; - Expr::rs_of(of, &super::camel(&name)).call(args) + let value = Expr::rs_of(of, &super::camel(&name)).call(args); + // A copy of the bytes, as `to_vec` makes it. + match (owner.as_str(), name.as_str()) { + ("str", "to_ascii_uppercase" | "to_ascii_lowercase") => string_from(value), + _ => value, + } + } + // The `String` a `Cow` owns, or one of the text it borrows. + ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rs("strCowIntoOwned", args), + ("AsRef", "as_ref") if textual(tcx, targ(gargs, 0)) && !cow_str(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => { + text(tcx, targ(gargs, 0), args.pop()?) } - // A `Cow`'s text, whichever variant holds it. - ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rs("strCowStr", args), - ("AsRef", "as_ref") if string(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => args.pop()?, // A `Cow<[T]>` borrows its slice, and its `Vec` is its own or a clone of what it // borrows, so it drops nothing. ("Cow", "into_owned") if let ty::Slice(elem) = targ(gargs, 0).kind() => { @@ -2870,8 +2890,11 @@ fn mapping<'tcx>( ("AsRef", "as_ref") | ("Borrow", "borrow") if let Some(borrowed) = cow_borrowed(tcx, targ(gargs, 0)) => { cow_deref(args.pop()?, borrowed) } - ("ToString", "to_string") | ("ToOwned", "to_owned") if matches!(self_ty()?.peel_refs().kind(), ty::Str) => { - b.t.pointee_value(self_ty()?, args.pop()?) + // A `String` with room for exactly its bytes, as `str`'s `to_owned` makes it, and its + // `to_string`, through as many references as std's impls name. + ("ToOwned", "to_owned") if self_ty()?.is_str() => string_from(args.pop()?), + ("ToString", "to_string") if self_ty()?.peel_refs().is_str() && refs(self_ty()?) <= 12 => { + string_from(b.t.pointee_value(self_ty()?, args.pop()?)) } // std's `ToOwned` for a `T: Clone` is its `clone`. ("ToOwned", "to_owned") if self_ty()?.is_sized(tcx, b.t.typing_env_pub()) => { @@ -2899,8 +2922,11 @@ fn mapping<'tcx>( ) { (true, true) => { let at = b.panic_at.clone().unwrap_or_else(Expr::undefined); - Expr::rs("panic", vec![args.pop()?, at, Expr::lit(owned.to_string())]) + let text = args.pop()?; + let text = if owned { text.member("v") } else { text }; + Expr::rs("panic", vec![text, at, Expr::lit(owned.to_string())]) } + (true, false) if owned => Expr::rs("panic", vec![args.pop()?.member("v")]), (true, false) => Expr::rs("panic", args), (false, true) => { let class = b.t.object_class( @@ -3050,10 +3076,11 @@ fn mapping<'tcx>( _ => Expr::rs("arrayFrom", vec![a]), } } + // Text alone is `to_owned`, as std's `as_str` gives it. ("fmt", "format") => { let parts = args.pop()?; match literal(&parts) { - Some(s) => Expr::Str(s), + Some(s) => string_from(Expr::Str(s)), None => Expr::rs("fmtFormat", vec![parts]), } } @@ -3083,16 +3110,28 @@ fn mapping<'tcx>( _ => return None, } } + // std's own for a `String` and a `Cow`, and for a `char`, a `bool`, and an + // unsigned integer, have room for exactly their bytes, and for a signed integer, for + // its most digits and a sign if it has one; `fmt::Arguments`' is `format`. Any other + // grows by what its `Display` writes. ("ToString", "to_string") => { let ty = targ(gargs, 0); let value = args.pop()?; - match ty.kind() { - ty::Adt(..) if textual(tcx, ty) => text(tcx, ty, value), - _ => { - let value = b.fmt_value(fmt::Trait::Display, ty, value, span, out); - Expr::rs("fmtToString", vec![value]) - } - } + let size = match ty.kind() { + ty::Adt(..) if textual(tcx, ty) && !string(tcx, ty) => return Some(string_from(text(tcx, ty, value))), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Arguments) => return Some(Expr::rs("fmtFormat", vec![value])), + ty::Char | ty::Bool | ty::Uint(_) => Some(0), + ty::Int(int) => Some(match int.bit_width().unwrap_or(32) { + 8 => 3, + 16 => 5, + 32 => 10, + 64 => 19, + _ => 39, + }), + _ => None, + }; + let value = b.fmt_value(fmt::Trait::Display, ty, value, span, out); + Expr::rs("fmtToString", [vec![value], size.map(|n: u32| Expr::lit(n.to_string())).into_iter().collect()].concat()) } // `fmt::Write`'s, of a `String`, a `Formatter`, or the crate's own writer. ("Write", "write_str" | "write_char" | "write_fmt") @@ -3306,6 +3345,13 @@ fn std_clone_from<'tcx>( format!("`clone_from` of `{ty}`, whose `clone_from` is its own, which is not supported yet"), ) }; + // A `String`'s bytes clone into its buffer, as an owned `Cow`'s do over an owned one's. + if owned_string(b.t.tcx, own) { + return Ok(("stringCloneFrom", vec![])); + } + if cow_str(b.t.tcx, own) { + return Ok(("strCowCloneFrom", vec![])); + } // A `Cow<[T]>`'s: an owned one's `Vec` clones into itself over an owned one's. if let Some(elem) = cow_slice(b.t.tcx, own) { return Ok(match elem.kind() { @@ -3407,10 +3453,12 @@ pub(super) fn clone_from_clones<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx> } let inner: Vec> = match (t.std_of(ty), ty.kind()) { (Some(Std::Vec | Std::VecDeque | Std::BinaryHeap), _) => return false, - // A hash table's and a B-tree set's clone each element anew, by its `clone`. Text is - // a JS string, which keeps no buffer. + // A hash table's and a B-tree set's clone each element anew, by its `clone`. A `String` + // keeps its buffer, as an owned `Cow`'s does, and a `Box` is a JS string. (Some(Std::HashMap | Std::HashSet | Std::HashTable | Std::BTreeSet), _) => vec![], - _ if textual(tcx, ty) => vec![], + (Some(Std::String), _) => return false, + _ if cow_str(tcx, ty) => return false, + _ if string(tcx, ty) => vec![], (_, ty::Adt(adt, args)) if is_std(tcx, adt.did()) => args.types().collect(), (_, ty::Array(elem, _)) => vec![*elem], _ => return false, @@ -3594,7 +3642,10 @@ fn pattern<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>, p: Expr) -> Option { Some(p) } - ty::Ref(..) if is_text(t, ty) => Some(p), + ty::Ref(..) if is_text(t, ty) => Some(match owned_string(t.tcx, ty.peel_refs()) { + true => p.member("v"), + false => p, + }), // Any of the chars of an array or slice. ty::Array(c, _) | ty::Slice(c) if c.is_char() => Some(Expr::rs("patternChars", vec![elements(p, ty)])), ty::Ref(_, inner, _) if matches!(inner.kind(), ty::Array(c, _) | ty::Slice(c) if c.is_char()) => { @@ -3640,6 +3691,16 @@ pub fn char_text(c: Expr) -> Expr { Expr::ident("String").member("fromCodePoint").call(vec![c]) } +/// How many references `ty` is through. +fn refs(mut ty: Ty<'_>) -> usize { + let mut n = 0; + while let ty::Ref(_, inner, _) = ty.kind() { + ty = *inner; + n += 1; + } + n +} + /// `rs.(args)`. fn rt2(args: Vec, of: &str, name: &str) -> Expr { Expr::rs_of(of, name).call(args) @@ -4096,9 +4157,9 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, ty::Adt(adt, args) => match Std::of(tcx, adt.did())? { Std::Option => b.t.none(args.type_at(0)), Std::Vec => vec_new(byte(args.type_at(0))), - Std::String => Expr::Str(String::new()), + Std::String => Expr::rs("stringNew", vec![]), // An owned empty `String` or `Vec`. - Std::Cow if cow_str(tcx, ty) => Expr::Str(String::new()), + Std::Cow if cow_str(tcx, ty) => Expr::rs("stringNew", vec![]), Std::Cow if let Some(elem) = cow_slice(tcx, ty) => vec_new(byte(elem)), Std::Duration => super::time::zero(), Std::Atomic => Expr::New( diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 1b191915d..c26ae4214 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -714,20 +714,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ); done(next, true) } - // A JS string can't change in place, so what the `&mut` borrows gets a new one. + // A `String` is an object, which each of its own steps edits in place. ("String", "push" | "push_str") | ("AddAssign", "add_assign") if owner == "String" - || (targ(0).is_some_and(|t| library::string(tcx, t)) && !self.b.t.translated(def_id, gargs)) => + || (targ(0).is_some_and(|t| library::owned_string(tcx, t)) + && !self.b.t.translated(def_id, gargs)) => { - let place = self.borrowed_place(&args[0].node, span, out)?; - let text = self.operand(&args[1].node, span, out); - let text = match name.as_str() { - "push" => library::char_text(text), - _ => text, - }; - let pushed = place.0.clone().binary("+", text); - self.set_borrowed(&place, pushed, span, out); - done(Expr::undefined(), false) + let values = self.operands(false, &[], args, tcx.types.unit, span, out); + let f = if name == "push" { "stringPush" } else { "stringPushStr" }; + done(Expr::rs(f, values), true) } ("AddAssign", "add_assign") if targ(0).is_some_and(|t| library::cow_str(tcx, t)) && !self.b.t.translated(def_id, gargs) => @@ -740,7 +735,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { done(Expr::undefined(), false) } // What the `&mut` borrows gets the value of the other case, as a byte, a char, and a - // JS string can't change in place. + // JS string can't change in place, and the case of ASCII keeps its length. ("u8" | "char" | "str", "make_ascii_uppercase" | "make_ascii_lowercase") => { let place = self.borrowed_place(&args[0].node, span, out)?; let to = crate::lower::camel(&name.replacen("make", "to", 1)); @@ -752,37 +747,36 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.set_borrowed(&place, changed, span, out); done(Expr::undefined(), false) } - // The extended string, from the iterator read as std's `Extend` reads it. + // The string extended, by the iterator read as std's `Extend` reads it. ("Extend", "extend") if targ(0).is_some_and(|t| self.b.t.std_of(t) == Some(Std::String)) => { let (item, source) = (targ(1)?, targ(2)?); - let place = self.borrowed_place(&args[0].node, span, out)?; + let s = self.operand(&args[0].node, span, out); let items = self.operand(&args[1].node, span, out); let iter = crate::lower::iter::iter_of(self.b.t, source)?; let items = crate::lower::iter::into_iter(self.b, source, items, span)?; - let extended = crate::lower::iter::string_extend(self.b, place.0.clone(), items, item, iter, span)?; - self.set_borrowed(&place, extended, span, out); - done(Expr::undefined(), false) + if crate::lower::iter::str_array(source) { + return done(Expr::rs("stringExtendArray", vec![s, items]), true); + } + done(crate::lower::iter::string_extend(self.b, s, items, item, iter, span)?, true) } - // No capacity is kept, and reading one is refused, but reserving past `isize::MAX` - // panics as std's does. - ("String", "reserve" | "reserve_exact") => { - let values = self.operands(false, &[true, true], args, tcx.types.unit, span, out); - done(Expr::rs("stringReserve", values), true) + ("String", "reserve" | "reserve_exact" | "try_reserve" | "try_reserve_exact") => { + let values = self.operands(false, &[], args, tcx.types.unit, span, out); + done(Expr::rs_of("string", &crate::lower::camel(&name)).call(values), true) } - // The error where `reserve` panics. - ("String", "try_reserve" | "try_reserve_exact") => { - let values = self.operands(false, &[true, true], args, tcx.types.unit, span, out); - done(Expr::rs("stringTryReserve", values), false) + ("String", "shrink_to_fit" | "shrink_to") => { + let mut values = self.operands(false, &[], args, tcx.types.unit, span, out); + if name == "shrink_to_fit" { + values.push(Expr::lit("0")); + } + done(Expr::rs("stringShrinkTo", values), true) } - ("String", "shrink_to_fit" | "shrink_to") => done(Expr::undefined(), false), - // The edited string, from the runtime with what it takes after the string. + // The string edited in place, by the runtime with what it takes after the string. ( "String", "clear" | "truncate" | "insert" | "insert_str" | "retain" | "replace_range" | "extend_from_within", ) => { - let place = self.borrowed_place(&args[0].node, span, out)?; let result = dest.ty(&self.mir.local_decls, tcx).ty; - let mut values = vec![place.0.clone()]; + let mut values = vec![self.operand(&args[0].node, span, out)]; values.extend(self.operands(false, &[], &args[1..], result, span, out)); if name == "insert" { let c = values.pop()?; @@ -808,35 +802,31 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span, }; let range = std::mem::replace(&mut values[1], Expr::undefined()); - let len = Expr::rs("stringLen", vec![values[0].clone()]); + let len = values[0].clone().member("len"); values[1] = crate::lower::collections::bounds(self.b, &call, range).within(len); } - let edited = match name.as_str() { - "clear" => Expr::Str(String::new()), - "truncate" => Expr::rs("stringTruncate", values), - "insert" | "insert_str" => Expr::rs("stringInsertStr", values), - "retain" => Expr::rs("stringRetain", values), - "replace_range" => Expr::rs("stringReplaceRange", values), - _ => Expr::rs("stringExtendFromWithin", values), + let f = match name.as_str() { + "clear" => "stringClear", + "truncate" => "stringTruncate", + "insert" | "insert_str" => "stringInsertStr", + "retain" => "stringRetain", + "replace_range" => "stringReplaceRange", + _ => "stringExtendFromWithin", }; - self.set_borrowed(&place, edited, span, out); + out.push(StmtKind::Expr(Expr::rs(f, values)).at(None)); out.extend(spent.map(|drop| StmtKind::Expr(drop).at(None))); done(Expr::undefined(), false) } - // The runtime gives the edited string and what the edit returns. ("String", "pop" | "remove" | "split_off") => { - let place = self.borrowed_place(&args[0].node, span, out)?; let result = dest.ty(&self.mir.local_decls, tcx).ty; - let mut values = vec![place.0.clone()]; + let mut values = vec![self.operand(&args[0].node, span, out)]; values.extend(self.operands(false, &[], &args[1..], result, span, out)); let f = match name.as_str() { "pop" => "stringPop", "remove" => "stringRemove", _ => "stringSplitOff", }; - let edit = self.path(Expr::rs(f, values), "edit", out); - self.set_borrowed(&place, edit.clone().index(Expr::lit("0")), span, out); - done(edit.index(Expr::lit("1")), false) + done(Expr::rs(f, values), true) } ("Write", "write_str" | "write_char" | "write_fmt") if tcx @@ -867,17 +857,22 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.set_borrowed(&place, value, span, out); done(Expr::undefined(), false) } - // A borrowed `Cow` owns its text first, the `String` it then is, and a `String` - // is its `str`, so the `&mut` borrows the same place. + // A borrowed `Cow` owns its text first, and the `&mut` is the `String` it then is. ("Cow", "to_mut") if targ(0).is_some_and(|t| t.is_str()) => { let place = self.borrowed_place(&args[0].node, span, out)?; - self.set_borrowed(&place, Expr::rs("strCowStr", vec![place.0.clone()]), span, out); - self.same_place(args, dest, span, out) + self.set_borrowed(&place, Expr::rs("strCowIntoOwned", vec![place.0.clone()]), span, out); + done(Expr::As(Box::new(place.0), crate::ts::Type::Rs("String", Vec::new())), false) } - ("String", "as_mut_str") => self.same_place(args, dest, span, out), + // A `String` is the place of its `str`. + ("String", "as_mut_str" | "leak") => done(self.operand(&args[0].node, span, out), false), ("DerefMut", "deref_mut") | ("AsMut", "as_mut") | ("BorrowMut", "borrow_mut") - if targ(0).is_some_and(|t| t.is_str() || self.b.t.std_of(t) == Some(Std::String)) + if targ(0).is_some_and(|t| self.b.t.std_of(t) == Some(Std::String)) && dest.ty(&self.mir.local_decls, tcx).ty.peel_refs().is_str() => + { + done(self.operand(&args[0].node, span, out), false) + } + ("DerefMut", "deref_mut") | ("AsMut", "as_mut") | ("BorrowMut", "borrow_mut") + if targ(0).is_some_and(|t| t.is_str()) && dest.ty(&self.mir.local_decls, tcx).ty.peel_refs().is_str() => { self.same_place(args, dest, span, out) } @@ -890,11 +885,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { self.same_place(args, dest, span, out) } - // A place nothing else holds: the `String` leaked, or `Default`'s empty `str`. - ("String", "leak") => { - let leaked = self.operand(&args[0].node, span, out); - done(Expr::Object(vec![(crate::ts::Key::Name("v".into()), leaked)]), true) - } + // A place nothing else holds: `Default`'s empty `str`. ("Default", "default") if targ(0) .and_then(|t| self.b.t.place_pointee(t)) @@ -1516,16 +1507,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => None, }; if std == Some(Std::String) { - let place = match through { - Some(value) => (self.path(value, "w", out).member("v"), None), - None => self.borrowed_place(&args[0].node, span, out)?, + let s = match through { + Some(value) => value, + None => self.operand(&args[0].node, span, out), }; let [arg] = <[Expr; 1]>::try_from(self.operands(true, &[], &args[1..], result, span, out)).ok()?; let mut written = Vec::new(); - let (value, result) = self.b.string_write(name, place.0.clone(), arg, literal, &mut written); + let result = self.b.string_write(name, s, arg, literal, &mut written); self.emit(written, false, out); - self.set_borrowed(&place, value, span, out); - return done(result, false); + return done(result, true); } let receiver = match through { Some(value) => value, @@ -1842,6 +1832,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if container.is_str() || self.b.t.std_of(container) == Some(Std::String) { let get = matches!(name, "get" | "get_mut"); let base = self.operand(&args[0].node, span, out); + // A `String` is the place of its text. + let base = match self.b.t.std_of(container) == Some(Std::String) && !matches!(name, "index_mut" | "get_mut") { + true => base.member("v"), + false => base, + }; let (base, (start, end)) = match self.range_bounds(&args[1].node, index_ty, span, out) { Some(bounds) if get => (base, bounds), Some(bounds) => (self.path(base, "s", out), bounds), diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 7c76ae280..ce1e242c1 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -636,7 +636,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let bytes = crate::lower::library::cow_slice(tcx, ty).is_some_and(crate::lower::byte); let owned = variant.is_some_and(|v| v.index() == 1); // What an `rs.Borrowed` holds, and what it owns: an `rs.Slice` and an - // `rs.Vec`, or text. + // `rs.Vec`, or text and an `rs.String`. let (held, owns) = match borrowed.kind() { ty::Slice(elem) => { let elem = self.b.t.ty(*elem, span); @@ -645,7 +645,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { crate::ts::Type::Rs("Vec", vec![elem]), ) } - _ => (crate::ts::Type::Builtin("string"), crate::ts::Type::Builtin("string")), + _ => (crate::ts::Type::Builtin("string"), crate::ts::Type::Rs("String", Vec::new())), }; let class = match (bytes, owned) { (true, false) => crate::ts::Type::Rs("ByteSlice", Vec::new()), diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 51e76b99c..23535d95c 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -211,11 +211,6 @@ pub struct Translator<'a, 'tcx> { census: bool, /// Refusals collected until translation settles, then reported or counted. refusals: Option>, - /// Reads of a `Bytes`' capacity, refused once translation settles if `string_bytes`, as - /// [`Self::string_capacity`] notes them. - capacity_reads: Vec<(Span, String)>, - /// Whether a crate makes a `Bytes` or a `Vec` of a `String`'s bytes, whose capacity JS keeps none of. - string_bytes: bool, /// Whether each type's drop does something JS can see, as [`Self::drops`] found. drops: rustc_data_structures::fx::FxHashMap, bool>, /// The types [`Self::drops`] is still deciding, and whether the query open now read one. @@ -443,7 +438,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { && t.comparing.is_subset(&t.compared) && (t.hooked || !t.hooking) { - t.refuse_capacity_reads(); return Some((t, out)); } read = std::mem::take(&mut t.read); @@ -501,8 +495,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { env: TypingEnv::fully_monomorphized(), census, refusals: Some(Vec::new()), - capacity_reads: Vec::new(), - string_bytes: false, drops: Default::default(), drops_open: Default::default(), drops_cycle: false, @@ -658,32 +650,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// Note a `Bytes` or a `Vec` made of a `String`'s bytes, whose capacity JS keeps none - /// of, so every crate is refused what [`Self::string_capacity`] notes: the bytes may - /// reach any of them. - pub fn string_bytes(&mut self) { - self.string_bytes = true; - } - - /// Note `what`, which reads the capacity of a `Bytes`' storage, refused once translation - /// settles if any crate makes a `Bytes` or a `Vec` of a `String`'s bytes. - pub fn string_capacity(&mut self, span: Span, what: &str) { - let msg = format!( - "`{what}` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported" - ); - let read = self.sited(span, msg); - self.capacity_reads.push(read); - } - - fn refuse_capacity_reads(&mut self) { - let reads = std::mem::take(&mut self.capacity_reads); - if self.string_bytes { - for (span, msg) in reads { - self.refuse(span, msg); - } - } - } - fn refuse(&mut self, span: Span, msg: String) { self.failed = true; match &mut self.refusals { @@ -1338,6 +1304,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Adt(..) if let Some(slice) = stock::uninit_slice(self.tcx, ty) => self.object_kind(slice), ty::Adt(adt, args) => match library::Std::of(self.tcx, adt.did()) { Some(library::Std::Vec) => Some(ObjectKind::Vec), + // Its text, length, and capacity, edited in place. + Some(library::Std::String) => Some(ObjectKind::Class), Some( library::Std::Formatter | library::Std::DebugStruct @@ -1699,7 +1667,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { true => Type::Rs("ByteVec", vec![]), false => Type::Rs("Vec", vec![self.ty(args.type_at(0), span)]), }, - library::Std::String => Type::Builtin("string"), + library::Std::String => Type::Rs("String", vec![]), library::Std::Cow if library::cow_str(tcx, Ty::new_adt(tcx, adt, args)) => Type::Rs("StrCow", vec![]), library::Std::Cow if let Some(elem) = library::cow_slice(tcx, Ty::new_adt(tcx, adt, args)) => { match elem.kind() { diff --git a/ts/src/lower/stock.rs b/ts/src/lower/stock.rs index 5829ee101..1ea39dbf3 100644 --- a/ts/src/lower/stock.rs +++ b/ts/src/lower/stock.rs @@ -11,7 +11,7 @@ use rustc_hir::def_id::{CrateNum, DefId}; use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeVisitableExt}; use super::body::Body; -use super::library::{self, Call, Std, key, string, targ}; +use super::library::{self, Call, Std, key, owned_string, string, targ}; use super::num::Int; use crate::ts::{Expr, Stmt, StmtKind}; @@ -341,6 +341,7 @@ fn as_slice<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr) -> Option value, ty::Array(e, _) if is_u8(*e) => Expr::rs("byteSliceFrom", vec![value]), _ if string(b.t.tcx, ty) => Expr::rs("stringAsBytes", vec![value]), + _ if owned_string(b.t.tcx, ty) => Expr::rs("stringAsBytes", vec![value.member("v")]), _ => match b.t.std_of(ty)? { Std::Bytes => value, Std::BytesMut => view(value), @@ -364,11 +365,9 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> let f = match (b.t.std_of(to), b.t.std_of(from)) { (Some(Std::Bytes), Some(Std::BytesMut)) => "bytesMutFreeze", (Some(Std::Bytes), _) if byte_vec(from) => "bytesFromVec", - // A `&'static str`'s bytes are static. A `String`'s are a vector whose capacity is - // their length, as JS keeps none of the `String`'s, so the program's reads of one are refused. + // A `&'static str`'s bytes are static, and a `String`'s are its vector, with its capacity. (Some(Std::Bytes), _) if from.is_ref() && string(tcx, from.peel_refs()) => "stringAsBytes", - (Some(Std::Bytes), _) if string(tcx, from) => { - b.t.string_bytes(); + (Some(Std::Bytes), _) if owned_string(tcx, from) => { let bytes = Expr::rs("stringIntoBytes", args.collect()); return Ok(Some(Expr::rs("bytesFromVec", vec![bytes]))); } @@ -377,18 +376,12 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> (Some(Std::BytesMut), _) => { let bytes = match as_slice(b, from.peel_refs(), args.next().expect("an operand")) { Some(bytes) if from.is_ref() => Expr::rs("bytesMutFrom", vec![bytes]), - Some(bytes) if b.t.std_of(from) == Some(Std::Bytes) => { - b.t.string_capacity(call.span, "BytesMut::from(Bytes)"); - Expr::rs("bytesMutFromBytes", vec![bytes]) - } + Some(bytes) if b.t.std_of(from) == Some(Std::Bytes) => Expr::rs("bytesMutFromBytes", vec![bytes]), _ => return Ok(None), }; return Ok(Some(bytes)); } - (_, Some(Std::Bytes)) if byte_vec(to) => { - b.t.string_capacity(call.span, "Vec::from(Bytes)"); - "bytesToByteVec" - } + (_, Some(Std::Bytes)) if byte_vec(to) => "bytesToByteVec", (_, Some(Std::BytesMut)) if byte_vec(to) => "bytesMutToByteVec", (_, Some(Std::Bytes | Std::BytesMut)) => return Ok(None), _ => return Err(args.collect()), @@ -448,10 +441,6 @@ fn bytes_own<'tcx>( out: &mut Vec, ) -> Option { let tcx = b.t.tcx; - // Whether the storage is unique, and whether truncating gives it up, hinge on its capacity. - if matches!(name, "is_unique" | "try_into_mut" | "truncate" | "clear") { - b.t.string_capacity(call.span, &format!("Bytes::{name}")); - } let mut args = args.into_iter(); Some(match name { "new" => Expr::rs("bytesNew", vec![]), @@ -703,15 +692,6 @@ fn put<'tcx>( // Into a `BytesMut` of no capacity, `bytes` copies it out whole and drops it, then takes // the copy's storage if no other handle holds it, so the runtime drops it there. if buffer == Buffer::BytesMut && !through { - // `bytes`' own puts fill a `BytesMut::with_capacity` of what they put, never one of no capacity. - let file = tcx - .sess - .source_map() - .lookup_source_file(call.span.source_callsite().lo()); - let own = tcx.crate_name(file.cnum).as_str() == "bytes"; - if !own && !matches!(source, Some(Buffer::BytesMut | Buffer::Slice)) { - b.t.string_capacity(call.span, "BufMut::put"); - } let f = match source { Some(Buffer::Bytes) => "bytesMutPutStorage", Some(Buffer::BytesMut) => "bytesMutPutMut", diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index b47fc389f..b07901186 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -624,7 +624,7 @@ import * as closures from "./closures.ts"; import {{ harness }} from {harness:?}; export {{ cases, input, ops }} from {harness:?}; -const fixture = {{ Pending: rs.Pending, u64: {{ of: rs.u64Of }}, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures, closures }}; +const fixture = {{ Pending: rs.Pending, u64: {{ of: rs.u64Of }}, string: rs.stringFrom, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures, closures }}; const script = harness(fixture); export const run = (input: rs.ByteSlice) => script(rs.byteSliceView(input)); "# @@ -820,11 +820,10 @@ fn crates() { snapshot("crates", &out); typecheck(&out); differential(&workspace(), "crates-fixture", &[], &out, "harness.ts", 1_000); - let cases: [(&str, &str, &[&str]); 4] = [ + let cases: [(&str, &str, &[&str]); 3] = [ ("refused", "refused.toml", &[]), ("shared", "ts.toml", &["--", "--features", "shared"]), ("alike", "alike.toml", &["--", "--features", "alike"]), - ("strings", "strings.toml", &[]), ]; for (case, config, cargo) in cases { let out = scratch().join("crates").join(case); diff --git a/ts/tests/reserve.ts b/ts/tests/reserve.ts index 2199a041b..a3c6494a4 100644 --- a/ts/tests/reserve.ts +++ b/ts/tests/reserve.ts @@ -19,8 +19,8 @@ globalThis.Uint8Array = class extends Native { } } as Uint8ArrayConstructor; -const debug = (e: rs.TryReserveError, spec: rs.Spec = {}) => rs.fmtToString(rs.fmtSpec(spec, (f) => rs.fmtTryReserveErrorDebug(e, f))); -const display = (e: rs.TryReserveError) => rs.fmtToString((f) => rs.fmtTryReserveErrorDisplay(e, f)); +const debug = (e: rs.TryReserveError, spec: rs.Spec = {}) => rs.fmtToString(rs.fmtSpec(spec, (f) => rs.fmtTryReserveErrorDebug(e, f))).v; +const display = (e: rs.TryReserveError) => rs.fmtToString((f) => rs.fmtTryReserveErrorDisplay(e, f)).v; const failed = (r: rs.Result, size: number): rs.TryReserveError => { assert.ok(!r.ok); assert.deepEqual(r.error.layout, { size, align: 1 }); diff --git a/ts/tests/task.ts b/ts/tests/task.ts index 8a6dfae91..2379fc38a 100644 --- a/ts/tests/task.ts +++ b/ts/tests/task.ts @@ -24,15 +24,16 @@ export type Bytes = { data: Uint8Array; length: number }; type Channel = Disposable; /** - * What the harness drives: the translation's roots, and the runtime's `Pending` and - * `u64`, whose values are `V`. + * What the harness drives: the translation's roots, and the runtime's `Pending`, `u64`, + * whose values are `V`, and `String`, whose values are `S`. */ -export interface Fixture { +export interface Fixture { Pending: symbol; u64: { of(value: number): V }; + string(text: string): S; Log: { "new"(): Log; - note(log: Log, event: string): void; + note(log: Log, event: S): void; text(log: Log): Bytes; clone$Clone(log: Log): Log; }; @@ -202,7 +203,7 @@ class Executor { /** What a step acts on: one script's fixture, log, executor, and channels. */ interface Run { - f: Fixture; + f: Fixture; log: Log; note: (event: string) => void; exec: Executor; @@ -358,10 +359,10 @@ const steps: [string, (r: Run, arg: number) => void][] = [ ]; /** The script runner, as `harness.rs` runs it natively. */ -export function harness(f: Fixture): (input: Uint8Array) => Bytes { +export function harness(f: Fixture): (input: Uint8Array) => Bytes { return (input) => { const log = f.Log.new(); - const note = (event: string) => f.Log.note(log, event); + const note = (event: string) => f.Log.note(log, f.string(event)); const exec = new Executor(note, f.Pending); const r: Run = { f, log, note, exec, channels: [] }; for (let i = 0; i < input.length; i += 2) { From a91c421b16046bfbeffafb46cb4b1d642b90678f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 11:56:44 -0800 Subject: [PATCH 05/11] style(ts): format Co-Authored-By: Claude Opus 5.5 --- ts/src/lower/fmt.rs | 9 ++++++++- ts/src/lower/library.rs | 21 +++++++++++++++++---- ts/src/lower/mir/call.rs | 16 ++++++++++++---- ts/src/lower/mir/place.rs | 5 ++++- 4 files changed, 41 insertions(+), 10 deletions(-) diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index d7fbb75e3..d89af51db 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -262,7 +262,14 @@ impl<'tcx> Body<'_, '_, 'tcx> { /// `fmt::Write`'s `name` of the `String` `s`, writing `arg`, a `fmt::Arguments` whose only /// piece is `literal` if it is one, in place: what the call returns. What a placeholder /// wrote before an error stays written. - pub fn string_write(&mut self, name: &str, s: Expr, arg: Expr, literal: Option, out: &mut Vec) -> Expr { + pub fn string_write( + &mut self, + name: &str, + s: Expr, + arg: Expr, + literal: Option, + out: &mut Vec, + ) -> Expr { let pushed = match (name, literal) { ("write_char", _) => Expr::rs("stringPush", vec![s, arg]), ("write_fmt", Some(text)) => Expr::rs("stringPushStr", vec![s, Expr::Str(text)]), diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 0007b977f..e496d905a 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1590,7 +1590,9 @@ fn mapping<'tcx>( _ if cow_str(tcx, to) && !raw.is_ref() && owned_string(tcx, raw) => { cow_made(tcx.types.str_, rustc_abi::VariantIdx::from_u32(1), value) } - _ if cow_str(tcx, to) => cow_made(tcx.types.str_, rustc_abi::FIRST_VARIANT, text(tcx, peeled, value)), + _ if cow_str(tcx, to) => { + cow_made(tcx.types.str_, rustc_abi::FIRST_VARIANT, text(tcx, peeled, value)) + } // A `Box` is its text, a `String`'s once it shrinks to fit. _ => text(tcx, peeled, value), }); @@ -2879,7 +2881,9 @@ fn mapping<'tcx>( } // The `String` a `Cow` owns, or one of the text it borrows. ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rs("strCowIntoOwned", args), - ("AsRef", "as_ref") if textual(tcx, targ(gargs, 0)) && !cow_str(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => { + ("AsRef", "as_ref") + if textual(tcx, targ(gargs, 0)) && !cow_str(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => + { text(tcx, targ(gargs, 0), args.pop()?) } // A `Cow<[T]>` borrows its slice, and its `Vec` is its own or a clone of what it @@ -3119,7 +3123,9 @@ fn mapping<'tcx>( let value = args.pop()?; let size = match ty.kind() { ty::Adt(..) if textual(tcx, ty) && !string(tcx, ty) => return Some(string_from(text(tcx, ty, value))), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Arguments) => return Some(Expr::rs("fmtFormat", vec![value])), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Arguments) => { + return Some(Expr::rs("fmtFormat", vec![value])); + } ty::Char | ty::Bool | ty::Uint(_) => Some(0), ty::Int(int) => Some(match int.bit_width().unwrap_or(32) { 8 => 3, @@ -3131,7 +3137,14 @@ fn mapping<'tcx>( _ => None, }; let value = b.fmt_value(fmt::Trait::Display, ty, value, span, out); - Expr::rs("fmtToString", [vec![value], size.map(|n: u32| Expr::lit(n.to_string())).into_iter().collect()].concat()) + Expr::rs( + "fmtToString", + [ + vec![value], + size.map(|n: u32| Expr::lit(n.to_string())).into_iter().collect(), + ] + .concat(), + ) } // `fmt::Write`'s, of a `String`, a `Formatter`, or the crate's own writer. ("Write", "write_str" | "write_char" | "write_fmt") diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index c26ae4214..d1ae2bc35 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -757,7 +757,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if crate::lower::iter::str_array(source) { return done(Expr::rs("stringExtendArray", vec![s, items]), true); } - done(crate::lower::iter::string_extend(self.b, s, items, item, iter, span)?, true) + done( + crate::lower::iter::string_extend(self.b, s, items, item, iter, span)?, + true, + ) } ("String", "reserve" | "reserve_exact" | "try_reserve" | "try_reserve_exact") => { let values = self.operands(false, &[], args, tcx.types.unit, span, out); @@ -861,7 +864,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ("Cow", "to_mut") if targ(0).is_some_and(|t| t.is_str()) => { let place = self.borrowed_place(&args[0].node, span, out)?; self.set_borrowed(&place, Expr::rs("strCowIntoOwned", vec![place.0.clone()]), span, out); - done(Expr::As(Box::new(place.0), crate::ts::Type::Rs("String", Vec::new())), false) + done( + Expr::As(Box::new(place.0), crate::ts::Type::Rs("String", Vec::new())), + false, + ) } // A `String` is the place of its `str`. ("String", "as_mut_str" | "leak") => done(self.operand(&args[0].node, span, out), false), @@ -872,7 +878,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { done(self.operand(&args[0].node, span, out), false) } ("DerefMut", "deref_mut") | ("AsMut", "as_mut") | ("BorrowMut", "borrow_mut") - if targ(0).is_some_and(|t| t.is_str()) && dest.ty(&self.mir.local_decls, tcx).ty.peel_refs().is_str() => + if targ(0).is_some_and(|t| t.is_str()) + && dest.ty(&self.mir.local_decls, tcx).ty.peel_refs().is_str() => { self.same_place(args, dest, span, out) } @@ -1833,7 +1840,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let get = matches!(name, "get" | "get_mut"); let base = self.operand(&args[0].node, span, out); // A `String` is the place of its text. - let base = match self.b.t.std_of(container) == Some(Std::String) && !matches!(name, "index_mut" | "get_mut") { + let base = match self.b.t.std_of(container) == Some(Std::String) && !matches!(name, "index_mut" | "get_mut") + { true => base.member("v"), false => base, }; diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index ce1e242c1..b6e6b28fe 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -645,7 +645,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { crate::ts::Type::Rs("Vec", vec![elem]), ) } - _ => (crate::ts::Type::Builtin("string"), crate::ts::Type::Rs("String", Vec::new())), + _ => ( + crate::ts::Type::Builtin("string"), + crate::ts::Type::Rs("String", Vec::new()), + ), }; let class = match (bytes, owned) { (true, false) => crate::ts::Type::Rs("ByteSlice", Vec::new()), From b597a206e933f26c4fd34ee47afd9ccee2225a1b Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 11:57:13 -0800 Subject: [PATCH 06/11] chore(quest): drop the slice quest's empty Related Co-Authored-By: Claude Opus 5.5 --- quest/m3/ts-slice-object.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/quest/m3/ts-slice-object.md b/quest/m3/ts-slice-object.md index 2986b77f0..825289500 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -39,6 +39,3 @@ costs a hot `&mut u8`, such as `read_exact(slice::from_mut(&mut byte))`. Public API: the translator's output and what a hand-written caller passes for a reference to an array. - -## Related - From 22a87cf806fb74c9e8d7dbb0afc6082630ed70ae Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 12:19:18 -0800 Subject: [PATCH 07/11] fix(ts): clone String::from(&String), and keep a hook's String payload String::from of a reference returned the source object, so mutating the copy changed it. A panic hook's String payload is now the String panic_any was given, or one panic! writes its message into from empty, as std's is. Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 + quest/m3/ts-panic-payload-capacity.md | 16 + .../lang/capacity/expected/capacity.ts | 102 +++--- ts/fixtures/lang/capacity/src/capacity.rs | 8 +- .../lang/panics/hook/expected/core/option.ts | 7 + .../lang/panics/hook/expected/hooked.Shown.ts | 2 +- .../lang/panics/hook/expected/hooked.ts | 304 ++++++++++-------- .../lang/panics/hook/expected/panics.ts | 5 +- ts/fixtures/lang/panics/src/hooked.rs | 21 +- ts/runtime/rs.ts | 7 +- ts/runtime/rs/hook.ts | 31 +- ts/src/lower/library.rs | 9 +- 12 files changed, 301 insertions(+), 212 deletions(-) create mode 100644 quest/m3/ts-panic-payload-capacity.md diff --git a/quest/m3/README.md b/quest/m3/README.md index 0a2e8410f..9d5910e25 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -22,3 +22,4 @@ generic std gap is planned here even when moq never calls it. - [rs.Slice](/quest/m3/ts-slice-object.md) - references to arrays of other values are a runtime slice too, and pointers compare by where they point - [Writes through iter_mut without a Place per item](/quest/m3/ts-iter-mut-places.md) - a loop over `iter_mut()` of copy values writes the slice's array by index - [Slices not yet written](/quest/m3/ts-uninit-slices.md) - `Box::new_uninit_slice` and `write_clone_of_slice` translate +- [std's panic messages with std's capacity](/quest/m3/ts-panic-payload-capacity.md) - a hook reads std's capacity from the `String` payload of std's own formatted panics diff --git a/quest/m3/ts-panic-payload-capacity.md b/quest/m3/ts-panic-payload-capacity.md new file mode 100644 index 000000000..1bd05c5c8 --- /dev/null +++ b/quest/m3/ts-panic-payload-capacity.md @@ -0,0 +1,16 @@ +# [S] std's panic messages with std's capacity + +## Goal + +A panic hook that downcasts the `String` payload of a panic std's own code formats, +such as `slice index starts at {} but ends at {}`, reads std's capacity from it. +std's `panic!` writes the message into an empty `String` piece by piece, while the +runtime's sites in `ts/runtime/rs/` pass one concatenated string with `owned` true, +which it writes in one push: exact only for a message of one piece, as +`panic_display`'s. + +## Plan + +Pass each such site's message as the `Arguments` std's format string makes, through +`panicFmt`, so the hook writes it as std does, and extend the `lang/panics` fixture's +`sized` hook to every case. diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index e2bd454aa..5ef9ec4b4 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -3749,9 +3749,9 @@ export function boundary(s: string, arg: rs.u8): rs.usize { */ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): void { let s!: rs.String; - let _302!: rs.String; - let _334!: rs.String; - let _405!: rs.String; + let _314!: rs.String; + let _346!: rs.String; + let _417!: rs.String; const _4: (a0: rs.u8) => string = (arg2: rs.u8): string => { const _42: rs.usize = rs.usizeRem(arg2 as rs.usize, rs.sliceFrom(["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]).length); if (!(_42 < 4)) { @@ -3843,11 +3843,15 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 18) { rs.drop(rs.stringDrain(s, { end: boundary(s.v, arg) })); } else if (_64 === 19) { + const copy: rs.String = rs.stringClone(s); + const _198: string = _4(arg); + rs.stringPushStr(copy, _198); + sized(out, copy.len, copy.cap); s = rs.stringClone(s); } else if (_64 === 20) { let over: rs.String = rs.stringWithCapacity(rs.u8Rem(arg, 24) as rs.usize); - const _202: string = _4(arg >> 2); - rs.stringPushStr(over, _202); + const _214: string = _4(arg >> 2); + rs.stringPushStr(over, _214); over = rs.stringCloneFrom(over, s); s = over; } else if (_64 === 21) { @@ -3863,11 +3867,11 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 25) { rs.stringPushStr(s, _4(arg)); } else if (_64 === 26) { - const _252: rs.String = s; - const _256: string = _4(arg >> 2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, _256)]; - const _253: rs.Arguments = [args4[0], "-", args4[1]]; - rs.resultUnwrap(rs.fmtWriteString(_252, _253), rs.fmtErrorDebug); + const _264: rs.String = s; + const _268: string = _4(arg >> 2); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, _268)]; + const _265: rs.Arguments = [args4[0], "-", args4[1]]; + rs.resultUnwrap(rs.fmtWriteString(_264, _265), rs.fmtErrorDebug); } else if (_64 === 27) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.u8Display(arg, f)]; s = rs.fmtFormat([args6[0], args6[1]]); @@ -3880,25 +3884,25 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 30) { s = rs.fmtFormat(["text alone"]); } else if (_64 === 31) { - const _303: rs.u8 = rs.u8Rem(arg, 6); - if (_303 === 0) { - const _306: rs.i8 = (arg << 24) >> 24; - _302 = rs.fmtToString((f: rs.Formatter) => rs.i8Display(_306, f), 3); - } else if (_303 === 1) { - const _308: rs.i32 = rs.i32Sub(arg as rs.i32, 128); - _302 = rs.fmtToString((f: rs.Formatter) => rs.i32Display(_308, f), 10); - } else if (_303 === 2) { - _302 = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); - } else if (_303 === 3) { - _302 = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(c, f), 0); - } else if (_303 === 4) { - const _314: boolean = rs.u8Rem(arg, 2) === 0; - _302 = rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_314, f), 0); + const _315: rs.u8 = rs.u8Rem(arg, 6); + if (_315 === 0) { + const _318: rs.i8 = (arg << 24) >> 24; + _314 = rs.fmtToString((f: rs.Formatter) => rs.i8Display(_318, f), 3); + } else if (_315 === 1) { + const _320: rs.i32 = rs.i32Sub(arg as rs.i32, 128); + _314 = rs.fmtToString((f: rs.Formatter) => rs.i32Display(_320, f), 10); + } else if (_315 === 2) { + _314 = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); + } else if (_315 === 3) { + _314 = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(c, f), 0); + } else if (_315 === 4) { + const _326: boolean = rs.u8Rem(arg, 2) === 0; + _314 = rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_326, f), 0); } else { const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - _302 = rs.fmtFormat([args12[0]]); + _314 = rs.fmtFormat([args12[0]]); } - s = _302; + s = _314; } else if (_64 === 32) { s = rs.strToLowercase(s.v); } else if (_64 === 33) { @@ -3906,21 +3910,21 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 34) { s = rs.stringFrom(rs.strToAsciiUppercase(s.v)); } else if (_64 === 35) { - const _335: rs.u8 = rs.u8Rem(arg, 5); - if (_335 === 0) { - _334 = rs.strReplace(s.v, "a", "b", true); - } else if (_335 === 1) { - _334 = rs.strReplace(s.v, "a", "xyz", true); - } else if (_335 === 2) { - _334 = rs.strReplace(s.v, String.fromCodePoint(c), "", true); - } else if (_335 === 3) { - _334 = rs.strReplace(s.v, (c2: rs.char): boolean => { + const _347: rs.u8 = rs.u8Rem(arg, 5); + if (_347 === 0) { + _346 = rs.strReplace(s.v, "a", "b", true); + } else if (_347 === 1) { + _346 = rs.strReplace(s.v, "a", "xyz", true); + } else if (_347 === 2) { + _346 = rs.strReplace(s.v, String.fromCodePoint(c), "", true); + } else if (_347 === 3) { + _346 = rs.strReplace(s.v, (c2: rs.char): boolean => { return rs.charIsAlphabetic(c2); }, "-", false); } else { - _334 = rs.strReplace(s.v, rs.stringFrom("é").v, "e", true); + _346 = rs.strReplace(s.v, rs.stringFrom("é").v, "e", true); } - s = _334; + s = _346; } else if (_64 === 36) { s = rs.strReplacen(s.v, "a", "bc", rs.u8Rem(arg, 3) as rs.usize); } else if (_64 === 37) { @@ -3934,37 +3938,37 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi sized(out, bytes3.length, bytes3.data.length); s = rs.resultUnwrap(rs.stringFromUtf8(bytes3), rs.fmtFromUtf8ErrorDebug); } else if (_64 === 39) { - const _388: rs.Iter = rs.iterRev(rs.strChars(s.v)); - s = rs.stringExtendChars(rs.stringNew(), _388); + const _400: rs.Iter = rs.iterRev(rs.strChars(s.v)); + s = rs.stringExtendChars(rs.stringNew(), _400); } else if (_64 === 40) { s = rs.stringFromStrings(rs.vecIntoIter(rs.vecFrom([s, rs.stringFrom(_4(arg))]))); } else if (_64 === 41) { const units: rs.Vec = rs.iterToVec(rs.strEncodeUtf16(s.v), "next", 2); if (rs.u8Rem(arg, 2) === 0) { - _405 = rs.resultUnwrap(rs.stringFromUtf16(rs.sliceFrom(units.items)), rs.fmtFromUtf16ErrorDebug); + _417 = rs.resultUnwrap(rs.stringFromUtf16(rs.sliceFrom(units.items)), rs.fmtFromUtf16ErrorDebug); } else { - _405 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); + _417 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); } - s = _405; + s = _417; } else if (_64 === 42) { const bytes4: rs.ByteVec = rs.stringIntoBytes(s); rs.byteVecPush(bytes4, 255); s = rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteVecSlice(bytes4))); } else if (_64 === 43) { - const _422: rs.Slice = rs.sliceFrom([s.v, _4(arg)]); - const _430: string = _4(arg >> 2); - s = rs.strsJoin(rs.sliceItems(_422), _430); + const _434: rs.Slice = rs.sliceFrom([s.v, _4(arg)]); + const _442: string = _4(arg >> 2); + s = rs.strsJoin(rs.sliceItems(_434), _442); } else if (_64 === 44) { s = rs.stringFrom(s.v); } else if (_64 === 45) { let cow: rs.StrCow = new rs.Borrowed(_4(arg)); cow = rs.strCowAdd(cow, new rs.Borrowed(s.v)); - const _449: string = _4(arg >> 2); - cow = rs.strCowAdd(cow, new rs.Borrowed(_449)); + const _461: string = _4(arg >> 2); + cow = rs.strCowAdd(cow, new rs.Borrowed(_461)); s = rs.strCowIntoOwned(cow); } else if (_64 === 46) { - const _458: string[] = [_4(arg), _4(arg >> 2)]; - s = rs.stringExtendArray(rs.stringNew(), rs.iterSlice(_458)); + const _470: string[] = [_4(arg), _4(arg >> 2)]; + s = rs.stringExtendArray(rs.stringNew(), rs.iterSlice(_470)); } else if (_64 === 47) { s = rs.stringAdd(rs.replaceIn(s, rs.stringNew()), _4(arg)); } diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index b6c682adb..94acf3d4d 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -711,7 +711,13 @@ pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { sized(out, rest.len(), rest.capacity()); } 18 => drop(s.drain(..boundary(&s, arg))), - 19 => s = s.clone(), + // A clone, and a `String::from` of a reference's, which leaves the original as it was. + 19 => { + let mut copy = String::from(&s); + copy.push_str(text(arg)); + sized(out, copy.len(), copy.capacity()); + s = s.clone(); + } // Grown from `with_capacity` only where it holds fewer. 20 => { let mut over = String::with_capacity(usize::from(arg % 24)); diff --git a/ts/fixtures/lang/panics/hook/expected/core/option.ts b/ts/fixtures/lang/panics/hook/expected/core/option.ts index 6f168ecb0..77c48304e 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/option.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/option.ts @@ -16,6 +16,13 @@ export function map$18ftgyp(self: rs.char | undefined, _: (a0: rs.char) => rs.u3 return self as rs.u32; } +export function map$0ded99z(self: rs.String | undefined, _: (a0: rs.String) => rs.usize): rs.usize | undefined { + if (self === undefined) { + return undefined; + } + return self.cap; +} + export function map$04ry0e1(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index 1ba331c7b..07b7edf10 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -21,7 +21,7 @@ export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result { + const _52: Any.Any = rs.hookPayload(info, of$ref_str, of$String); + const capacity: rs.usize | undefined = option_map$0ded99z(_52 instanceof of$String ? _52.v : undefined, (a0: rs.String): rs.usize => { + return a0.cap; + }); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(capacity, f, rs.usizeDebug)]; + rs.stringPushStr(note, rs.fmtFormat(["capacity ", args2[0], "\n"]).v); + }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); + captured(info); + }, (): void => { + rs.drop(captured); + }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); +} + export function tracked(n: rs.u8, caller: rs.Location): rs.u8 { const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; rs.panicFmt(["tracked ", args2[0]], caller); @@ -92,94 +113,97 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); hook(); const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(n, n)); - const _10: rs.u8 = rs.u8Rem(kind, 32, { file: "fixtures/lang/panics/src/hooked.rs", line: 84, col: 11 }); + const _10: rs.u8 = rs.u8Rem(kind, 32, { file: "fixtures/lang/panics/src/hooked.rs", line: 95, col: 11 }); if (_10 === 0) { - rs.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 85, col: 14 }); + rs.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 96, col: 14 }); } else if (_10 === 1) { + sized(); const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["formatted ", args2[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 86, col: 14 }); + rs.panicFmt(["formatted ", args2[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 99, col: 13 }); } else if (_10 === 2) { - rs.byteVecPush(out, v.data[rs.idx(v, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 24 })]); + rs.byteVecPush(out, v.data[rs.idx(v, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 24 })]); } else if (_10 === 3) { - rs.byteVecPush(out, rs.u8Add(rs.max(n, 200), rs.max(n, 100), { file: "fixtures/lang/panics/src/hooked.rs", line: 88, col: 23 })); + rs.byteVecPush(out, rs.u8Add(rs.max(n, 200), rs.max(n, 100), { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 23 })); } else if (_10 === 4) { - rs.byteVecPush(out, rs.optionUnwrap(filter$0hq86nl(n, (_24: rs.u8): boolean => { + rs.byteVecPush(out, rs.optionUnwrap(filter$0hq86nl(n, (_22: rs.u8): boolean => { return false; - }), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 89, col: 49 })); + }), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 103, col: 49 })); } else if (_10 === 5) { - rs.byteVecPush(out, rs.resultUnwrap(rs.Err(n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 90, col: 40 })); + rs.byteVecPush(out, rs.resultUnwrap(rs.Err(n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 40 })); } else if (_10 === 6) { rs.byteVecPush(out, rs.optionExpect(filter$0hq86nl(n, (_2: rs.u8): boolean => { return false; - }), "expected", undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 91, col: 49 })); + }), "expected", undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 49 })); } else if (_10 === 7) { - const part2 = rs.usizeAdd(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 51 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 39 }); - rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteVecSlice(v), part2, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 38 })); + const part2 = rs.usizeAdd(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 51 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 39 }); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteVecSlice(v), part2, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 38 })); } else if (_10 === 8) { const cell: rs.RefCell = new rs.RefCell(n); - const _held: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 95, col: 30 }); - const _56: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 96, col: 28 }); - rs.byteVecPush(out, _56.value); - rs.refMutRelease(_56); + const _held: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 109, col: 30 }); + const _57: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 28 }); + rs.byteVecPush(out, _57.value); + rs.refMutRelease(_57); rs.refMutRelease(_held); } else if (_10 === 9) { rs.byteVecPush(out, rs.intPow(rs.max(n, 2), 9, 8, false, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/mod.rs", line: 590, col: 5 })); } else if (_10 === 10) { - rs.byteVecPush(out, rs.u8Div(100, rs.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 99, col: 24 })); + rs.byteVecPush(out, rs.u8Div(100, rs.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 24 })); } else if (_10 === 11) { - rs.byteVecPush(out, rs.byteVecRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 34 })); + rs.byteVecPush(out, rs.byteVecRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 34 })); } else if (_10 === 12) { - rs.byteVecPush(out, rs.byteVecSwapRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 46 }))); + rs.byteVecPush(out, rs.byteVecSwapRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 46 }))); } else if (_10 === 13) { - rs.byteSliceRotateLeft(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 37 })); + rs.byteSliceRotateLeft(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 37 })); } else if (_10 === 14) { - rs.byteVecPush(out, rs.hashIndex(rs.hashNew() as rs.HashMap, n, { file: "fixtures/lang/panics/src/hooked.rs", line: 103, col: 48 })); + rs.byteVecPush(out, rs.hashIndex(rs.hashNew() as rs.HashMap, n, { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 48 })); } else if (_10 === 15) { - rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 15 }); + rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 118, col: 15 }); } else if (_10 === 16) { + sized(); const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panic(rs.fmtFormat(["any ", args4[0]]).v, { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); + const _94: rs.String = rs.fmtFormat(["any ", args4[0]]); + rs.panic(_94.v, { file: "fixtures/lang/panics/src/hooked.rs", line: 121, col: 13 }, _94); } else if (_10 === 17) { - const _104: rs.u8 = rs.u8WrappingAdd(n, 1); - if (!(n === _104)) { - rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(_104, f), ["differ"], { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 15 }); + const _106: rs.u8 = rs.u8WrappingAdd(n, 1); + if (!(n === _106)) { + rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(_106, f), ["differ"], { file: "fixtures/lang/panics/src/hooked.rs", line: 123, col: 15 }); } } else if (_10 === 18) { - rs.byteVecPush(out, tracked(n, { file: "fixtures/lang/panics/src/hooked.rs", line: 107, col: 24 })); + rs.byteVecPush(out, tracked(n, { file: "fixtures/lang/panics/src/hooked.rs", line: 124, col: 24 })); } else if (_10 === 19) { - rs.byteVecPush(out, rs.dequeIndex(rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(v))), 1, true) as rs.VecDeque, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 49 })); + rs.byteVecPush(out, rs.dequeIndex(rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(v))), 1, true) as rs.VecDeque, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 125, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 125, col: 49 })); } else if (_10 === 20) { rs.byteVecPush(out, result_unwrapOr$1tftpn5(rs.u8TryFrom(rs.durationAsSecs(rs.durationAdd({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)))), 0)); } else if (_10 === 21) { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strSlice("éé", 0, rs.usizeAdd(rs.usizeMul(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 56 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 41 }))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strSlice("éé", 0, rs.usizeAdd(rs.usizeMul(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 56 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 41 }))); } else if (_10 === 22) { - rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 111, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 128, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 23) { - const _150: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _152: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 112, col: 42 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.byteVecDrain(_150, _152, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); + const _152: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _154: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 129, col: 42 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.byteVecDrain(_152, _154, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); } else if (_10 === 24) { - rs.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 15 }, false); + rs.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 130, col: 15 }); } else if (_10 === 25) { - rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 131, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 26) { - const _165: rs.u8 = rs.u8WrappingAdd(n, 1); - if (!(n === _165)) { - rs.panic("assertion failed: n == n.wrapping_add(1)", { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 15 }); + const _167: rs.u8 = rs.u8WrappingAdd(n, 1); + if (!(n === _167)) { + rs.panic("assertion failed: n == n.wrapping_add(1)", { file: "fixtures/lang/panics/src/hooked.rs", line: 132, col: 15 }); } } else if (_10 === 27) { - rs.panic("explicit panic", { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 15 }); + rs.panic("explicit panic", { file: "fixtures/lang/panics/src/hooked.rs", line: 133, col: 15 }); } else if (_10 === 28) { - rs.panic("internal error: entered unreachable code", { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 15 }); + rs.panic("internal error: entered unreachable code", { file: "fixtures/lang/panics/src/hooked.rs", line: 134, col: 15 }); } else if (_10 === 29) { - rs.panic("not yet implemented", { file: "fixtures/lang/panics/src/hooked.rs", line: 118, col: 15 }); + rs.panic("not yet implemented", { file: "fixtures/lang/panics/src/hooked.rs", line: 135, col: 15 }); } else if (_10 === 30) { if (n === n) { - rs.assertFailed("!=", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(n, f), undefined as rs.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 119, col: 15 }); + rs.assertFailed("!=", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(n, f), undefined as rs.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 136, col: 15 }); } } else if (_10 === 31) { const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["not implemented: not ", args6[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 120, col: 15 }); + rs.panicFmt(["not implemented: not ", args6[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 137, col: 15 }); } else { rs.byteVecPush(out, rs.hashLen(rs.hashWithCapacity(4294967295, 469762048) as rs.HashMap) & 0xff); } @@ -196,9 +220,9 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const captured2 = prev; rs.setHook(rs.closure((info: rs.PanicHookInfo): undefined => { record(info); - const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 152, col: 15 }); + const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 169, col: 15 }); if (_4 === 0) { - rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 153, col: 18 }); + rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 170, col: 18 }); } else if (_4 === 1) { rs.drop(rs.takeHook()); } else { @@ -208,14 +232,14 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.drop(captured2); }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); rs.byteVecPush(out, n); - const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 159, col: 11 }); + const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 176, col: 11 }); if (_13 === 3 || _13 === 4) { - const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 56 }) === 4 }; + const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 177, col: 56 }) === 4 }; const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Shown.fmt$fmt_Display(_19, f)]; - rs.panicFmt(["first ", args2[0], " ", args2[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 18 }); + rs.panicFmt(["first ", args2[0], " ", args2[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 177, col: 18 }); } else { const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["first ", args4[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 161, col: 14 }); + rs.panicFmt(["first ", args4[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 178, col: 14 }); } } @@ -246,13 +270,13 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _19: rs.u16[] = [n as rs.u16]; const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_19), true, undefined, undefined, 2, true); b0: { - const k: rs.u8 = rs.u8Rem(kind, 70, { file: "fixtures/lang/panics/src/hooked.rs", line: 183, col: 11 }); + const k: rs.u8 = rs.u8Rem(kind, 70, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 11 }); if (k === 0) { - rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 184, col: 48 })).length & 0xff); + rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 201, col: 48 })).length & 0xff); } else if (k === 1) { - rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 185, col: 37 })); + rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 202, col: 37 })); } else if (k === 2) { - rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 25 })); + rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 203, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 203, col: 25 })); } else if (k === 3) { rs.byteVecPush(out, rs.u8FromF64(rs.f64Clamp(n as rs.f64, 1.0, 0.0))); } else if (k === 4) { @@ -260,7 +284,7 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (k === 5) { rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.charEncodeUtf8(rs.max(n, 128) as rs.char, rs.byteSliceFrom(Uint8Array.of(0))).v)); } else if (k === 6) { - const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 191, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 192, col: 18 }); + const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 209, col: 18 }); const _69: rs.u16[] = [0]; rs.byteVecPush(out, rs.charEncodeUtf16(_62, rs.sliceFrom(_69)).length & 0xff); } else if (k === 7) { @@ -269,7 +293,7 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _239[1]; }), "next"); } else if (k === 8) { - const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 35 }), n as rs.u16); + const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 217, col: 35 }), n as rs.u16); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRange(map, _81), (_237: [rs.u16, rs.u8]): rs.u8 => { return _237[1]; }), "next"); @@ -279,29 +303,29 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _232 & 0xff; }), "next"); } else if (k === 10) { - const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 205, col: 36 }), n as rs.u16); + const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 222, col: 36 }), n as rs.u16); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(set, _97), (_230: rs.u16): rs.u8 => { return _230 & 0xff; }), "next"); } else if (k === 11) { - rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 206, col: 36 }), n); + rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 223, col: 36 }), n); } else if (k === 12) { - rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 207, col: 34 }), 0); + rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 224, col: 34 }), 0); } else if (k === 13) { - rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 37 })); + rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 225, col: 37 })); } else if (k === 14) { - rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 209, col: 41 })); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 226, col: 41 })); } else if (k === 15) { - rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 210, col: 42 }), true); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 227, col: 42 }), true); } else if (k === 16) { - rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 211, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 228, col: 50 }))), undefined, true); } else if (k === 17) { const _136: Uint8Array = Uint8Array.of(n); - rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 212, col: 58 }))), undefined, true); + rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 229, col: 58 }))), undefined, true); } else if (k === 18) { const mutex: rs.Mutex = new rs.Mutex(n); const _held: rs.Result, rs.Mutex> = rs.Ok(rs.mutexLock(mutex)); - const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 216, col: 36 }); + const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 233, col: 36 }); rs.byteVecPush(out, _146.value); rs.mutexUnlock(_146); drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8(_held); @@ -343,40 +367,40 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, ready2.intoInner()); } else if (k === 23) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 243, col: 48 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 260, col: 48 }))) & 0xff); } else if (k === 24) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 244, col: 44 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 261, col: 44 }))) & 0xff); } else if (k === 25) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 245, col: 45 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 262, col: 45 }))) & 0xff); } else if (k === 26) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 246, col: 62 })))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 263, col: 62 })))) & 0xff); } else if (k === 27) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 247, col: 41 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 264, col: 41 }))) & 0xff); } else if (k === 28) { const _231: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 248, col: 44 }), rs.usizeStep); + const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 44 }), rs.usizeStep); rs.byteVecExtendFromWithin(_231, _233, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3614, col: 21 }); } else if (k === 29) { const _238: rs.VecDeque = rs.dequeClone(deque); - const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 249, col: 46 }), rs.usizeStep); + const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 266, col: 46 }), rs.usizeStep); rs.iterExtendBytes(out, rs.dequeDrain(_238, _240, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1998, col: 36 }), "next"); } else if (k === 30) { - const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 250, col: 38 }), rs.usizeStep); + const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 38 }), rs.usizeStep); rs.iterExtendBytes(out, rs.dequeRange(deque, _245, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), undefined, true); } else if (k === 31) { const _251: rs.VecDeque = rs.dequeClone(deque); - const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 251, col: 50 }), rs.usizeStep); + const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 268, col: 50 }), rs.usizeStep); rs.iterExtendBytes(out, rs.iterMap(rs.dequeRangeMut(_251, _253, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), (v5: rs.Place): rs.u8 => { return v5.v; }), undefined, true); } else if (k === 32) { const cell2: rs.RefCell = new rs.RefCell(rs.byteVecFrom(Uint8Array.of(n))); - const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 254, col: 30 }); + const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 30 }); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(cell2, new rs.ByteVec(), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1434, col: 14 })), undefined, true); rs.refRelease(_held2); } else if (k === 33) { ((cell4: rs.RefCell): undefined => { - rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 54 }); + rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 275, col: 54 }); })(SHARED.get()); rs.localKeyWithBorrowMutPlace(SHARED, (v4: rs.Place): undefined => { v4.v = n; @@ -392,25 +416,25 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }); } else if (k === 35) { const _277: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 43 }), rs.usizeStep); + const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 282, col: 43 }), rs.usizeStep); const _282: Uint8Array = Uint8Array.of(n); rs.iterExtendBytes(out, rs.spliceFrom(rs.byteVecSplice(_277, _279, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), rs.iterSlice(_282), true), "next"); } else if (k === 36) { - rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a0: rs.char): rs.u32 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 284, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a0: rs.char): rs.u32 => { return a0 as rs.u32; }), (c2: rs.u32): rs.u8 => { return c2 & 0xff; })), undefined, true); } else if (k === 37) { - const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 59 }); + const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 288, col: 59 }); if (!(_294 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _294, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 21 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _294, { file: "fixtures/lang/panics/src/hooked.rs", line: 288, col: 21 }, true); } rs.fence([0, 4][_294], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); } else if (k === 38) { - const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 68 }); + const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 289, col: 68 }); if (!(_301 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _301, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 30 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _301, { file: "fixtures/lang/panics/src/hooked.rs", line: 289, col: 30 }, true); } rs.fence([0, 4][_301], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); } else if (k === 39) { @@ -428,45 +452,45 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (k === 45) { rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1461, col: 9 }))) & 0xff); } else if (k === 46) { - rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 303, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); } else if (k === 47) { const _365: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 291, col: 47 }), rs.usizeStep); + const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 47 }), rs.usizeStep); rs.iterExtendBytes(out, rs.byteVecExtractIf(_365, _367, (_29: rs.Place): boolean => { return true; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), "next"); } else if (k === 48) { const _374: rs.Vec = rs.vecFrom([n as rs.u16]); - const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 292, col: 56 }) }; + const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 56 }) }; rs.byteVecPush(out, rs.ownedCount(rs.vecExtractIfMut(_374, _377, (_2: rs.Place): boolean => { return true; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), undefined, undefined) & 0xff); } else if (k === 49) { - rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 27 }), rs.u8Step), 3), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 27 }), rs.u8Step), 3), undefined, true); } else if (k === 50) { - rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 50 }))), undefined, true); } else if (k === 51) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { return rs.u64Low(x) & 0xff; }), undefined, true); } else if (k === 52) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 314, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 314, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 314, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { return c & 0xff; }), undefined, true); } else if (k === 68) { - const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 304, col: 50 })); - rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 32 })); + const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 50 })); + rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 323, col: 32 })); rs.byteVecPush(out, v2.length & 0xff); } else { if (53 <= k) { if (k <= 56) { - joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 31 }), n, out); + joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 318, col: 31 }), n, out); break b0; } } if (57 <= k) { if (k <= 67) { - rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 302, col: 42 }), n)); + rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 42 }), n)); break b0; } } @@ -484,16 +508,16 @@ export function joined(kind: rs.u8, n: rs.u8, out: rs.ByteVec): void { let joined!: rs.ByteVec; const big: rs.ByteVec = rs.byteVecOf(n, 1 << 16); const refs: (a0: rs.usize) => rs.Vec = (count: rs.usize): rs.Vec => { - return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 40 }), count, undefined); + return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 334, col: 40 }), count, undefined); }; if (kind === 0) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 19 })).items)); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 19 })).items)); } else if (kind === 1) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 320, col: 19 })).items), rs.byteSliceFrom(Uint8Array.of(n))); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 337, col: 19 })).items), rs.byteSliceFrom(Uint8Array.of(n))); } else if (kind === 2) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 19 })).items)); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 338, col: 19 })).items)); } else { - joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 42 }), undefined).items), 2, rs.sliceFrom([1])).items), (_2: rs.u16): rs.u8 => { + joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 42 }), undefined).items), 2, rs.sliceFrom([1])).items), (_2: rs.u16): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -516,10 +540,10 @@ export function compared(kind: rs.u8, n: rs.u8): rs.u8 { const _5: [rs.RefCell, rs.RefCell] = [new rs.RefCell(n), new rs.RefCell(rs.u8WrappingAdd(n, 1))]; const a: rs.RefCell = _5[0]; const b: rs.RefCell = _5[1]; - if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 20 }) === 0)) { - _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 59 }); + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 20 }) === 0)) { + _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 59 }); } else { - _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 35 }); + _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 35 }); } if (kind === 0) { _0 = rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; @@ -566,11 +590,11 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const at: rs.usize = n as rs.usize; const whole: rs.ByteSlice = rs.bytesFromVec(rs.byteVecOf(n, 4)); b0: { - const k: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 378, col: 24 }); + const k: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 395, col: 24 }); if (0 <= k) { if (k <= 1) { rs.setHook((info: rs.PanicHookInfo): undefined => { - const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 380, col: 38 }); + const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 397, col: 38 }); const _10: string = at2.file; const _126: rs.u32 = at2.line; const _14: rs.u32 = at2.col; @@ -579,16 +603,16 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); - rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 383, col: 13 }); + rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 400, col: 13 }); }, { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); const subset: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); if (k === 0) { - const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 30 })); + const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 30 })); held = rs.bytesSliceRef(_22, subset); rs.bytesDrop(_22); } else { const _32: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); - const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 51 }); + const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 405, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 405, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 405, col: 51 }); held = rs.bytesSliceRef(_32, _35); rs.bytesDrop(_32); } @@ -600,38 +624,38 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } hook(); - const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 44 })); - const _52: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 395, col: 11 }); + const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 411, col: 44 })); + const _52: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 412, col: 11 }); if (_52 === 2) { - const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 396, col: 49 }), 2); + const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 413, col: 49 }), 2); rs.byteVecExtendFromSlice(out, _56); rs.bytesDrop(_56); } else if (_52 === 3) { - const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 397, col: 51 })); + const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 414, col: 51 })); rs.byteVecExtendFromSlice(out, _63); rs.bytesDrop(_63); } else if (_52 === 4) { - const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 49 }), 4294967295, rs.usizeStep); + const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 415, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 415, col: 49 }), 4294967295, rs.usizeStep); const _70: rs.ByteSlice = rs.bytesSliceInclusive(whole, _72); rs.byteVecExtendFromSlice(out, _70); rs.bytesDrop(_70); } else if (_52 === 5) { let _81: rs.ByteSlice = rs.bytesClone(whole); - const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 399, col: 60 }); + const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 416, col: 60 }); const _79: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _81, (value9) => _81 = value9), _83); rs.byteVecExtendFromSlice(out, _79); rs.bytesDrop(_79); rs.bytesDrop(_81); } else if (_52 === 6) { let _89: rs.ByteSlice = rs.bytesClone(whole); - const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 400, col: 61 }); + const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 417, col: 61 }); const _87: rs.ByteSlice = rs.bytesSplitOff(rs.place(() => _89, (value8) => _89 = value8), _91); rs.byteVecExtendFromSlice(out, _87); rs.bytesDrop(_87); rs.bytesDrop(_89); } else if (_52 === 7) { let _94: rs.ByteSlice = rs.bytesClone(whole); - const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 401, col: 36 }); + const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 418, col: 36 }); rs.bytesAdvance(rs.place(() => _94, (value7) => _94 = value7), _96); rs.bytesDrop(_94); } else if (_52 === 8) { @@ -640,12 +664,12 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.bytesDrop(_101); } else if (_52 === 9) { let _107: rs.ByteSlice = rs.bytesClone(whole); - const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 46 }); + const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 420, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 420, col: 46 }); rs.byteVecPush(out, rs.u64Low(rs.u64FromBeBytes(rs.bytesReadInt(rs.place(() => _107, (value5) => _107 = value5), 8, _109, false, false))) & 0xff); rs.bytesDrop(_107); } else if (_52 === 10) { - let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 21 }); - const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 35 }); + let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 421, col: 21 }); + const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 421, col: 35 }); rs.byteSliceAdvance(rs.place(() => _114, (value4) => _114 = value4), _116); } else if (_52 === 11) { let _120: rs.ByteSlice = rs.bytesClone(whole); @@ -654,75 +678,75 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.bytesDrop(_120); } else if (_52 === 12) { let _129: rs.ByteSlice = rs.bytesClone(whole); - const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 406, col: 66 }); + const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 423, col: 66 }); const _127: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _129, (value2) => _129 = value2), _131); rs.byteVecExtendFromSlice(out, _127); rs.bytesDrop(_127); rs.bytesDrop(_129); } else if (_52 === 13) { - let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 44 }); - const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 64 }); + let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 424, col: 44 }); + const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 424, col: 64 }); const _135: rs.ByteSlice = rs.byteSliceCopyToBytes(rs.place(() => _137, (value) => _137 = value), _139); rs.byteVecExtendFromSlice(out, _135); rs.bytesDrop(_135); } else if (_52 === 14) { const _146: rs.BytesMut = rs.bytesMutFrom(data); - const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 408, col: 68 })); + const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 425, col: 68 })); rs.byteVecExtendFromSlice(out, rs.bytesMutView(_144)); _144[Symbol.dispose](); _146[Symbol.dispose](); } else if (_52 === 15) { const _154: rs.BytesMut = rs.bytesMutWithCapacity(4); - const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 409, col: 75 })); + const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 426, col: 75 })); rs.byteVecExtendFromSlice(out, rs.bytesMutView(_152)); _152[Symbol.dispose](); _154[Symbol.dispose](); } else if (_52 === 16) { - const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 411, col: 49 })); - rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 413, col: 32 })); + const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 428, col: 49 })); + rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 430, col: 32 })); rs.byteVecPush(out, b.length & 0xff); b[Symbol.dispose](); } else if (_52 === 17) { - const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 417, col: 49 })); - rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 419, col: 36 })); + const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 49 })); + rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 436, col: 36 })); rs.byteVecPush(out, b2.length & 0xff); b2[Symbol.dispose](); } else if (_52 === 18) { - const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 423, col: 50 })); - rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 425, col: 36 })); + const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 440, col: 50 })); + rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 36 })); rs.byteVecPush(out, v.length & 0xff); } else if (_52 === 19) { const _197: rs.BytesMut = rs.bytesMutFrom(data); - rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 428, col: 44 })); + rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 445, col: 44 })); _197[Symbol.dispose](); } else if (_52 === 20) { - const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 429, col: 44 })); + const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 446, col: 44 })); rs.byteVecPush(out, (rs.bytesMutReadWord(_204, 4, false) as rs.u32) & 0xff); _204[Symbol.dispose](); } else if (_52 === 21) { - const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 430, col: 48 })); + const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 447, col: 48 })); rs.byteVecPush(out, _212.cap & 0xff); _212[Symbol.dispose](); } else if (_52 === 22) { const _tail: rs.BytesMut = rs.bytesMutSplitOff(shared, 4); - rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 28 })); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 28 })); _tail[Symbol.dispose](); } else if (_52 === 23) { rs.bytesMutSplitTo(shared, 4)[Symbol.dispose](); - rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 28 })); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 456, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 456, col: 28 })); } else if (_52 === 24) { const _235: rs.u64 = n as rs.u64; - const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 45 }); + const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 458, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 458, col: 45 }); rs.bytesMutPutInt(shared, rs.u64ToBeBytes(_235), _236, false); } else if (_52 === 25) { const _240: rs.i64 = n as rs.i64; - const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 41 }); + const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 459, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 459, col: 41 }); rs.byteVecPutInt(out, rs.i64ToBeBytes(_240), _241, false); } else if (_52 === 26) { - rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 40 })); + rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 460, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 460, col: 40 })); } else if (_52 === 27) { const _253: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesClone(whole), 2); - const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 444, col: 74 })); + const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 461, col: 74 })); rs.byteVecExtendFromSlice(out, _251); rs.bytesDrop(_251); drop$bytes_buf_Take_bytes_Bytes(_253); @@ -732,15 +756,15 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { drop$bytes_buf_Take_bytes_Bytes(_261); } else if (_52 === 29) { const chunk: rs.ByteSlice = rs.bytesMutChunkMut(shared); - UninitSlice.writeByte(chunk, rs.usizeAdd(UninitSlice.len(chunk), rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 449, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 449, col: 30 }), n); + UninitSlice.writeByte(chunk, rs.usizeAdd(UninitSlice.len(chunk), rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 466, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 466, col: 30 }), n); } else if (_52 === 30) { - UninitSlice.writeByte(UninitSlice.indexMut$ops_IndexMut_ops_RangeFrom_usize(rs.byteVecChunkMut(rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 40 }))), new rs.RangeFrom(rs.usizeAdd(65, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 65 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 60 }), rs.usizeStep), { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 59 }), 0, n); + UninitSlice.writeByte(UninitSlice.indexMut$ops_IndexMut_ops_RangeFrom_usize(rs.byteVecChunkMut(rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 40 }))), new rs.RangeFrom(rs.usizeAdd(65, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 65 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 60 }), rs.usizeStep), { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 59 }), 0, n); } else if (_52 === 31) { const _287: rs.BytesMut = rs.bytesMutWithCapacity(0); - UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(rs.bytesMutChunkMut(_287), { end: rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 452, col: 45 }) }, { file: "fixtures/lang/panics/src/hooked.rs", line: 452, col: 42 }), rs.byteSliceFrom(rs.bytes(3).fill(n))); + UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(rs.bytesMutChunkMut(_287), { end: rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 469, col: 45 }) }, { file: "fixtures/lang/panics/src/hooked.rs", line: 469, col: 42 }), rs.byteSliceFrom(rs.bytes(3).fill(n))); _287[Symbol.dispose](); } else { - const _297: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 453, col: 40 })); + const _297: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 470, col: 40 })); rs.byteVecPush(out, _297.length & 0xff); _297[Symbol.dispose](); } diff --git a/ts/fixtures/lang/panics/hook/expected/panics.ts b/ts/fixtures/lang/panics/hook/expected/panics.ts index 2522791c9..7a1c6707c 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.ts @@ -497,9 +497,10 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const _9: rs.u8 = rs.u8Rem(kind, 8, { file: "fixtures/lang/panics/src/panics.rs", line: 288, col: 11 }); if (_9 === 0) { - rs.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }, false); + rs.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }); } else if (_9 === 1) { - rs.panic(text(data).v, { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, true); + const _13: rs.String = text(data); + rs.panic(_13.v, { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, _13); } else if (_9 === 2) { rs.panicAny(new of$u8(first), { file: "fixtures/lang/panics/src/panics.rs", line: 291, col: 14 }); } else if (_9 === 3) { diff --git a/ts/fixtures/lang/panics/src/hooked.rs b/ts/fixtures/lang/panics/src/hooked.rs index 04715c750..9dc8aa149 100644 --- a/ts/fixtures/lang/panics/src/hooked.rs +++ b/ts/fixtures/lang/panics/src/hooked.rs @@ -71,6 +71,17 @@ fn hook() { })); } +/// Have the hook also write a `String` payload's capacity, which `panic!` formats into one +/// from empty and `panic_any` keeps. +fn sized() { + let prev = panic::take_hook(); + panic::set_hook(Box::new(move |info| { + let capacity = info.payload().downcast_ref::().map(String::capacity); + NOTE.with_borrow_mut(|note| note.push_str(&format!("capacity {capacity:?}\n"))); + prev(info); + })); +} + #[track_caller] fn tracked(n: u8) -> u8 { panic!("tracked {n}") @@ -83,7 +94,10 @@ pub fn panicked(kind: u8, data: &[u8], out: &mut Vec) { let v = vec![n, n]; match kind % 32 { 0 => panic!("literal"), - 1 => panic!("formatted {n}"), + 1 => { + sized(); + panic!("formatted {n}") + } 2 => out.push(v[usize::from(n) + 2]), 3 => out.push(n.max(200) + n.max(100)), 4 => out.push(Some(n).filter(|_| false).unwrap()), @@ -102,7 +116,10 @@ pub fn panicked(kind: u8, data: &[u8], out: &mut Vec) { 13 => v.clone().rotate_left(usize::from(n) + 3), 14 => out.push(HashMap::::new()[&n]), 15 => panic::panic_any(u32::from(n)), - 16 => panic::panic_any(format!("any {n}")), + 16 => { + sized(); + panic::panic_any(format!("any {n}")) + } 17 => assert_eq!(n, n.wrapping_add(1), "differ"), 18 => out.push(tracked(n)), 19 => out.push(VecDeque::from(v.clone())[usize::from(n) + 2]), diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 3005a91dd..5c98250c6 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -40,7 +40,7 @@ export class Panic extends Error { * What `panic` runs before it throws, once a program sets a hook: `rs/hook.ts`'s, which * gives the text it formatted, if any. */ - declare static hooked?: (message: string | Arguments, at: Location | string | undefined, owned?: boolean) => string | undefined; + declare static hooked?: (message: string | Arguments, at: Location | string | undefined, owned?: boolean | RsString) => string | undefined; override name = "Panic"; } @@ -51,9 +51,10 @@ export class Abort extends Panic { /** * Panic with `message`, at `at`, or at the key of std's or `bytes`' site the hook finds it at, whose - * text is a `String` if `owned` says so, as `Panic.hooked` reads it. + * payload is the `String` `owned`, or one `message` is written into if `owned` is true, as + * `Panic.hooked` reads it. */ -export function panic(message: string, at?: Location | string, owned?: boolean): never { +export function panic(message: string, at?: Location | string, owned?: boolean | RsString): never { Panic.hooked?.(message, at, owned); throw new Panic(message); } diff --git a/ts/runtime/rs/hook.ts b/ts/runtime/rs/hook.ts index f61b49a79..f197c1dd2 100644 --- a/ts/runtime/rs/hook.ts +++ b/ts/runtime/rs/hook.ts @@ -1,8 +1,8 @@ // `std::panic`'s hook, for rust2-ts output: only a program that sets one reaches this // module, so a bundler drops all of it from one that doesn't. `rs.ts` re-exports all of it. -import { type String as RsString, stringFrom } from "./str.ts"; -import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtFormatText, Panic, panic } from "../rs.ts"; +import { type String as RsString, stringNew, stringPushStr } from "./str.ts"; +import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtWriteString, Panic, panic } from "../rs.ts"; import { fmtLocationDisplay, type Location } from "./location.ts"; import { drop } from "./task.ts"; @@ -10,8 +10,8 @@ import { drop } from "./task.ts"; export interface PanicHookInfo { /** `payload_as_str`: the payload, if it is a `&str` or a `String`. */ readonly text: string | undefined; - /** Whether that text is a `String`, as a message `panic!` formats is, rather than a `&'static str`. */ - readonly owned: boolean; + /** The payload, if it is a `String`, as a message `panic!` formats is, rather than a `&'static str`. */ + readonly string: RsString | undefined; /** Any other payload, as the `dyn Any` object `panic_any` made of it. */ readonly payload: object | undefined; /** Where it panicked. */ @@ -37,12 +37,13 @@ let sites: Sites | undefined; /** * Run the hook on a panic at `at`, or at the key of std's or `bytes`' site in `Sites`, whose payload is - * `message` or else `payload`: a `String` if `owned`, or if it is `Arguments` with - * placeholders, as `Arguments::as_str` says. It formats `Arguments` once the panic has - * begun, as std does, and gives the text. A panic while the hook runs aborts, as std's does, + * `message` or else `payload`: the `String` `owned`, or one written from empty as std's + * `panic!` writes its message: `message` in one write if `owned` is true, or `Arguments` + * with placeholders, as `Arguments::as_str` says, by `write_fmt` once the panic has begun. + * It gives the text. A panic while the hook runs aborts, as std's does, * without running it again. */ -function run(message: string | Arguments | undefined, at: Location | string | undefined, owned?: boolean, payload?: object): string | undefined { +function run(message: string | Arguments | undefined, at: Location | string | undefined, owned?: boolean | RsString, payload?: object): string | undefined { const literal = typeof message === "object" ? asStr(message) : message; if (hooking) throw new Abort(`${literal ?? ""}\nthread panicked while processing panic. aborting.`); if (hook === defaultHook) return undefined; @@ -50,8 +51,16 @@ function run(message: string | Arguments | undefined, at: Location | string | un if (location === undefined) throw new Error(`rust2-ts: a panic its hook can't locate: ${literal ?? "a formatted message"}`); hooking = true; try { - const text = typeof message === "object" ? fmtFormatText(message) : message; - hook({ text, owned: owned ?? literal === undefined, payload, location }); + let string = typeof owned === "object" ? owned : undefined; + if (typeof message === "object" && literal === undefined) { + string = stringNew(); + fmtWriteString(string, message); + } else if (owned === true) { + string = stringNew(); + stringPushStr(string, literal ?? ""); + } + const text = string?.v ?? literal; + hook({ text, string, payload, location }); return text; } finally { hooking = false; @@ -100,7 +109,7 @@ export function panicAny(payload: object, at?: Location): never { */ export function hookPayload(info: PanicHookInfo, str: new (text: string) => object, string: new (text: RsString) => object): object { if (info.payload !== undefined) return info.payload; - return info.owned ? new string(stringFrom(info.text ?? "")) : new str(info.text ?? ""); + return info.string !== undefined ? new string(info.string) : new str(info.text ?? ""); } /** `PanicHookInfo`'s `Display`: where it panicked, then any text, as the default hook's first lines. */ diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index e496d905a..b68b2c309 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1574,7 +1574,8 @@ fn mapping<'tcx>( // `Some` or `Ready` of a value is the value. let some = matches!(to.kind(), ty::Adt(adt, args) if matches!(Std::of(tcx, adt.did()), Some(Std::Option | Std::Poll)) && args.type_at(0) == targ(gargs, 1)); - if to == from || some { + // `String::from(&String)` clones the `rs.String` object. + if (to == from && !targ(gargs, 1).is_ref()) || some { return Some(value); } // Text into text: a `&mut str` is the `rs.Place` of its text, as a `String` is. @@ -2927,8 +2928,10 @@ fn mapping<'tcx>( (true, true) => { let at = b.panic_at.clone().unwrap_or_else(Expr::undefined); let text = args.pop()?; - let text = if owned { text.member("v") } else { text }; - Expr::rs("panic", vec![text, at, Expr::lit(owned.to_string())]) + match owned { + true => Expr::rs("panic", vec![text.clone().member("v"), at, text]), + false => Expr::rs("panic", vec![text, at]), + } } (true, false) if owned => Expr::rs("panic", vec![args.pop()?.member("v")]), (true, false) => Expr::rs("panic", args), From 89f58fd7f8d25781751f60acc13de539c8fa1395 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 12:22:33 -0800 Subject: [PATCH 08/11] chore(quest): drop the panic payload quest for the PR's follow-ups Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 - quest/m3/ts-panic-payload-capacity.md | 16 ---------------- 2 files changed, 17 deletions(-) delete mode 100644 quest/m3/ts-panic-payload-capacity.md diff --git a/quest/m3/README.md b/quest/m3/README.md index 9d5910e25..0a2e8410f 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -22,4 +22,3 @@ generic std gap is planned here even when moq never calls it. - [rs.Slice](/quest/m3/ts-slice-object.md) - references to arrays of other values are a runtime slice too, and pointers compare by where they point - [Writes through iter_mut without a Place per item](/quest/m3/ts-iter-mut-places.md) - a loop over `iter_mut()` of copy values writes the slice's array by index - [Slices not yet written](/quest/m3/ts-uninit-slices.md) - `Box::new_uninit_slice` and `write_clone_of_slice` translate -- [std's panic messages with std's capacity](/quest/m3/ts-panic-payload-capacity.md) - a hook reads std's capacity from the `String` payload of std's own formatted panics diff --git a/quest/m3/ts-panic-payload-capacity.md b/quest/m3/ts-panic-payload-capacity.md deleted file mode 100644 index 1bd05c5c8..000000000 --- a/quest/m3/ts-panic-payload-capacity.md +++ /dev/null @@ -1,16 +0,0 @@ -# [S] std's panic messages with std's capacity - -## Goal - -A panic hook that downcasts the `String` payload of a panic std's own code formats, -such as `slice index starts at {} but ends at {}`, reads std's capacity from it. -std's `panic!` writes the message into an empty `String` piece by piece, while the -runtime's sites in `ts/runtime/rs/` pass one concatenated string with `owned` true, -which it writes in one push: exact only for a message of one piece, as -`panic_display`'s. - -## Plan - -Pass each such site's message as the `Arguments` std's format string makes, through -`panicFmt`, so the hook writes it as std does, and extend the `lang/panics` fixture's -`sized` hook to every case. From 52a2022495ab936fc4b405c33b6d933718607a16 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 4 Nov 2026 12:54:33 -0800 Subject: [PATCH 09/11] fix(ts): pass a dyn shim's &mut receiver as std's mapping takes it A shim calling std's mapping, which takes what a `&mut` points at, passes that, as a call's operands do. #593's forwarding through `&mut` impls relies on it, so `&mut &mut String` as a `dyn Write` passed its place. Co-Authored-By: Claude Opus 5.5 --- ts/src/lower/dynamic.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/ts/src/lower/dynamic.rs b/ts/src/lower/dynamic.rs index 7d022b290..79004eb9f 100644 --- a/ts/src/lower/dynamic.rs +++ b/ts/src/lower/dynamic.rs @@ -514,6 +514,14 @@ impl<'tcx> Translator<'_, 'tcx> { return; }; let mut b = Body::new(self); + // What a `&mut` receiver points at, where std's mapping takes that, as a call's + // operands pass it. + let receiver = match b.t.mapped(method.def_id, args) + && super::pointer::pointees(b.t, method.def_id, args).first() == Some(&true) + { + true => b.t.pointee_value(sig.inputs()[0], receiver), + false => receiver, + }; let mut params = Vec::new(); let mut values = Vec::new(); for (i, input) in sig.inputs()[1..].iter().enumerate() { From e6f549267894949fa9101115de05a925f7e072d8 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 14:21:49 -0800 Subject: [PATCH 10/11] perf(ts): key a hash collection of text by the text itself A HashMap or HashSet keyed by String or Cow hashed each key's text through the runtime's hasher into a chain, 2.3-4.0x main's JS string keys on the bench's str/keyed workloads. rs.HASH_TEXT files each key under its text as a JS map key, which the engine hashes, so a chain holds one key. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/codec/expected/bench.ts | 2 +- .../lang/collections/expected/collections.ts | 2 +- ts/fixtures/lang/cows/expected/cows.ts | 4 +-- ts/fixtures/lang/hashes/expected/hashes.ts | 2 +- ts/fixtures/stock/expected/maps.ts | 2 +- ts/runtime/rs/collections.ts | 29 ++++++++++++------- ts/runtime/rs/hash.ts | 5 +++- ts/src/lower/collections.rs | 4 +++ 8 files changed, 32 insertions(+), 18 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index ad407f3ef..3f88f1708 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -639,7 +639,7 @@ export function keyed(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const args3 = [(f: rs.Formatter) => rs.fmtPad(f, part), (f: rs.Formatter) => rs.u32Display(i2, f)]; return rs.fmtFormat([args3[0], "/", args3[1]]); }), undefined, 12, true); - const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashMap; + const map: rs.HashMap = rs.hashNew(rs.HASH_TEXT) as rs.HashMap; const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(keys.items)); while (true) { const _32: [rs.usize, rs.String] | rs.Done = iter.next(); diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index 6c8e84cd1..a2e262077 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -364,7 +364,7 @@ export function hashMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } rs.byteVecPush(out, rs.hashLen(tuples) & 0xff); } else { - const words: rs.HashMap = rs.hashNew(rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashMap; + const words: rs.HashMap = rs.hashNew(rs.HASH_TEXT) as rs.HashMap; for (const b6 of rs.byteSliceView(data)) { const _515: rs.usize = rs.usizeRem(b6 as rs.usize, rs.sliceFrom(["", "a", "ab", "b", "é", "", "￿", "𐀀"]).length); if (!(_515 < 8)) { diff --git a/ts/fixtures/lang/cows/expected/cows.ts b/ts/fixtures/lang/cows/expected/cows.ts index 494e8ecb2..c31c7ddc5 100644 --- a/ts/fixtures/lang/cows/expected/cows.ts +++ b/ts/fixtures/lang/cows/expected/cows.ts @@ -367,10 +367,10 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeSet, _336, true, undefined, undefined, 12, true), [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rest } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]), borrows), "next"); const _347: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeIter(counts); - const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.eqStr, true)) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); + const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.HASH_TEXT) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(hashed, (first as unknown) as rs.StrCow), 255)); rs.byteVecPush(out, rs.hashContains(hashed, (rest as unknown) as rs.StrCow) ? 1 : 0); - const both: rs.HashSet = rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.eqStr, true)) as rs.HashSet; + const both: rs.HashSet = rs.hashNew(rs.HASH_TEXT) as rs.HashSet; const _361: rs.StrCow = cow(first, owned); rs.hashAdd(both, _361); const _366: rs.StrCow = cow(first, !owned); diff --git a/ts/fixtures/lang/hashes/expected/hashes.ts b/ts/fixtures/lang/hashes/expected/hashes.ts index 457409960..3a7a4ad97 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.ts @@ -1249,7 +1249,7 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_2, 4)))); }); - return rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashSet, _3, undefined, undefined, 117440512); + return rs.hashExtendKeys(rs.hashNew(rs.HASH_TEXT) as rs.HashSet, _3, undefined, undefined, 117440512); }; const _175: (a0: rs.ByteSlice) => hashes_Index.Index = (bytes4: rs.ByteSlice): hashes_Index.Index => { const _46: rs.Iter<[rs.u8, rs.String]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, rs.String] => { diff --git a/ts/fixtures/stock/expected/maps.ts b/ts/fixtures/stock/expected/maps.ts index b89968b39..5d9fbff43 100644 --- a/ts/fixtures/stock/expected/maps.ts +++ b/ts/fixtures/stock/expected/maps.ts @@ -33,7 +33,7 @@ export function put(out: rs.ByteVec, n: rs.usize): void { export function map(data: rs.ByteSlice, out: rs.ByteVec): void { const own: rs.HashMap = rs.hashNew() as rs.HashMap; const pairs: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; - const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512, rs.hashing(rs.hashStr, rs.eqStr, true)) as rs.HashSet; + const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512, rs.HASH_TEXT) as rs.HashSet; const iter: rs.Iter = rs.byteSliceChunks(data, 2); while (true) { const _12: rs.ByteSlice | rs.Done = iter.next(); diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index f45d44266..11cee0aea 100644 --- a/ts/runtime/rs/collections.ts +++ b/ts/runtime/rs/collections.ts @@ -17,7 +17,7 @@ import { Borrowed, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; -import type { Hashing } from "./hash.ts"; +import type { HashKey, Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; import type { String as RsString } from "./str.ts"; import { @@ -321,6 +321,13 @@ function textOf(s: string | RsString | Borrowed): string { return typeof s === "string" ? s : s instanceof Borrowed ? s.slice : s.v; } +/** + * How a hash collection finds a key that is a `String` or a `Cow`, or a `str` looking + * one up: by its text, which the engine hashes as a JS map key, so the keys filed under + * one are equal. + */ +export const HASH_TEXT: Hashing> = { hash: textOf, eq: () => true, all: true }; + /** `PartialEq::eq` of tuples, from each field's. */ export function eqTuple(fields: readonly ((a: never, b: never) => boolean)[]): (a: T, b: T) => boolean { return (a, b) => { @@ -455,12 +462,12 @@ interface Slot { * `HashMap`, and `HashSet` as a map to `undefined`, std's or hashbrown's. A key * that is a JS primitive, a number, string, or boolean, is its own JS map key, as Rust * compares it; a key that is an object goes by its hash, to a chain of the keys `Eq` - * tells apart. Iteration visits the first kind in insertion order and then the second by + * tells apart, or by its text where it is a `String` or a `Cow`, as `HASH_TEXT` finds one. Iteration visits the first kind in insertion order and then the second by * hash, an order Rust leaves unspecified. */ export interface HashMap { p: Map; - o: Map> | undefined; + o: Map> | undefined; /** How many keys `o` holds. */ n: number; /** How to find a key that is an object, or `undefined` if no key is one. */ @@ -495,7 +502,7 @@ function hashed(m: HashMap, key: K): boolean { * The slot holding a key equal to `key`, a hashed key whose hash is `hash` if given, which * compares by `key`'s `eq`, as std's lookups do. */ -function slot(m: HashMap, key: K, hash?: number): Slot | undefined { +function slot(m: HashMap, key: K, hash?: HashKey): Slot | undefined { const h = m.h as Hashing; for (let s = m.o?.get(hash ?? h.hash(key)); s !== undefined; s = s.next) if (h.eq(key, s.k)) return s; return undefined; @@ -702,8 +709,8 @@ export function hashRemoveEntry(m: HashMap, key: K): [K, V] | undefi } /** Take `s`, a slot whose key's hash is `hash`, out of `m`. */ -function unlink(m: HashMap, hash: number, s: Slot): void { - const o = m.o as Map>; +function unlink(m: HashMap, hash: HashKey, s: Slot): void { + const o = m.o as Map>; let prev = o.get(hash) as Slot; if (prev === s) { if (s.next !== undefined) o.set(hash, s.next); @@ -829,9 +836,9 @@ function retainHash(m: HashMap, f: (key: K, value: V | Place) => class HashExtractIf extends Iter implements Disposable { private readonly m: HashMap; private readonly p: Iterator<[K, V]>; - private readonly o: Iterator<[number, Slot]> | undefined; + private readonly o: Iterator<[HashKey, Slot]> | undefined; /** The chain it reads, by its hash, the slot it reads next, and the last it kept there. */ - private hash = 0; + private hash: HashKey = 0; private at: Slot | undefined; private kept: Slot | undefined; private readonly f: (key: K, value: V | Place) => boolean; @@ -865,7 +872,7 @@ class HashExtractIf extends Iter implements Disposable { return (this.keys ? key : [key, now]) as T; } if (this.at === undefined) { - [this.hash, this.at] = (this.o as Iterator<[number, Slot]>).next().value as [number, Slot]; + [this.hash, this.at] = (this.o as Iterator<[HashKey, Slot]>).next().value as [HashKey, Slot]; this.kept = undefined; } const s = this.at; @@ -874,7 +881,7 @@ class HashExtractIf extends Iter implements Disposable { this.kept = s; continue; } - const o = m.o as Map>; + const o = m.o as Map>; if (this.kept !== undefined) this.kept.next = s.next; else if (s.next !== undefined) o.set(this.hash, s.next); else o.delete(this.hash); @@ -3091,7 +3098,7 @@ export interface Entry { readonly o: boolean; /** A hashed key's slot if it is occupied, and its hash. */ readonly s: Slot | undefined; - readonly h: number | undefined; + readonly h: HashKey | undefined; /** A B-tree's node holding the key, and its index there, or else the leaf and the complement of where it goes. */ readonly l: Node | undefined; readonly i: number; diff --git a/ts/runtime/rs/hash.ts b/ts/runtime/rs/hash.ts index e25674d8f..c5018c119 100644 --- a/ts/runtime/rs/hash.ts +++ b/ts/runtime/rs/hash.ts @@ -757,9 +757,12 @@ export function hashFinish(s: Hasher): u64 { return s.finish(); } +/** The JS map key a hash collection files a key that is a JS object under: its hash, or its text. */ +export type HashKey = number | string; + /** How a hash collection finds a key that is a JS object: its `Hash` and `Eq`. */ export interface Hashing { - readonly hash: (key: K) => number; + readonly hash: (key: K) => HashKey; readonly eq: (a: K, b: K) => boolean; /** Whether a key that is a JS primitive goes by them too: an enum with its own `Eq`. */ readonly all: boolean; diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 65537a8de..72886b8f4 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -1111,6 +1111,10 @@ fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span b.t.err(span, format!("hashing by the hasher of `{coll}`")); return None; }; + // Text goes by itself, as a JS map key the engine hashes. + if library::owned_string(b.t.tcx, peeled) || library::cow_str(b.t.tcx, peeled) { + return Some(Some(Expr::Rs("HASH_TEXT".into()))); + } let mut values = vec![hash_fn(b, key, hasher, span), eq_fn(b, key, span)]; // A fieldless enum is a JS string, and a bound value may be any primitive, which its // own `Eq` may tell apart where JS can't, and a `String` and an owned `Cow` are From 06272388ac349b4bd05c9c4801c48c5d0d191296 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 14:50:54 -0800 Subject: [PATCH 11/11] fix(ts): clone a str into a String, as std's clone_into clears and pushes it Co-Authored-By: Claude Opus 5.5 --- .../lang/capacity/expected/capacity.ts | 98 ++++++++++--------- ts/fixtures/lang/capacity/src/capacity.rs | 7 +- ts/runtime/rs/str.ts | 10 +- ts/tests/fixtures.rs | 4 +- 4 files changed, 65 insertions(+), 54 deletions(-) diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 0c81f1fa6..653b24bd7 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -3714,9 +3714,9 @@ export function boundary(s: string, arg: rs.u8): rs.usize { */ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): void { let s!: rs.String; - let _314!: rs.String; - let _346!: rs.String; - let _417!: rs.String; + let _318!: rs.String; + let _350!: rs.String; + let _421!: rs.String; const _4: (a0: rs.u8) => string = (arg2: rs.u8): string => { const _42: rs.usize = rs.usizeRem(arg2 as rs.usize, rs.sliceFrom(["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]).length); if (!(_42 < 4)) { @@ -3817,7 +3817,11 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi let over: rs.String = rs.stringWithCapacity(rs.u8Rem(arg, 24) as rs.usize); const _214: string = _4(arg >> 2); rs.stringPushStr(over, _214); - over = rs.stringCloneFrom(over, s); + if ((arg & 128) === 0) { + over = rs.stringCloneFrom(over, s); + } else { + over = rs.stringCloneFrom(over, s.v); + } s = over; } else if (_64 === 21) { rs.stringExtendChars(s, rs.iterFilter(rs.strChars(_4(arg)), (c3: rs.char): boolean => { @@ -3832,10 +3836,10 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 25) { rs.stringPushStr(s, _4(arg)); } else if (_64 === 26) { - const _264: rs.String = s; - const _268: string = _4(arg >> 2); - const args18 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, _268)]; - rs.resultUnwrap(rs.fmtWriteString(_264, [args18[0], "-", args18[1]]), rs.fmtErrorDebug); + const _268: rs.String = s; + const _272: string = _4(arg >> 2); + const args18 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, _272)]; + rs.resultUnwrap(rs.fmtWriteString(_268, [args18[0], "-", args18[1]]), rs.fmtErrorDebug); } else if (_64 === 27) { const args17 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.u8Display(arg, f)]; s = rs.fmtFormat([args17[0], args17[1]]); @@ -3847,24 +3851,24 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 30) { s = rs.fmtFormat(["text alone"]); } else if (_64 === 31) { - const _315: rs.u8 = rs.u8Rem(arg, 6); - if (_315 === 0) { - const _318: rs.i8 = (arg << 24) >> 24; - _314 = rs.fmtToString((f: rs.Formatter) => rs.i8Display(_318, f), 3); - } else if (_315 === 1) { - const _320: rs.i32 = rs.i32Sub(arg as rs.i32, 128); - _314 = rs.fmtToString((f: rs.Formatter) => rs.i32Display(_320, f), 10); - } else if (_315 === 2) { - _314 = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); - } else if (_315 === 3) { - _314 = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(c, f), 0); - } else if (_315 === 4) { - const _326: boolean = rs.u8Rem(arg, 2) === 0; - _314 = rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_326, f), 0); + const _319: rs.u8 = rs.u8Rem(arg, 6); + if (_319 === 0) { + const _322: rs.i8 = (arg << 24) >> 24; + _318 = rs.fmtToString((f: rs.Formatter) => rs.i8Display(_322, f), 3); + } else if (_319 === 1) { + const _324: rs.i32 = rs.i32Sub(arg as rs.i32, 128); + _318 = rs.fmtToString((f: rs.Formatter) => rs.i32Display(_324, f), 10); + } else if (_319 === 2) { + _318 = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); + } else if (_319 === 3) { + _318 = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(c, f), 0); + } else if (_319 === 4) { + const _330: boolean = rs.u8Rem(arg, 2) === 0; + _318 = rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_330, f), 0); } else { - _314 = rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f)]); + _318 = rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f)]); } - s = _314; + s = _318; } else if (_64 === 32) { s = rs.strToLowercase(s.v); } else if (_64 === 33) { @@ -3872,21 +3876,21 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi } else if (_64 === 34) { s = rs.stringFrom(rs.strToAsciiUppercase(s.v)); } else if (_64 === 35) { - const _347: rs.u8 = rs.u8Rem(arg, 5); - if (_347 === 0) { - _346 = rs.strReplace(s.v, "a", "b", true); - } else if (_347 === 1) { - _346 = rs.strReplace(s.v, "a", "xyz", true); - } else if (_347 === 2) { - _346 = rs.strReplace(s.v, String.fromCodePoint(c), "", true); - } else if (_347 === 3) { - _346 = rs.strReplace(s.v, (c2: rs.char): boolean => { + const _351: rs.u8 = rs.u8Rem(arg, 5); + if (_351 === 0) { + _350 = rs.strReplace(s.v, "a", "b", true); + } else if (_351 === 1) { + _350 = rs.strReplace(s.v, "a", "xyz", true); + } else if (_351 === 2) { + _350 = rs.strReplace(s.v, String.fromCodePoint(c), "", true); + } else if (_351 === 3) { + _350 = rs.strReplace(s.v, (c2: rs.char): boolean => { return rs.charIsAlphabetic(c2); }, "-", false); } else { - _346 = rs.strReplace(s.v, rs.stringFrom("é").v, "e", true); + _350 = rs.strReplace(s.v, rs.stringFrom("é").v, "e", true); } - s = _346; + s = _350; } else if (_64 === 36) { s = rs.strReplacen(s.v, "a", "bc", rs.u8Rem(arg, 3) as rs.usize); } else if (_64 === 37) { @@ -3900,37 +3904,37 @@ export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): voi sized(out, bytes3.length, bytes3.data.length); s = rs.resultUnwrap(rs.stringFromUtf8(bytes3), rs.fmtFromUtf8ErrorDebug); } else if (_64 === 39) { - const _400: rs.Iter = rs.iterRev(rs.strChars(s.v)); - s = rs.stringExtendChars(rs.stringNew(), _400); + const _404: rs.Iter = rs.iterRev(rs.strChars(s.v)); + s = rs.stringExtendChars(rs.stringNew(), _404); } else if (_64 === 40) { s = rs.stringFromStrings(rs.vecIntoIter(rs.vecFrom([s, rs.stringFrom(_4(arg))]))); } else if (_64 === 41) { const units: rs.Vec = rs.iterToVec(rs.strEncodeUtf16(s.v), "next", 2); if (rs.u8Rem(arg, 2) === 0) { - _417 = rs.resultUnwrap(rs.stringFromUtf16(rs.sliceFrom(units.items)), rs.fmtFromUtf16ErrorDebug); + _421 = rs.resultUnwrap(rs.stringFromUtf16(rs.sliceFrom(units.items)), rs.fmtFromUtf16ErrorDebug); } else { - _417 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); + _421 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); } - s = _417; + s = _421; } else if (_64 === 42) { const bytes4: rs.ByteVec = rs.stringIntoBytes(s); rs.byteVecPush(bytes4, 255); s = rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteVecSlice(bytes4))); } else if (_64 === 43) { - const _434: rs.Slice = rs.sliceFrom([s.v, _4(arg)]); - const _442: string = _4(arg >> 2); - s = rs.strsJoin(rs.sliceItems(_434), _442); + const _438: rs.Slice = rs.sliceFrom([s.v, _4(arg)]); + const _446: string = _4(arg >> 2); + s = rs.strsJoin(rs.sliceItems(_438), _446); } else if (_64 === 44) { s = rs.stringFrom(s.v); } else if (_64 === 45) { let cow: rs.StrCow = new rs.Borrowed(_4(arg)); cow = rs.strCowAdd(cow, new rs.Borrowed(s.v)); - const _461: string = _4(arg >> 2); - cow = rs.strCowAdd(cow, new rs.Borrowed(_461)); + const _465: string = _4(arg >> 2); + cow = rs.strCowAdd(cow, new rs.Borrowed(_465)); s = rs.strCowIntoOwned(cow); } else if (_64 === 46) { - const _470: string[] = [_4(arg), _4(arg >> 2)]; - s = rs.stringExtendArray(rs.stringNew(), rs.iterSlice(_470)); + const _474: string[] = [_4(arg), _4(arg >> 2)]; + s = rs.stringExtendArray(rs.stringNew(), rs.iterSlice(_474)); } else if (_64 === 47) { s = rs.stringAdd(rs.replaceIn(s, rs.stringNew()), _4(arg)); } diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index 94acf3d4d..61a5ba27b 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -718,11 +718,14 @@ pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { sized(out, copy.len(), copy.capacity()); s = s.clone(); } - // Grown from `with_capacity` only where it holds fewer. + // Grown from `with_capacity` only where it holds fewer, by a `String`'s or a `str`'s. 20 => { let mut over = String::with_capacity(usize::from(arg % 24)); over.push_str(text(arg >> 2)); - over.clone_from(&s); + match arg & 0x80 { + 0 => over.clone_from(&s), + _ => s.as_str().clone_into(&mut over), + } s = over; } 21 => s.extend(text(arg).chars().filter(|c| *c != 'e')), diff --git a/ts/runtime/rs/str.ts b/ts/runtime/rs/str.ts index c4184117c..cde28f933 100644 --- a/ts/runtime/rs/str.ts +++ b/ts/runtime/rs/str.ts @@ -1379,11 +1379,15 @@ export function stringClone(s: RsString): RsString { return new RsString(s.v, s.len, s.len); } -/** `clone_from` of `src` into `s`, as `Vec`'s clears it and extends it by `src`'s bytes. */ -export function stringCloneFrom(s: RsString, src: RsString): RsString { +/** + * `clone_from` of `src` into `s`, as `Vec`'s clears it and extends it by `src`'s bytes, + * and `str::clone_into`, which clears it and pushes the text. + */ +export function stringCloneFrom(s: RsString, src: RsString | string): RsString { s.v = ""; s.len = 0 as usize; - stringPushStr(s, src.v, src.len); + if (typeof src === "string") stringPushStr(s, src); + else stringPushStr(s, src.v, src.len); return s; } diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index d73706f19..6a2663d74 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -813,8 +813,8 @@ fn bind() { /// A package and its dependency translate as one program, trait objects of the /// dependency's trait and its safe twin of its `unsafe` included, and run as native Rust /// does. Its `unsafe` that nothing binds is refused at its span, and so are a module of -/// the package's that would share the dependency's files, two instances whose suffixes -/// are alike, and the package's read of the capacity of the dependency's `String` bytes. +/// the package's that would share the dependency's files, and two instances whose +/// suffixes are alike. #[test] fn crates() { let out = translated("crates");