1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
|
// New version of JS promise integration API
// Modified https://github.com/WebAssembly/js-promise-integration/tree/main/test/js-api/js-promise-integration
var tests = Promise.resolve();
function test(fn, n) {
tests = tests.then(() => {
let t = {res: null};
print("# " + n);
fn(t);
return t.res;
});
}
function promise_test(fn, n) {
tests = tests.then(() => {
print("# " + n);
return fn();
});
}
function assert_true(f) { assertEq(f, true); }
function assert_equals(a, b) { assertEq(a, b); }
function assert_array_equals(a, b) {
assert_equals(a.length, a.length);
for (let i = 0; i < a.length; i++) {
assert_equals(a[i], b[i]);
}
}
function assert_throws(ex, fn) {
try {
fn(); assertEq(false, true);
} catch(e) {
assertEq(e instanceof ex, true);
}
}
function promise_rejects(t, obj, p) {
t.res = p.then(() => {
assertEq(true, false);
}, (e) => {
assertEq(e instanceof obj.constructor, true);
});
}
function ToPromising(wasm_export) {
let sig = wasm_export.type();
assert_true(sig.parameters.length > 0);
assert_equals('externref', sig.parameters[0]);
let wrapper_sig = {
parameters: sig.parameters.slice(1),
results: ['externref']
};
return new WebAssembly.Function(
wrapper_sig, wasm_export, {promising: 'first'});
}
promise_test(async () => {
let js_import = new WebAssembly.Suspending(
() => Promise.resolve(42)
);
let instance = wasmEvalText(`(module
(import "m" "import" (func $import (result i32)))
(func (export "test") (result i32)
call $import
)
)`, {m: {import: js_import}});
let wrapped_export = WebAssembly.promising(instance.exports.test);
let export_promise = wrapped_export();
assert_true(export_promise instanceof Promise);
assert_equals(42, await export_promise);
}, "Suspend once");
promise_test(async () => {
let i = 0;
function js_import() {
return Promise.resolve(++i);
};
let wasm_js_import = new WebAssembly.Suspending(js_import);
// void test() {
// for (i = 0; i < 5; ++i) {
// g = g + await import();
// }
// }
let instance = wasmEvalText(`(module
(import "m" "import" (func $import (param externref) (result i32)))
(global (export "g") (mut i32) (i32.const 0))
(func (export "test") (param externref)
(local i32)
i32.const 5
local.set 1
loop
local.get 0
call $import
global.get 0
i32.add
global.set 0
local.get 1
i32.const 1
i32.sub
local.tee 1
br_if 0
end
)
)`, {m: {import: wasm_js_import}});
let wrapped_export = WebAssembly.promising(instance.exports.test);
let export_promise = wrapped_export();
assert_equals(0, instance.exports.g.value);
assert_true(export_promise instanceof Promise);
await export_promise;
assert_equals(15, instance.exports.g.value);
}, "Suspend/resume in a loop");
promise_test(async () => {
function js_import() {
return 42
};
let wasm_js_import = new WebAssembly.Suspending(js_import);
let instance = wasmEvalText(`(module
(import "m" "import" (func $import (param externref) (result i32)))
(global (export "g") (mut i32) (i32.const 0))
(func (export "test") (param externref) (result i32)
local.get 0
call $import
global.set 0
global.get 0
)
)`, {m: {import: wasm_js_import}});
let wrapped_export = WebAssembly.promising(instance.exports.test);
await wrapped_export();
assert_equals(42, instance.exports.g.value);
}, "Do not suspend if the import's return value is not a Promise");
test(t => {
let tag = new WebAssembly.Tag({parameters: []});
function js_import() {
return Promise.resolve();
};
let wasm_js_import = new WebAssembly.Suspending(js_import);
function js_throw() {
throw new Error();
}
let instance = wasmEvalText(`(module
(import "m" "import" (func $import (param externref) (result i32)))
(import "m" "js_throw" (func $js_throw))
(func (export "test") (param externref) (result i32)
local.get 0
call $import
call $js_throw
)
)`, {m: {import: wasm_js_import, js_throw}});
let wrapped_export = WebAssembly.promising(instance.exports.test);
let export_promise = wrapped_export();
assert_true(export_promise instanceof Promise);
promise_rejects(t, new Error(), export_promise);
}, "Throw after the first suspension");
// TODO: Use wasm exception handling to check that the exception can be caught in wasm.
test(t => {
let tag = new WebAssembly.Tag({parameters: ['i32']});
function js_import() {
return Promise.reject(new Error());
};
let wasm_js_import = new WebAssembly.Suspending(js_import);
let instance = wasmEvalText(`(module
(import "m" "import" (func $import (param externref) (result i32)))
(func (export "test") (param externref) (result i32)
local.get 0
call $import
)
)`, {m: {import: wasm_js_import, tag: tag}});
let wrapped_export = WebAssembly.promising(instance.exports.test);
let export_promise = wrapped_export();
assert_true(export_promise instanceof Promise);
promise_rejects(t, new Error(), export_promise);
}, "Rejecting promise");
async function TestNestedSuspenders(suspend) {
// Nest two suspenders. The call chain looks like:
// outer (wasm) -> outer (js) -> inner (wasm) -> inner (js)
// If 'suspend' is true, the inner JS function returns a Promise, which
// suspends the inner wasm function, which returns a Promise, which suspends
// the outer wasm function, which returns a Promise. The inner Promise
// resolves first, which resumes the inner continuation. Then the outer
// promise resolves which resumes the outer continuation.
// If 'suspend' is false, the inner and outer JS functions return a regular
// value and no computation is suspended.
let inner = new WebAssembly.Suspending(
() => suspend ? Promise.resolve(42) : 43,
);
let export_inner;
let outer = new WebAssembly.Suspending(
() => suspend ? export_inner() : 42,
);
let instance = wasmEvalText(`(module
(import "m" "inner" (func $inner (param externref) (result i32)))
(import "m" "outer" (func $outer (param externref) (result i32)))
(func (export "outer") (param externref) (result i32)
local.get 0
call $outer
)
(func (export "inner") (param externref) (result i32)
local.get 0
call $inner
)
)`, {m: {inner, outer}});
export_inner = WebAssembly.promising(instance.exports.inner);
let export_outer = WebAssembly.promising(instance.exports.outer);
let result = export_outer();
assert_true(result instanceof Promise);
assert_equals(42, await result);
}
promise_test(async () => {
return TestNestedSuspenders(true);
}, "Test nested suspenders with suspension");
promise_test(async () => {
return TestNestedSuspenders(false);
}, "Test nested suspenders with no suspension");
test(t => {
let instance = wasmEvalText(`(module
(func (export "test") (result i32)
call 0
)
)`);
let wrapper = WebAssembly.promising(instance.exports.test);
promise_rejects(t, new InternalError(), wrapper());
}, "Stack overflow");
// TODO: Test suspension with funcref.
test(t => {
// The call stack of this test looks like:
// export1 -> import1 -> export2 -> import2
// Where export1 is "promising" and import2 is "suspending". Returning a
// promise from import2 should trap because of the JS import in the middle.
let instance;
function import1() {
// import1 -> export2 (unwrapped)
instance.exports.export2();
}
function import2() {
return Promise.resolve(0);
}
import2 = new WebAssembly.Suspending(import2);
instance = wasmEvalText(`(module
(import "m" "import1" (func $import1 (result i32)))
(import "m" "import2" (func $import2 (result i32)))
(func (export "export1") (result i32)
;; export1 -> import1 (unwrapped)
call $import1
)
(func (export "export2") (result i32)
;; export2 -> import2 (suspending)
call $import2
)
)`,
{'m': {'import1': import1, 'import2': import2}});
// export1 (promising)
let wrapper = WebAssembly.promising(instance.exports.export1);
promise_rejects(t, new WebAssembly.RuntimeError(), wrapper());
}, "Test that trying to suspend JS frames traps");
tests.then(() => print('Done'));
|
