From 4118cd3b80eae5a09da207146a5dbff475ea16b5 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 16:51:48 -0700 Subject: [PATCH 1/2] chore(quest): claim quest/m2/ts-model/kio-std.md Quest-Claim: e0bb8a6498a2f827 From 0e4bacbbbcf94cca2583dca7562e84f1bdeb6c9f Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 19:41:20 -0700 Subject: [PATCH 2/2] feat(ts): translate array::from_fn and maps whose values can be undefined array::from_fn calls its function on each index in order, into an array or, of bytes, a Uint8Array. A HashMap's or BTreeMap's value can now be an Option or (): get, get_mut, insert, and remove take the Option's rt.None last, so None stays apart from Some(None). Keys and set and deque items that can be undefined still fail with a span. Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-model/README.md | 1 - quest/m2/ts-model/kio-std.md | 24 -- ts/README.md | 2 +- ts/fixtures/lang/expected/arrays.ts | 97 ++++++ ts/fixtures/lang/expected/collections.ts | 400 ++++++++++++++++++++++- ts/fixtures/lang/expected/combinators.ts | 6 +- ts/fixtures/lang/expected/core/option.ts | 2 +- ts/fixtures/lang/expected/fmt.ts | 5 +- ts/fixtures/lang/expected/harness.ts | 68 ++-- ts/fixtures/lang/expected/lib.ts | 21 ++ ts/fixtures/lang/expected/wrappers.ts | 29 +- ts/fixtures/lang/src/arrays.rs | 57 ++++ ts/fixtures/lang/src/collections.rs | 121 +++++++ ts/fixtures/lang/src/harness.rs | 6 +- ts/fixtures/lang/src/lib.rs | 5 +- ts/fixtures/reject/census.md | 7 +- ts/fixtures/reject/expected.txt | 2 +- ts/fixtures/reject/src/lib.rs | 6 +- ts/runtime/rt.ts | 14 + ts/runtime/rt/collections.ts | 56 +++- ts/src/lower/collections.rs | 31 +- ts/src/lower/library.rs | 16 +- 22 files changed, 852 insertions(+), 124 deletions(-) delete mode 100644 quest/m2/ts-model/kio-std.md create mode 100644 ts/fixtures/lang/expected/arrays.ts create mode 100644 ts/fixtures/lang/src/arrays.rs diff --git a/quest/m2/ts-model/README.md b/quest/m2/ts-model/README.md index 5aab22361..7efd4094d 100644 --- a/quest/m2/ts-model/README.md +++ b/quest/m2/ts-model/README.md @@ -50,6 +50,5 @@ Public API: the translator's output for moq-net's model. - [Float formatting](/quest/m2/ts-model/floats.md) - `f64` formats and parses as std does - [The rest of std the model reaches](/quest/m2/ts-model/std-rest.md) - `Vec` and `VecDeque` capacity, and `RandomState` - [Writes through places the model still refuses](/quest/m2/ts-model/places.md) - `get_or_insert_default` through a `&mut`, and `mem::take` of a captured `&mut Vec` -- [std gaps kio reaches](/quest/m2/ts-model/kio-std.md) - `array::from_fn`, `Default` of arrays and `()`, and maps of `Option`s - [bytes' BytesMut, Buf, and BufMut](/quest/m2/ts-model/bytes.md) - map without config, so the model's `BytesMut` binding goes - [Async in the TypeScript translator](/quest/m2/ts-async.md) - kio's producers and consumers are futures diff --git a/quest/m2/ts-model/kio-std.md b/quest/m2/ts-model/kio-std.md deleted file mode 100644 index 6bc7b0240..000000000 --- a/quest/m2/ts-model/kio-std.md +++ /dev/null @@ -1,24 +0,0 @@ -# [S] std gaps kio reaches - -## Goal - -rust2-ts translates the std that kio reaches and no other quest owns, proven by -differential tests against native Rust: `array::from_fn`, `Default` of arrays (kio's -`[Atomic; 8]::default()`) and of `()`, and a `HashMap` whose values are `Option`s -(`shared.rs`). - -## Plan - -Found by [#167](https://github.com/kixelated/rust2/pull/167) and -[#183](https://github.com/kixelated/rust2/pull/183). kio's `static` atomics belong to -[shared ownership](/quest/m2/ts-shared.md). Kept apart from -[the rest of std](/quest/m2/ts-model/std-rest.md), whose capacity work is a hot-path change -of its own. - -- `Default` and `from_fn` of an array run element by element in index order, which an - element whose constructor has effects or panics observes. -- A map of `Option`s needs its `Option`-returning methods (`get`, `insert`, `remove`) to - tell `None` from `Some(None)`; [#134](https://github.com/kixelated/rust2/pull/134) gave - `rt.None` for that. - -Public API: the translator's output. diff --git a/ts/README.md b/ts/README.md index a4adb6208..a43244f2c 100644 --- a/ts/README.md +++ b/ts/README.md @@ -506,7 +506,7 @@ These fail translation: formatting and parsing an `f64`, and `f64::clamp`, whose that drops given to a std function that drops it beside another value that drops, as `for_each` of items that drop does, or keeps it other than in an iterator adaptor, and values that drop in some iterators ([drop order](/quest/m3/ts-drop-order.md)), a `Cow` of other than `str`, -a collection holding a type that can be `undefined`, as `()` and `Option` can, a std +a collection's key or item of a type that can be `undefined`, as `()` and `Option` can (a map's value can be), a std function without a mapping of its own that makes or reads an `Option` whose `None` is `rt.None`, as `find` over `Option`s does, an `Option` of an `Option` of `()` or another `Option`, an instance of a generic type whose field is an `Option` of a type parameter diff --git a/ts/fixtures/lang/expected/arrays.ts b/ts/fixtures/lang/expected/arrays.ts new file mode 100644 index 000000000..cfc2e7204 --- /dev/null +++ b/ts/fixtures/lang/expected/arrays.ts @@ -0,0 +1,97 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** Each byte an operation, its value the operand; each puts what it read. */ +export function fromFns(data: rt.ByteSlice, out: rt.ByteVec): void { + let s!: string; + for (const op of rt.byteSliceView(data)) { + const _10: rt.u8 = rt.u8Rem(op, 5); + if (_10 === 0) { + const seen: rt.usize[] = []; + const bytes: Uint8Array = rt.bytesFromFn(4, (i6: rt.usize): rt.u8 => { + seen.push(i6); + return rt.u8WrappingMul(op, rt.u8Add(i6 & 0xff, 1)); + }); + const wide: rt.u64[] = rt.arrayFromFn(3, (i7: rt.usize): rt.u64 => { + return rt.u64Shl(op as rt.u64, rt.usizeMul(i7, 30)); + }); + const _23: rt.ByteSlice = rt.byteSliceFrom(bytes); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_23), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(wide, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtList(seen, f, rt.usizeDebug)]; + s = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + } else if (_10 === 1) { + const counts: rt.Atomic[] = rt.arrayFromFn(8, (_2: rt.usize): rt.Atomic => { + return new rt.Atomic(op as rt.u64); + }); + const _37: rt.usize = rt.u8Rem(op, 8) as rt.usize; + if (!(_37 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _37); + } + rt.atomicFetch(counts[_37], rt.u64WrappingAdd, 1, 0); + const copy: rt.Atomic[] = rt.arrayFromFn(8, (i4: rt.usize): rt.Atomic => { + if (!(i4 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i4); + } + return new rt.Atomic(rt.atomicLoad(counts[i4], 0)); + }); + rt.atomicStore(copy[0], 0, 0); + const loads: rt.u64[] = rt.arrayFromFn(8, (i5: rt.usize): rt.u64 => { + if (!(i5 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i5); + } + return rt.atomicLoad(counts[i5], 0); + }); + const _57: rt.u64 = rt.atomicLoad(copy[0], 0); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(loads, f, rt.u64Debug), (f: rt.Formatter) => rt.u64Display(_57, f)]; + s = rt.fmtFormat([args4[0], " ", args4[1]]); + } else if (_10 === 2) { + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(op, f)]; + const captured = rt.fmtFormat(["w", args6[0]]); + const words: string[] = rt.arrayFromFn(3, (i2: rt.usize): string => { + const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, captured), (f: rt.Formatter) => rt.usizeDisplay(i2, f)]; + return rt.fmtFormat([args14[0], args14[1]]); + }); + const _79: string[] = rt.arrayFromFn(0, (i3: rt.usize): string => { + return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(i3, f)); + }); + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(words, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(_79, f, rt.fmtStr)]; + s = rt.fmtFormat([args8[0], " ", args8[1]]); + } else if (_10 === 3) { + const grid: Uint8Array[] = rt.arrayFromFn(3, (i: rt.usize): Uint8Array => { + return rt.bytesFromFn(2, (j: rt.usize): rt.u8 => { + return rt.u8WrappingAdd(op, rt.usizeAdd(rt.usizeMul(i, 2), j) & 0xff); + }); + }); + const named: rt.u16[] = rt.arrayFromFn(4, doubled); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(grid, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(named, f, rt.u16Debug)]; + s = rt.fmtFormat([args10[0], " ", args10[1]]); + } else { + const _108: rt.usize[] = counted$2(op); + const _110: rt.usize[] = counted$5(op); + const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(_108, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtList(_110, f, rt.usizeDebug)]; + s = rt.fmtFormat([args12[0], " ", args12[1]]); + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + rt.byteVecPush(out, 10); + } +} + +export function doubled(i: rt.usize): rt.u16 { + return rt.u16Mul(i & 0xffff, 2); +} + +/** An array as long as `N` says, of `N` instances. */ +export function counted$2(op: rt.u8): rt.usize[] { + return rt.arrayFromFn(2, (i: rt.usize): rt.usize => { + return rt.usizeAdd(rt.usizeMul(i, 2), op as rt.usize); + }); +} + +/** An array as long as `N` says, of `N` instances. */ +export function counted$5(op: rt.u8): rt.usize[] { + return rt.arrayFromFn(5, (i: rt.usize): rt.usize => { + return rt.usizeAdd(rt.usizeMul(i, 5), op as rt.usize); + }); +} + +//# sourceMappingURL=arrays.ts.map diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index a0a466758..fc7dbb716 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$Bumped, copy$Tally, copy$Wrap_u8, copy$u8_Tally, copy$u8_str, copy$u8_u16, copy$u8_u16s, copy$u8_u8, copy$u8_u8s } from "./lib.ts"; +import { copy$Bumped, copy$Tally, copy$Wrap_u8, copy$u8_Tally, copy$u8_bool, copy$u8_str, copy$u8_u16, copy$u8_u16s, copy$u8_u8, copy$u8_u8s } from "./lib.ts"; import * as Clash from "./collections.Clash.ts"; import * as Cloned from "./collections.Cloned.ts"; import * as Dir from "./collections.Dir.ts"; @@ -11,7 +11,8 @@ import * as Nibble from "./collections.Nibble.ts"; import * as Pair from "./collections.Pair.ts"; import * as Rank from "./collections.Rank.ts"; import * as Tally from "./collections.Tally.ts"; -import { unwrapOr$Option_u16, unwrapOr$Option_u8, mapOr$Option_Nibble_u8_sets_closure4, mapOr$Option_Rank_Tally_u8_hash_maps_closure11, mapOr$Option_Tally_u8_hash_maps_closure10, mapOr$Option_u16_u8_hash_maps_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOr$Option_u8_u8_u8s_stores_closure2_closure0 } from "./core/option.ts"; +import { thenSome$bool_u8 } from "./core/bool.ts"; +import { unwrapOr$Option_u16, unwrapOr$Option_u8, map$Option_u8_String_optionals_closure2_closure0, mapOr$Option_Nibble_u8_sets_closure4, mapOr$Option_Rank_Tally_u8_hash_maps_closure11, mapOr$Option_Tally_u8_hash_maps_closure10, mapOr$Option_u16_u8_hash_maps_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOr$Option_u8_u8_u8s_stores_closure2_closure0, clone$Clone_Option_String, flatten$Option_Option_u8 } from "./core/option.ts"; import * as Wrap from "./generics.Wrap.ts"; import * as Bumped from "./iters.Bumped.ts"; @@ -1176,4 +1177,399 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); } +export function get$OptionMap_Option_String_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8): string | undefined | rt.None { + return rt.hashGet(self, k, rt.None); +} + +export function get$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8): rt.u8 | undefined | rt.None { + return rt.hashGet(self, k, rt.None); +} + +export function get$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap, k: rt.u8): undefined | rt.None { + return rt.hashGet(self, k, rt.None); +} + +export function insert$OptionMap_Option_String_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8, v: string | undefined): string | undefined | rt.None { + return rt.hashInsert(self, k, v, undefined, rt.None); +} + +export function insert$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8, v: rt.u8 | undefined): rt.u8 | undefined | rt.None { + return rt.hashInsert(self, k, v, undefined, rt.None); +} + +export function insert$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap, k: rt.u8, _: undefined): undefined | rt.None { + return rt.hashInsert(self, k, undefined, undefined, rt.None); +} + +export function remove$OptionMap_Option_String_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8): string | undefined | rt.None { + return rt.hashRemove(self, k, undefined, rt.None); +} + +export function remove$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8): rt.u8 | undefined | rt.None { + return rt.hashRemove(self, k, undefined, rt.None); +} + +export function remove$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap, k: rt.u8): undefined | rt.None { + return rt.hashRemove(self, k, undefined, rt.None); +} + +export function getMut$OptionMap_Option_String_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8): rt.Place | undefined { + return rt.hashGetMut(self, k); +} + +export function getMut$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8): rt.Place | undefined { + return rt.hashGetMut(self, k); +} + +export function getMut$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap, k: rt.u8): rt.Place | undefined { + return rt.hashGetMut(self, k); +} + +export function sorted$OptionMap_Option_String_HashMap_u8_Option_String(self: rt.HashMap): [rt.u8, string | undefined][] { + const all: [rt.u8, string | undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, string | undefined]): [rt.u8, string | undefined] => { + return [_2[0], clone$Clone_Option_String(_2[1])] as [rt.u8, string | undefined]; + })); + rt.sliceSortByKey(all, (_22: [rt.u8, string | undefined]): rt.u8 => { + return _22[0]; + }, rt.cmpLt(rt.cmp)); + return all; +} + +export function sorted$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap): [rt.u8, rt.u8 | undefined][] { + const all: [rt.u8, rt.u8 | undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { + return [_2[0], _2[1]] as [rt.u8, rt.u8 | undefined]; + })); + rt.sliceSortByKey(all, (_22: [rt.u8, rt.u8 | undefined]): rt.u8 => { + return _22[0]; + }, rt.cmpLt(rt.cmp)); + return all; +} + +export function sorted$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap): [rt.u8, undefined][] { + const all: [rt.u8, undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, undefined]): [rt.u8, undefined] => { + const _5: rt.u8 = _2[0]; + _2[1]; + return [_5, undefined] as [rt.u8, undefined]; + })); + rt.sliceSortByKey(all, (_22: [rt.u8, undefined]): rt.u8 => { + return _22[0]; + }, rt.cmpLt(rt.cmp)); + return all; +} + +export function get$OptionMap_Option_u8_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8): rt.u8 | undefined | rt.None { + return rt.btreeGet(self, k, rt.None); +} + +export function get$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8): undefined | rt.None { + return rt.btreeGet(self, k, rt.None); +} + +export function insert$OptionMap_Option_u8_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8, v: rt.u8 | undefined): rt.u8 | undefined | rt.None { + return rt.btreeInsert(self, k, v, undefined, rt.None); +} + +export function insert$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8, _: undefined): undefined | rt.None { + return rt.btreeInsert(self, k, undefined, undefined, rt.None); +} + +export function remove$OptionMap_Option_u8_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8): rt.u8 | undefined | rt.None { + return rt.btreeRemove(self, k, undefined, rt.None); +} + +export function remove$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8): undefined | rt.None { + return rt.btreeRemove(self, k, undefined, rt.None); +} + +export function getMut$OptionMap_Option_u8_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8): rt.Place | undefined { + return rt.btreeGetMut(self, k); +} + +export function getMut$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8): rt.Place | undefined { + return rt.btreeGetMut(self, k); +} + +export function sorted$OptionMap_Option_u8_BTreeMap_u8_Option_u8(self: rt.BTreeMap): [rt.u8, rt.u8 | undefined][] { + return rt.iterToArray(rt.iterMap(rt.btreeIter(self), (_22: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { + return [_22[0], _22[1]] as [rt.u8, rt.u8 | undefined]; + })); +} + +export function sorted$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap): [rt.u8, undefined][] { + return rt.iterToArray(rt.iterMap(rt.btreeIter(self), (_22: [rt.u8, undefined]): [rt.u8, undefined] => { + const _5: rt.u8 = _22[0]; + _22[1]; + return [_5, undefined] as [rt.u8, undefined]; + })); +} + +/** + * 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_HashMap_u8_Option_String(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => string | undefined, out: rt.ByteVec): void { + let read!: string; + for (const b of rt.byteSliceView(data)) { + const k: rt.u8 = rt.u8Rem(b, 8); + const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + if (_14 === 0) { + const _24: string | undefined = value(b); + const part3 = insert$OptionMap_Option_String_HashMap_u8_Option_String(map, k, _24); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, (value: string | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr), rt.None)]; + read = rt.fmtFormat([args2[0], " "]); + } else if (_14 === 1) { + const part2 = get$OptionMap_Option_String_HashMap_u8_Option_String(map, k); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: string | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr), rt.None)]; + read = rt.fmtFormat([args4[0], " "]); + } else if (_14 === 2) { + const part = remove$OptionMap_Option_String_HashMap_u8_Option_String(map, k); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: string | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr), rt.None)]; + read = rt.fmtFormat([args6[0], " "]); + } else { + const _49: rt.Place | undefined = getMut$OptionMap_Option_String_HashMap_u8_Option_String(map, k); + if (_49 === undefined) { + read = "- "; + } else { + const v: rt.Place = _49; + const _53: string | undefined = value(rt.u8Div(b, 2)); + v.v = _53; + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v.v, f, rt.fmtStr)]; + read = rt.fmtFormat(["=", args8[0], " "]); + } + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + } + const part4 = sorted$OptionMap_Option_String_HashMap_u8_Option_String(map); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, (value: [rt.u8, string | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.fmtStr)], f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); +} + +/** + * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and + * `value` making what `insert` and `get_mut` put. + */ +export function optional$Option_u8_BTreeMap_u8_Option_u8(map: rt.BTreeMap, data: rt.ByteSlice, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { + let read!: string; + for (const b of rt.byteSliceView(data)) { + const k: rt.u8 = rt.u8Rem(b, 8); + const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + if (_14 === 0) { + const _24: rt.u8 | undefined = value(b); + const part3 = insert$OptionMap_Option_u8_BTreeMap_u8_Option_u8(map, k, _24); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; + read = rt.fmtFormat([args2[0], " "]); + } else if (_14 === 1) { + const part2 = get$OptionMap_Option_u8_BTreeMap_u8_Option_u8(map, k); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; + read = rt.fmtFormat([args4[0], " "]); + } else if (_14 === 2) { + const part = remove$OptionMap_Option_u8_BTreeMap_u8_Option_u8(map, k); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; + read = rt.fmtFormat([args6[0], " "]); + } else { + const _49: rt.Place | undefined = getMut$OptionMap_Option_u8_BTreeMap_u8_Option_u8(map, k); + if (_49 === undefined) { + read = "- "; + } else { + const v: rt.Place = _49; + const _53: rt.u8 | undefined = value(rt.u8Div(b, 2)); + v.v = _53; + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v.v, f, rt.u8Debug)]; + read = rt.fmtFormat(["=", args8[0], " "]); + } + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + } + const part4 = sorted$OptionMap_Option_u8_BTreeMap_u8_Option_u8(map); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); +} + +/** + * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and + * `value` making what `insert` and `get_mut` put. + */ +export function optional$Option_u8_HashMap_u8_Option_u8(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { + let read!: string; + for (const b of rt.byteSliceView(data)) { + const k: rt.u8 = rt.u8Rem(b, 8); + const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + if (_14 === 0) { + const _24: rt.u8 | undefined = value(b); + const part3 = insert$OptionMap_Option_u8_HashMap_u8_Option_u8(map, k, _24); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; + read = rt.fmtFormat([args2[0], " "]); + } else if (_14 === 1) { + const part2 = get$OptionMap_Option_u8_HashMap_u8_Option_u8(map, k); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; + read = rt.fmtFormat([args4[0], " "]); + } else if (_14 === 2) { + const part = remove$OptionMap_Option_u8_HashMap_u8_Option_u8(map, k); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; + read = rt.fmtFormat([args6[0], " "]); + } else { + const _49: rt.Place | undefined = getMut$OptionMap_Option_u8_HashMap_u8_Option_u8(map, k); + if (_49 === undefined) { + read = "- "; + } else { + const v: rt.Place = _49; + const _53: rt.u8 | undefined = value(rt.u8Div(b, 2)); + v.v = _53; + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v.v, f, rt.u8Debug)]; + read = rt.fmtFormat(["=", args8[0], " "]); + } + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + } + const part4 = sorted$OptionMap_Option_u8_HashMap_u8_Option_u8(map); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); +} + +/** + * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and + * `value` making what `insert` and `get_mut` put. + */ +export function optional$unit_BTreeMap_u8_unit(map: rt.BTreeMap, data: rt.ByteSlice, value: (a0: rt.u8) => void, out: rt.ByteVec): void { + let read!: string; + for (const b of rt.byteSliceView(data)) { + const k: rt.u8 = rt.u8Rem(b, 8); + const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + if (_14 === 0) { + value(b); + const part3 = insert$OptionMap_unit_BTreeMap_u8_unit(map, k, undefined); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.fmtUnit, rt.None)]; + read = rt.fmtFormat([args2[0], " "]); + } else if (_14 === 1) { + const part2 = get$OptionMap_unit_BTreeMap_u8_unit(map, k); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.fmtUnit, rt.None)]; + read = rt.fmtFormat([args4[0], " "]); + } else if (_14 === 2) { + const part = remove$OptionMap_unit_BTreeMap_u8_unit(map, k); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.fmtUnit, rt.None)]; + read = rt.fmtFormat([args6[0], " "]); + } else { + const _49: rt.Place | undefined = getMut$OptionMap_unit_BTreeMap_u8_unit(map, k); + if (_49 === undefined) { + read = "- "; + } else { + const v: rt.Place = _49; + value(rt.u8Div(b, 2)); + v.v = undefined; + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(v.v, f)]; + read = rt.fmtFormat(["=", args8[0], " "]); + } + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + } + const part4 = sorted$OptionMap_unit_BTreeMap_u8_unit(map); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, (value: [rt.u8, undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtUnit(value[1], f)], f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); +} + +/** + * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and + * `value` making what `insert` and `get_mut` put. + */ +export function optional$unit_HashMap_u8_unit(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => void, out: rt.ByteVec): void { + let read!: string; + for (const b of rt.byteSliceView(data)) { + const k: rt.u8 = rt.u8Rem(b, 8); + const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + if (_14 === 0) { + value(b); + const part3 = insert$OptionMap_unit_HashMap_u8_unit(map, k, undefined); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.fmtUnit, rt.None)]; + read = rt.fmtFormat([args2[0], " "]); + } else if (_14 === 1) { + const part2 = get$OptionMap_unit_HashMap_u8_unit(map, k); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.fmtUnit, rt.None)]; + read = rt.fmtFormat([args4[0], " "]); + } else if (_14 === 2) { + const part = remove$OptionMap_unit_HashMap_u8_unit(map, k); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.fmtUnit, rt.None)]; + read = rt.fmtFormat([args6[0], " "]); + } else { + const _49: rt.Place | undefined = getMut$OptionMap_unit_HashMap_u8_unit(map, k); + if (_49 === undefined) { + read = "- "; + } else { + const v: rt.Place = _49; + value(rt.u8Div(b, 2)); + v.v = undefined; + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(v.v, f)]; + read = rt.fmtFormat(["=", args8[0], " "]); + } + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + } + const part4 = sorted$OptionMap_unit_HashMap_u8_unit(map); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, (value: [rt.u8, undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtUnit(value[1], f)], f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); +} + +/** `b`, unless a multiple of 3. */ +export function some(b: rt.u8): rt.u8 | undefined { + return thenSome$bool_u8(rt.u8Rem(b, 3) !== 0, b); +} + +/** What `Default` makes of `T`, as kio's `Shared::default` makes its map. */ +export function made$BTreeMap_u8_Option_u8(): rt.BTreeMap { + return rt.btreeNew(rt.cmp) as rt.BTreeMap; +} + +/** What `Default` makes of `T`, as kio's `Shared::default` makes its map. */ +export function made$HashMap_u8_Option_String(): rt.HashMap { + return rt.hashNew() as rt.HashMap; +} + +/** + * Maps whose values are `Option`s or `()`, whose `get`, `insert`, and `remove` return an + * `Option` of one: by key, by hash of a key that is an object, and in order. + */ +export function optionals(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let read!: rt.u8 | undefined | rt.None; + const _4: rt.u8 = rt.u8Rem(kind, 6); + if (_4 === 0) { + optional$Option_u8_HashMap_u8_Option_u8(rt.hashNew() as rt.HashMap, data, some, out); + } else if (_4 === 1) { + optional$Option_u8_BTreeMap_u8_Option_u8(made$BTreeMap_u8_Option_u8(), data, some, out); + } else if (_4 === 2) { + optional$unit_HashMap_u8_unit(rt.hashNew() as rt.HashMap, data, (_22: rt.u8): void => {}, out); + } else if (_4 === 3) { + optional$unit_BTreeMap_u8_unit(rt.btreeNew(rt.cmp) as rt.BTreeMap, data, (_2: rt.u8): void => {}, out); + } else if (_4 === 4) { + optional$Option_String_HashMap_u8_Option_String(made$HashMap_u8_Option_String(), data, (b2: rt.u8): string | undefined => { + return map$Option_u8_String_optionals_closure2_closure0(some(b2), (b3: rt.u8): string => { + return rt.fmtToString((f: rt.Formatter) => rt.u8Display(b3, f)); + }); + }, out); + } else { + const map: rt.HashMap<[rt.u8, boolean], rt.u8 | undefined> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashInt, rt.hashInt]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, boolean], rt.u8 | undefined>; + for (const b of rt.byteSliceView(data)) { + const k: [rt.u8, boolean] = [rt.u8Rem(b, 4), (b & 16) !== 0]; + const _29: rt.u8 = rt.u8Rem(rt.u8Div(b, 32), 4); + if (_29 === 0) { + const _34: rt.u8 | undefined = some(b); + read = rt.hashInsert(map, copy$u8_bool(k), _34, undefined, rt.None); + } else if (_29 === 1) { + read = rt.hashGet(map, k, rt.None); + } else if (_29 === 2) { + read = rt.hashRemove(map, k, undefined, rt.None); + } else { + read = rt.entryOrInsertMut(rt.entry(map, copy$u8_bool(k)), undefined as rt.u8 | undefined).v; + } + const _56: rt.u8 | undefined | rt.None = read; + const _50: rt.u8 | undefined = flatten$Option_Option_u8(read); + const _53: boolean = rt.hashContains(map, k); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_56, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_50, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBool(_53, f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]))); + } + const all: [[rt.u8, boolean], rt.u8 | undefined][] = rt.iterToArray(rt.hashIter(map)); + rt.sliceSort(all, rt.cmpLt(rt.cmpTuple([rt.cmpTuple([rt.cmp, rt.cmp]), rt.cmpOption(rt.cmp)]))); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all, f, (value: [[rt.u8, boolean], rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0][0], f), (f: rt.Formatter) => rt.fmtBool(value[0][1], f)], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); + } +} + //# sourceMappingURL=collections.ts.map diff --git a/ts/fixtures/lang/expected/combinators.ts b/ts/fixtures/lang/expected/combinators.ts index cb3533c3e..545d36921 100644 --- a/ts/fixtures/lang/expected/combinators.ts +++ b/ts/fixtures/lang/expected/combinators.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import { copy$Result_u32s_u16, copy$u32s } from "./lib.ts"; -import { isSomeAnd$Option_u8_bools_closure0, isNoneOr$Option_u8_options_closure1, unwrapOr$Option_u8, unwrapOrElse$Option_String_owned_closure3, unwrapOrElse$Option_u8_options_closure9, unwrapOrDefault$Option_String, unwrapOrDefault$Option_Vec_u8, unwrapOrDefault$Option_u8, map$Option_u8_String_owned_closure0, map$Option_u8_Vec_u8_owned_closure4, map$Option_u8_u32s_owned_closure9, map$Option_u8_u8_elements_closure8, inspect$Option_u8_options_closure11, mapOr$Option_u16_u8_hash_maps_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOrElse$Option_u8_u8_options_closure7_options_closure8, okOr$Option_u32s_u8, okOr$Option_u8_u16, okOr$Option_u8_u8, okOrElse$Option_Vec_u8_String_owned_closure5, okOrElse$Option_u8_u16_options_closure12, and$Option_u8_u8, andThen$Option_u8_u8_options_closure2, filter$Option_String_owned_closure1, filter$Option_u8_combinators_closure0, or$Option_u8, orElse$Option_String_owned_closure2, orElse$Option_u8_options_closure6, xor$Option_u8, zip$Option_u8_u8, clone$Clone_Option_String } from "./core/option.ts"; +import { isSomeAnd$Option_u8_bools_closure0, isNoneOr$Option_u8_options_closure1, unwrapOr$Option_u8, unwrapOrElse$Option_String_owned_closure3, unwrapOrElse$Option_u8_options_closure9, unwrapOrDefault$Option_String, unwrapOrDefault$Option_Vec_u8, unwrapOrDefault$Option_u8, map$Option_u8_String_optionals_closure2_closure0, map$Option_u8_Vec_u8_owned_closure4, map$Option_u8_u32s_owned_closure9, map$Option_u8_u8_elements_closure8, inspect$Option_u8_options_closure11, mapOr$Option_u16_u8_hash_maps_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOrElse$Option_u8_u8_options_closure7_options_closure8, okOr$Option_u32s_u8, okOr$Option_u8_u16, okOr$Option_u8_u8, okOrElse$Option_Vec_u8_String_owned_closure5, okOrElse$Option_u8_u16_options_closure12, and$Option_u8_u8, andThen$Option_u8_u8_options_closure2, filter$Option_String_owned_closure1, filter$Option_u8_combinators_closure0, or$Option_u8, orElse$Option_String_owned_closure2, orElse$Option_u8_options_closure6, xor$Option_u8, zip$Option_u8_u8, clone$Clone_Option_String } from "./core/option.ts"; import { isOkAnd$Result_u8_u16_results_closure5, isErrAnd$Result_u8_u16_results_closure6, ok$Result_u8_u16, err$Result_u8_u16, asRef$Result_u8_u16, map$Result_Vec_u8_String_Vec_u8_owned_closure6, map$Result_u8_u16_u8_options_closure13, mapOr$Result_u8_u16_u8_results_closure7, mapOrElse$Result_u8_u16_u8_results_closure8_results_closure9, mapErr$Result_u32s_u8_u16_from, mapErr$Result_u8_u16_u16_results_closure14, inspect$Result_u8_u16_results_closure12, inspectErr$Result_u8_u16_results_closure13, unwrapOrDefault$Result_u8_u16, and$Result_u8_u16_u8, andThen$Result_u8_u16_u8_results_closure3, or$Result_u8_u16_u16, orElse$Result_u8_u16_u16_results_closure4, unwrapOr$Result_u8_u16, unwrapOrElse$Result_u8_u16_results_closure11, unwrapOrElse$Result_u8_u8_panics_closure1, copied$Result_u8_u16, clone$Clone_Result_Vec_u8_String } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ @@ -135,7 +135,7 @@ export function results(a: rt.u8 | undefined, b: rt.u8 | undefined, limit: rt.u8 /** Values JS shares where Rust clones or moves them. */ export function owned(a: rt.u8 | undefined, b: rt.u8 | undefined, out: rt.ByteVec): void { let matched!: rt.Result; - const s: string | undefined = map$Option_u8_String_owned_closure0(a, (x2: rt.u8): string => { + const s: string | undefined = map$Option_u8_String_optionals_closure2_closure0(a, (x2: rt.u8): string => { return rt.fmtToString((f: rt.Formatter) => rt.u8Display(x2, f)); }); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(unwrapOrDefault$Option_String(filter$Option_String_owned_closure1(clone$Clone_Option_String(s), (s2: string): boolean => { @@ -143,7 +143,7 @@ export function owned(a: rt.u8 | undefined, b: rt.u8 | undefined, out: rt.ByteVe })))); rt.byteVecPush(out, 124); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(unwrapOrElse$Option_String_owned_closure3(orElse$Option_String_owned_closure2(s, (): string | undefined => { - return map$Option_u8_String_owned_closure0(b, (y2: rt.u8): string => { + return map$Option_u8_String_optionals_closure2_closure0(b, (y2: rt.u8): string => { return rt.fmtToString((f: rt.Formatter) => rt.u8Display(y2, f)); }); }), (): string => { diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 38cb3b2da..a90efa76f 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -246,7 +246,7 @@ export function map$Option_u8_Side_side(self: rt.u8 | undefined, _: (a0: rt.u8) return side(self); } -export function map$Option_u8_String_owned_closure0(self: rt.u8 | undefined, f: (a0: rt.u8) => string): string | undefined { +export function map$Option_u8_String_optionals_closure2_closure0(self: rt.u8 | undefined, f: (a0: rt.u8) => string): string | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 59d2ed152..8efad1329 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { copy$Pair } from "./lib.ts"; import { unwrapOr$Option_char, unwrapOr$Option_u8 } from "./core/option.ts"; import * as Bare from "./fmt.Bare.ts"; import * as Braced from "./fmt.Braced.ts"; @@ -251,7 +252,7 @@ export function nested(data: rt.ByteSlice): Nested.Nested { _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; } const _35: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 0, rt.min(data.length, 4))); - const _40: Pair.Pair[] = [{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }].slice(); + const _40: Pair.Pair[] = [{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }].map(copy$Pair); if (!(rt.u8Rem(at(5), 2) === 0)) { _49 = undefined; } else { @@ -365,7 +366,7 @@ export function written(data: rt.ByteSlice, out: rt.ByteVec): void { const empty: Manual.Manual = { id: 0, list: _71 }; const args8: rt.Fmt[] = [(f: rt.Formatter) => Manual.fmt$Debug(manual, f), (f: rt.Formatter) => Manual.fmt$Debug(empty, f)]; put(out, rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]])); - const seq: Seq.Seq = { _0: [{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice() }; + const seq: Seq.Seq = { _0: [{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].map(copy$Pair) }; const _97: Pair.Pair[] = []; const none: Seq.Seq = { _0: _97 }; const args10: rt.Fmt[] = [(f: rt.Formatter) => Seq.fmt$Debug(seq, f), (f: rt.Formatter) => Seq.fmt$Debug(none, f)]; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index cd5a08f0d..3238d3a5c 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,12 +1,14 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { copy$str_forabfnu8au8bmutstdvecVecu8, copy$str_forabfnu8au8bmutstdvecVecu8s } from "./lib.ts"; +import { fromFns } from "./arrays.ts"; import { atomics } from "./atomics.ts"; import { captures } from "./captures.ts"; import { cells } from "./cells.ts"; import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; -import { hashMaps, sets, btreeMaps, deques, vecs, stores } from "./collections.ts"; +import { hashMaps, sets, btreeMaps, deques, vecs, stores, optionals } from "./collections.ts"; import { combinators } from "./combinators.ts"; import { arcs, rcs } from "./counts.ts"; import { cows } from "./cows.ts"; @@ -34,67 +36,69 @@ import { wrappers } from "./wrappers.ts"; * case added at the end moves no other. */ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void][] { - return [["ints::u8_op", u8Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u16_op", u16Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u32_op", u32Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u64_op", u64Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u128_op", u128Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::usize_op", usizeOp] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i8_op", i8Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i16_op", i16Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i32_op", i32Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i64_op", i64Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i128_op", i128Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::isize_op", isizeOp] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::neg", neg] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::cast", cast] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::convert", (_216: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void => { + return copy$str_forabfnu8au8bmutstdvecVecu8s([["ints::u8_op", u8Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u16_op", u16Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u32_op", u32Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u64_op", u64Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::u128_op", u128Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::usize_op", usizeOp] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i8_op", i8Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i16_op", i16Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i32_op", i32Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i64_op", i64Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::i128_op", i128Op] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::isize_op", isizeOp] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::neg", neg] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::cast", cast] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::convert", (_222: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void => { convert(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::copies", (_217: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::copies", (_223: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): void => { copies(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::loops", (_218: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::loops", (_224: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): void => { loops(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::patterns", (_219: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::patterns", (_225: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): void => { patterns(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::closures", (_220: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::closures", (_226: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): void => { closures(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::discriminants", (_221: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::discriminants", (_227: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): void => { discriminants(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::library", (_222: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::library", (_228: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): void => { library(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::ints", ints] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::strings", (_223: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::ints", ints] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::strings", (_229: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): void => { strings(data8, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::derived", (_224: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::derived", (_230: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): void => { derived(data9, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::written", (_225: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::written", (_231: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): void => { written(data10, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::panics", panics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["generics::methods", (_226: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::panics", panics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["generics::methods", (_232: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): void => { methods(data11, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::adaptors", adaptors] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::consumers", consumers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranges", (_227: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::adaptors", adaptors] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::consumers", consumers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranges", (_233: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): void => { ranges(data12, out12); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::options", (_228: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::options", (_234: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): void => { options(data13, out13); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::own", (_229: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::own", (_235: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): void => { own(data14, out14); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::values", (_230: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::values", (_236: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): void => { values(data15, out15); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::order", (_231: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::order", (_237: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): void => { order(data16, out16); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::hash_maps", hashMaps] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::sets", sets] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::btree_maps", btreeMaps] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::deques", (_232: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::hash_maps", hashMaps] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::sets", sets] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::btree_maps", btreeMaps] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::deques", (_238: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): void => { deques(data17, out17); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::flows", (_233: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::flows", (_239: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): void => { flows(data18, out18); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::keys", keys] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["chars::chars", chars] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::strs", strs] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::vecs", (_234: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::keys", keys] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["chars::chars", chars] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::strs", strs] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::vecs", (_240: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): void => { vecs(data19, out19); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::slices", slices] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::stores", (_235: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["strs::slices", slices] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::stores", (_241: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): void => { stores(data20, out20); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["chunks::chunks", chunks] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cows::cows", cows] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["durations::durations", durations] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["combinators::combinators", combinators] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["splits::splits", splits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["nested::nested", nested] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["refs::refs", (_236: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["chunks::chunks", chunks] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cows::cows", cows] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["durations::durations", durations] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["combinators::combinators", combinators] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["splits::splits", splits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["nested::nested", nested] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["refs::refs", (_242: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): void => { refs(data21, out21); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_237: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::counts", (_243: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): void => { counts(data22, out22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_238: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_244: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { rounding(out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["atomics::atomics", atomics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::overrides", overrides] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_239: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["atomics::atomics", atomics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::overrides", overrides] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_245: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { dyns(data23, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cells::cells", cells] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::shared", (_240: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cells::cells", cells] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::shared", (_246: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): void => { shared(data24, out25); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranked", ranked] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["captures::captures", captures] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::locks", (_241: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::ranked", ranked] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["captures::captures", captures] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::locks", (_247: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): void => { locks(data25, out26); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::relock", (_242: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["locks::relock", (_248: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): void => { relock(data26, out27); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["defaults::defaults", (_243: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["defaults::defaults", (_249: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): void => { defaults(data27, out28); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::arcs", (_244: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::arcs", (_250: rt.u8, data28: rt.ByteSlice, out29: rt.ByteVec): void => { arcs(data28, out29); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::rcs", (_245: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): void => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["counts::rcs", (_251: rt.u8, data29: rt.ByteSlice, out30: rt.ByteVec): void => { rcs(data29, out30); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["arrays::from_fns", (_252: rt.u8, data30: rt.ByteSlice, out31: rt.ByteVec): void => { + fromFns(data30, out31); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["collections::optionals", optionals] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]).map(copy$str_forabfnu8au8bmutstdvecVecu8); } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index 162149fcf..e3facc0f7 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -3,6 +3,7 @@ import * as rt from "./rt.ts"; import type * as Tally from "./collections.Tally.ts"; import type * as Window from "./durations.Window.ts"; +import type * as Pair from "./fmt.Pair.ts"; import type * as Either from "./generics.Either.ts"; import * as Wrap from "./generics.Wrap.ts"; import type * as Bumped from "./iters.Bumped.ts"; @@ -18,6 +19,10 @@ import type * as Mark from "./shapes.Mark.ts"; import type * as Point from "./shapes.Point.ts"; import type * as Shape from "./shapes.Shape.ts"; +export function copy$Bound_u64(v: rt.RangeBound): rt.RangeBound { + return v.tag === "Unbounded" ? v : { tag: v.tag, _0: v._0 } as rt.RangeBound; +} + export function copy$Bumped(v: Bumped.Bumped): Bumped.Bumped { return { _0: v._0 }; } @@ -108,6 +113,10 @@ export function copy$Option_usize_u8(v: [rt.usize, rt.u8] | undefined): [rt.usiz return v === undefined ? v : copy$usize_u8(v); } +export function copy$Pair(v: Pair.Pair): Pair.Pair { + return { _0: v._0, _1: v._1 }; +} + export function copy$Point(v: Point.Point): Point.Point { return { x: v.x, y: v.y }; } @@ -170,6 +179,14 @@ export function copy$chars(v: rt.char[]): rt.char[] { return v.slice(); } +export function copy$str_forabfnu8au8bmutstdvecVecu8(v: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void] { + return [v[0], v[1]]; +} + +export function copy$str_forabfnu8au8bmutstdvecVecu8s(v: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void][]): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void][] { + return v.map(copy$str_forabfnu8au8bmutstdvecVecu8); +} + export function copy$u32s(v: rt.u32[]): rt.u32[] { return v.slice(); } @@ -186,6 +203,10 @@ export function copy$u8_Tally(v: [rt.u8, Tally.Tally]): [rt.u8, Tally.Tally] { return [v[0], copy$Tally(v[1])]; } +export function copy$u8_bool(v: [rt.u8, boolean]): [rt.u8, boolean] { + return [v[0], v[1]]; +} + export function copy$u8_str(v: [rt.u8, string]): [rt.u8, string] { return [v[0], v[1]]; } diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index bf531b141..253cdd520 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { copy$Bound_u64 } from "./lib.ts"; import { unwrapOr$Option_NonZero_u64, unwrapOr$Option_u8, mapOr$Option_usize_u8_consumers_closure8 } from "./core/option.ts"; import { put } from "./fmt.ts"; import * as Scale from "./wrappers.Scale.ts"; @@ -31,7 +32,7 @@ export function bounds$Bound_u64_Bound_u64(out: rt.ByteVec, r: [rt.RangeBound = r[0]; + const _10: rt.RangeBound = copy$Bound_u64(r[0]); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -39,7 +40,7 @@ export function bounds$Bound_u64_Bound_u64(out: rt.ByteVec, r: [rt.RangeBound = r[1]; + const _17: rt.RangeBound = copy$Bound_u64(r[1]); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { @@ -61,7 +62,7 @@ export function bounds$RangeFrom_u64(out: rt.ByteVec, r: { start: rt.u64 }): voi let end!: rt.u64 | undefined; putBound(out, { tag: "Included", _0: r.start } as rt.RangeBound); putBound(out, { tag: "Unbounded" } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Included", _0: r.start } as rt.RangeBound; + const _10: rt.RangeBound = copy$Bound_u64({ tag: "Included", _0: r.start } as rt.RangeBound); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -69,7 +70,7 @@ export function bounds$RangeFrom_u64(out: rt.ByteVec, r: { start: rt.u64 }): voi } else { start = 0; } - const _17: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _17: rt.RangeBound = copy$Bound_u64({ tag: "Unbounded" } as rt.RangeBound); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { @@ -91,7 +92,7 @@ export function bounds$RangeFull(out: rt.ByteVec, _: undefined): void { let end!: rt.u64 | undefined; putBound(out, { tag: "Unbounded" } as rt.RangeBound); putBound(out, { tag: "Unbounded" } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _10: rt.RangeBound = copy$Bound_u64({ tag: "Unbounded" } as rt.RangeBound); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -99,7 +100,7 @@ export function bounds$RangeFull(out: rt.ByteVec, _: undefined): void { } else { start = 0; } - const _17: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _17: rt.RangeBound = copy$Bound_u64({ tag: "Unbounded" } as rt.RangeBound); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { @@ -121,7 +122,7 @@ export function bounds$RangeInclusive_u64(out: rt.ByteVec, r: rt.RangeInclusive< let end!: rt.u64 | undefined; putBound(out, rt.rangeInclusiveStartBound(r) as rt.RangeBound); putBound(out, rt.rangeInclusiveEndBound(r) as rt.RangeBound); - const _10: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; + const _10: rt.RangeBound = copy$Bound_u64(rt.rangeInclusiveStartBound(r) as rt.RangeBound); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -129,7 +130,7 @@ export function bounds$RangeInclusive_u64(out: rt.ByteVec, r: rt.RangeInclusive< } else { start = 0; } - const _17: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; + const _17: rt.RangeBound = copy$Bound_u64(rt.rangeInclusiveEndBound(r) as rt.RangeBound); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { @@ -151,7 +152,7 @@ export function bounds$RangeToInclusive_u64(out: rt.ByteVec, r: { end: rt.u64; i let end!: rt.u64 | undefined; putBound(out, { tag: "Unbounded" } as rt.RangeBound); putBound(out, { tag: "Included", _0: r.end } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _10: rt.RangeBound = copy$Bound_u64({ tag: "Unbounded" } as rt.RangeBound); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -159,7 +160,7 @@ export function bounds$RangeToInclusive_u64(out: rt.ByteVec, r: { end: rt.u64; i } else { start = 0; } - const _17: rt.RangeBound = { tag: "Included", _0: r.end } as rt.RangeBound; + const _17: rt.RangeBound = copy$Bound_u64({ tag: "Included", _0: r.end } as rt.RangeBound); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { @@ -181,7 +182,7 @@ export function bounds$RangeTo_u64(out: rt.ByteVec, r: { end: rt.u64 }): void { let end!: rt.u64 | undefined; putBound(out, { tag: "Unbounded" } as rt.RangeBound); putBound(out, { tag: "Excluded", _0: r.end } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _10: rt.RangeBound = copy$Bound_u64({ tag: "Unbounded" } as rt.RangeBound); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -189,7 +190,7 @@ export function bounds$RangeTo_u64(out: rt.ByteVec, r: { end: rt.u64 }): void { } else { start = 0; } - const _17: rt.RangeBound = { tag: "Excluded", _0: r.end } as rt.RangeBound; + const _17: rt.RangeBound = copy$Bound_u64({ tag: "Excluded", _0: r.end } as rt.RangeBound); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { @@ -211,7 +212,7 @@ export function bounds$Range_u64(out: rt.ByteVec, r: rt.Range): void { let end!: rt.u64 | undefined; putBound(out, { tag: "Included", _0: r.start } as rt.RangeBound); putBound(out, { tag: "Excluded", _0: r.end } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Included", _0: r.start } as rt.RangeBound; + const _10: rt.RangeBound = copy$Bound_u64({ tag: "Included", _0: r.start } as rt.RangeBound); if (_10.tag === "Included") { start = (_10 as { tag: "Included"; _0: rt.u64 })._0; } else if (_10.tag === "Excluded") { @@ -219,7 +220,7 @@ export function bounds$Range_u64(out: rt.ByteVec, r: rt.Range): void { } else { start = 0; } - const _17: rt.RangeBound = { tag: "Excluded", _0: r.end } as rt.RangeBound; + const _17: rt.RangeBound = copy$Bound_u64({ tag: "Excluded", _0: r.end } as rt.RangeBound); if (_17.tag === "Included") { end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); } else if (_17.tag === "Excluded") { diff --git a/ts/fixtures/lang/src/arrays.rs b/ts/fixtures/lang/src/arrays.rs new file mode 100644 index 000000000..0126762f6 --- /dev/null +++ b/ts/fixtures/lang/src/arrays.rs @@ -0,0 +1,57 @@ +//! Arrays `array::from_fn` makes, calling its function on each index in order: of bytes, +//! wide integers, atomics each its own, strings, nested arrays, none at all, and a length +//! a const parameter gives. + +use std::sync::atomic::{AtomicU64, Ordering}; + +/// Each byte an operation, its value the operand; each puts what it read. +pub fn from_fns(data: &[u8], out: &mut Vec) { + for &op in data { + let s = match op % 5 { + // The order the function sees, through what it captured by `&mut`. + 0 => { + let mut seen = Vec::new(); + let bytes: [u8; 4] = std::array::from_fn(|i| { + seen.push(i); + op.wrapping_mul(i as u8 + 1) + }); + let wide: [u64; 3] = std::array::from_fn(|i| u64::from(op) << (i * 30)); + format!("{bytes:?} {wide:?} {seen:?}") + } + // kio's: each atomic its own, which a store to one doesn't change in another. + 1 => { + let counts: [AtomicU64; 8] = std::array::from_fn(|_| AtomicU64::new(u64::from(op))); + counts[usize::from(op % 8)].fetch_add(1, Ordering::Relaxed); + let copy: [AtomicU64; 8] = std::array::from_fn(|i| AtomicU64::new(counts[i].load(Ordering::Relaxed))); + copy[0].store(0, Ordering::Relaxed); + let loads: [u64; 8] = std::array::from_fn(|i| counts[i].load(Ordering::Relaxed)); + format!("{loads:?} {}", copy[0].load(Ordering::Relaxed)) + } + // A function that owns what it captured, which drops after the last call. + 2 => { + let word = format!("w{op}"); + let words: [String; 3] = std::array::from_fn(move |i| format!("{word}{i}")); + let none: [String; 0] = std::array::from_fn(|i| i.to_string()); + format!("{words:?} {none:?}") + } + 3 => { + let grid: [[u8; 2]; 3] = + std::array::from_fn(|i| std::array::from_fn(|j| op.wrapping_add((i * 2 + j) as u8))); + let named: [u16; 4] = std::array::from_fn(doubled); + format!("{grid:?} {named:?}") + } + _ => format!("{:?} {:?}", counted::<2>(op), counted::<5>(op)), + }; + out.extend_from_slice(s.as_bytes()); + out.push(b'\n'); + } +} + +fn doubled(i: usize) -> u16 { + i as u16 * 2 +} + +/// An array as long as `N` says, of `N` instances. +fn counted(op: u8) -> [usize; N] { + std::array::from_fn(|i| i * N + usize::from(op)) +} diff --git a/ts/fixtures/lang/src/collections.rs b/ts/fixtures/lang/src/collections.rs index 0e9a3aa1c..06356fa5b 100644 --- a/ts/fixtures/lang/src/collections.rs +++ b/ts/fixtures/lang/src/collections.rs @@ -869,3 +869,124 @@ pub fn stores(data: &[u8], out: &mut Vec) { out.extend_from_slice(&[held.pair.1, holders[2].pair.0]); out.extend_from_slice(&[pair.0, pair.1]); } + +/// What a script of operations on a map of `V`s reads, written as text: `None` apart from +/// `Some(None)` where `V` is an `Option`, and `Some(())` where it is `()`. +trait OptionMap { + fn get(&self, k: u8) -> Option<&V>; + fn insert(&mut self, k: u8, v: V) -> Option; + fn remove(&mut self, k: u8) -> Option; + fn get_mut(&mut self, k: u8) -> Option<&mut V>; + fn sorted(&self) -> Vec<(u8, V)>; +} + +impl OptionMap for HashMap { + fn get(&self, k: u8) -> Option<&V> { + HashMap::get(self, &k) + } + fn insert(&mut self, k: u8, v: V) -> Option { + HashMap::insert(self, k, v) + } + fn remove(&mut self, k: u8) -> Option { + HashMap::remove(self, &k) + } + fn get_mut(&mut self, k: u8) -> Option<&mut V> { + HashMap::get_mut(self, &k) + } + fn sorted(&self) -> Vec<(u8, V)> { + let mut all: Vec<(u8, V)> = self.iter().map(|(k, v)| (*k, v.clone())).collect(); + all.sort_by_key(|(k, _)| *k); + all + } +} + +impl OptionMap for BTreeMap { + fn get(&self, k: u8) -> Option<&V> { + BTreeMap::get(self, &k) + } + fn insert(&mut self, k: u8, v: V) -> Option { + BTreeMap::insert(self, k, v) + } + fn remove(&mut self, k: u8) -> Option { + BTreeMap::remove(self, &k) + } + fn get_mut(&mut self, k: u8) -> Option<&mut V> { + BTreeMap::get_mut(self, &k) + } + fn sorted(&self) -> Vec<(u8, V)> { + self.iter().map(|(k, v)| (*k, v.clone())).collect() + } +} + +/// 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. +fn optional>( + mut map: M, + data: &[u8], + value: fn(u8) -> V, + out: &mut Vec, +) { + for &b in data { + let k = b % 8; + let read = match b / 8 % 4 { + 0 => format!("{:?} ", map.insert(k, value(b))), + 1 => format!("{:?} ", map.get(k)), + 2 => format!("{:?} ", map.remove(k)), + _ => match map.get_mut(k) { + Some(v) => { + *v = value(b / 2); + format!("={v:?} ") + } + None => "- ".into(), + }, + }; + out.extend_from_slice(read.as_bytes()); + } + out.extend_from_slice(format!("{:?}", map.sorted()).as_bytes()); +} + +/// `b`, unless a multiple of 3. +fn some(b: u8) -> Option { + (b % 3 != 0).then_some(b) +} + +/// What `Default` makes of `T`, as kio's `Shared::default` makes its map. +fn made() -> T { + T::default() +} + +/// Maps whose values are `Option`s or `()`, whose `get`, `insert`, and `remove` return an +/// `Option` of one: by key, by hash of a key that is an object, and in order. +pub fn optionals(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 6 { + 0 => optional(HashMap::>::new(), data, some, out), + 1 => optional(made::>>(), data, some, out), + 2 => optional(HashMap::::new(), data, |_| (), out), + 3 => optional(BTreeMap::::new(), data, |_| (), out), + 4 => optional( + made::>>(), + data, + |b| some(b).map(|b| b.to_string()), + out, + ), + // Keys found by their hash, and moq-net's reads of one: a `Some(None)` there, cloned + // and flattened, and the entry API. + _ => { + let mut map: HashMap<(u8, bool), Option> = HashMap::new(); + for &b in data { + let k = (b % 4, b & 0x10 != 0); + let read = match b / 32 % 4 { + 0 => map.insert(k, some(b)), + 1 => map.get(&k).cloned(), + 2 => map.remove(&k), + _ => Some(*map.entry(k).or_insert(None)), + }; + let s = format!("{read:?} {:?} {} ", read.flatten(), map.contains_key(&k)); + out.extend_from_slice(s.as_bytes()); + } + let mut all: Vec<_> = map.into_iter().collect(); + all.sort(); + out.extend_from_slice(format!("{all:?}").as_bytes()); + } + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index aff1a0e9d..72d531116 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,8 +2,8 @@ //! case and the rest is its input. use crate::{ - atomics, captures, cells, chars, chunks, collections, combinators, counts, cows, defaults, durations, dyns, edits, - floats, fmt, generics, ints, iters, keys, locks, nested, refs, shapes, splits, strs, utf8, wrappers, + arrays, atomics, captures, cells, chars, chunks, collections, combinators, counts, cows, defaults, durations, dyns, + edits, floats, fmt, generics, ints, iters, keys, locks, nested, refs, shapes, splits, strs, utf8, wrappers, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -93,6 +93,8 @@ fn cases() -> Vec<(&'static str, Case)> { ("defaults::defaults", |_, data, out| defaults::defaults(data, out)), ("counts::arcs", |_, data, out| counts::arcs(data, out)), ("counts::rcs", |_, data, out| counts::rcs(data, out)), + ("arrays::from_fns", |_, data, out| arrays::from_fns(data, out)), + ("collections::optionals", collections::optionals), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index bd196839c..7fa4476fe 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -5,12 +5,13 @@ //! types, formatting, collections, UTF-8 decoding, `&mut` to values JS copies, the //! standard library calls it maps, `Option`'s and `Result`'s combinators from core's //! MIR, `Option`s of values that can already be `undefined`, atomics, trait objects, -//! one-time cells, mutexes, the defaults of std types, and the counts of shared -//! pointers. +//! one-time cells, mutexes, the defaults of std types, the counts of shared pointers, +//! arrays `array::from_fn` makes, and maps of `Option`s. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. +mod arrays; mod atomics; mod captures; mod cells; diff --git a/ts/fixtures/reject/census.md b/ts/fixtures/reject/census.md index 20e1a77f3..e80a9c9cf 100644 --- a/ts/fixtures/reject/census.md +++ b/ts/fixtures/reject/census.md @@ -70,7 +70,6 @@ The type or module each refused type or path belongs to. | 3 | `std::vec::Vec` | fixtures/reject/src/lib.rs:268:52 | | 3 | `u8` | fixtures/reject/src/lib.rs:80:2 | | 3 | `{closure}` | fixtures/reject/src/lib.rs:369:13 | -| 2 | `HashMap` | fixtures/reject/src/lib.rs:263:6 | | 2 | `Meters` | fixtures/reject/src/lib.rs:85:2 | | 2 | `Poll` | fixtures/reject/src/lib.rs:105:20 | | 2 | `Scaled` | fixtures/reject/src/lib.rs:479:23 | @@ -86,6 +85,8 @@ The type or module each refused type or path belongs to. | 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:159:1 | | 1 | `Entry` | fixtures/reject/src/lib.rs:369:13 | | 1 | `FusedIterator` | fixtures/reject/src/lib.rs:213:1 | +| 1 | `HashMap` | fixtures/reject/src/lib.rs:286:6 | +| 1 | `HashSet` | fixtures/reject/src/lib.rs:263:6 | | 1 | `Hasher` | fixtures/reject/src/lib.rs:294:9 | | 1 | `Maybe` | fixtures/reject/src/lib.rs:31:2 | | 1 | `Noisy` | fixtures/reject/src/lib.rs:53:13 | @@ -132,7 +133,7 @@ The type or module each refused type or path belongs to. | 1 | `_` is not supported: its field `_` is `_`, typed `_`, whose `Pending` would be `rt.OuterPending` as `_` | `Waiting`, `poll`, `Poll`, `rt.Poll`, `Poll` | fixtures/reject/src/lib.rs:517:2 | | 1 | `_` of `_` by `_`, which is not supported yet | `HashMap::contains_key`, `std::collections::HashMap`, `u8` | fixtures/reject/src/lib.rs:286:6 | | 1 | `_` of `_`, which drops `_`, which is not supported yet | `into_keys`, `std::collections::HashMap`, `Noisy` | fixtures/reject/src/lib.rs:53:13 | -| 1 | `_` of `_`, whose `None` is `rt.None`, which is not supported yet | `HashMap::get`, `Option` | fixtures/reject/src/lib.rs:263:6 | +| 1 | `_` of `_`, whose `None` is `rt.None`, which is not supported yet | `HashSet::get`, `Option` | fixtures/reject/src/lib.rs:263:6 | | 1 | `_` of `_`, whose `None` is `rt.None`, which is not supported yet | `Iterator::find`, `Option` | fixtures/reject/src/lib.rs:41:42 | | 1 | `_` of a reference to an array of bytes it is generic over, which its mapping would take as the array, not as a slice of it | `std::iter::Iterator::count` | fixtures/reject/src/lib.rs:247:38 | | 1 | `_` of a reference to an array of bytes it is generic over, which its mapping would take as the array, not as a slice of it | `std::iter::Iterator::filter` | fixtures/reject/src/lib.rs:247:16 | @@ -250,7 +251,7 @@ The type or module each refused type or path belongs to.
`_` of `_`, whose `None` is `rt.None`, which is not supported yet (2) - fixtures/reject/src/lib.rs:41:42: `Iterator::find` of `Option>`, whose `None` is `rt.None`, which is not supported yet -- fixtures/reject/src/lib.rs:263:6: `HashMap::get` of `Option<&std::option::Option>`, whose `None` is `rt.None`, which is not supported yet +- fixtures/reject/src/lib.rs:263:6: `HashSet::get` of `Option<&std::option::Option>`, whose `None` is `rt.None`, which is not supported yet
diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 8fb358eaf..ddb765df4 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -37,7 +37,7 @@ replacing the value behind a reference to `[u16; 1]` at fixtures/reject/src/lib. `std::iter::Iterator::filter` of a reference to an array of bytes it is generic over, which its mapping would take as the array, not as a slice of it at fixtures/reject/src/lib.rs:247:16 `std::iter::Iterator::count` of a reference to an array of bytes it is generic over, which its mapping would take as the array, not as a slice of it at fixtures/reject/src/lib.rs:247:38 a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:257:14 -`HashMap::get` of `Option<&std::option::Option>`, whose `None` is `rt.None`, which is not supported yet at fixtures/reject/src/lib.rs:263:6 +`HashSet::get` of `Option<&std::option::Option>`, whose `None` is `rt.None`, which is not supported yet at fixtures/reject/src/lib.rs:263:6 hashing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:268:52 comparing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:268:52 `HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet at fixtures/reject/src/lib.rs:286:6 diff --git a/ts/fixtures/reject/src/lib.rs b/ts/fixtures/reject/src/lib.rs index e2908ab6a..a1a35e9f2 100644 --- a/ts/fixtures/reject/src/lib.rs +++ b/ts/fixtures/reject/src/lib.rs @@ -258,9 +258,9 @@ pub fn copied_closure(n: u8) -> u8 { g().wrapping_add(h()) } -/// `get`'s `None` and `Some(&None)` would both be `undefined`. -pub fn optional(map: &std::collections::HashMap>) -> bool { - map.get(&1).is_some() +/// A set's `get` of an item that can be `undefined`: its `None` and `Some(&None)` would both be. +pub fn optional(set: &std::collections::HashSet>) -> bool { + set.get(&None).is_some() } /// A key the runtime has no `Hash` and `Eq` of. diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index a64f9f669..72a5d0810 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -576,6 +576,20 @@ export function bytes(n: number): Uint8Array { return out; } +/** `array::from_fn`: `f` of each index, called in order. */ +export function arrayFromFn(n: number, f: (i: number) => T): T[] { + const out: T[] = []; + for (let i = 0; i < n; i++) out.push(f(i)); + return out; +} + +/** `array::from_fn` of bytes. */ +export function bytesFromFn(n: number, f: (i: number) => number): Uint8Array { + const out = bytes(n); + for (let i = 0; i < n; i++) out[i] = f(i); + return out; +} + /** `Vec`: a growable byte buffer. */ export class ByteVec { /** The storage; only the first `length` bytes are the vector. */ diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 71fda53b8..cc6295370 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -434,8 +434,16 @@ export function hashLen(m: HashMap): number { return m.p.size + m.n; } -export function hashGet(m: HashMap, key: K): V | undefined { - return hashed(m, key) ? slot(m, key)?.v : m.p.get(key); +/** `HashMap::get`: the value there, or else `none`, the `None` of an `Option` of a value that can be `undefined`. */ +export function hashGet(m: HashMap, key: K): V | undefined; +export function hashGet(m: HashMap, key: K, none: None): V | None; +export function hashGet(m: HashMap, key: K, none?: None): V | None | undefined { + if (hashed(m, key)) { + const s = slot(m, key); + return s === undefined ? none : s.v; + } + const v = m.p.get(key); + return v !== undefined || none === undefined || m.p.has(key) ? v : none; } /** `HashMap::get_mut` of a value JS copies: its place, if the map holds `key`. */ @@ -465,13 +473,16 @@ function dropPairs(keys: readonly K[], values: readonly V[], k?: (key: K) for (let i = 0; i < keys.length; i++) dropPair(keys[i], values[i], k, v); } -/** `HashMap::insert`: the old value, if any. An equal key already there stays, and `key` drops. */ -export function hashInsert(m: HashMap, key: K, value: V, k?: (key: K) => void): V | undefined { +/** `HashMap::insert`: the old value, or else `none`. An equal key already there stays, and `key` drops. */ +export function hashInsert(m: HashMap, key: K, value: V, k?: (key: K) => void): V | undefined; +export function hashInsert(m: HashMap, key: K, value: V, k: ((key: K) => void) | undefined, none: None): V | None; +export function hashInsert(m: HashMap, key: K, value: V, k?: (key: K) => void, none?: None): V | None | undefined { if (!hashed(m, key)) { const had = m.p.has(key); const old = m.p.get(key); m.p.set(key, value); - if (had) k?.(key); + if (!had) return none; + k?.(key); return old; } // Hashed once, as std's is, into an empty map too. @@ -484,7 +495,7 @@ export function hashInsert(m: HashMap, key: K, value: V, k?: (key: K return old; } add(m, key, value, hash); - return undefined; + return none; } /** Add a hashed key that is not there yet, whose hash is `hash`: its new slot. */ @@ -544,17 +555,19 @@ function unlink(m: HashMap, hash: number, s: Slot): void { m.n--; } -/** `HashMap::remove`: the value there, if any, whose key drops. */ -export function hashRemove(m: HashMap, key: K, k?: (key: K) => void): V | undefined { +/** `HashMap::remove`: the value there, whose key drops, or else `none`. */ +export function hashRemove(m: HashMap, key: K, k?: (key: K) => void): V | undefined; +export function hashRemove(m: HashMap, key: K, k: ((key: K) => void) | undefined, none: None): V | None; +export function hashRemove(m: HashMap, key: K, k?: (key: K) => void, none?: None): V | None | undefined { if (!hashed(m, key)) { - if (!m.p.has(key)) return undefined; + if (!m.p.has(key)) return none; const old = m.p.get(key); m.p.delete(key); k?.(key); return old; } const entry = hashRemoveEntry(m, key); - if (entry === undefined) return undefined; + if (entry === undefined) return none; k?.(entry[0]); return entry[1]; } @@ -908,10 +921,13 @@ export function btreeLen(m: BTreeMap): number { return m.n; } -export function btreeGet(m: BTreeMap, key: K): V | undefined { +/** `BTreeMap::get`: the value there, or else `none`, the `None` of an `Option` of a value that can be `undefined`. */ +export function btreeGet(m: BTreeMap, key: K): V | undefined; +export function btreeGet(m: BTreeMap, key: K, none: None): V | None; +export function btreeGet(m: BTreeMap, key: K, none?: None): V | None | undefined { const l = leafOf(m, key); const i = search(l.k, key, m.c); - return i < 0 ? undefined : l.v[i]; + return i < 0 ? none : l.v[i]; } /** `BTreeMap::get_mut` of a value JS copies: its place, if the map holds `key`. */ @@ -940,13 +956,15 @@ export function btreeIndex(m: BTreeMap, key: K): V { return l.v[i]; } -/** `BTreeMap::insert`: the old value, if any. An equal key already there stays, and `key` drops. */ -export function btreeInsert(m: BTreeMap, key: K, value: V, k?: (key: K) => void): V | undefined { +/** `BTreeMap::insert`: the old value, or else `none`. An equal key already there stays, and `key` drops. */ +export function btreeInsert(m: BTreeMap, key: K, value: V, k?: (key: K) => void): V | undefined; +export function btreeInsert(m: BTreeMap, key: K, value: V, k: ((key: K) => void) | undefined, none: None): V | None; +export function btreeInsert(m: BTreeMap, key: K, value: V, k?: (key: K) => void, none?: None): V | None | undefined { const l = leafOf(m, key); const i = search(l.k, key, m.c); if (i < 0) { insertAt(m, l, ~i, key, value); - return undefined; + return none; } k?.(key); const old = l.v[i]; @@ -1009,11 +1027,13 @@ export function btreeRemoveEntry(m: BTreeMap, key: K): [K, V] | unde return entry; } -/** `BTreeMap::remove`: the value there, if any, whose key drops. */ -export function btreeRemove(m: BTreeMap, key: K, k?: (key: K) => void): V | undefined { +/** `BTreeMap::remove`: the value there, whose key drops, or else `none`. */ +export function btreeRemove(m: BTreeMap, key: K, k?: (key: K) => void): V | undefined; +export function btreeRemove(m: BTreeMap, key: K, k: ((key: K) => void) | undefined, none: None): V | None; +export function btreeRemove(m: BTreeMap, key: K, k?: (key: K) => void, none?: None): V | None | undefined { const l = leafOf(m, key); const i = search(l.k, key, m.c); - if (i < 0) return undefined; + if (i < 0) return none; const held = l.k[i]; const value = l.v[i]; removeAt(m, l, i); diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 78737fd13..015349b1c 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -176,12 +176,17 @@ pub fn call<'tcx>( return Ok(None); }; // The runtime drops what std's would rather than return or keep, given what drops it. - let Some(lost) = discarded(std, owner, name) else { - return Ok(Some(e)); - }; - let Some(droppers) = b.t.droppers(lost.iter().map(|&n| arg(coll, n)), span) else { + let lost = discarded(std, owner, name).unwrap_or_default(); + let Some(mut droppers) = b.t.droppers(lost.iter().map(|&n| arg(coll, n)), span) else { return Ok(Some(Expr::undefined())); }; + // A map's value that can be `undefined`, whose `Option` `get` returns tells `None` apart. + if library::none_last(owner, name) + && let Some(none) = library::sentinel_option(b.t, call).and_then(|inner| b.t.none_arg(inner)) + { + droppers.resize(lost.len(), Expr::undefined()); + droppers.push(none); + } if droppers.is_empty() { return Ok(Some(e)); } @@ -265,15 +270,17 @@ fn same_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { || (library::string(tcx, key) && library::string(tcx, by)) } -/// A key, value, or item type of `coll` that can be `undefined` in JS, so that an `Option` -/// of it, as `get` returns, could not tell `None` from `Some`. +/// A key or item type of `coll` that can be `undefined` in JS, so that an `Option` of it, +/// as `first` returns, could not tell `None` from `Some`. A map's value can be: its +/// `get`, `insert`, and `remove` take the `Option`'s `rt.None`. fn undefined_arg<'tcx>(b: &Body<'_, '_, 'tcx>, std: Std, coll: Ty<'tcx>) -> Option> { - let n = match std { - Std::HashMap | Std::BTreeMap | Std::Entry => 2, - Std::HashSet | Std::BTreeSet | Std::VecDeque => 1, - _ => 0, - }; - (0..n).map(|i| arg(coll, i)).find(|&t| b.t.erases_to(t).undefined) + if !matches!( + std, + Std::HashMap | Std::BTreeMap | Std::Entry | Std::HashSet | Std::BTreeSet | Std::VecDeque + ) { + return None; + } + Some(arg(coll, 0)).filter(|&key| b.t.erases_to(key).undefined) } /// Whether `call` lends a value a collection or an atomic holds that JS copies, which its diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 25310f3a2..93647e1de 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -591,17 +591,19 @@ fn takes_none(owner: &str, name: &str) -> bool { /// Whether the runtime function `owner::name` maps to takes the `None` of the `Option` it /// makes or reads, where that is `rt.None`, last: after what drops its operands. -fn none_last(owner: &str, name: &str) -> bool { +pub(super) fn none_last(owner: &str, name: &str) -> bool { matches!( (owner, name), - ("Option", "unwrap" | "expect") | ("slice", "first" | "get") + ("Option", "unwrap" | "expect") + | ("slice", "first" | "get") + | ("HashMap" | "BTreeMap", "get" | "get_mut" | "insert" | "remove") ) } /// The type of the first `Some` whose `Option`'s `None` is `rt.None`, of those in the /// signature and bounds of the function `call` calls, over its type arguments: what the /// mapping of a std function would make or read with `undefined` for `None`. -fn sentinel_option<'tcx>(t: &Translator<'_, 'tcx>, call: &Call<'tcx>) -> Option> { +pub(super) fn sentinel_option<'tcx>(t: &Translator<'_, 'tcx>, call: &Call<'tcx>) -> Option> { let tcx = t.tcx; let sig = tcx.fn_sig(call.def_id).instantiate_identity().skip_norm_wip(); let sig = tcx.instantiate_bound_regions_with_erased(sig); @@ -1430,6 +1432,14 @@ fn mapping<'tcx>( let layout = tcx.layout_of(env.as_query_input(targ(gargs, 0))).ok()?; Expr::lit(layout.size.bytes().to_string()) } + ("array", "from_fn") => { + let n = gargs.consts().next()?.try_to_target_usize(tcx)?; + let f = match targ(gargs, 0).kind() { + ty::Uint(ty::UintTy::U8) => "bytesFromFn", + _ => "arrayFromFn", + }; + Expr::rt(f, vec![Expr::lit(n.to_string()), args.pop()?]) + } ("fmt", "format") => { let parts = args.pop()?; match literal(&parts) {