feat(ts): translate vec![x; n] of a value that drops

quest/m3/README.md

@@ -30,7 +30,6 @@ generic std gap is planned here even when moq never calls it.
 - [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does
 - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number
 - [A slice's chunks as mutable arrays](/quest/m3/ts-slice-conversions.md) - `as_chunks_mut` and `as_rchunks_mut` translate, writes landing in the slice
-- [Repeated values that drop](/quest/m3/ts-vec-from-elem-drops.md) - `vec![x; n]` translates where `x` drops, cloned and dropped as std's `from_elem` does
 - [A vector's capacity where clone_from writes it in a container](/quest/m3/ts-clone-from-capacity.md) - a `Vec` an array, slice, `Option`, or list clones over keeps its capacity as std's does
 - [Comparing pointers to arrays of other values than bytes](/quest/m3/ts-array-ref-identity.md) - `ptr::eq` of pointers to a `[T; N]` of non-bytes translates, as a slice lends them too
 - [An Arc's pointer](/quest/m3/ts-arc-pointers.md) - `Arc::as_ptr` and `Rc::as_ptr` translate, comparable by `ptr::addr_eq`

ts/fixtures/lang/clones/expected/clones.ts

@@ -1,7 +1,7 @@
 // Generated by rust2-ts. Do not edit.
 
 import * as rt from "./rt.ts";
-import { drop$Vec_clones_Logged, drop$array1_clones_Logged, drop$array2_clones_Kept, drop$array2_clones_Logged, drop$clones_Slot, drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged, drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair, drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged, drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged, drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged, drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged, drop$tuple3_array2_clones_Logged_String_clones_Logged, drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged, drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged, drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept } from "./lib.ts";
+import { drop$Vec_clones_Logged, drop$array1_clones_Logged, drop$array2_clones_Kept, drop$array2_clones_Logged, drop$clones_Slot, drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged, drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_clones_Logged, drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_clones_Logged_String, drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair, drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged, drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String, drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged, drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged, drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged, drop$tuple3_array2_clones_Logged_String_clones_Logged, drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged, drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged, drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept } from "./lib.ts";
 import * as Countdown from "./clones.Countdown.ts";
 import * as Fussy from "./clones.Fussy.ts";
 import * as Kept from "./clones.Kept.ts";
@@ -10,7 +10,7 @@ import * as Pair from "./clones.Pair.ts";
 import * as Plan from "./clones.Plan.ts";
 import * as Slot from "./clones.Slot.ts";
 import { then$1uqvqbl } from "./core/bool.ts";
-import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0y3liwu as option_map$0y3liwu, mapOr$1yabfom as option_mapOr$1yabfom, mapOr$1surhce as option_mapOr$1surhce, mapOr$02k4ito as option_mapOr$02k4ito, clone$0bhdqd8 as option_clone$0bhdqd8 } from "./core/option.ts";
+import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0y3liwu as option_map$0y3liwu, mapOr$1yabfom as option_mapOr$1yabfom, mapOr$1surhce as option_mapOr$1surhce, mapOr$02k4ito as option_mapOr$02k4ito, clone$0bhdqd8 as option_clone$0bhdqd8, clone$1jx0028 as option_clone$1jx0028 } from "./core/option.ts";
 
 /** Puts what was logged since the last flush, after a marker. */
 export function flush(log: rt.RefCell<rt.ByteVec>, out: rt.ByteVec): void {
@@ -8086,4 +8086,163 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo
 	log[Symbol.dispose]();
 }
 
+/**
+ * `vec![x; n]` of values that clone and drop themselves, as std's `from_elem` makes it:
+ * `n - 1` clones of `x` in order, then `x` itself, or `x` dropped where `n` is 0, of a
+ * `Logged`, its own `Clone`, an array, an `Option`, a tuple, nested `Vec`s, and through a
+ * generic function, with `n` from the input.
+ */
+export function repeats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void {
+	let slot!: Slot.Slot;
+	const _11: (a0: Logged.Logged[], a1: rt.ByteVec) => undefined = (a: Logged.Logged[], out2: rt.ByteVec): undefined => {
+		rt.iterExtendBytes(out2, rt.iterMap(rt.iterSlice(a), Logged.id), undefined, true);
+	};
+	const log: rt.Arc<rt.RefCell<rt.ByteVec>> = new rt.Arc(new rt.RefCell(new rt.ByteVec()));
+	const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => {
+		return new Logged.Logged(id, rt.arcClone(log));
+	};
+	const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => {
+		return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 48)) & 126;
+	};
+	const n: (a0: rt.usize) => rt.usize = (i2: rt.usize): rt.usize => {
+		return rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), i2 & 0xff), 5) as rt.usize;
+	};
+	const _12: rt.u8 = rt.u8Rem(kind, 8);
+	if (_12 === 0) {
+		const part17 = at(0);
+		const v: Logged.Logged[] = rt.vecFromElem(logged(part17), n(1), Logged.clone$Clone, rt.drop);
+		flush(log.value, out);
+		_11(v, out);
+		rt.byteVecPush(out, rt.vecCapacity(v, 8) & 0xff);
+		rt.dropAll(v);
+		flush(log.value, out);
+	} else if (_12 === 1) {
+		const row: Logged.Logged[] = rt.vecWithCapacity(6, 8);
+		const _43: rt.Iter<Logged.Logged> = rt.iterMap(new rt.Range(0, n(1)), (i3: rt.usize): Logged.Logged => {
+			return logged(at(rt.usizeAdd(2, i3)));
+		});
+		rt.iterExtend(row, _43, undefined, 8, true);
+		const v2: Logged.Logged[][] = rt.vecFromElem(row, n(0), (a04: Logged.Logged[]): Logged.Logged[] => {
+			return rt.vecExact(a04.map(Logged.clone$Clone), 8);
+		}, drop$Vec_clones_Logged);
+		flush(log.value, out);
+		for (const _62 of v2) {
+			_11(_62, out);
+			rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(254, rt.vecCapacity(_62, 8) & 0xff)), undefined, true);
+		}
+		rt.dropAll(v2, drop$Vec_clones_Logged);
+		flush(log.value, out);
+	} else if (_12 === 2) {
+		const part13 = at(0);
+		const _80: Logged.Logged = logged(part13);
+		const part14 = at(1);
+		const v3: Logged.Logged[][] = rt.vecFromElem([_80, logged(part14)], n(2), (a03: Logged.Logged[]): Logged.Logged[] => {
+			return a03.map(Logged.clone$Clone);
+		}, drop$array2_clones_Logged);
+		flush(log.value, out);
+		rt.iterForEach(rt.iterSlice(v3), (row3: Logged.Logged[]): undefined => {
+			_11(row3, out);
+		});
+		rt.dropAll(v3, drop$array2_clones_Logged);
+		flush(log.value, out);
+	} else if (_12 === 3) {
+		const part11 = at(0);
+		const v4: Kept.Kept[] = rt.vecFromElem(new Kept.Kept(logged(part11)), n(1), Kept.clone$Clone, rt.drop);
+		flush(log.value, out);
+		rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v4), (k: Kept.Kept): rt.u8 => {
+			return Logged.id(k._0);
+		}), undefined, true);
+		rt.dropAll(v4);
+		flush(log.value, out);
+		if (rt.u8Rem(at(2), 3) === 0) {
+			slot = { tag: "Empty" } as Slot.Slot;
+		} else {
+			const part12 = at(3);
+			slot = { tag: "Held", _0: new Kept.Kept(logged(part12)) } as Slot.Slot;
+		}
+		const slots: Slot.Slot[] = rt.vecFromElem(slot, n(4), Slot.clone$Clone, drop$clones_Slot);
+		flush(log.value, out);
+		rt.dropAll(slots, drop$clones_Slot);
+		flush(log.value, out);
+	} else if (_12 === 4) {
+		const part9 = at(0);
+		const some: Array<Logged.Logged | undefined> = rt.vecFromElem(logged(part9), n(1), option_clone$1jx0028, rt.drop);
+		const none: Array<Logged.Logged | undefined> = rt.vecFromElem(undefined as Logged.Logged | undefined, n(2), option_clone$1jx0028, rt.drop);
+		flush(log.value, out);
+		rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(some), (x: Logged.Logged | undefined): rt.u8 => {
+			return option_mapOr$1yabfom(x, 254, Logged.id);
+		}), undefined, true);
+		rt.byteVecPush(out, none.length & 0xff);
+		const part10 = at(3);
+		const _194: rt.u8 = at(4);
+		const pairs: [Logged.Logged, string][] = rt.vecFromElem([logged(part10), rt.fmtToString((f: rt.Formatter) => rt.u8Display(_194, f))] as [Logged.Logged, string], n(5), (a02: [Logged.Logged, string]): [Logged.Logged, string] => {
+			return rt.tupleClone(a02, [Logged.clone$Clone, undefined]);
+		}, drop$tuple2_clones_Logged_String);
+		flush(log.value, out);
+		rt.iterForEach(rt.iterSlice(pairs), (_2: [Logged.Logged, string]): undefined => {
+			rt.iterExtendBytes(out, rt.iterChain(rt.strBytes(_2[1]), rt.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 [Array<Logged.Logged | undefined>, Array<Logged.Logged | undefined>, [Logged.Logged, string][]]);
+		flush(log.value, out);
+	} else if (_12 === 5) {
+		const part8 = at(0);
+		const v5: Logged.Logged[][] = rt.vecFromElem(rt.vecFromElem(logged(part8), n(1), Logged.clone$Clone, rt.drop), n(2), (a0: Logged.Logged[]): Logged.Logged[] => {
+			return rt.vecExact(a0.map(Logged.clone$Clone), 8);
+		}, drop$Vec_clones_Logged);
+		flush(log.value, out);
+		rt.iterForEach(rt.iterSlice(v5), (row2: Logged.Logged[]): undefined => {
+			_11(row2, out);
+		});
+		rt.dropAll(v5, drop$Vec_clones_Logged);
+		flush(log.value, out);
+	} else if (_12 === 6) {
+		const count: () => rt.usize = (): rt.usize => {
+			const _510: rt.RefCell<rt.ByteVec> = rt.refCellBorrowMut(log.value);
+			rt.byteVecPush(_510.value, 251);
+			rt.refMutRelease(_510);
+			return n(1);
+		};
+		const part5 = at(0);
+		const v6: Logged.Logged[] = rt.vecFromElem(logged(part5), count(), Logged.clone$Clone, rt.drop);
+		const _255: rt.RefCell<rt.ByteVec> = rt.refCellBorrowMut(log.value);
+		rt.byteVecPush(_255.value, 250);
+		rt.refMutRelease(_255);
+		flush(log.value, out);
+		_11(v6, out);
+		const part7 = at(2);
+		const empty: Logged.Logged[] = rt.vecFromElem(logged(part7), 0, Logged.clone$Clone, rt.drop);
+		const _276: rt.RefCell<rt.ByteVec> = rt.refCellBorrowMut(log.value);
+		rt.byteVecPush(_276.value, 250);
+		rt.refMutRelease(_276);
+		flush(log.value, out);
+		drop$tuple2_Vec_clones_Logged_Vec_clones_Logged([v6, empty] as [Logged.Logged[], Logged.Logged[]]);
+		flush(log.value, out);
+	} else {
+		const part = at(0);
+		const v7: Logged.Logged[] = repeated$clones_Logged(logged(part), n(1));
+		flush(log.value, out);
+		_11(v7, out);
+		const part3 = at(2);
+		const _308: Logged.Logged = logged(part3);
+		const part4 = at(3);
+		const rows: Logged.Logged[][] = repeated$Vec_clones_Logged([_308, logged(part4)], n(4));
+		flush(log.value, out);
+		drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged([v7, rows] as [Logged.Logged[], Logged.Logged[][]]);
+		flush(log.value, out);
+	}
+	log[Symbol.dispose]();
+}
+
+/** `vec![x; n]` where only its bound says `x` clones. */
+export function repeated$Vec_clones_Logged(x: Logged.Logged[], n: rt.usize): Logged.Logged[][] {
+	return rt.vecFromElem(x, n, (a0: Logged.Logged[]): Logged.Logged[] => {
+		return rt.vecExact(a0.map(Logged.clone$Clone), 8);
+	}, drop$Vec_clones_Logged);
+}
+
+/** `vec![x; n]` where only its bound says `x` clones. */
+export function repeated$clones_Logged(x: Logged.Logged, n: rt.usize): Logged.Logged[] {
+	return rt.vecFromElem(x, n, Logged.clone$Clone, rt.drop);
+}
+
 //# sourceMappingURL=clones.ts.map

ts/fixtures/lang/clones/expected/core/option.ts

@@ -45,4 +45,11 @@ export function clone$0bhdqd8(self: Logged.Logged[] | undefined): Logged.Logged[
 	return self.map(Logged.clone$Clone);
 }
 
+export function clone$1jx0028(self: Logged.Logged | undefined): Logged.Logged | undefined {
+	if (self === undefined) {
+		return undefined;
+	}
+	return Logged.clone$Clone(self);
+}
+
 //# sourceMappingURL=option.ts.map

ts/fixtures/lang/clones/expected/lib.ts

@@ -1,7 +1,7 @@
 // Generated by rust2-ts. Do not edit.
 
 import * as rt from "./rt.ts";
-import { iters, arrays, cloneFroms } from "./clones.ts";
+import { iters, arrays, cloneFroms, repeats } from "./clones.ts";
 import type * as Kept from "./clones.Kept.ts";
 import type * as Logged from "./clones.Logged.ts";
 import type * as Pair from "./clones.Pair.ts";
@@ -39,11 +39,25 @@ export function drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged
 	rt.dropAll(_1[1], drop$array2_clones_Logged);
 }
 
+export function drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged(_1: [Logged.Logged[], Logged.Logged[][]]): void {
+	rt.dropAll(_1[0]);
+	rt.dropAll(_1[1], drop$Vec_clones_Logged);
+}
+
+export function drop$tuple2_Vec_clones_Logged_Vec_clones_Logged(_1: [Logged.Logged[], Logged.Logged[]]): void {
+	rt.dropAll(_1[0]);
+	rt.dropAll(_1[1]);
+}
+
 export function drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged(_1: [Logged.Logged[][], Logged.Logged[][]]): void {
 	rt.dropAll(_1[0], drop$array2_clones_Logged);
 	rt.dropAll(_1[1], drop$array2_clones_Logged);
 }
 
+export function drop$tuple2_clones_Logged_String(_1: [Logged.Logged, 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 {
 	drop$tuple3_array2_clones_Logged_String_clones_Logged(_1[0]);
 	_1[1][Symbol.dispose]();
@@ -55,6 +69,12 @@ export function drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Log
 	rt.dropAll(_1[2]);
 }
 
+export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [Array<Logged.Logged | undefined>, Array<Logged.Logged | undefined>, [Logged.Logged, string][]]): void {
+	rt.dropAll(_1[0]);
+	rt.dropAll(_1[1]);
+	rt.dropAll(_1[2], drop$tuple2_clones_Logged_String);
+}
+
 export function drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged(_1: [Logged.Logged[][], Logged.Logged[][], Logged.Logged[][]]): void {
 	rt.dropAll(_1[0], drop$Vec_clones_Logged);
 	rt.dropAll(_1[1], drop$Vec_clones_Logged);
@@ -110,7 +130,7 @@ export function drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones
  * their count, so a case added at the end moves no other.
  */
 export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] {
-	return [["clones::iters", iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::clone_froms", cloneFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]];
+	return [["clones::iters", iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::clone_froms", cloneFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::repeats", repeats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]];
 }
 
 //# sourceMappingURL=lib.ts.map