Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion quest/m2/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,6 @@ The fork's feature quests folded into the [exporter](/quest/m1/ffi-export.md);
- [Async in the TypeScript translator](/quest/m2/ts-async.md) - moq-net's and kio's async code translates with Rust's lazy futures
- [Shared ownership](/quest/m2/ts-shared.md) - `Arc`/`Rc`/`Weak` keep exact counts, and locks and atomics become plain values
- [Matches TypeScript has already narrowed](/quest/m2/ts-narrow-test.md) - an inner match on a value an outer match decided passes `tsc`
- [Small std gaps](/quest/m2/ts-std-gaps.md) - `bool::then`, `iter::successors`, `usize::from(bool)`, and `None.ok_or` narrowing
- [Translate moq-net's model to TypeScript](/quest/m2/ts-model.md) - the driver grows from moq-net's codec to its model, for moq to compare against WASM
- [Waiting: Swift 6.4 in nixpkgs-unstable](/quest/m2/uniffi-swift-arm.md) - the nightly UniFFI fixtures move back to arm
- [Waiting: ubrn reads UniFFI 0.32](/quest/m2/ubrn-release.md) - the binding benchmark's browser runner pins a ubrn release, not an open PR
19 changes: 0 additions & 19 deletions quest/m2/ts-std-gaps.md

This file was deleted.

2 changes: 1 addition & 1 deletion ts/fixtures/lang/expected/collections.ts
Original file line number Diff line number Diff line change
Expand Up @@ -783,7 +783,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi
const o: rt.Ordering = rt.orderingThen(rt.orderingReverse(Nibble.cmp$Ord(a2, b4)), (): rt.Ordering => {
return rt.cmp(y, x);
}, true);
rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$Ord(a2, b4), -1) === 0 ? 1 : 0) << 2) & 0xff));
rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$Ord(a2, b4), -1 as rt.Ordering) === 0 ? 1 : 0) << 2) & 0xff));
if (o === -1) {
_401 = 1;
} else if (o === 0) {
Expand Down
2 changes: 1 addition & 1 deletion ts/fixtures/lang/expected/fmt.ts
Original file line number Diff line number Diff line change
Expand Up @@ -381,7 +381,7 @@ export function panics(kind: rt.u8, rest: rt.ByteSlice, out: rt.ByteVec): void {
}
} else if (_7 === 4) {
if (!(n === 7)) {
rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(7, f), undefined);
rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(7, f), undefined as rt.Arguments | undefined);
}
} else if (_7 === 5) {
const _58: Pair.Pair = { _0: n, _1: 1 };
Expand Down
48 changes: 32 additions & 16 deletions ts/fixtures/lang/expected/iters.ts
Original file line number Diff line number Diff line change
Expand Up @@ -441,16 +441,22 @@ export function fullRange(out: rt.ByteVec): undefined {

/** Iterators of `Option`, which keep each `None` apart from their end. */
export function options(data: rt.ByteSlice, out: rt.ByteVec): void {
const all: Array<rt.u8 | undefined> = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b2: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b2, 3) === 0)) {
return b2;
const _68: (a0: rt.u8, a1: rt.ByteVec) => rt.u8 | undefined = (b2: rt.u8, calls2: rt.ByteVec): rt.u8 | undefined => {
rt.byteVecPush(calls2, b2);
return rt.optionMap(rt.u8CheckedSub(b2, 1), (b3: rt.u8): rt.u8 => {
return rt.u8Div(b3, 2);
});
};
const all: Array<rt.u8 | undefined> = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b4, 3) === 0)) {
return b4;
}
return undefined;
}));
rt.byteVecPush(out, all.length & 0xff);
const iter: rt.Iter<rt.u8 | undefined> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b3: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b3, 3) === 0)) {
return b3;
const iter: rt.Iter<rt.u8 | undefined> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b5, 3) === 0)) {
return b5;
}
return undefined;
});
Expand All @@ -466,18 +472,18 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void {
rt.byteVecPush(out, item);
}
}
rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b4, 3) === 0)) {
return b4;
rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b6: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b6, 3) === 0)) {
return b6;
}
return undefined;
}), (value: rt.u8 | undefined) => rt.iterOption(value)))));
rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => {
return o !== undefined;
})) & 0xff);
rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b5, 3) === 0)) {
return b5;
rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b7: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b7, 3) === 0)) {
return b7;
}
return undefined;
})), 205));
Expand All @@ -498,14 +504,24 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void {
n = rt.u8Add(n, 1);
return rt.thenSome(n < 4, n);
}))));
const calls: rt.ByteVec = new rt.ByteVec();
const first2: rt.u8 | undefined = rt.byteSliceFirst(data);
rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterSuccessors(first2, (b8: rt.u8): rt.u8 | undefined => {
return _68(b8, calls);
}), rt.usizeRem(data.length, 4)))));
rt.byteVecExtendFromSlice(out, rt.byteVecSlice(calls));
rt.byteVecPush(out, rt.iterCount(rt.iterSuccessors(first2, (b9: rt.u8): rt.u8 | undefined => {
return _68(b9, calls);
})) & 0xff);
rt.byteVecExtendFromSlice(out, rt.byteVecSlice(calls));
const iter3: Gaps.Gaps = { data, at: 0 };
while (true) {
const _70: rt.u8 | undefined | rt.Done = Gaps.next$Iterator(iter3);
if (_70 === rt.DONE) {
const _99: rt.u8 | undefined | rt.Done = Gaps.next$Iterator(iter3);
if (_99 === rt.DONE) {
break;
}
rt.byteVecPush(out, rt.optionMapOr(_70, 170, (b6: rt.u8): rt.u8 => {
return b6;
rt.byteVecPush(out, rt.optionMapOr(_99, 170, (b10: rt.u8): rt.u8 => {
return b10;
}));
}
}
Expand Down
76 changes: 59 additions & 17 deletions ts/fixtures/lang/expected/shapes.ts
Original file line number Diff line number Diff line change
Expand Up @@ -1665,27 +1665,27 @@ export function library(data: rt.ByteSlice, out: rt.ByteVec): void {
const _3: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => {
const _4: rt.u8 | undefined = rt.u8CheckedAdd(a2, b2);
if (_4 !== undefined) {
const _82: rt.u8 | undefined = rt.u8CheckedMul(_4, 2);
if (_82 !== undefined) {
return rt.u8Sub(_82, 1);
const _83: rt.u8 | undefined = rt.u8CheckedMul(_4, 2);
if (_83 !== undefined) {
return rt.u8Sub(_83, 1);
}
return undefined;
}
return undefined;
};
const _30: (a0: rt.u8) => rt.Poll<rt.Result<rt.u8, rt.u8>> = (a3: rt.u8): rt.Poll<rt.Result<rt.u8, rt.u8>> => {
let half!: rt.Result<rt.u8, Dir.Dir>;
const _47: Dir.Dir | undefined = dir(a3);
let half2!: rt.Result<rt.u8, Dir.Dir>;
const _45: Dir.Dir | undefined = dir(a3);
b0: {
if (_47 !== undefined) {
if (_45 !== undefined) {
if (rt.u8Rem(a3, 2) === 1) {
half = rt.Err(_47);
half2 = rt.Err(_45);
break b0;
}
}
half = rt.Ok(rt.u8Div(a3, 2));
half2 = rt.Ok(rt.u8Div(a3, 2));
}
const _132: rt.Result<rt.u8, Dir.Dir> = half;
const _132: rt.Result<rt.u8, Dir.Dir> = half2;
if (_132.ok) {
return rt.Ok(_132.value);
}
Expand All @@ -1699,10 +1699,10 @@ export function library(data: rt.ByteSlice, out: rt.ByteVec): void {
} else {
parsed = rt.Ok(a);
}
const mapped: rt.Result<rt.u8, rt.u8> = rt.resultMapErr(rt.resultMap(parsed, (n5: rt.u8): rt.u8 => {
return rt.u8Div(n5, 2);
}), (e2: string): rt.u8 => {
return rt.stringLen(e2) & 0xff;
const mapped: rt.Result<rt.u8, rt.u8> = rt.resultMapErr(rt.resultMap(parsed, (n7: rt.u8): rt.u8 => {
return rt.u8Div(n7, 2);
}), (e4: string): rt.u8 => {
return rt.stringLen(e4) & 0xff;
});
if (mapped.ok) {
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, mapped.value)));
Expand All @@ -1719,15 +1719,57 @@ export function library(data: rt.ByteSlice, out: rt.ByteVec): void {
} else {
rt.byteVecPush(out, 4);
}
const _45: rt.Result<string, rt.FromUtf8Error> = rt.stringFromUtf8(rt.byteSliceToByteVec(data));
if (_45.ok) {
const s: string = _45.value;
const _46: rt.Result<string, rt.FromUtf8Error> = rt.stringFromUtf8(rt.byteSliceToByteVec(data));
if (_46.ok) {
const s: string = _46.value;
rt.byteVecPush(out, 1);
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.stringLen(s) as rt.u32)));
rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s));
} else {
rt.byteVecPush(out, 0);
}
let calls: rt.u8 = 0;
const iter: rt.Iter<rt.u8> = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6);
while (true) {
const _66: rt.u8 | rt.Done = iter.next();
if (_66 === rt.DONE) {
break;
}
const x: rt.u8 = _66;
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.optionUnwrapOr(rt.boolThen(rt.u8Rem(x, 2) === 0, (): rt.u8 => {
calls = rt.u8Add(calls, 1);
return rt.u8Div(x, 2);
}), 238), calls)));
rt.byteVecPush(out, rt.optionMapOr(rt.boolThen(x > 128, (): rt.ByteVec => {
return new rt.ByteVec();
}), 2, (v: rt.ByteVec): rt.u8 => {
return v.length & 0xff;
}));
const flag: boolean = rt.u8Rem(x, 3) === 0;
rt.byteVecPush(out, rt.u8Add(rt.u8Add(flag ? 1 : 0, ((flag ? 1 : 0)) & 0xff), ((flag ? 1 : 0)) & 0xff));
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(flag ? 1 : 0)));
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(flag ? 1 : 0)));
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(flag ? 1 : 0)));
}
const _117: rt.Result<rt.u8, rt.u8> = rt.optionOkOr(undefined as rt.u8 | undefined, a);
if (_117.ok) {
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(5, _117.value)));
} else {
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(6, _117.error)));
}
const iter2: rt.Iter<rt.Result<rt.u8, rt.u8>> = rt.iterSlice([rt.optionOkOr(undefined as rt.u8 | undefined, b), rt.optionOkOr(undefined as rt.u8 | undefined, a)]);
while (true) {
const _134: rt.Result<rt.u8, rt.u8> | rt.Done = iter2.next();
if (_134 === rt.DONE) {
break;
}
const result: rt.Result<rt.u8, rt.u8> = _134;
if (result.ok) {
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(5, result.value)));
} else {
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(6, result.error)));
}
}
}

/** Steps a total by `x`: breaks with what it can't take, or continues with the new total. */
Expand Down Expand Up @@ -1833,7 +1875,7 @@ export function flows(data: rt.ByteSlice, out: rt.ByteVec): void {
rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(flow3.value));
}
}
const slot: rt.Mutex<rt.u8 | undefined> = new rt.Mutex(undefined);
const slot: rt.Mutex<rt.u8 | undefined> = new rt.Mutex(undefined as rt.u8 | undefined);
for (const x2 of rt.byteSliceView(data)) {
const held: rt.Mutex<rt.u8 | undefined> = slot;
const _114: rt.u8 | undefined = held.value;
Expand Down
105 changes: 56 additions & 49 deletions ts/fixtures/lang/expected/strs.ts
Original file line number Diff line number Diff line change
Expand Up @@ -273,7 +273,7 @@ export function pattern(kind: rt.u8, s: string): string {
* one matches before each char and after the last.
*/
export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void {
let _211!: [rt.usize, rt.usize];
let _209!: [rt.usize, rt.usize];
let sliced!: string;
const s: string = text(data);
const p: string = pattern(kind, s);
Expand Down Expand Up @@ -322,59 +322,66 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void {
return rt.charIsAsciiDigit(c);
}) ? 1 : 0);
putOffset(out, rt.strRfind(s, p));
} else if (_8 === 3) {
let path: string = s;
while (true) {
const _125: rt.usize | undefined = rt.strRfind(path, "/");
if (_125 !== undefined) {
path = rt.strSlice(path, 0, _125);
put(out, path);
} else {
break;
}
}
put(out, path);
} else if (_8 === 4) {
const keep: rt.usize = rt.usizeAdd(rt.u8Rem(rt.u8Div(kind, 8), 4) as rt.usize, 1);
put(out, rt.optionUnwrapOr(rt.optionMap(rt.iterNth(rt.strMatchIndices(s, "/"), rt.usizeSub(keep, 1)), (_2: [rt.usize, string]): string => {
return rt.strSlice(s, 0, _2[0]);
}), "none"));
const part5 = rt.optionMapOr(rt.iterNth(rt.strMatchIndices(s, "/"), rt.usizeSub(keep, 1)), rt.stringLen(s), (_22: [rt.usize, string]): rt.usize => {
return rt.usizeAdd(_22[0], 1);
});
put(out, rt.strSlice(s, part5));
} else if (_8 === 5) {
const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"));
put(out, parts.join(p));
put(out, rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (part3: string): string => {
return part3;
})).join(p));
put(out, ["a", "", s].join("/"));
} else {
const at2: (a0: rt.u8) => rt.usize = (b2: rt.u8): rt.usize => {
if ((kind & 32) === 0) {
return rt.usizeRem(b2 as rt.usize, rt.usizeAdd(rt.stringLen(s), 2));
if (_8 === 3) {
const iter3: rt.Iter<string> = rt.iterSuccessors(s, (path: string): string | undefined => {
const _73: string = path;
return rt.boolThen(!((path.length === 0)), (): string => {
return rt.optionMapOr(rt.strRfind(_73, "/"), "", (slash: rt.usize): string => {
return rt.strSlice(_73, 0, slash);
});
});
});
while (true) {
const _129: string | rt.Done = iter3.next();
if (_129 === rt.DONE) {
break b0;
}
put(out, _129);
}
return rt.usizeSaturatingSub(rt.usizeAdd(rt.stringLen(s), 1), rt.usizeRem(b2 as rt.usize, 4));
};
if (!(data.length >= 2)) {
_211 = [0, 0] as [rt.usize, rt.usize];
} else {
_211 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rt.usize, rt.usize];
}
const a: rt.usize = _211[0];
const b: rt.usize = _211[1];
const _225: rt.u8 = rt.u8Rem(rt.u8Div(kind, 8), 4);
if (_225 === 0) {
sliced = rt.strSlice(s, a, b);
} else if (_225 === 1) {
sliced = rt.strSlice(s, a);
} else if (_225 === 2) {
sliced = rt.strSlice(s, 0, b);
if (_8 === 4) {
const keep: rt.usize = rt.usizeAdd(rt.u8Rem(rt.u8Div(kind, 8), 4) as rt.usize, 1);
put(out, rt.optionUnwrapOr(rt.optionMap(rt.iterNth(rt.strMatchIndices(s, "/"), rt.usizeSub(keep, 1)), (_2: [rt.usize, string]): string => {
return rt.strSlice(s, 0, _2[0]);
}), "none"));
const part5 = rt.optionMapOr(rt.iterNth(rt.strMatchIndices(s, "/"), rt.usizeSub(keep, 1)), rt.stringLen(s), (_22: [rt.usize, string]): rt.usize => {
return rt.usizeAdd(_22[0], 1);
});
put(out, rt.strSlice(s, part5));
} else if (_8 === 5) {
const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"));
put(out, parts.join(p));
put(out, rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (part3: string): string => {
return part3;
})).join(p));
put(out, ["a", "", s].join("/"));
} else {
sliced = rt.strSlice(s, 0);
const at2: (a0: rt.u8) => rt.usize = (b2: rt.u8): rt.usize => {
if ((kind & 32) === 0) {
return rt.usizeRem(b2 as rt.usize, rt.usizeAdd(rt.stringLen(s), 2));
}
return rt.usizeSaturatingSub(rt.usizeAdd(rt.stringLen(s), 1), rt.usizeRem(b2 as rt.usize, 4));
};
if (!(data.length >= 2)) {
_209 = [0, 0] as [rt.usize, rt.usize];
} else {
_209 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rt.usize, rt.usize];
}
const a: rt.usize = _209[0];
const b: rt.usize = _209[1];
const _223: rt.u8 = rt.u8Rem(rt.u8Div(kind, 8), 4);
if (_223 === 0) {
sliced = rt.strSlice(s, a, b);
} else if (_223 === 1) {
sliced = rt.strSlice(s, a);
} else if (_223 === 2) {
sliced = rt.strSlice(s, 0, b);
} else {
sliced = rt.strSlice(s, 0);
}
put(out, sliced);
}
put(out, sliced);
}
}
}
Expand Down
16 changes: 16 additions & 0 deletions ts/fixtures/lang/src/iters.rs
Original file line number Diff line number Diff line change
Expand Up @@ -397,6 +397,22 @@ pub fn options(data: &[u8], out: &mut Vec<u8>) {
})
.collect();
out.extend_from_slice(&counted);
// `successors` calls its closure on each item as it yields it, and never again once
// it returned `None`.
let mut calls = Vec::new();
let halving = |b: &u8, calls: &mut Vec<u8>| {
calls.push(*b);
b.checked_sub(1).map(|b| b / 2)
};
let first = data.first().copied();
let taken: Vec<u8> = std::iter::successors(first, |b| halving(b, &mut calls))
.take(data.len() % 4)
.collect();
out.extend_from_slice(&taken);
out.extend_from_slice(&calls);
let count = std::iter::successors(first, |b| halving(b, &mut calls)).count();
out.push(count as u8);
out.extend_from_slice(&calls);
// The crate's own iterator, whose items are options.
let gaps = Gaps { data, at: 0 };
for gap in gaps {
Expand Down
Loading