From 2164f6b1eb7216c1045d547c94f26fe3ceaa9403 Mon Sep 17 00:00:00 2001 From: Aapo Alasuutari Date: Thu, 11 Aug 2022 16:56:56 +0300 Subject: [PATCH] perf(ops): Monomorphic sync op calls (#15337) Welcome to better optimised op calls! Currently opSync is called with parameters of every type and count. This most definitely makes the call megamorphic. Additionally, it seems that spread params leads to V8 not being able to optimise the calls quite as well (apparently Fast Calls cannot be used with spread params). Monomorphising op calls should lead to some improved performance. Now that unwrapping of sync ops results is done on Rust side, this is pretty simple: ``` opSync("op_foo", param1, param2); // -> turns to ops.op_foo(param1, param2); ``` This means sync op calls are now just directly calling the native binding function. When V8 Fast API Calls are enabled, this will enable those to be called on the optimised path. Monomorphising async ops likely requires using callbacks and is left as an exercise to the reader. --- bench_util/README.md | 2 +- bench_util/benches/op_baseline.rs | 6 +- cli/bench/deno_common.js | 6 +- cli/bench/http/deno_http_ops.js | 2 +- .../bench/recursive_permissions_pledge.js | 6 +- .../op_exit_op_set_exit_code_in_worker.ts | 2 +- .../op_exit_op_set_exit_code_worker.js | 2 +- cli/tests/testdata/set_exit_code_0.ts | 2 +- cli/tests/testdata/set_exit_code_1.ts | 2 +- cli/tests/testdata/set_exit_code_2.ts | 2 +- .../test/recursive_permissions_pledge.js | 6 +- cli/tests/testdata/unstable_ffi_1.js | 2 +- cli/tests/testdata/unstable_ffi_10.js | 2 +- cli/tests/testdata/unstable_ffi_11.js | 2 +- cli/tests/testdata/unstable_ffi_12.js | 2 +- cli/tests/testdata/unstable_ffi_13.js | 2 +- cli/tests/testdata/unstable_ffi_14.js | 2 +- cli/tests/testdata/unstable_ffi_15.js | 2 +- cli/tests/testdata/unstable_ffi_2.js | 2 +- cli/tests/testdata/unstable_ffi_4.js | 2 +- cli/tests/testdata/unstable_ffi_5.js | 2 +- cli/tests/testdata/unstable_ffi_6.js | 2 +- cli/tests/testdata/unstable_ffi_7.js | 2 +- cli/tests/testdata/unstable_ffi_8.js | 2 +- cli/tests/testdata/unstable_ffi_9.js | 2 +- cli/tests/unit/opcall_test.ts | 2 +- cli/tsc/99_main_compiler.js | 32 ++- cli/tsc/compiler.d.ts | 5 +- core/01_core.js | 80 +++--- core/02_error.js | 5 +- core/encode_decode_test.js | 14 +- core/error_builder_test.js | 3 +- core/examples/hello_world.rs | 4 +- core/examples/http_bench_json_ops.js | 2 +- core/examples/schedule_task.rs | 10 +- core/lib.deno_core.d.ts | 10 +- core/modules.rs | 2 +- core/runtime.rs | 78 +++--- core/serialize_deserialize_test.js | 15 +- ext/broadcast_channel/01_broadcast_channel.js | 7 +- ext/crypto/00_crypto.js | 113 +++++---- ext/fetch/22_http_client.js | 4 +- ext/fetch/26_fetch.js | 8 +- ext/ffi/00_ffi.js | 68 ++--- ext/http/01_http.js | 6 +- ext/net/01_net.js | 8 +- ext/net/02_tls.js | 3 +- ext/node/01_require.js | 34 ++- ext/url/00_url.js | 16 +- ext/url/01_urlpattern.js | 9 +- ext/web/00_infra.js | 5 +- ext/web/02_timers.js | 5 +- ext/web/05_base64.js | 5 +- ext/web/08_text_encoding.js | 11 +- ext/web/09_file.js | 9 +- ext/web/11_blob_url.js | 6 +- ext/web/13_message_port.js | 6 +- ext/web/14_compression.js | 15 +- ext/webgpu/src/01_webgpu.js | 232 +++++++----------- ext/websocket/01_websocket.js | 4 +- ext/websocket/02_websocketstream.js | 4 +- ext/webstorage/01_webstorage.js | 15 +- runtime/js/10_permissions.js | 8 +- runtime/js/11_workers.js | 7 +- runtime/js/12_io.js | 5 +- runtime/js/30_fs.js | 55 +++-- runtime/js/30_os.js | 29 +-- runtime/js/40_files.js | 6 +- runtime/js/40_fs_events.js | 3 +- runtime/js/40_http.js | 3 +- runtime/js/40_process.js | 5 +- runtime/js/40_read_file.js | 9 +- runtime/js/40_signals.js | 5 +- runtime/js/40_spawn.js | 7 +- runtime/js/40_testing.js | 38 +-- runtime/js/40_tty.js | 7 +- runtime/js/40_write_file.js | 5 +- runtime/js/99_main.js | 25 +- test_ffi/tests/bench.js | 4 + test_ffi/tests/test.js | 26 +- 80 files changed, 552 insertions(+), 616 deletions(-) diff --git a/bench_util/README.md b/bench_util/README.md index 68f93a3b9b..0ec15f0d0b 100644 --- a/bench_util/README.md +++ b/bench_util/README.md @@ -30,7 +30,7 @@ fn setup() -> Vec { } fn bench_op_nop(b: &mut Bencher) { - bench_js_sync(b, r#"Deno.core.opSync("op_nop", null, null);"#, setup); + bench_js_sync(b, r#"Deno.core.ops.op_nop();"#, setup); } benchmark_group!(benches, bench_op_nop); diff --git a/bench_util/benches/op_baseline.rs b/bench_util/benches/op_baseline.rs index 46501e4f73..317be79829 100644 --- a/bench_util/benches/op_baseline.rs +++ b/bench_util/benches/op_baseline.rs @@ -30,15 +30,15 @@ async fn op_pi_async() -> i64 { } fn bench_op_pi_json(b: &mut Bencher) { - bench_js_sync(b, r#"Deno.core.opSync("op_pi_json", null);"#, setup); + bench_js_sync(b, r#"Deno.core.ops.op_pi_json();"#, setup); } fn bench_op_nop(b: &mut Bencher) { - bench_js_sync(b, r#"Deno.core.opSync("op_nop", null, null, null);"#, setup); + bench_js_sync(b, r#"Deno.core.ops.op_nop();"#, setup); } fn bench_op_async(b: &mut Bencher) { - bench_js_async(b, r#"Deno.core.opAsync("op_pi_async", null);"#, setup); + bench_js_async(b, r#"Deno.core.opAsync("op_pi_async");"#, setup); } fn bench_is_proxy(b: &mut Bencher) { diff --git a/cli/bench/deno_common.js b/cli/bench/deno_common.js index c31ccd981c..abafdc519d 100644 --- a/cli/bench/deno_common.js +++ b/cli/bench/deno_common.js @@ -6,7 +6,11 @@ Deno.bench("date_now", { n: 5e5 }, () => { }); // Void ops measure op-overhead -Deno.bench("op_void_sync", { n: 1e7 }, () => Deno.core.opSync("op_void_sync")); +Deno.bench( + "op_void_sync", + { n: 1e7 }, + () => Deno.core.ops.op_void_sync(), +); Deno.bench( "op_void_async", diff --git a/cli/bench/http/deno_http_ops.js b/cli/bench/http/deno_http_ops.js index aac5cea726..f65b32170f 100644 --- a/cli/bench/http/deno_http_ops.js +++ b/cli/bench/http/deno_http_ops.js @@ -19,7 +19,7 @@ class Http { } for await (const conn of tcp) { - const id = Deno.core.opSync("op_http_start", conn.rid); + const id = Deno.core.ops.op_http_start(conn.rid); const http = new Http(id); (async () => { for await (const req of http) { diff --git a/cli/tests/testdata/bench/recursive_permissions_pledge.js b/cli/tests/testdata/bench/recursive_permissions_pledge.js index dcdcbf5744..dbba96f262 100644 --- a/cli/tests/testdata/bench/recursive_permissions_pledge.js +++ b/cli/tests/testdata/bench/recursive_permissions_pledge.js @@ -1,8 +1,6 @@ -Deno.core.opSync( - "op_pledge_test_permissions", +Deno.core.ops.op_pledge_test_permissions( "none", ); -Deno.core.opSync( - "op_pledge_test_permissions", +Deno.core.ops.op_pledge_test_permissions( "inherit", ); diff --git a/cli/tests/testdata/op_exit_op_set_exit_code_in_worker.ts b/cli/tests/testdata/op_exit_op_set_exit_code_in_worker.ts index ddc0781ebc..b2ed912de9 100644 --- a/cli/tests/testdata/op_exit_op_set_exit_code_in_worker.ts +++ b/cli/tests/testdata/op_exit_op_set_exit_code_in_worker.ts @@ -3,7 +3,7 @@ // `self.close()`. // @ts-ignore Deno.core doesn't have type-defs -Deno.core.opSync("op_set_exit_code", 21); +Deno.core.ops.op_set_exit_code(21); const worker = new Worker( import.meta.resolve("./op_exit_op_set_exit_code_worker.js"), diff --git a/cli/tests/testdata/op_exit_op_set_exit_code_worker.js b/cli/tests/testdata/op_exit_op_set_exit_code_worker.js index 54e5cd5629..3e60557478 100644 --- a/cli/tests/testdata/op_exit_op_set_exit_code_worker.js +++ b/cli/tests/testdata/op_exit_op_set_exit_code_worker.js @@ -1,4 +1,4 @@ self.onmessage = () => { - Deno.core.opSync("op_set_exit_code", 42); + Deno.core.ops.op_set_exit_code(42); Deno.exit(); }; diff --git a/cli/tests/testdata/set_exit_code_0.ts b/cli/tests/testdata/set_exit_code_0.ts index 7eb14fa3c2..362a9f28a1 100644 --- a/cli/tests/testdata/set_exit_code_0.ts +++ b/cli/tests/testdata/set_exit_code_0.ts @@ -1,2 +1,2 @@ -Deno.core.opSync("op_set_exit_code", 42); +Deno.core.ops.op_set_exit_code(42); Deno.exit(0); // Takes precedence. diff --git a/cli/tests/testdata/set_exit_code_1.ts b/cli/tests/testdata/set_exit_code_1.ts index 96ec9889cc..b10863568a 100644 --- a/cli/tests/testdata/set_exit_code_1.ts +++ b/cli/tests/testdata/set_exit_code_1.ts @@ -1,2 +1,2 @@ -Deno.core.opSync("op_set_exit_code", 42); +Deno.core.ops.op_set_exit_code(42); Deno.exit(); diff --git a/cli/tests/testdata/set_exit_code_2.ts b/cli/tests/testdata/set_exit_code_2.ts index a1f2b5d3c8..d68812caef 100644 --- a/cli/tests/testdata/set_exit_code_2.ts +++ b/cli/tests/testdata/set_exit_code_2.ts @@ -1,2 +1,2 @@ -Deno.core.opSync("op_set_exit_code", 42); +Deno.core.ops.op_set_exit_code(42); // Exits naturally. diff --git a/cli/tests/testdata/test/recursive_permissions_pledge.js b/cli/tests/testdata/test/recursive_permissions_pledge.js index dcdcbf5744..dbba96f262 100644 --- a/cli/tests/testdata/test/recursive_permissions_pledge.js +++ b/cli/tests/testdata/test/recursive_permissions_pledge.js @@ -1,8 +1,6 @@ -Deno.core.opSync( - "op_pledge_test_permissions", +Deno.core.ops.op_pledge_test_permissions( "none", ); -Deno.core.opSync( - "op_pledge_test_permissions", +Deno.core.ops.op_pledge_test_permissions( "inherit", ); diff --git a/cli/tests/testdata/unstable_ffi_1.js b/cli/tests/testdata/unstable_ffi_1.js index a24a002384..8ca6c3a601 100644 --- a/cli/tests/testdata/unstable_ffi_1.js +++ b/cli/tests/testdata/unstable_ffi_1.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_load", { path: "", symbols: {} }); +Deno.core.ops.op_ffi_load({ path: "", symbols: {} }); diff --git a/cli/tests/testdata/unstable_ffi_10.js b/cli/tests/testdata/unstable_ffi_10.js index e8fc9b3f0c..83687c5841 100644 --- a/cli/tests/testdata/unstable_ffi_10.js +++ b/cli/tests/testdata/unstable_ffi_10.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_i16", 0n); +Deno.core.ops.op_ffi_read_i16(0n); diff --git a/cli/tests/testdata/unstable_ffi_11.js b/cli/tests/testdata/unstable_ffi_11.js index 77c86109a5..5538753be9 100644 --- a/cli/tests/testdata/unstable_ffi_11.js +++ b/cli/tests/testdata/unstable_ffi_11.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_u32", 0n); +Deno.core.ops.op_ffi_read_u32(0n); diff --git a/cli/tests/testdata/unstable_ffi_12.js b/cli/tests/testdata/unstable_ffi_12.js index 65934a82fd..089c9b5b19 100644 --- a/cli/tests/testdata/unstable_ffi_12.js +++ b/cli/tests/testdata/unstable_ffi_12.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_i32", 0n); +Deno.core.ops.op_ffi_read_i32(0n); diff --git a/cli/tests/testdata/unstable_ffi_13.js b/cli/tests/testdata/unstable_ffi_13.js index 0ab43781b3..630be2e6d3 100644 --- a/cli/tests/testdata/unstable_ffi_13.js +++ b/cli/tests/testdata/unstable_ffi_13.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_u64", 0n); +Deno.core.ops.op_ffi_read_u64(0n); diff --git a/cli/tests/testdata/unstable_ffi_14.js b/cli/tests/testdata/unstable_ffi_14.js index b65a50a209..b04c7865e6 100644 --- a/cli/tests/testdata/unstable_ffi_14.js +++ b/cli/tests/testdata/unstable_ffi_14.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_f32", 0n); +Deno.core.ops.op_ffi_read_f32(0n); diff --git a/cli/tests/testdata/unstable_ffi_15.js b/cli/tests/testdata/unstable_ffi_15.js index de9f291688..865f63c754 100644 --- a/cli/tests/testdata/unstable_ffi_15.js +++ b/cli/tests/testdata/unstable_ffi_15.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_f64", 0n); +Deno.core.ops.op_ffi_read_f64(0n); diff --git a/cli/tests/testdata/unstable_ffi_2.js b/cli/tests/testdata/unstable_ffi_2.js index fe3d9d709e..7f3f34f371 100644 --- a/cli/tests/testdata/unstable_ffi_2.js +++ b/cli/tests/testdata/unstable_ffi_2.js @@ -1,4 +1,4 @@ -Deno.core.opSync("op_ffi_call_ptr", 0n, { +Deno.core.ops.op_ffi_call_ptr(0n, { name: null, parameters: [], result: "void", diff --git a/cli/tests/testdata/unstable_ffi_4.js b/cli/tests/testdata/unstable_ffi_4.js index 3e05bbf420..8b4f3d75ae 100644 --- a/cli/tests/testdata/unstable_ffi_4.js +++ b/cli/tests/testdata/unstable_ffi_4.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_ptr_of", new Uint8Array(0)); +Deno.core.ops.op_ffi_ptr_of(new Uint8Array(0)); diff --git a/cli/tests/testdata/unstable_ffi_5.js b/cli/tests/testdata/unstable_ffi_5.js index dc494023d4..d08d8eaa4c 100644 --- a/cli/tests/testdata/unstable_ffi_5.js +++ b/cli/tests/testdata/unstable_ffi_5.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_buf_copy_into", 0n, new Uint8Array(0), 0); +Deno.core.ops.op_ffi_buf_copy_into(0n, new Uint8Array(0), 0); diff --git a/cli/tests/testdata/unstable_ffi_6.js b/cli/tests/testdata/unstable_ffi_6.js index c66681225e..9e4f1c761f 100644 --- a/cli/tests/testdata/unstable_ffi_6.js +++ b/cli/tests/testdata/unstable_ffi_6.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_cstr_read", 0n); +Deno.core.ops.op_ffi_cstr_read(0n); diff --git a/cli/tests/testdata/unstable_ffi_7.js b/cli/tests/testdata/unstable_ffi_7.js index a0c27a71c6..96e60f377a 100644 --- a/cli/tests/testdata/unstable_ffi_7.js +++ b/cli/tests/testdata/unstable_ffi_7.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_u8", 0n); +Deno.core.ops.op_ffi_read_u8(0n); diff --git a/cli/tests/testdata/unstable_ffi_8.js b/cli/tests/testdata/unstable_ffi_8.js index 7c51f8aa3d..187b83891b 100644 --- a/cli/tests/testdata/unstable_ffi_8.js +++ b/cli/tests/testdata/unstable_ffi_8.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_i8", 0n); +Deno.core.ops.op_ffi_read_i8(0n); diff --git a/cli/tests/testdata/unstable_ffi_9.js b/cli/tests/testdata/unstable_ffi_9.js index 7798e4d2c4..e968e534cd 100644 --- a/cli/tests/testdata/unstable_ffi_9.js +++ b/cli/tests/testdata/unstable_ffi_9.js @@ -1 +1 @@ -Deno.core.opSync("op_ffi_read_u16", 0n); +Deno.core.ops.op_ffi_read_u16(0n); diff --git a/cli/tests/unit/opcall_test.ts b/cli/tests/unit/opcall_test.ts index 5e783efc8d..9707318555 100644 --- a/cli/tests/unit/opcall_test.ts +++ b/cli/tests/unit/opcall_test.ts @@ -44,7 +44,7 @@ Deno.test(async function opsAsyncBadResource() { Deno.test(function opsSyncBadResource() { try { const nonExistingRid = 9999; - Deno.core.opSync("op_read_sync", nonExistingRid, new Uint8Array(0)); + Deno.core.ops.op_read_sync(nonExistingRid, new Uint8Array(0)); } catch (e) { if (!(e instanceof Deno.errors.BadResource)) { throw e; diff --git a/cli/tsc/99_main_compiler.js b/cli/tsc/99_main_compiler.js index b1d62348b4..ab43af38db 100644 --- a/cli/tsc/99_main_compiler.js +++ b/cli/tsc/99_main_compiler.js @@ -15,6 +15,7 @@ delete Object.prototype.__proto__; ((window) => { /** @type {DenoCore} */ const core = window.Deno.core; + const ops = core.ops; let logDebug = false; let logSource = "JS"; @@ -250,7 +251,7 @@ delete Object.prototype.__proto__; } this.#lastCheckTimeMs = timeMs; - return core.opSync("op_is_cancelled", {}); + return ops.op_is_cancelled(); } throwIfCancellationRequested() { @@ -274,11 +275,11 @@ delete Object.prototype.__proto__; fileExists(specifier) { debug(`host.fileExists("${specifier}")`); specifier = normalizedToOriginalMap.get(specifier) ?? specifier; - return core.opSync("op_exists", { specifier }); + return ops.op_exists({ specifier }); }, readFile(specifier) { debug(`host.readFile("${specifier}")`); - return core.opSync("op_load", { specifier }).data; + return ops.op_load({ specifier }).data; }, getCancellationToken() { // createLanguageService will call this immediately and cache it @@ -309,8 +310,7 @@ delete Object.prototype.__proto__; } /** @type {{ data: string; scriptKind: ts.ScriptKind; version: string; }} */ - const { data, scriptKind, version } = core.opSync( - "op_load", + const { data, scriptKind, version } = ops.op_load( { specifier }, ); assert( @@ -338,14 +338,13 @@ delete Object.prototype.__proto__; }, writeFile(fileName, data, _writeByteOrderMark, _onError, _sourceFiles) { debug(`host.writeFile("${fileName}")`); - return core.opSync( - "op_emit", + return ops.op_emit( { fileName, data }, ); }, getCurrentDirectory() { debug(`host.getCurrentDirectory()`); - return cwd ?? core.opSync("op_cwd", null); + return cwd ?? ops.op_cwd(); }, getCanonicalFileName(fileName) { return fileName; @@ -361,7 +360,7 @@ delete Object.prototype.__proto__; debug(` base: ${base}`); debug(` specifiers: ${specifiers.join(", ")}`); /** @type {Array<[string, ts.Extension] | undefined>} */ - const resolved = core.opSync("op_resolve", { + const resolved = ops.op_resolve({ specifiers, base, }); @@ -384,7 +383,7 @@ delete Object.prototype.__proto__; } }, createHash(data) { - return core.opSync("op_create_hash", { data }).hash; + return ops.op_create_hash({ data }).hash; }, // LanguageServiceHost @@ -399,7 +398,7 @@ delete Object.prototype.__proto__; if (scriptFileNamesCache) { return scriptFileNamesCache; } - return scriptFileNamesCache = core.opSync("op_script_names", undefined); + return scriptFileNamesCache = ops.op_script_names(); }, getScriptVersion(specifier) { debug(`host.getScriptVersion("${specifier}")`); @@ -412,7 +411,7 @@ delete Object.prototype.__proto__; if (scriptVersionCache.has(specifier)) { return scriptVersionCache.get(specifier); } - const scriptVersion = core.opSync("op_script_version", { specifier }); + const scriptVersion = ops.op_script_version({ specifier }); scriptVersionCache.set(specifier, scriptVersion); return scriptVersion; }, @@ -433,8 +432,7 @@ delete Object.prototype.__proto__; }; } - const fileInfo = core.opSync( - "op_load", + const fileInfo = ops.op_load( { specifier }, ); if (fileInfo) { @@ -567,7 +565,7 @@ delete Object.prototype.__proto__; performanceProgram({ program }); - core.opSync("op_respond", { + ops.op_respond({ diagnostics: fromTypeScriptDiagnostic(diagnostics), stats: performanceEnd(), }); @@ -579,7 +577,7 @@ delete Object.prototype.__proto__; * @param {any} data */ function respond(id, data = null) { - core.opSync("op_respond", { id, data }); + ops.op_respond({ id, data }); } /** @@ -942,7 +940,7 @@ delete Object.prototype.__proto__; // ensure the snapshot is setup properly. /** @type {{ buildSpecifier: string; libs: string[] }} */ - const { buildSpecifier, libs } = core.opSync("op_build_info", {}); + const { buildSpecifier, libs } = ops.op_build_info(); for (const lib of libs) { const specifier = `lib.${lib}.d.ts`; // we are using internal APIs here to "inject" our custom libraries into diff --git a/cli/tsc/compiler.d.ts b/cli/tsc/compiler.d.ts index bf06604709..31c8b8c649 100644 --- a/cli/tsc/compiler.d.ts +++ b/cli/tsc/compiler.d.ts @@ -39,8 +39,9 @@ declare global { encode(value: string): Uint8Array; // deno-lint-ignore no-explicit-any opSync(name: string, params: T): any; - ops(): void; - print(msg: string, stderr: bool): void; + // deno-lint-ignore no-explicit-any + ops: Record any>; + print(msg: string, stderr: boolean): void; registerErrorClass( name: string, Ctor: typeof Error, diff --git a/core/01_core.js b/core/01_core.js index 1dfb88c99c..aaff59148e 100644 --- a/core/01_core.js +++ b/core/01_core.js @@ -187,31 +187,31 @@ if (!hasPromise(promiseId)) { return; } - opSync("op_ref_op", promiseId); + ops.op_ref_op(promiseId); } function unrefOp(promiseId) { if (!hasPromise(promiseId)) { return; } - opSync("op_unref_op", promiseId); + ops.op_unref_op(promiseId); } function resources() { - return ObjectFromEntries(opSync("op_resources")); + return ObjectFromEntries(ops.op_resources()); } function metrics() { - const [aggregate, perOps] = opSync("op_metrics"); + const [aggregate, perOps] = ops.op_metrics(); aggregate.ops = ObjectFromEntries(ArrayPrototypeMap( - core.opSync("op_op_names"), + ops.op_op_names(), (opName, opId) => [opName, perOps[opId]], )); return aggregate; } - function queueMicrotask(...args) { - return opSync("op_queue_microtask", ...args); + function queueMicrotask(cb) { + return ops.op_queue_microtask(cb); } // Some "extensions" rely on "BadResource" and "Interrupted" errors in the @@ -252,40 +252,44 @@ opCallTraces, refOp, unrefOp, - close: opSync.bind(null, "op_close"), - tryClose: opSync.bind(null, "op_try_close"), + close: (rid) => ops.op_close(rid), + tryClose: (rid) => ops.op_try_close(rid), read: opAsync.bind(null, "op_read"), write: opAsync.bind(null, "op_write"), shutdown: opAsync.bind(null, "op_shutdown"), - print: opSync.bind(null, "op_print"), - setMacrotaskCallback: opSync.bind(null, "op_set_macrotask_callback"), - setNextTickCallback: opSync.bind(null, "op_set_next_tick_callback"), - runMicrotasks: opSync.bind(null, "op_run_microtasks"), - hasTickScheduled: opSync.bind(null, "op_has_tick_scheduled"), - setHasTickScheduled: opSync.bind(null, "op_set_has_tick_scheduled"), - evalContext: opSync.bind(null, "op_eval_context"), - createHostObject: opSync.bind(null, "op_create_host_object"), - encode: opSync.bind(null, "op_encode"), - decode: opSync.bind(null, "op_decode"), - serialize: opSync.bind(null, "op_serialize"), - deserialize: opSync.bind(null, "op_deserialize"), - getPromiseDetails: opSync.bind(null, "op_get_promise_details"), - getProxyDetails: opSync.bind(null, "op_get_proxy_details"), - isProxy: opSync.bind(null, "op_is_proxy"), - memoryUsage: opSync.bind(null, "op_memory_usage"), - setWasmStreamingCallback: opSync.bind( - null, - "op_set_wasm_streaming_callback", - ), - abortWasmStreaming: opSync.bind(null, "op_abort_wasm_streaming"), - destructureError: opSync.bind(null, "op_destructure_error"), - terminate: opSync.bind(null, "op_terminate"), - opNames: opSync.bind(null, "op_op_names"), - eventLoopHasMoreWork: opSync.bind(null, "op_event_loop_has_more_work"), - setPromiseRejectCallback: opSync.bind( - null, - "op_set_promise_reject_callback", - ), + print: (msg, isErr) => ops.op_print(msg, isErr), + setMacrotaskCallback: (fn) => ops.op_set_macrotask_callback(fn), + setNextTickCallback: (fn) => ops.op_set_next_tick_callback(fn), + runMicrotasks: () => ops.op_run_microtasks(), + hasTickScheduled: () => ops.op_has_tick_scheduled(), + setHasTickScheduled: (bool) => ops.op_set_has_tick_scheduled(bool), + evalContext: ( + source, + specifier, + ) => ops.op_eval_context(source, specifier), + createHostObject: () => ops.op_create_host_object(), + encode: (text) => ops.op_encode(text), + decode: (buffer) => ops.op_decode(buffer), + serialize: ( + value, + options, + errorCallback, + ) => ops.op_serialize(value, options, errorCallback), + deserialize: (buffer, options) => ops.op_deserialize(buffer, options), + getPromiseDetails: (promise) => ops.op_get_promise_details(promise), + getProxyDetails: (proxy) => ops.op_get_proxy_details(proxy), + isProxy: (value) => ops.op_is_proxy(value), + memoryUsage: () => ops.op_memory_usage(), + setWasmStreamingCallback: (fn) => ops.op_set_wasm_streaming_callback(fn), + abortWasmStreaming: ( + rid, + error, + ) => ops.op_abort_wasm_streaming(rid, error), + destructureError: (error) => ops.op_destructure_error(error), + terminate: (exception) => ops.op_terminate(exception), + opNames: () => ops.op_op_names(), + eventLoopHasMoreWork: () => ops.op_event_loop_has_more_work(), + setPromiseRejectCallback: (fn) => ops.op_set_promise_reject_callback(fn), }); ObjectAssign(globalThis.__bootstrap, { core }); diff --git a/core/02_error.js b/core/02_error.js index d061164e7e..edb9c48436 100644 --- a/core/02_error.js +++ b/core/02_error.js @@ -3,6 +3,7 @@ ((window) => { const core = Deno.core; + const ops = core.ops; const { Error, ObjectFreeze, @@ -22,7 +23,7 @@ } let result = ""; if (cse.fileName) { - result += core.opSync("op_format_file_name", cse.fileName); + result += ops.op_format_file_name(cse.fileName); } else { if (cse.isEval) { if (cse.evalOrigin == null) { @@ -116,7 +117,7 @@ function sourceMapCallSiteEval(cse) { if (cse.fileName && cse.lineNumber != null && cse.columnNumber != null) { - return { ...cse, ...core.opSync("op_apply_source_map", cse) }; + return { ...cse, ...ops.op_apply_source_map(cse) }; } return cse; } diff --git a/core/encode_decode_test.js b/core/encode_decode_test.js index 5165b196c9..663bc1af63 100644 --- a/core/encode_decode_test.js +++ b/core/encode_decode_test.js @@ -33,31 +33,31 @@ function main() { 108, 100 ]; - const empty = Deno.core.opSync("op_encode", ""); + const empty = Deno.core.ops.op_encode(""); if (empty.length !== 0) throw new Error("assert"); assertArrayEquals( - Array.from(Deno.core.opSync("op_encode", "𝓽𝓮𝔁𝓽")), + Array.from(Deno.core.ops.op_encode("𝓽𝓮𝔁𝓽")), fixture1, ); assertArrayEquals( - Array.from(Deno.core.opSync("op_encode", "Hello \udc12\ud834 World")), + Array.from(Deno.core.ops.op_encode("Hello \udc12\ud834 World")), fixture2, ); - const emptyBuf = Deno.core.opSync("op_decode", new Uint8Array(0)); + const emptyBuf = Deno.core.ops.op_decode(new Uint8Array(0)); if (emptyBuf !== "") throw new Error("assert"); - assert(Deno.core.opSync("op_decode", new Uint8Array(fixture1)) === "𝓽𝓮𝔁𝓽"); + assert(Deno.core.ops.op_decode(new Uint8Array(fixture1)) === "𝓽𝓮𝔁𝓽"); assert( - Deno.core.opSync("op_decode", new Uint8Array(fixture2)) === + Deno.core.ops.op_decode(new Uint8Array(fixture2)) === "Hello �� World", ); // See https://github.com/denoland/deno/issues/6649 let thrown = false; try { - Deno.core.opSync("op_decode", new Uint8Array(2 ** 29)); + Deno.core.ops.op_decode(new Uint8Array(2 ** 29)); } catch (e) { thrown = true; assert(e instanceof RangeError); diff --git a/core/error_builder_test.js b/core/error_builder_test.js index 8a3ca0383d..7f89651274 100644 --- a/core/error_builder_test.js +++ b/core/error_builder_test.js @@ -1,5 +1,6 @@ // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. const { core } = Deno; +const { ops } = core; class DOMException { constructor(message, code) { @@ -16,7 +17,7 @@ core.registerErrorBuilder( ); try { - core.opSync("op_err", undefined, null); + ops.op_err(); throw new Error("op_err didn't throw!"); } catch (err) { if (!(err instanceof DOMException)) { diff --git a/core/examples/hello_world.rs b/core/examples/hello_world.rs index 13a47221d9..9260cfe56f 100644 --- a/core/examples/hello_world.rs +++ b/core/examples/hello_world.rs @@ -53,11 +53,11 @@ const arr = [1, 2, 3]; print("The sum of"); print(arr); print("is"); -print(Deno.core.opSync('op_sum', arr)); +print(Deno.core.ops.op_sum(arr)); // And incorrect usage try { - print(Deno.core.opSync('op_sum', 0)); + print(Deno.core.ops.op_sum(0)); } catch(e) { print('Exception:'); print(e); diff --git a/core/examples/http_bench_json_ops.js b/core/examples/http_bench_json_ops.js index 5b16776f40..cea3449878 100644 --- a/core/examples/http_bench_json_ops.js +++ b/core/examples/http_bench_json_ops.js @@ -11,7 +11,7 @@ const responseBuf = new Uint8Array( /** Listens on 0.0.0.0:4500, returns rid. */ function listen() { - return Deno.core.opSync("op_listen"); + return Deno.core.ops.op_listen(); } /** Accepts a connection, returns rid. */ diff --git a/core/examples/schedule_task.rs b/core/examples/schedule_task.rs index bd4bcb028d..475c2d9ad8 100644 --- a/core/examples/schedule_task.rs +++ b/core/examples/schedule_task.rs @@ -52,11 +52,11 @@ fn main() { let future = async move { // Schedule 10 tasks. js_runtime - .execute_script( - "", - r#"for (let i = 1; i <= 10; i++) Deno.core.opSync("op_schedule_task", i);"# - ) - .unwrap(); + .execute_script( + "", + r#"for (let i = 1; i <= 10; i++) Deno.core.ops.op_schedule_task(i);"#, + ) + .unwrap(); js_runtime.run_event_loop(false).await }; runtime.block_on(future).unwrap(); diff --git a/core/lib.deno_core.d.ts b/core/lib.deno_core.d.ts index bd3729ed99..c5662794a6 100644 --- a/core/lib.deno_core.d.ts +++ b/core/lib.deno_core.d.ts @@ -10,15 +10,13 @@ declare namespace Deno { /** Call an op in Rust, and synchronously receive the result. */ function opSync( opName: string, - a?: any, - b?: any, + ...args: any[] ): any; /** Call an op in Rust, and asynchronously receive the result. */ function opAsync( opName: string, - a?: any, - b?: any, + ...args: any[] ): Promise; /** Mark following promise as "ref", ie. event loop won't exit @@ -30,10 +28,10 @@ declare namespace Deno { function unrefOps(promiseId: number): void; /** - * Retrieve a list of all registered ops, in the form of a map that maps op + * List of all registered ops, in the form of a map that maps op * name to internal numerical op id. */ - function ops(): Record; + const ops: Record any>; /** * Retrieve a list of all open resources, in the form of a map that maps diff --git a/core/modules.rs b/core/modules.rs index aec8c498ff..c4fa53b516 100644 --- a/core/modules.rs +++ b/core/modules.rs @@ -1518,7 +1518,7 @@ import "/a.js"; import { b } from './b.js' if (b() != 'b') throw Error(); let control = 42; - Deno.core.opSync("op_test", control); + Deno.core.ops.op_test(control); "#, ) .unwrap(); diff --git a/core/runtime.rs b/core/runtime.rs index 3f3caac5e5..541aa7c021 100644 --- a/core/runtime.rs +++ b/core/runtime.rs @@ -2301,8 +2301,8 @@ pub mod tests { .execute_script( "filename.js", r#" - Deno.core.opSync("op_unref_op", p1[promiseIdSymbol]); - Deno.core.opSync("op_unref_op", p2[promiseIdSymbol]); + Deno.core.ops.op_unref_op(p1[promiseIdSymbol]); + Deno.core.ops.op_unref_op(p2[promiseIdSymbol]); "#, ) .unwrap(); @@ -2317,8 +2317,8 @@ pub mod tests { .execute_script( "filename.js", r#" - Deno.core.opSync("op_ref_op", p1[promiseIdSymbol]); - Deno.core.opSync("op_ref_op", p2[promiseIdSymbol]); + Deno.core.ops.op_ref_op(p1[promiseIdSymbol]); + Deno.core.ops.op_ref_op(p2[promiseIdSymbol]); "#, ) .unwrap(); @@ -3045,7 +3045,7 @@ assertEquals(1, notify_return_value); let error = runtime .execute_script( "core_js_stack_frame.js", - "Deno.core.opSync('non_existent');", + "Deno.core.opAsync('non_existent');", ) .unwrap_err(); let error_string = error.to_string(); @@ -3073,7 +3073,7 @@ assertEquals(1, notify_return_value); (function () { const o = { a: 1, b: 2}; const p = new Proxy(o, {}); - return Deno.core.opSync("op_is_proxy", p) && !Deno.core.opSync("op_is_proxy", o) && !Deno.core.opSync("op_is_proxy", 42); + return Deno.core.ops.op_is_proxy(p) && !Deno.core.ops.op_is_proxy(o) && !Deno.core.ops.op_is_proxy(42); })() "#, ) @@ -3150,16 +3150,16 @@ assertEquals(1, notify_return_value); r#" (async function () { const results = []; - Deno.core.opSync("op_set_macrotask_callback", () => { + Deno.core.ops.op_set_macrotask_callback(() => { results.push("macrotask"); return true; }); - Deno.core.opSync("op_set_next_tick_callback", () => { + Deno.core.ops.op_set_next_tick_callback(() => { results.push("nextTick"); - Deno.core.opSync("op_set_has_tick_scheduled", false); + Deno.core.ops.op_set_has_tick_scheduled(false); }); - Deno.core.opSync("op_set_has_tick_scheduled", true); + Deno.core.ops.op_set_has_tick_scheduled(true); await Deno.core.opAsync('op_async_sleep'); if (results[0] != "nextTick") { throw new Error(`expected nextTick, got: ${results[0]}`); @@ -3182,10 +3182,10 @@ assertEquals(1, notify_return_value); .execute_script( "multiple_macrotasks_and_nextticks.js", r#" - Deno.core.opSync("op_set_macrotask_callback", () => { return true; }); - Deno.core.opSync("op_set_macrotask_callback", () => { return true; }); - Deno.core.opSync("op_set_next_tick_callback", () => {}); - Deno.core.opSync("op_set_next_tick_callback", () => {}); + Deno.core.ops.op_set_macrotask_callback(() => { return true; }); + Deno.core.ops.op_set_macrotask_callback(() => { return true; }); + Deno.core.ops.op_set_next_tick_callback(() => {}); + Deno.core.ops.op_set_next_tick_callback(() => {}); "#, ) .unwrap(); @@ -3228,12 +3228,12 @@ assertEquals(1, notify_return_value); .execute_script( "has_tick_scheduled.js", r#" - Deno.core.opSync("op_set_macrotask_callback", () => { - Deno.core.opSync("op_macrotask"); + Deno.core.ops.op_set_macrotask_callback(() => { + Deno.core.ops.op_macrotask(); return true; // We're done. }); - Deno.core.opSync("op_set_next_tick_callback", () => Deno.core.opSync("op_next_tick")); - Deno.core.opSync("op_set_has_tick_scheduled", true); + Deno.core.ops.op_set_next_tick_callback(() => Deno.core.ops.op_next_tick()); + Deno.core.ops.op_set_has_tick_scheduled(true); "#, ) .unwrap(); @@ -3359,15 +3359,15 @@ assertEquals(1, notify_return_value); "promise_reject_callback.js", r#" // Note: |promise| is not the promise created below, it's a child. - Deno.core.opSync("op_set_promise_reject_callback", (type, promise, reason) => { + Deno.core.ops.op_set_promise_reject_callback((type, promise, reason) => { if (type !== /* PromiseRejectWithNoHandler */ 0) { throw Error("unexpected type: " + type); } if (reason.message !== "reject") { throw Error("unexpected reason: " + reason); } - Deno.core.opSync("op_store_pending_promise_exception", promise); - Deno.core.opSync("op_promise_reject"); + Deno.core.ops.op_store_pending_promise_exception(promise); + Deno.core.ops.op_promise_reject(); }); new Promise((_, reject) => reject(Error("reject"))); @@ -3383,7 +3383,7 @@ assertEquals(1, notify_return_value); "promise_reject_callback.js", r#" { - const prev = Deno.core.opSync("op_set_promise_reject_callback", (...args) => { + const prev = Deno.core.ops.op_set_promise_reject_callback((...args) => { prev(...args); }); } @@ -3434,10 +3434,10 @@ assertEquals(1, notify_return_value); _is_dyn_import: bool, ) -> Pin> { let source = r#" - Deno.core.opSync("op_set_promise_reject_callback", (type, promise, reason) => { - Deno.core.opSync("op_promise_reject"); + Deno.core.ops.op_set_promise_reject_callback((type, promise, reason) => { + Deno.core.ops.op_promise_reject(); }); - + throw new Error('top level throw'); "#; @@ -3485,7 +3485,7 @@ assertEquals(1, notify_return_value); assert!(runtime .execute_script( "test_op_return_serde_v8_error.js", - "Deno.core.opSync('op_err')" + "Deno.core.ops.op_err()" ) .is_err()); } @@ -3508,7 +3508,7 @@ assertEquals(1, notify_return_value); ..Default::default() }); let r = runtime - .execute_script("test.js", "Deno.core.opSync('op_add_4', 1, 2, 3, 4)") + .execute_script("test.js", "Deno.core.ops.op_add_4(1, 2, 3, 4)") .unwrap(); let scope = &mut runtime.handle_scope(); assert_eq!(r.open(scope).integer_value(scope), Some(10)); @@ -3529,7 +3529,7 @@ assertEquals(1, notify_return_value); ..Default::default() }); let r = runtime - .execute_script("test.js", "Deno.core.opSync('op_foo')") + .execute_script("test.js", "Deno.core.ops.op_foo()") .unwrap(); let scope = &mut runtime.handle_scope(); assert!(r.open(scope).is_undefined()); @@ -3573,7 +3573,7 @@ assertEquals(1, notify_return_value); if (!(a1.length > 0 && a1b.length > 0)) { throw new Error("a1 & a1b should have a length"); } - let sum = Deno.core.opSync('op_sum_take', a1b); + let sum = Deno.core.ops.op_sum_take(a1b); if (sum !== 6) { throw new Error(`Bad sum: ${sum}`); } @@ -3581,7 +3581,7 @@ assertEquals(1, notify_return_value); throw new Error("expecting a1 & a1b to be detached"); } - const a3 = Deno.core.opSync('op_boomerang', a2b); + const a3 = Deno.core.ops.op_boomerang(a2b); if (a3.byteLength != 3) { throw new Error(`Expected a3.byteLength === 3, got ${a3.byteLength}`); } @@ -3597,7 +3597,7 @@ assertEquals(1, notify_return_value); w32[0] = 1; w32[1] = 2; w32[2] = 3; const assertWasmThrow = (() => { try { - let sum = Deno.core.opSync('op_sum_take', w32.subarray(0, 2)); + let sum = Deno.core.ops.op_sum_take(w32.subarray(0, 2)); return false; } catch(e) { return e.message.includes('ExpectedDetachable'); @@ -3635,10 +3635,10 @@ assertEquals(1, notify_return_value); .execute_script( "test.js", r#" - if (Deno.core.opSync('op_foo') !== 42) { + if (Deno.core.ops.op_foo() !== 42) { throw new Error("Exptected op_foo() === 42"); } - if (Deno.core.opSync('op_bar') !== undefined) { + if (Deno.core.ops.op_bar() !== undefined) { throw new Error("Expected op_bar to be disabled") } "#, @@ -3680,7 +3680,7 @@ assertEquals(1, notify_return_value); }); let realm = runtime.create_realm().unwrap(); let ret = realm - .execute_script(runtime.v8_isolate(), "", "Deno.core.opSync('op_test')") + .execute_script(runtime.v8_isolate(), "", "Deno.core.ops.op_test()") .unwrap(); let scope = &mut realm.handle_scope(runtime.v8_isolate()); @@ -3710,7 +3710,7 @@ assertEquals(1, notify_return_value); }); let realm = runtime.create_realm().unwrap(); let ret = realm - .execute_script(runtime.v8_isolate(), "", "Deno.core.opSync('op_test')") + .execute_script(runtime.v8_isolate(), "", "Deno.core.ops.op_test()") .unwrap(); let scope = &mut realm.handle_scope(runtime.v8_isolate()); @@ -3749,10 +3749,10 @@ assertEquals(1, notify_return_value); runtime.v8_isolate(), "", r#" - const buf = Deno.core.opSync("op_test", false); + const buf = Deno.core.ops.op_test(false); let err; try { - Deno.core.opSync("op_test", true); + Deno.core.ops.op_test(true); } catch(e) { err = e; } @@ -3870,7 +3870,7 @@ assertEquals(1, notify_return_value); "", r#" let promiseIdSymbol = Symbol.for("Deno.core.internalPromiseId"); - Deno.core.opSync("op_unref_op", promise[promiseIdSymbol]); + Deno.core.ops.op_unref_op(promise[promiseIdSymbol]); "#, ) .unwrap(); @@ -3882,7 +3882,7 @@ assertEquals(1, notify_return_value); "", r#" let promiseIdSymbol = Symbol.for("Deno.core.internalPromiseId"); - Deno.core.opSync("op_unref_op", promise[promiseIdSymbol]); + Deno.core.ops.op_unref_op(promise[promiseIdSymbol]); "#, ) .unwrap(); diff --git a/core/serialize_deserialize_test.js b/core/serialize_deserialize_test.js index cd7aa69b1d..724239fcb9 100644 --- a/core/serialize_deserialize_test.js +++ b/core/serialize_deserialize_test.js @@ -21,12 +21,11 @@ function main() { const emptyString = ""; const emptyStringSerialized = [255, 15, 34, 0]; assertArrayEquals( - Deno.core.opSync("op_serialize", emptyString), + Deno.core.ops.op_serialize(emptyString), emptyStringSerialized, ); assert( - Deno.core.opSync( - "op_deserialize", + Deno.core.ops.op_deserialize( new Uint8Array(emptyStringSerialized), ) === emptyString, @@ -39,13 +38,12 @@ function main() { 34, 1, 97, 48, 95, 36, 0, 4, ]; assertArrayEquals( - Deno.core.opSync("op_serialize", primitiveValueArray), + Deno.core.ops.op_serialize(primitiveValueArray), primitiveValueArraySerialized, ); assertArrayEquals( - Deno.core.opSync( - "op_deserialize", + Deno.core.ops.op_deserialize( new Uint8Array(primitiveValueArraySerialized), ), primitiveValueArray, @@ -63,12 +61,11 @@ function main() { ]; assertArrayEquals( - Deno.core.opSync("op_serialize", circularObject), + Deno.core.ops.op_serialize(circularObject), circularObjectSerialized, ); - const deserializedCircularObject = Deno.core.opSync( - "op_deserialize", + const deserializedCircularObject = Deno.core.ops.op_deserialize( new Uint8Array(circularObjectSerialized), ); assert(deserializedCircularObject.test == deserializedCircularObject); diff --git a/ext/broadcast_channel/01_broadcast_channel.js b/ext/broadcast_channel/01_broadcast_channel.js index f3b0917090..e14b597790 100644 --- a/ext/broadcast_channel/01_broadcast_channel.js +++ b/ext/broadcast_channel/01_broadcast_channel.js @@ -6,6 +6,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { defineEventHandler, setTarget } = window.__bootstrap.event; const { DOMException } = window.__bootstrap.domException; @@ -92,7 +93,7 @@ if (rid === null) { // Create the rid immediately, otherwise there is a time window (and a // race condition) where messages can get lost, because recv() is async. - rid = core.opSync("op_broadcast_subscribe"); + rid = ops.op_broadcast_subscribe(); recv(); } } @@ -128,7 +129,9 @@ if (index === -1) return; ArrayPrototypeSplice(channels, index, 1); - if (channels.length === 0) core.opSync("op_broadcast_unsubscribe", rid); + if (channels.length === 0) { + ops.op_broadcast_unsubscribe(rid); + } } } diff --git a/ext/crypto/00_crypto.js b/ext/crypto/00_crypto.js index 2b14a204e9..d00f29e7c2 100644 --- a/ext/crypto/00_crypto.js +++ b/ext/crypto/00_crypto.js @@ -10,6 +10,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { DOMException } = window.__bootstrap.domException; @@ -1374,7 +1375,7 @@ switch (normalizedAlgorithm.name) { case "AES-KW": { - const cipherText = await core.opSync("op_crypto_wrap_key", { + const cipherText = await ops.op_crypto_wrap_key({ key: keyData, algorithm: normalizedAlgorithm.name, }, bytes); @@ -1510,7 +1511,7 @@ switch (normalizedAlgorithm.name) { case "AES-KW": { - const plainText = await core.opSync("op_crypto_unwrap_key", { + const plainText = await ops.op_crypto_unwrap_key({ key: keyData, algorithm: normalizedAlgorithm.name, }, wrappedKey); @@ -1986,7 +1987,7 @@ }; // 3. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ format: "jwksecret", algorithm: "AES", }, innerKey); @@ -2080,8 +2081,7 @@ } // 4. - const { rawData } = core.opSync( - "op_crypto_import_key", + const { rawData } = ops.op_crypto_import_key( { algorithm: "AES" }, { jwkSecret: jwk }, ); @@ -2241,8 +2241,7 @@ } // 4. - const { rawData } = core.opSync( - "op_crypto_import_key", + const { rawData } = ops.op_crypto_import_key( { algorithm: "HMAC" }, { jwkSecret: jwk }, ); @@ -2427,7 +2426,7 @@ } // 3. - const { rawData } = core.opSync("op_crypto_import_key", { + const { rawData } = ops.op_crypto_import_key({ algorithm: normalizedAlgorithm.name, namedCurve: normalizedAlgorithm.namedCurve, }, { raw: keyData }); @@ -2468,7 +2467,7 @@ } // 2-9. - const { rawData } = core.opSync("op_crypto_import_key", { + const { rawData } = ops.op_crypto_import_key({ algorithm: normalizedAlgorithm.name, namedCurve: normalizedAlgorithm.namedCurve, }, { pkcs8: keyData }); @@ -2511,7 +2510,7 @@ } // 2-12 - const { rawData } = core.opSync("op_crypto_import_key", { + const { rawData } = ops.op_crypto_import_key({ algorithm: normalizedAlgorithm.name, namedCurve: normalizedAlgorithm.namedCurve, }, { spki: keyData }); @@ -2655,7 +2654,7 @@ if (jwk.d !== undefined) { // it's also a Private key - const { rawData } = core.opSync("op_crypto_import_key", { + const { rawData } = ops.op_crypto_import_key({ algorithm: normalizedAlgorithm.name, namedCurve: normalizedAlgorithm.namedCurve, }, { jwkPrivateEc: jwk }); @@ -2678,7 +2677,7 @@ return key; } else { - const { rawData } = core.opSync("op_crypto_import_key", { + const { rawData } = ops.op_crypto_import_key({ algorithm: normalizedAlgorithm.name, namedCurve: normalizedAlgorithm.namedCurve, }, { jwkPublicEc: jwk }); @@ -2759,15 +2758,15 @@ } // 2-9. - const { modulusLength, publicExponent, rawData } = core.opSync( - "op_crypto_import_key", - { - algorithm: normalizedAlgorithm.name, - // Needed to perform step 7 without normalization. - hash: normalizedAlgorithm.hash.name, - }, - { pkcs8: keyData }, - ); + const { modulusLength, publicExponent, rawData } = ops + .op_crypto_import_key( + { + algorithm: normalizedAlgorithm.name, + // Needed to perform step 7 without normalization. + hash: normalizedAlgorithm.hash.name, + }, + { pkcs8: keyData }, + ); const handle = {}; WeakMapPrototypeSet(KEY_STORE, handle, rawData); @@ -2805,15 +2804,15 @@ } // 2-9. - const { modulusLength, publicExponent, rawData } = core.opSync( - "op_crypto_import_key", - { - algorithm: normalizedAlgorithm.name, - // Needed to perform step 7 without normalization. - hash: normalizedAlgorithm.hash.name, - }, - { spki: keyData }, - ); + const { modulusLength, publicExponent, rawData } = ops + .op_crypto_import_key( + { + algorithm: normalizedAlgorithm.name, + // Needed to perform step 7 without normalization. + hash: normalizedAlgorithm.hash.name, + }, + { spki: keyData }, + ); const handle = {}; WeakMapPrototypeSet(KEY_STORE, handle, rawData); @@ -3055,14 +3054,14 @@ ); } - const { modulusLength, publicExponent, rawData } = core.opSync( - "op_crypto_import_key", - { - algorithm: normalizedAlgorithm.name, - hash: normalizedAlgorithm.hash.name, - }, - { jwkPrivateRsa: jwk }, - ); + const { modulusLength, publicExponent, rawData } = ops + .op_crypto_import_key( + { + algorithm: normalizedAlgorithm.name, + hash: normalizedAlgorithm.hash.name, + }, + { jwkPrivateRsa: jwk }, + ); const handle = {}; WeakMapPrototypeSet(KEY_STORE, handle, rawData); @@ -3098,14 +3097,14 @@ ); } - const { modulusLength, publicExponent, rawData } = core.opSync( - "op_crypto_import_key", - { - algorithm: normalizedAlgorithm.name, - hash: normalizedAlgorithm.hash.name, - }, - { jwkPublicRsa: jwk }, - ); + const { modulusLength, publicExponent, rawData } = ops + .op_crypto_import_key( + { + algorithm: normalizedAlgorithm.name, + hash: normalizedAlgorithm.hash.name, + }, + { jwkPublicRsa: jwk }, + ); const handle = {}; WeakMapPrototypeSet(KEY_STORE, handle, rawData); @@ -3259,7 +3258,7 @@ }; // 3. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ format: "jwksecret", algorithm: key[_algorithm].name, }, innerKey); @@ -3313,7 +3312,7 @@ } // 2. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ algorithm: key[_algorithm].name, format: "pkcs8", }, innerKey); @@ -3331,7 +3330,7 @@ } // 2. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ algorithm: key[_algorithm].name, format: "spki", }, innerKey); @@ -3412,7 +3411,7 @@ } // 5-6. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ format: key[_type] === "private" ? "jwkprivate" : "jwkpublic", algorithm: key[_algorithm].name, }, innerKey); @@ -3443,7 +3442,7 @@ } // 2. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ algorithm: key[_algorithm].name, namedCurve: key[_algorithm].namedCurve, format: "raw", @@ -3461,7 +3460,7 @@ } // 2. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ algorithm: key[_algorithm].name, namedCurve: key[_algorithm].namedCurve, format: "pkcs8", @@ -3479,7 +3478,7 @@ } // 2. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ algorithm: key[_algorithm].name, namedCurve: key[_algorithm].namedCurve, format: "spki", @@ -3523,7 +3522,7 @@ jwk.alg = algNamedCurve; // 3.2 - 3.4. - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ format: key[_type] === "private" ? "jwkprivate" : "jwkpublic", algorithm: key[_algorithm].name, namedCurve: key[_algorithm].namedCurve, @@ -3550,7 +3549,7 @@ jwk.crv = key[_algorithm].namedCurve; // 3.2 - 3.4 - const data = core.opSync("op_crypto_export_key", { + const data = ops.op_crypto_export_key({ format: key[_type] === "private" ? "jwkprivate" : "jwkpublic", algorithm: key[_algorithm].name, namedCurve: key[_algorithm].namedCurve, @@ -3925,13 +3924,13 @@ arrayBufferView.byteOffset, arrayBufferView.byteLength, ); - core.opSync("op_crypto_get_random_values", ui8); + ops.op_crypto_get_random_values(ui8); return arrayBufferView; } randomUUID() { webidl.assertBranded(this, CryptoPrototype); - return core.opSync("op_crypto_random_uuid"); + return ops.op_crypto_random_uuid(); } get subtle() { diff --git a/ext/fetch/22_http_client.js b/ext/fetch/22_http_client.js index f0c2394c38..d096b08ca7 100644 --- a/ext/fetch/22_http_client.js +++ b/ext/fetch/22_http_client.js @@ -13,6 +13,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; /** * @param {Deno.CreateHttpClientOptions} options @@ -21,8 +22,7 @@ function createHttpClient(options) { options.caCerts ??= []; return new HttpClient( - core.opSync( - "op_fetch_custom_client", + ops.op_fetch_custom_client( options, ), ); diff --git a/ext/fetch/26_fetch.js b/ext/fetch/26_fetch.js index 9a4916e21f..a069583a74 100644 --- a/ext/fetch/26_fetch.js +++ b/ext/fetch/26_fetch.js @@ -13,6 +13,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { byteLowerCase } = window.__bootstrap.infra; const { BlobPrototype } = window.__bootstrap.file; @@ -68,8 +69,7 @@ * @returns {{ requestRid: number, requestBodyRid: number | null }} */ function opFetch(method, url, headers, clientRid, hasBody, bodyLength, body) { - return core.opSync( - "op_fetch", + return ops.op_fetch( method, url, headers, @@ -560,7 +560,7 @@ } // Pass the resolved URL to v8. - core.opSync("op_wasm_streaming_set_url", rid, res.url); + ops.op_wasm_streaming_set_url(rid, res.url); if (res.body !== null) { // 2.6. @@ -571,7 +571,7 @@ while (true) { const { value: chunk, done } = await reader.read(); if (done) break; - core.opSync("op_wasm_streaming_feed", rid, chunk); + ops.op_wasm_streaming_feed(rid, chunk); } })().then( // 2.7 diff --git a/ext/ffi/00_ffi.js b/ext/ffi/00_ffi.js index 7ba5aadc04..ca9cb34742 100644 --- a/ext/ffi/00_ffi.js +++ b/ext/ffi/00_ffi.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const __bootstrap = window.__bootstrap; const { BigInt, @@ -45,108 +46,93 @@ } getUint8(offset = 0) { - return core.opSync( - "op_ffi_read_u8", + return ops.op_ffi_read_u8( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getInt8(offset = 0) { - return core.opSync( - "op_ffi_read_i8", + return ops.op_ffi_read_i8( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getUint16(offset = 0) { - return core.opSync( - "op_ffi_read_u16", + return ops.op_ffi_read_u16( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getInt16(offset = 0) { - return core.opSync( - "op_ffi_read_i16", + return ops.op_ffi_read_i16( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getUint32(offset = 0) { - return core.opSync( - "op_ffi_read_u32", + return ops.op_ffi_read_u32( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getInt32(offset = 0) { - return core.opSync( - "op_ffi_read_i32", + return ops.op_ffi_read_i32( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getBigUint64(offset = 0) { - return core.opSync( - "op_ffi_read_u64", + return ops.op_ffi_read_u64( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getBigInt64(offset = 0) { - return core.opSync( - "op_ffi_read_i64", + return ops.op_ffi_read_i64( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getFloat32(offset = 0) { - return core.opSync( - "op_ffi_read_f32", + return ops.op_ffi_read_f32( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getFloat64(offset = 0) { - return core.opSync( - "op_ffi_read_f64", + return ops.op_ffi_read_f64( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } getCString(offset = 0) { - return core.opSync( - "op_ffi_cstr_read", + return ops.op_ffi_cstr_read( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, ); } static getCString(pointer, offset = 0) { - return core.opSync( - "op_ffi_cstr_read", + return ops.op_ffi_cstr_read( offset ? BigInt(pointer) + BigInt(offset) : pointer, ); } getArrayBuffer(byteLength, offset = 0) { - return core.opSync( - "op_ffi_get_buf", + return ops.op_ffi_get_buf( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, byteLength, ); } static getArrayBuffer(pointer, byteLength, offset = 0) { - return core.opSync( - "op_ffi_get_buf", + return ops.op_ffi_get_buf( offset ? BigInt(pointer) + BigInt(offset) : pointer, byteLength, ); } copyInto(destination, offset = 0) { - core.opSync( - "op_ffi_buf_copy_into", + ops.op_ffi_buf_copy_into( offset ? BigInt(this.pointer) + BigInt(offset) : this.pointer, destination, destination.byteLength, @@ -154,8 +140,7 @@ } static copyInto(pointer, destination, offset = 0) { - core.opSync( - "op_ffi_buf_copy_into", + ops.op_ffi_buf_copy_into( offset ? BigInt(pointer) + BigInt(offset) : pointer, destination, destination.byteLength, @@ -168,7 +153,7 @@ if (ObjectPrototypeIsPrototypeOf(UnsafeCallbackPrototype, value)) { return value.pointer; } - return core.opSync("op_ffi_ptr_of", value); + return ops.op_ffi_ptr_of(value); } } @@ -221,8 +206,7 @@ return promise; } else { - return core.opSync( - "op_ffi_call_ptr", + return ops.op_ffi_call_ptr( this.pointer, this.definition, parameters, @@ -258,8 +242,7 @@ "Invalid UnsafeCallback, cannot be nonblocking", ); } - const [rid, pointer] = core.opSync( - "op_ffi_unsafe_callback_create", + const [rid, pointer] = ops.op_ffi_unsafe_callback_create( definition, callback, ); @@ -272,7 +255,7 @@ ref() { if (this.#refcount++ === 0) { - core.opSync("op_ffi_unsafe_callback_ref", true); + ops.op_ffi_unsafe_callback_ref(true); } } @@ -280,14 +263,14 @@ // Only decrement refcount if it is positive, and only // unref the callback if refcount reaches zero. if (this.#refcount > 0 && --this.#refcount === 0) { - core.opSync("op_ffi_unsafe_callback_ref", false); + ops.op_ffi_unsafe_callback_ref(false); } } close() { if (this.#refcount) { this.#refcount = 0; - core.opSync("op_ffi_unsafe_callback_ref", false); + ops.op_ffi_unsafe_callback_ref(false); } core.close(this.#rid); } @@ -300,7 +283,7 @@ symbols = {}; constructor(path, symbols) { - [this.#rid, this.symbols] = core.opSync("op_ffi_load", { path, symbols }); + [this.#rid, this.symbols] = ops.op_ffi_load({ path, symbols }); for (const symbol in symbols) { if ("type" in symbols[symbol]) { const type = symbols[symbol].type; @@ -311,8 +294,7 @@ } const name = symbols[symbol].name || symbol; - const value = core.opSync( - "op_ffi_get_static", + const value = ops.op_ffi_get_static( this.#rid, name, type, diff --git a/ext/http/01_http.js b/ext/http/01_http.js index 332763451e..34457ab0b9 100644 --- a/ext/http/01_http.js +++ b/ext/http/01_http.js @@ -15,7 +15,7 @@ fromInnerResponse, } = window.__bootstrap.fetch; const core = window.Deno.core; - const { BadResourcePrototype, InterruptedPrototype } = core; + const { BadResourcePrototype, InterruptedPrototype, ops } = core; const { ReadableStream, ReadableStreamPrototype } = window.__bootstrap.streams; const abortSignal = window.__bootstrap.abortSignal; @@ -126,7 +126,7 @@ const innerRequest = newInnerRequest( method, url, - () => core.opSync("op_http_headers", streamRid), + () => ops.op_http_headers(streamRid), body !== null ? new InnerBody(body) : null, false, ); @@ -438,7 +438,7 @@ ); } - const accept = core.opSync("op_http_websocket_accept_header", websocketKey); + const accept = ops.op_http_websocket_accept_header(websocketKey); const r = newInnerResponse(101); r.headerList = [ diff --git a/ext/net/01_net.js b/ext/net/01_net.js index fde75fe568..2c7ec0f47a 100644 --- a/ext/net/01_net.js +++ b/ext/net/01_net.js @@ -3,7 +3,7 @@ ((window) => { const core = window.Deno.core; - const { BadResourcePrototype, InterruptedPrototype } = core; + const { BadResourcePrototype, InterruptedPrototype, ops } = core; const { WritableStream, readableStreamForRid } = window.__bootstrap.streams; const { Error, @@ -42,7 +42,7 @@ } function opListen(args) { - return core.opSync("op_net_listen", args); + return ops.op_net_listen(args); } function opConnect(args) { @@ -157,11 +157,11 @@ class TcpConn extends Conn { setNoDelay(nodelay = true) { - return core.opSync("op_set_nodelay", this.rid, nodelay); + return ops.op_set_nodelay(this.rid, nodelay); } setKeepAlive(keepalive = true) { - return core.opSync("op_set_keepalive", this.rid, keepalive); + return ops.op_set_keepalive(this.rid, keepalive); } } diff --git a/ext/net/02_tls.js b/ext/net/02_tls.js index 86f6515211..04b25caf97 100644 --- a/ext/net/02_tls.js +++ b/ext/net/02_tls.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { Listener, Conn } = window.__bootstrap.net; function opConnectTls( @@ -16,7 +17,7 @@ } function opListenTls(args) { - return core.opSync("op_tls_listen", args); + return ops.op_tls_listen(args); } function opStartTls(args) { diff --git a/ext/node/01_require.js b/ext/node/01_require.js index 7b89e9dc37..ccccb85785 100644 --- a/ext/node/01_require.js +++ b/ext/node/01_require.js @@ -31,16 +31,17 @@ RegExpPrototypeTest, } = window.__bootstrap.primordials; const core = window.Deno.core; + const ops = core.ops; // Map used to store CJS parsing data. const cjsParseCache = new SafeWeakMap(); function pathDirname(filepath) { - return core.opSync("op_require_path_dirname", filepath); + return ops.op_require_path_dirname(filepath); } function pathResolve(...args) { - return core.opSync("op_require_path_resolve", args); + return ops.op_require_path_resolve(args); } function assert(cond) { @@ -76,7 +77,7 @@ return result; } } - const result = core.opSync("op_require_stat", filename); + const result = ops.op_require_stat(filename); if (statCache !== null && result >= 0) { statCache.set(filename, result); } @@ -162,7 +163,7 @@ if (maybeCached) { return maybeCached; } - const rp = core.opSync("op_require_real_path", requestPath); + const rp = ops.op_require_real_path(requestPath); realpathCache.set(requestPath, rp); return rp; } @@ -181,7 +182,7 @@ // Find the longest (possibly multi-dot) extension registered in // Module._extensions function findLongestRegisteredExtension(filename) { - const name = core.opSync("op_require_path_basename", filename); + const name = ops.op_require_path_basename(filename); let currentExtension; let index; let startIndex = 0; @@ -269,7 +270,7 @@ const CHAR_FORWARD_SLASH = 47; const TRAILING_SLASH_REGEX = /(?:^|\/)\.?\.$/; Module._findPath = function (request, paths, isMain) { - const absoluteRequest = core.opSync("op_require_path_is_absolute", request); + const absoluteRequest = ops.op_require_path_is_absolute(request); if (absoluteRequest) { paths = [""]; } else if (!paths || paths.length === 0) { @@ -346,12 +347,11 @@ }; Module._nodeModulePaths = function (from) { - return core.opSync("op_require_node_module_paths", from); + return ops.op_require_node_module_paths(from); }; Module._resolveLookupPaths = function (request, parent) { - return core.opSync( - "op_require_resolve_lookup_paths", + return ops.op_require_resolve_lookup_paths( request, parent?.paths, parent?.filename ?? "", @@ -475,8 +475,7 @@ if (typeof options === "object" && options !== null) { if (ArrayIsArray(options.paths)) { - const isRelative = core.opSync( - "op_require_is_request_relative", + const isRelative = ops.op_require_is_request_relative( request, ); @@ -537,13 +536,12 @@ // Try module self resolution first // TODO(bartlomieju): make into a single op - const parentPath = core.opSync( - "op_require_try_self_parent_path", + const parentPath = ops.op_require_try_self_parent_path( !!parent, parent?.filename, parent?.id, ); - // const selfResolved = core.opSync("op_require_try_self", parentPath, request); + // const selfResolved = ops.op_require_try_self(parentPath, request); const selfResolved = false; if (selfResolved) { const cacheKey = request + "\x00" + @@ -666,7 +664,7 @@ }; Module._extensions[".js"] = function (module, filename) { - const content = core.opSync("op_require_read_file", filename); + const content = ops.op_require_read_file(filename); console.log(`TODO: Module._extensions[".js"] is ESM`); @@ -682,7 +680,7 @@ // Native extension for .json Module._extensions[".json"] = function (module, filename) { - const content = core.opSync("op_require_read_file", filename); + const content = ops.op_require_read_file(filename); try { module.exports = JSONParse(stripBOM(content)); @@ -698,7 +696,7 @@ }; function createRequireFromPath(filename) { - const proxyPath = core.opSync("op_require_proxy_path", filename); + const proxyPath = ops.op_require_proxy_path(filename); const mod = new Module(proxyPath); mod.filename = proxyPath; mod.paths = Module._nodeModulePaths(mod.path); @@ -737,7 +735,7 @@ Module.createRequire = createRequire; Module._initPaths = function () { - const paths = core.opSync("op_require_init_paths"); + const paths = ops.op_require_init_paths(); modulePaths = paths; Module.globalPaths = ArrayPrototypeSlice(modulePaths); }; diff --git a/ext/url/00_url.js b/ext/url/00_url.js index 06630a2d01..ab87e85e0f 100644 --- a/ext/url/00_url.js +++ b/ext/url/00_url.js @@ -9,6 +9,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { ArrayIsArray, @@ -43,10 +44,12 @@ // Helper functions function opUrlReparse(href, setter, value) { - return _urlParts(core.opSync("op_url_reparse", href, [setter, value])); + return _urlParts( + ops.op_url_reparse(href, [setter, value]), + ); } function opUrlParse(href, maybeBase) { - return _urlParts(core.opSync("op_url_parse", href, maybeBase)); + return _urlParts(ops.op_url_parse(href, maybeBase)); } function _urlParts(internalParts) { // WARNING: must match UrlParts serialization rust's url_result() @@ -101,7 +104,7 @@ if (init[0] == "?") { init = StringPrototypeSlice(init, 1); } - this[_list] = core.opSync("op_url_parse_search_params", init); + this[_list] = ops.op_url_parse_search_params(init); } else if (ArrayIsArray(init)) { // Overload: sequence> this[_list] = ArrayPrototypeMap(init, (pair, i) => { @@ -291,7 +294,7 @@ */ toString() { webidl.assertBranded(this, URLSearchParamsPrototype); - return core.opSync("op_url_stringify_search_params", this[_list]); + return ops.op_url_stringify_search_params(this[_list]); } } @@ -348,8 +351,7 @@ #updateSearchParams() { if (this.#queryObject !== null) { const params = this.#queryObject[_list]; - const newParams = core.opSync( - "op_url_parse_search_params", + const newParams = ops.op_url_parse_search_params( StringPrototypeSlice(this.search, 1), ); ArrayPrototypeSplice( @@ -617,7 +619,7 @@ * @returns {[string, string][]} */ function parseUrlEncoded(bytes) { - return core.opSync("op_url_parse_search_params", null, bytes); + return ops.op_url_parse_search_params(null, bytes); } webidl diff --git a/ext/url/01_urlpattern.js b/ext/url/01_urlpattern.js index 51968e68a4..ac18a4c821 100644 --- a/ext/url/01_urlpattern.js +++ b/ext/url/01_urlpattern.js @@ -11,6 +11,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { ArrayPrototypeMap, @@ -68,7 +69,7 @@ }); } - const components = core.opSync("op_urlpattern_parse", input, baseURL); + const components = ops.op_urlpattern_parse(input, baseURL); for (const key of ObjectKeys(components)) { try { @@ -144,8 +145,7 @@ }); } - const res = core.opSync( - "op_urlpattern_process_match_input", + const res = ops.op_urlpattern_process_match_input( input, baseURL, ); @@ -184,8 +184,7 @@ }); } - const res = core.opSync( - "op_urlpattern_process_match_input", + const res = ops.op_urlpattern_process_match_input( input, baseURL, ); diff --git a/ext/web/00_infra.js b/ext/web/00_infra.js index bf931f8c7f..9a9db5c22f 100644 --- a/ext/web/00_infra.js +++ b/ext/web/00_infra.js @@ -10,6 +10,7 @@ ((window) => { const core = Deno.core; + const ops = core.ops; const { ArrayPrototypeJoin, ArrayPrototypeMap, @@ -239,7 +240,7 @@ * @returns {string} */ function forgivingBase64Encode(data) { - return core.opSync("op_base64_encode", data); + return ops.op_base64_encode(data); } /** @@ -247,7 +248,7 @@ * @returns {Uint8Array} */ function forgivingBase64Decode(data) { - return core.opSync("op_base64_decode", data); + return ops.op_base64_decode(data); } /** diff --git a/ext/web/02_timers.js b/ext/web/02_timers.js index a4ce33a184..07b9587eae 100644 --- a/ext/web/02_timers.js +++ b/ext/web/02_timers.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { ArrayPrototypePush, ArrayPrototypeShift, @@ -25,7 +26,7 @@ const { assert } = window.__bootstrap.infra; function opNow() { - return core.opSync("op_now"); + return ops.op_now(); } // --------------------------------------------------------------------------- @@ -103,7 +104,7 @@ // TODO(@andreubotella): Deal with overflow. // https://github.com/whatwg/html/issues/7358 id = nextId++; - const cancelRid = core.opSync("op_timer_handle"); + const cancelRid = ops.op_timer_handle(); timerInfo = { cancelRid, isRef: true, promiseId: -1 }; // Step 4 in "run steps after a timeout". diff --git a/ext/web/05_base64.js b/ext/web/05_base64.js index 8238831f86..89c409ae23 100644 --- a/ext/web/05_base64.js +++ b/ext/web/05_base64.js @@ -10,6 +10,7 @@ ((window) => { const core = Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { DOMException } = window.__bootstrap.domException; const { TypeError } = window.__bootstrap.primordials; @@ -26,7 +27,7 @@ context: "Argument 1", }); try { - return core.opSync("op_base64_atob", data); + return ops.op_base64_atob(data); } catch (e) { if (e instanceof TypeError) { throw new DOMException( @@ -50,7 +51,7 @@ context: "Argument 1", }); try { - return core.opSync("op_base64_btoa", data); + return ops.op_base64_btoa(data); } catch (e) { if (e instanceof TypeError) { throw new DOMException( diff --git a/ext/web/08_text_encoding.js b/ext/web/08_text_encoding.js index 282618da30..44087b1dea 100644 --- a/ext/web/08_text_encoding.js +++ b/ext/web/08_text_encoding.js @@ -13,6 +13,7 @@ ((window) => { const core = Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { ArrayBufferIsView, @@ -51,7 +52,7 @@ prefix, context: "Argument 2", }); - const encoding = core.opSync("op_encoding_normalize_label", label); + const encoding = ops.op_encoding_normalize_label(label); this.#encoding = encoding; this.#fatal = options.fatal; this.#ignoreBOM = options.ignoreBOM; @@ -124,7 +125,7 @@ } if (!options.stream && this.#rid === null) { - return core.opSync("op_encoding_decode_single", input, { + return ops.op_encoding_decode_single(input, { label: this.#encoding, fatal: this.#fatal, ignoreBom: this.#ignoreBOM, @@ -132,13 +133,13 @@ } if (this.#rid === null) { - this.#rid = core.opSync("op_encoding_new_decoder", { + this.#rid = ops.op_encoding_new_decoder({ label: this.#encoding, fatal: this.#fatal, ignoreBom: this.#ignoreBOM, }); } - return core.opSync("op_encoding_decode", input, { + return ops.op_encoding_decode(input, { rid: this.#rid, stream: options.stream, }); @@ -200,7 +201,7 @@ context: "Argument 2", allowShared: true, }); - return core.opSync("op_encoding_encode_into", source, destination); + return ops.op_encoding_encode_into(source, destination); } } diff --git a/ext/web/09_file.js b/ext/web/09_file.js index 50cce9004e..d01858c922 100644 --- a/ext/web/09_file.js +++ b/ext/web/09_file.js @@ -13,6 +13,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { ArrayBufferPrototype, @@ -505,7 +506,7 @@ // A finalization registry to deallocate a blob part when its JS reference is // garbage collected. const registry = new FinalizationRegistry((uuid) => { - core.opSync("op_blob_remove_part", uuid); + ops.op_blob_remove_part(uuid); }); // TODO(lucacasonato): get a better stream from Rust in BlobReference#stream @@ -533,7 +534,7 @@ * @returns {BlobReference} */ static fromUint8Array(data) { - const id = core.opSync("op_blob_create_part", data); + const id = ops.op_blob_create_part(data); return new BlobReference(id, data.byteLength); } @@ -548,7 +549,7 @@ */ slice(start, end) { const size = end - start; - const id = core.opSync("op_blob_slice_part", this._id, { + const id = ops.op_blob_slice_part(this._id, { start, len: size, }); @@ -588,7 +589,7 @@ * @returns {Blob | null} */ function blobFromObjectUrl(url) { - const blobData = core.opSync("op_blob_from_object_url", url); + const blobData = ops.op_blob_from_object_url(url); if (blobData === null) { return null; } diff --git a/ext/web/11_blob_url.js b/ext/web/11_blob_url.js index cd9d0929ee..9a705f3917 100644 --- a/ext/web/11_blob_url.js +++ b/ext/web/11_blob_url.js @@ -14,6 +14,7 @@ ((window) => { const core = Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { getParts } = window.__bootstrap.file; const { URL } = window.__bootstrap.url; @@ -30,8 +31,7 @@ prefix, }); - const url = core.opSync( - "op_blob_create_object_url", + const url = ops.op_blob_create_object_url( blob.type, getParts(blob), ); @@ -51,7 +51,7 @@ prefix, }); - core.opSync("op_blob_revoke_object_url", url); + ops.op_blob_revoke_object_url(url); } URL.createObjectURL = createObjectURL; diff --git a/ext/web/13_message_port.js b/ext/web/13_message_port.js index 19aa0a93bd..1fbeeaff7b 100644 --- a/ext/web/13_message_port.js +++ b/ext/web/13_message_port.js @@ -10,7 +10,7 @@ ((window) => { const core = window.Deno.core; - const { InterruptedPrototype } = core; + const { InterruptedPrototype, ops } = core; const webidl = window.__bootstrap.webidl; const { setEventTargetData } = window.__bootstrap.eventTarget; const { defineEventHandler } = window.__bootstrap.event; @@ -128,7 +128,7 @@ } const data = serializeJsMessageData(message, transfer); if (this[_id] === null) return; - core.opSync("op_message_port_post_message", this[_id], data); + ops.op_message_port_post_message(this[_id], data); } start() { @@ -193,7 +193,7 @@ * @returns {[number, number]} */ function opCreateEntangledMessagePort() { - return core.opSync("op_message_port_create_entangled"); + return ops.op_message_port_create_entangled(); } /** diff --git a/ext/web/14_compression.js b/ext/web/14_compression.js index a96a7ce431..c56954c742 100644 --- a/ext/web/14_compression.js +++ b/ext/web/14_compression.js @@ -9,6 +9,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { TransformStream } = window.__bootstrap.streams; @@ -32,7 +33,7 @@ context: "Argument 1", }); - const rid = core.opSync("op_compression_new", format, false); + const rid = ops.op_compression_new(format, false); this.#transform = new TransformStream({ transform(chunk, controller) { @@ -40,15 +41,14 @@ prefix, context: "chunk", }); - const output = core.opSync( - "op_compression_write", + const output = ops.op_compression_write( rid, chunk, ); maybeEnqueue(controller, output); }, flush(controller) { - const output = core.opSync("op_compression_finish", rid); + const output = ops.op_compression_finish(rid); maybeEnqueue(controller, output); }, }); @@ -81,7 +81,7 @@ context: "Argument 1", }); - const rid = core.opSync("op_compression_new", format, true); + const rid = ops.op_compression_new(format, true); this.#transform = new TransformStream({ transform(chunk, controller) { @@ -89,15 +89,14 @@ prefix, context: "chunk", }); - const output = core.opSync( - "op_compression_write", + const output = ops.op_compression_write( rid, chunk, ); maybeEnqueue(controller, output); }, flush(controller) { - const output = core.opSync("op_compression_finish", rid); + const output = ops.op_compression_finish(rid); maybeEnqueue(controller, output); }, }); diff --git a/ext/webgpu/src/01_webgpu.js b/ext/webgpu/src/01_webgpu.js index 79d1f497c0..9b8c7eb50a 100644 --- a/ext/webgpu/src/01_webgpu.js +++ b/ext/webgpu/src/01_webgpu.js @@ -10,6 +10,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const eventTarget = window.__bootstrap.eventTarget; const { DOMException } = window.__bootstrap.domException; @@ -940,8 +941,7 @@ context: "Argument 1", }); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync( - "op_webgpu_create_buffer", + const { rid, err } = ops.op_webgpu_create_buffer( device.rid, descriptor.label, descriptor.size, @@ -991,7 +991,7 @@ context: "Argument 1", }); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync("op_webgpu_create_texture", { + const { rid, err } = ops.op_webgpu_create_texture({ deviceRid: device.rid, ...descriptor, size: normalizeGPUExtent3D(descriptor.size), @@ -1019,7 +1019,7 @@ context: "Argument 1", }); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync("op_webgpu_create_sampler", { + const { rid, err } = ops.op_webgpu_create_sampler({ deviceRid: device.rid, ...descriptor, }); @@ -1059,8 +1059,7 @@ } } - const { rid, err } = core.opSync( - "op_webgpu_create_bind_group_layout", + const { rid, err } = ops.op_webgpu_create_bind_group_layout( device.rid, descriptor.label, descriptor.entries, @@ -1102,8 +1101,7 @@ return rid; }, ); - const { rid, err } = core.opSync( - "op_webgpu_create_pipeline_layout", + const { rid, err } = ops.op_webgpu_create_pipeline_layout( device.rid, descriptor.label, bindGroupLayouts, @@ -1197,8 +1195,7 @@ } }); - const { rid, err } = core.opSync( - "op_webgpu_create_bind_group", + const { rid, err } = ops.op_webgpu_create_bind_group( device.rid, descriptor.label, layout, @@ -1227,8 +1224,7 @@ context: "Argument 1", }); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync( - "op_webgpu_create_shader_module", + const { rid, err } = ops.op_webgpu_create_shader_module( device.rid, descriptor.label, descriptor.code, @@ -1278,8 +1274,7 @@ selfContext: "this", }); - const { rid, err } = core.opSync( - "op_webgpu_create_compute_pipeline", + const { rid, err } = ops.op_webgpu_create_compute_pipeline( device.rid, descriptor.label, layout, @@ -1350,7 +1345,7 @@ }; } - const { rid, err } = core.opSync("op_webgpu_create_render_pipeline", { + const { rid, err } = ops.op_webgpu_create_render_pipeline({ deviceRid: device.rid, label: descriptor.label, layout, @@ -1397,8 +1392,7 @@ context: "Argument 1", }); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync( - "op_webgpu_create_command_encoder", + const { rid, err } = ops.op_webgpu_create_command_encoder( device.rid, descriptor.label, ); @@ -1430,8 +1424,7 @@ }, ); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync( - "op_webgpu_create_render_bundle_encoder", + const { rid, err } = ops.op_webgpu_create_render_bundle_encoder( { deviceRid: device.rid, ...descriptor, @@ -1464,7 +1457,7 @@ }, ); const device = assertDevice(this, { prefix, context: "this" }); - const { rid, err } = core.opSync("op_webgpu_create_query_set", { + const { rid, err } = ops.op_webgpu_create_query_set({ deviceRid: device.rid, ...descriptor, }); @@ -1595,8 +1588,7 @@ return rid; }, ); - const { err } = core.opSync( - "op_webgpu_queue_submit", + const { err } = ops.op_webgpu_queue_submit( device.rid, commandBufferRids, ); @@ -1654,8 +1646,7 @@ selfContext: "this", resourceContext: "Argument 1", }); - const { err } = core.opSync( - "op_webgpu_write_buffer", + const { err } = ops.op_webgpu_write_buffer( device.rid, bufferRid, bufferOffset, @@ -1702,8 +1693,7 @@ selfContext: "this", resourceContext: "texture", }); - const { err } = core.opSync( - "op_webgpu_write_texture", + const { err } = ops.op_webgpu_write_texture( device.rid, { texture: textureRid, @@ -1960,8 +1950,7 @@ } const buffer = new ArrayBuffer(rangeSize); - const { rid } = core.opSync( - "op_webgpu_buffer_get_mapped_range", + const { rid } = ops.op_webgpu_buffer_get_mapped_range( bufferRid, offset, size, @@ -2015,8 +2004,7 @@ throw new DOMException(`${prefix}: invalid state.`, "OperationError"); } for (const [buffer, mappedRid] of mappedRanges) { - const { err } = core.opSync( - "op_webgpu_buffer_unmap", + const { err } = ops.op_webgpu_buffer_unmap( bufferRid, mappedRid, ...new SafeArrayIterator(write ? [new Uint8Array(buffer)] : []), @@ -2153,7 +2141,7 @@ }); const device = assertDevice(this, { prefix, context: "this" }); const textureRid = assertResource(this, { prefix, context: "this" }); - const { rid, err } = core.opSync("op_webgpu_create_texture_view", { + const { rid, err } = ops.op_webgpu_create_texture_view({ textureRid, ...descriptor, }); @@ -2536,11 +2524,11 @@ prefix, context: "this", }); - const { rid, label, err } = core.opSync( - "op_webgpu_compute_pipeline_get_bind_group_layout", - computePipelineRid, - index, - ); + const { rid, label, err } = ops + .op_webgpu_compute_pipeline_get_bind_group_layout( + computePipelineRid, + index, + ); device.pushError(err); const bindGroupLayout = createGPUBindGroupLayout( @@ -2613,11 +2601,11 @@ prefix, context: "this", }); - const { rid, label, err } = core.opSync( - "op_webgpu_render_pipeline_get_bind_group_layout", - renderPipelineRid, - index, - ); + const { rid, label, err } = ops + .op_webgpu_render_pipeline_get_bind_group_layout( + renderPipelineRid, + index, + ); device.pushError(err); const bindGroupLayout = createGPUBindGroupLayout( @@ -2807,8 +2795,7 @@ }, ); - const { rid } = core.opSync( - "op_webgpu_command_encoder_begin_render_pass", + const { rid } = ops.op_webgpu_command_encoder_begin_render_pass( commandEncoderRid, descriptor.label, colorAttachments, @@ -2842,8 +2829,7 @@ context: "this", }); - const { rid } = core.opSync( - "op_webgpu_command_encoder_begin_compute_pass", + const { rid } = ops.op_webgpu_command_encoder_begin_compute_pass( commandEncoderRid, descriptor.label, ); @@ -2919,8 +2905,7 @@ selfContext: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_copy_buffer_to_buffer", + const { err } = ops.op_webgpu_command_encoder_copy_buffer_to_buffer( commandEncoderRid, sourceRid, sourceOffset, @@ -2977,8 +2962,7 @@ selfContext: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_copy_buffer_to_texture", + const { err } = ops.op_webgpu_command_encoder_copy_buffer_to_texture( commandEncoderRid, { ...source, @@ -3042,8 +3026,7 @@ resourceContext: "buffer in Argument 2", selfContext: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_copy_texture_to_buffer", + const { err } = ops.op_webgpu_command_encoder_copy_texture_to_buffer( commandEncoderRid, { texture: sourceTextureRid, @@ -3107,8 +3090,7 @@ resourceContext: "texture in Argument 2", selfContext: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_copy_texture_to_texture", + const { err } = ops.op_webgpu_command_encoder_copy_texture_to_texture( commandEncoderRid, { texture: sourceTextureRid, @@ -3161,8 +3143,7 @@ prefix, context: "Argument 1", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_clear_buffer", + const { err } = ops.op_webgpu_command_encoder_clear_buffer( commandEncoderRid, bufferRid, offset, @@ -3188,8 +3169,7 @@ prefix, context: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_push_debug_group", + const { err } = ops.op_webgpu_command_encoder_push_debug_group( commandEncoderRid, groupLabel, ); @@ -3204,8 +3184,7 @@ prefix, context: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_pop_debug_group", + const { err } = ops.op_webgpu_command_encoder_pop_debug_group( commandEncoderRid, ); device.pushError(err); @@ -3228,8 +3207,7 @@ prefix, context: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_insert_debug_marker", + const { err } = ops.op_webgpu_command_encoder_insert_debug_marker( commandEncoderRid, markerLabel, ); @@ -3267,8 +3245,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_write_timestamp", + const { err } = ops.op_webgpu_command_encoder_write_timestamp( commandEncoderRid, querySetRid, queryIndex, @@ -3337,8 +3314,7 @@ resourceContext: "Argument 3", selfContext: "this", }); - const { err } = core.opSync( - "op_webgpu_command_encoder_resolve_query_set", + const { err } = ops.op_webgpu_command_encoder_resolve_query_set( commandEncoderRid, querySetRid, firstQuery, @@ -3365,8 +3341,7 @@ prefix, context: "this", }); - const { rid, err } = core.opSync( - "op_webgpu_command_encoder_finish", + const { rid, err } = ops.op_webgpu_command_encoder_finish( commandEncoderRid, descriptor.label, ); @@ -3465,7 +3440,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync("op_webgpu_render_pass_set_viewport", { + ops.op_webgpu_render_pass_set_viewport({ renderPassRid, x, y, @@ -3512,8 +3487,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_set_scissor_rect", + ops.op_webgpu_render_pass_set_scissor_rect( renderPassRid, x, y, @@ -3543,8 +3517,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_set_blend_constant", + ops.op_webgpu_render_pass_set_blend_constant( renderPassRid, normalizeGPUColor(color), ); @@ -3571,8 +3544,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_set_stencil_reference", + ops.op_webgpu_render_pass_set_stencil_reference( renderPassRid, reference, ); @@ -3621,8 +3593,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_begin_pipeline_statistics_query", + ops.op_webgpu_render_pass_begin_pipeline_statistics_query( renderPassRid, querySetRid, queryIndex, @@ -3642,8 +3613,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_end_pipeline_statistics_query", + ops.op_webgpu_render_pass_end_pipeline_statistics_query( renderPassRid, ); } @@ -3683,8 +3653,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_write_timestamp", + ops.op_webgpu_render_pass_write_timestamp( renderPassRid, querySetRid, queryIndex, @@ -3722,8 +3691,7 @@ }); return rid; }); - core.opSync( - "op_webgpu_render_pass_execute_bundles", + ops.op_webgpu_render_pass_execute_bundles( renderPassRid, bundleRids, ); @@ -3741,8 +3709,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - const { err } = core.opSync( - "op_webgpu_render_pass_end", + const { err } = ops.op_webgpu_render_pass_end( commandEncoderRid, renderPassRid, ); @@ -3789,8 +3756,7 @@ dynamicOffsetsDataStart = 0; dynamicOffsetsDataLength = dynamicOffsetsData.length; } - core.opSync( - "op_webgpu_render_pass_set_bind_group", + ops.op_webgpu_render_pass_set_bind_group( renderPassRid, index, bindGroupRid, @@ -3821,8 +3787,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_push_debug_group", + ops.op_webgpu_render_pass_push_debug_group( renderPassRid, groupLabel, ); @@ -3841,7 +3806,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync("op_webgpu_render_pass_pop_debug_group", renderPassRid); + ops.op_webgpu_render_pass_pop_debug_group(renderPassRid); } /** @@ -3865,8 +3830,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_insert_debug_marker", + ops.op_webgpu_render_pass_insert_debug_marker( renderPassRid, markerLabel, ); @@ -3902,8 +3866,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_set_pipeline", + ops.op_webgpu_render_pass_set_pipeline( renderPassRid, pipelineRid, ); @@ -3956,8 +3919,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_set_index_buffer", + ops.op_webgpu_render_pass_set_index_buffer( renderPassRid, bufferRid, indexFormat, @@ -4013,8 +3975,7 @@ resourceContext: "Argument 2", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_set_vertex_buffer", + ops.op_webgpu_render_pass_set_vertex_buffer( renderPassRid, slot, bufferRid, @@ -4058,8 +4019,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_draw", + ops.op_webgpu_render_pass_draw( renderPassRid, vertexCount, instanceCount, @@ -4115,8 +4075,7 @@ context: "encoder referenced by this", }); const renderPassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_render_pass_draw_indexed", + ops.op_webgpu_render_pass_draw_indexed( renderPassRid, indexCount, instanceCount, @@ -4161,8 +4120,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_draw_indirect", + ops.op_webgpu_render_pass_draw_indirect( renderPassRid, indirectBufferRid, indirectOffset, @@ -4204,8 +4162,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_pass_draw_indexed_indirect", + ops.op_webgpu_render_pass_draw_indexed_indirect( renderPassRid, indirectBufferRid, indirectOffset, @@ -4288,8 +4245,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_compute_pass_set_pipeline", + ops.op_webgpu_compute_pass_set_pipeline( computePassRid, pipelineRid, ); @@ -4330,8 +4286,7 @@ context: "encoder referenced by this", }); const computePassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_compute_pass_dispatch_workgroups", + ops.op_webgpu_compute_pass_dispatch_workgroups( computePassRid, workgroupCountX, workgroupCountY, @@ -4374,8 +4329,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_compute_pass_dispatch_workgroups_indirect", + ops.op_webgpu_compute_pass_dispatch_workgroups_indirect( computePassRid, indirectBufferRid, indirectOffset, @@ -4417,8 +4371,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_compute_pass_begin_pipeline_statistics_query", + ops.op_webgpu_compute_pass_begin_pipeline_statistics_query( computePassRid, querySetRid, queryIndex, @@ -4438,8 +4391,7 @@ context: "encoder referenced by this", }); const computePassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_compute_pass_end_pipeline_statistics_query", + ops.op_webgpu_compute_pass_end_pipeline_statistics_query( computePassRid, ); } @@ -4479,8 +4431,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_compute_pass_write_timestamp", + ops.op_webgpu_compute_pass_write_timestamp( computePassRid, querySetRid, queryIndex, @@ -4499,8 +4450,7 @@ context: "encoder referenced by this", }); const computePassRid = assertResource(this, { prefix, context: "this" }); - const { err } = core.opSync( - "op_webgpu_compute_pass_end", + const { err } = ops.op_webgpu_compute_pass_end( commandEncoderRid, computePassRid, ); @@ -4547,8 +4497,7 @@ dynamicOffsetsDataStart = 0; dynamicOffsetsDataLength = dynamicOffsetsData.length; } - core.opSync( - "op_webgpu_compute_pass_set_bind_group", + ops.op_webgpu_compute_pass_set_bind_group( computePassRid, index, bindGroupRid, @@ -4579,8 +4528,7 @@ context: "encoder referenced by this", }); const computePassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_compute_pass_push_debug_group", + ops.op_webgpu_compute_pass_push_debug_group( computePassRid, groupLabel, ); @@ -4599,7 +4547,7 @@ context: "encoder referenced by this", }); const computePassRid = assertResource(this, { prefix, context: "this" }); - core.opSync("op_webgpu_compute_pass_pop_debug_group", computePassRid); + ops.op_webgpu_compute_pass_pop_debug_group(computePassRid); } /** @@ -4623,8 +4571,7 @@ context: "encoder referenced by this", }); const computePassRid = assertResource(this, { prefix, context: "this" }); - core.opSync( - "op_webgpu_compute_pass_insert_debug_marker", + ops.op_webgpu_compute_pass_insert_debug_marker( computePassRid, markerLabel, ); @@ -4734,8 +4681,7 @@ prefix, context: "this", }); - const { rid, err } = core.opSync( - "op_webgpu_render_bundle_encoder_finish", + const { rid, err } = ops.op_webgpu_render_bundle_encoder_finish( renderBundleEncoderRid, descriptor.label, ); @@ -4786,8 +4732,7 @@ dynamicOffsetsDataStart = 0; dynamicOffsetsDataLength = dynamicOffsetsData.length; } - core.opSync( - "op_webgpu_render_bundle_encoder_set_bind_group", + ops.op_webgpu_render_bundle_encoder_set_bind_group( renderBundleEncoderRid, index, bindGroupRid, @@ -4814,8 +4759,7 @@ prefix, context: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_push_debug_group", + ops.op_webgpu_render_bundle_encoder_push_debug_group( renderBundleEncoderRid, groupLabel, ); @@ -4830,8 +4774,7 @@ prefix, context: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_pop_debug_group", + ops.op_webgpu_render_bundle_encoder_pop_debug_group( renderBundleEncoderRid, ); } @@ -4853,8 +4796,7 @@ prefix, context: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_insert_debug_marker", + ops.op_webgpu_render_bundle_encoder_insert_debug_marker( renderBundleEncoderRid, markerLabel, ); @@ -4886,8 +4828,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_set_pipeline", + ops.op_webgpu_render_bundle_encoder_set_pipeline( renderBundleEncoderRid, pipelineRid, ); @@ -4934,8 +4875,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_set_index_buffer", + ops.op_webgpu_render_bundle_encoder_set_index_buffer( renderBundleEncoderRid, bufferRid, indexFormat, @@ -4985,8 +4925,7 @@ resourceContext: "Argument 2", selfContext: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_set_vertex_buffer", + ops.op_webgpu_render_bundle_encoder_set_vertex_buffer( renderBundleEncoderRid, slot, bufferRid, @@ -5026,8 +4965,7 @@ prefix, context: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_draw", + ops.op_webgpu_render_bundle_encoder_draw( renderBundleEncoderRid, vertexCount, instanceCount, @@ -5079,8 +5017,7 @@ prefix, context: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_draw_indexed", + ops.op_webgpu_render_bundle_encoder_draw_indexed( renderBundleEncoderRid, indexCount, instanceCount, @@ -5121,8 +5058,7 @@ resourceContext: "Argument 1", selfContext: "this", }); - core.opSync( - "op_webgpu_render_bundle_encoder_draw_indirect", + ops.op_webgpu_render_bundle_encoder_draw_indirect( renderBundleEncoderRid, indirectBufferRid, indirectOffset, diff --git a/ext/websocket/01_websocket.js b/ext/websocket/01_websocket.js index 8c407dff8d..bdb29526e3 100644 --- a/ext/websocket/01_websocket.js +++ b/ext/websocket/01_websocket.js @@ -5,6 +5,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { URL } = window.__bootstrap.url; const webidl = window.__bootstrap.webidl; const { HTTP_TOKEN_CODE_POINT_RE } = window.__bootstrap.infra; @@ -189,8 +190,7 @@ this[_url] = wsURL.href; - core.opSync( - "op_ws_check_permission_and_cancel_handle", + ops.op_ws_check_permission_and_cancel_handle( this[_url], false, ); diff --git a/ext/websocket/02_websocketstream.js b/ext/websocket/02_websocketstream.js index df87c0c972..5266c8dfb6 100644 --- a/ext/websocket/02_websocketstream.js +++ b/ext/websocket/02_websocketstream.js @@ -5,6 +5,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { writableStreamClose, Deferred } = window.__bootstrap.streams; const { DOMException } = window.__bootstrap.domException; @@ -128,8 +129,7 @@ fillHeaders(headers, options.headers); } - const cancelRid = core.opSync( - "op_ws_check_permission_and_cancel_handle", + const cancelRid = ops.op_ws_check_permission_and_cancel_handle( this[_url], true, ); diff --git a/ext/webstorage/01_webstorage.js b/ext/webstorage/01_webstorage.js index 5b9cccd6dd..0e9b28b1f1 100644 --- a/ext/webstorage/01_webstorage.js +++ b/ext/webstorage/01_webstorage.js @@ -4,6 +4,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const webidl = window.__bootstrap.webidl; const { SafeArrayIterator, @@ -28,7 +29,7 @@ get length() { webidl.assertBranded(this, StoragePrototype); - return core.opSync("op_webstorage_length", this[_persistent]); + return ops.op_webstorage_length(this[_persistent]); } key(index) { @@ -40,7 +41,7 @@ context: "Argument 1", }); - return core.opSync("op_webstorage_key", index, this[_persistent]); + return ops.op_webstorage_key(index, this[_persistent]); } setItem(key, value) { @@ -56,7 +57,7 @@ context: "Argument 2", }); - core.opSync("op_webstorage_set", key, value, this[_persistent]); + ops.op_webstorage_set(key, value, this[_persistent]); } getItem(key) { @@ -68,7 +69,7 @@ context: "Argument 1", }); - return core.opSync("op_webstorage_get", key, this[_persistent]); + return ops.op_webstorage_get(key, this[_persistent]); } removeItem(key) { @@ -80,12 +81,12 @@ context: "Argument 1", }); - core.opSync("op_webstorage_remove", key, this[_persistent]); + ops.op_webstorage_remove(key, this[_persistent]); } clear() { webidl.assertBranded(this, StoragePrototype); - core.opSync("op_webstorage_clear", this[_persistent]); + ops.op_webstorage_clear(this[_persistent]); } } @@ -136,7 +137,7 @@ (typeof target.getItem(p)) === "string"; }, ownKeys() { - return core.opSync("op_webstorage_iterate_keys", persistent); + return ops.op_webstorage_iterate_keys(persistent); }, getOwnPropertyDescriptor(target, key) { if (arguments.length === 1) { diff --git a/runtime/js/10_permissions.js b/runtime/js/10_permissions.js index 4bf9db7524..af66c9d2e9 100644 --- a/runtime/js/10_permissions.js +++ b/runtime/js/10_permissions.js @@ -5,7 +5,7 @@ const { Event, EventTarget, - Deno: { core }, + Deno: { core: { ops } }, __bootstrap: { webUtil: { illegalConstructorKey } }, } = window; const { pathFromURL } = window.__bootstrap.util; @@ -48,7 +48,7 @@ * @returns {Deno.PermissionState} */ function opQuery(desc) { - return core.opSync("op_query_permission", desc); + return ops.op_query_permission(desc); } /** @@ -56,7 +56,7 @@ * @returns {Deno.PermissionState} */ function opRevoke(desc) { - return core.opSync("op_revoke_permission", desc); + return ops.op_revoke_permission(desc); } /** @@ -64,7 +64,7 @@ * @returns {Deno.PermissionState} */ function opRequest(desc) { - return core.opSync("op_request_permission", desc); + return ops.op_request_permission(desc); } class PermissionStatus extends EventTarget { diff --git a/runtime/js/11_workers.js b/runtime/js/11_workers.js index 948542d1c1..5e3253dff3 100644 --- a/runtime/js/11_workers.js +++ b/runtime/js/11_workers.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { Error, ObjectPrototypeIsPrototypeOf, @@ -31,7 +32,7 @@ name, workerType, ) { - return core.opSync("op_create_worker", { + return ops.op_create_worker({ hasSourceCode, name, permissions: serializePermissions(permissions), @@ -42,11 +43,11 @@ } function hostTerminateWorker(id) { - core.opSync("op_host_terminate_worker", id); + ops.op_host_terminate_worker(id); } function hostPostMessage(id, data) { - core.opSync("op_host_post_message", id, data); + ops.op_host_post_message(id, data); } function hostRecvCtrl(id) { diff --git a/runtime/js/12_io.js b/runtime/js/12_io.js index ab0839ec64..e41657d967 100644 --- a/runtime/js/12_io.js +++ b/runtime/js/12_io.js @@ -7,6 +7,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { Uint8Array, ArrayPrototypePush, @@ -91,7 +92,7 @@ return 0; } - const nread = core.opSync("op_read_sync", rid, buffer); + const nread = ops.op_read_sync(rid, buffer); return nread === 0 ? null : nread; } @@ -107,7 +108,7 @@ } function writeSync(rid, data) { - return core.opSync("op_write_sync", rid, data); + return ops.op_write_sync(rid, data); } function write(rid, data) { diff --git a/runtime/js/30_fs.js b/runtime/js/30_fs.js index 51f2c411e2..2457713e64 100644 --- a/runtime/js/30_fs.js +++ b/runtime/js/30_fs.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { Date, DatePrototype, @@ -15,7 +16,7 @@ const build = window.__bootstrap.build.build; function chmodSync(path, mode) { - core.opSync("op_chmod_sync", { path: pathFromURL(path), mode }); + ops.op_chmod_sync({ path: pathFromURL(path), mode }); } async function chmod(path, mode) { @@ -27,7 +28,7 @@ uid, gid, ) { - core.opSync("op_chown_sync", { path: pathFromURL(path), uid, gid }); + ops.op_chown_sync({ path: pathFromURL(path), uid, gid }); } async function chown( @@ -45,7 +46,7 @@ fromPath, toPath, ) { - core.opSync("op_copy_file_sync", { + ops.op_copy_file_sync({ from: pathFromURL(fromPath), to: pathFromURL(toPath), }); @@ -62,15 +63,15 @@ } function cwd() { - return core.opSync("op_cwd"); + return ops.op_cwd(); } function chdir(directory) { - core.opSync("op_chdir", pathFromURL(directory)); + ops.op_chdir(pathFromURL(directory)); } function makeTempDirSync(options = {}) { - return core.opSync("op_make_temp_dir_sync", options); + return ops.op_make_temp_dir_sync(options); } function makeTempDir(options = {}) { @@ -78,7 +79,7 @@ } function makeTempFileSync(options = {}) { - return core.opSync("op_make_temp_file_sync", options); + return ops.op_make_temp_file_sync(options); } function makeTempFile(options = {}) { @@ -99,7 +100,7 @@ } function mkdirSync(path, options) { - core.opSync("op_mkdir_sync", mkdirArgs(path, options)); + ops.op_mkdir_sync(mkdirArgs(path, options)); } async function mkdir( @@ -110,7 +111,7 @@ } function readDirSync(path) { - return core.opSync("op_read_dir_sync", pathFromURL(path))[ + return ops.op_read_dir_sync(pathFromURL(path))[ SymbolIterator ](); } @@ -128,7 +129,7 @@ } function readLinkSync(path) { - return core.opSync("op_read_link_sync", pathFromURL(path)); + return ops.op_read_link_sync(pathFromURL(path)); } function readLink(path) { @@ -136,7 +137,7 @@ } function realPathSync(path) { - return core.opSync("op_realpath_sync", pathFromURL(path)); + return ops.op_realpath_sync(pathFromURL(path)); } function realPath(path) { @@ -147,7 +148,7 @@ path, options = {}, ) { - core.opSync("op_remove_sync", { + ops.op_remove_sync({ path: pathFromURL(path), recursive: !!options.recursive, }); @@ -164,7 +165,7 @@ } function renameSync(oldpath, newpath) { - core.opSync("op_rename_sync", { + ops.op_rename_sync({ oldpath: pathFromURL(oldpath), newpath: pathFromURL(newpath), }); @@ -203,7 +204,7 @@ } function fstatSync(rid) { - return parseFileInfo(core.opSync("op_fstat_sync", rid)); + return parseFileInfo(ops.op_fstat_sync(rid)); } async function fstat(rid) { @@ -219,7 +220,7 @@ } function lstatSync(path) { - const res = core.opSync("op_stat_sync", { + const res = ops.op_stat_sync({ path: pathFromURL(path), lstat: true, }); @@ -235,7 +236,7 @@ } function statSync(path) { - const res = core.opSync("op_stat_sync", { + const res = ops.op_stat_sync({ path: pathFromURL(path), lstat: false, }); @@ -251,7 +252,7 @@ } function ftruncateSync(rid, len) { - core.opSync("op_ftruncate_sync", { rid, len: coerceLen(len) }); + ops.op_ftruncate_sync({ rid, len: coerceLen(len) }); } async function ftruncate(rid, len) { @@ -259,7 +260,7 @@ } function truncateSync(path, len) { - core.opSync("op_truncate_sync", { path, len: coerceLen(len) }); + ops.op_truncate_sync({ path, len: coerceLen(len) }); } async function truncate(path, len) { @@ -267,11 +268,11 @@ } function umask(mask) { - return core.opSync("op_umask", mask); + return ops.op_umask(mask); } function linkSync(oldpath, newpath) { - core.opSync("op_link_sync", { oldpath, newpath }); + ops.op_link_sync({ oldpath, newpath }); } async function link(oldpath, newpath) { @@ -304,7 +305,7 @@ atime, mtime, ) { - core.opSync("op_futime_sync", { + ops.op_futime_sync({ rid, atime: toUnixTimeFromEpoch(atime), mtime: toUnixTimeFromEpoch(mtime), @@ -328,7 +329,7 @@ atime, mtime, ) { - core.opSync("op_utime_sync", { + ops.op_utime_sync({ path: pathFromURL(path), atime: toUnixTimeFromEpoch(atime), mtime: toUnixTimeFromEpoch(mtime), @@ -352,7 +353,7 @@ newpath, options, ) { - core.opSync("op_symlink_sync", { + ops.op_symlink_sync({ oldpath: pathFromURL(oldpath), newpath: pathFromURL(newpath), options, @@ -372,7 +373,7 @@ } function fdatasyncSync(rid) { - core.opSync("op_fdatasync_sync", rid); + ops.op_fdatasync_sync(rid); } async function fdatasync(rid) { @@ -380,7 +381,7 @@ } function fsyncSync(rid) { - core.opSync("op_fsync_sync", rid); + ops.op_fsync_sync(rid); } async function fsync(rid) { @@ -388,7 +389,7 @@ } function flockSync(rid, exclusive) { - core.opSync("op_flock_sync", rid, exclusive === true); + ops.op_flock_sync(rid, exclusive === true); } async function flock(rid, exclusive) { @@ -396,7 +397,7 @@ } function funlockSync(rid) { - core.opSync("op_funlock_sync", rid); + ops.op_funlock_sync(rid); } async function funlock(rid) { diff --git a/runtime/js/30_os.js b/runtime/js/30_os.js index f9df423051..c3addd0439 100644 --- a/runtime/js/30_os.js +++ b/runtime/js/30_os.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { Error, SymbolFor, @@ -11,31 +12,31 @@ const windowDispatchEvent = window.dispatchEvent.bind(window); function loadavg() { - return core.opSync("op_loadavg"); + return ops.op_loadavg(); } function hostname() { - return core.opSync("op_hostname"); + return ops.op_hostname(); } function osRelease() { - return core.opSync("op_os_release"); + return ops.op_os_release(); } function systemMemoryInfo() { - return core.opSync("op_system_memory_info"); + return ops.op_system_memory_info(); } function networkInterfaces() { - return core.opSync("op_network_interfaces"); + return ops.op_network_interfaces(); } function getGid() { - return core.opSync("op_getgid"); + return ops.op_getgid(); } function getUid() { - return core.opSync("op_getuid"); + return ops.op_getuid(); } // This is an internal only method used by the test harness to override the @@ -48,7 +49,7 @@ function exit(code) { // Set exit code first so unload event listeners can override it. if (typeof code === "number") { - core.opSync("op_set_exit_code", code); + ops.op_set_exit_code(code); } else { code = 0; } @@ -65,33 +66,33 @@ return; } - core.opSync("op_exit"); + ops.op_exit(); throw new Error("Code not reachable"); } function setEnv(key, value) { - core.opSync("op_set_env", key, value); + ops.op_set_env(key, value); } function getEnv(key) { - return core.opSync("op_get_env", key) ?? undefined; + return ops.op_get_env(key) ?? undefined; } function deleteEnv(key) { - core.opSync("op_delete_env", key); + ops.op_delete_env(key); } const env = { get: getEnv, toObject() { - return core.opSync("op_env"); + return ops.op_env(); }, set: setEnv, delete: deleteEnv, }; function execPath() { - return core.opSync("op_exec_path"); + return ops.op_exec_path(); } window.__bootstrap.os = { diff --git a/runtime/js/40_files.js b/runtime/js/40_files.js index d2148be2fc..12e406abad 100644 --- a/runtime/js/40_files.js +++ b/runtime/js/40_files.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { read, readSync, write, writeSync } = window.__bootstrap.io; const { ftruncate, ftruncateSync, fstat, fstatSync } = window.__bootstrap.fs; const { pathFromURL } = window.__bootstrap.util; @@ -19,7 +20,7 @@ offset, whence, ) { - return core.opSync("op_seek_sync", { rid, offset, whence }); + return ops.op_seek_sync({ rid, offset, whence }); } function seek( @@ -36,8 +37,7 @@ ) { checkOpenOptions(options); const mode = options?.mode; - const rid = core.opSync( - "op_open_sync", + const rid = ops.op_open_sync( { path: pathFromURL(path), options, mode }, ); diff --git a/runtime/js/40_fs_events.js b/runtime/js/40_fs_events.js index 939d3ac7b5..8027c27eb2 100644 --- a/runtime/js/40_fs_events.js +++ b/runtime/js/40_fs_events.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { BadResourcePrototype, InterruptedPrototype } = core; const { ArrayIsArray, @@ -15,7 +16,7 @@ constructor(paths, options) { const { recursive } = options; - this.#rid = core.opSync("op_fs_events_open", { recursive, paths }); + this.#rid = ops.op_fs_events_open({ recursive, paths }); } get rid() { diff --git a/runtime/js/40_http.js b/runtime/js/40_http.js index 4a87434384..36d8103741 100644 --- a/runtime/js/40_http.js +++ b/runtime/js/40_http.js @@ -3,10 +3,11 @@ ((window) => { const core = window.__bootstrap.core; + const ops = core.ops; const { HttpConn } = window.__bootstrap.http; function serveHttp(conn) { - const rid = core.opSync("op_http_start", conn.rid); + const rid = ops.op_http_start(conn.rid); return new HttpConn(rid, conn.remoteAddr, conn.localAddr); } diff --git a/runtime/js/40_process.js b/runtime/js/40_process.js index 7a52844045..e3f6fc7a08 100644 --- a/runtime/js/40_process.js +++ b/runtime/js/40_process.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { FsFile } = window.__bootstrap.files; const { readAll } = window.__bootstrap.io; const { pathFromURL } = window.__bootstrap.util; @@ -16,7 +17,7 @@ } = window.__bootstrap.primordials; function opKill(pid, signo) { - core.opSync("op_kill", pid, signo); + ops.op_kill(pid, signo); } function opRunStatus(rid) { @@ -25,7 +26,7 @@ function opRun(request) { assert(request.cmd.length > 0); - return core.opSync("op_run", request); + return ops.op_run(request); } async function runStatus(rid) { diff --git a/runtime/js/40_read_file.js b/runtime/js/40_read_file.js index 8a52e4f700..fd656c1cb6 100644 --- a/runtime/js/40_read_file.js +++ b/runtime/js/40_read_file.js @@ -3,11 +3,12 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { pathFromURL } = window.__bootstrap.util; const { abortSignal } = window.__bootstrap; function readFileSync(path) { - return core.opSync("op_readfile_sync", pathFromURL(path)); + return ops.op_readfile_sync(pathFromURL(path)); } async function readFile(path, options) { @@ -15,7 +16,7 @@ let abortHandler; if (options?.signal) { options.signal.throwIfAborted(); - cancelRid = core.opSync("op_cancel_handle"); + cancelRid = ops.op_cancel_handle(); abortHandler = () => core.tryClose(cancelRid); options.signal[abortSignal.add](abortHandler); } @@ -38,7 +39,7 @@ } function readTextFileSync(path) { - return core.opSync("op_readfile_text_sync", pathFromURL(path)); + return ops.op_readfile_text_sync(pathFromURL(path)); } async function readTextFile(path, options) { @@ -46,7 +47,7 @@ let abortHandler; if (options?.signal) { options.signal.throwIfAborted(); - cancelRid = core.opSync("op_cancel_handle"); + cancelRid = ops.op_cancel_handle(); abortHandler = () => core.tryClose(cancelRid); options.signal[abortSignal.add](abortHandler); } diff --git a/runtime/js/40_signals.js b/runtime/js/40_signals.js index d387b068f3..94171628f0 100644 --- a/runtime/js/40_signals.js +++ b/runtime/js/40_signals.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { Set, SymbolFor, @@ -10,7 +11,7 @@ } = window.__bootstrap.primordials; function bindSignal(signo) { - return core.opSync("op_signal_bind", signo); + return ops.op_signal_bind(signo); } function pollSignal(rid) { @@ -20,7 +21,7 @@ } function unbindSignal(rid) { - core.opSync("op_signal_unbind", rid); + ops.op_signal_unbind(rid); } // Stores signal listeners and resource data. This has type of diff --git a/runtime/js/40_spawn.js b/runtime/js/40_spawn.js index 87db84f4b0..4fae9e6b77 100644 --- a/runtime/js/40_spawn.js +++ b/runtime/js/40_spawn.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { pathFromURL } = window.__bootstrap.util; const { illegalConstructorKey } = window.__bootstrap.webUtil; const { add, remove } = window.__bootstrap.abortSignal; @@ -32,7 +33,7 @@ stderr = "piped", signal = undefined, } = {}) { - const child = core.opSync("op_spawn_child", { + const child = ops.op_spawn_child({ cmd: pathFromURL(command), args: ArrayPrototypeMap(args, String), cwd: pathFromURL(cwd), @@ -203,7 +204,7 @@ if (this.#rid === null) { throw new TypeError("Child process has already terminated."); } - core.opSync("op_kill", this.#pid, signo); + ops.op_kill(this.#pid, signo); } ref() { @@ -246,7 +247,7 @@ "Piped stdin is not supported for this function, use 'Deno.spawnChild()' instead", ); } - const result = core.opSync("op_spawn_sync", { + const result = ops.op_spawn_sync({ cmd: pathFromURL(command), args: ArrayPrototypeMap(args, String), cwd: pathFromURL(cwd), diff --git a/runtime/js/40_testing.js b/runtime/js/40_testing.js index fabdb8dc48..276fef6a63 100644 --- a/runtime/js/40_testing.js +++ b/runtime/js/40_testing.js @@ -3,6 +3,7 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; const { setExitHandler } = window.__bootstrap.os; const { Console } = window.__bootstrap.console; const { serializePermissions } = window.__bootstrap.permissions; @@ -510,14 +511,13 @@ } function pledgePermissions(permissions) { - return core.opSync( - "op_pledge_test_permissions", + return ops.op_pledge_test_permissions( serializePermissions(permissions), ); } function restorePermissions(token) { - core.opSync("op_restore_test_permissions", token); + ops.op_restore_test_permissions(token); } function withPermissions(fn, permissions) { @@ -709,7 +709,7 @@ columnNumber: jsError.frames[1].columnNumber, }; - const { id, filteredOut } = core.opSync("op_register_test", testDesc); + const { id, filteredOut } = ops.op_register_test(testDesc); testDesc.id = id; testDesc.filteredOut = filteredOut; @@ -731,7 +731,7 @@ return; } - core.opSync("op_bench_check_unstable"); + ops.op_bench_check_unstable(); let benchDesc; const defaults = { ignore: false, @@ -815,7 +815,7 @@ const AsyncFunction = (async () => {}).constructor; benchDesc.async = AsyncFunction === benchDesc.fn.constructor; - const { id, filteredOut } = core.opSync("op_register_bench", benchDesc); + const { id, filteredOut } = ops.op_register_bench(benchDesc); benchDesc.id = id; benchDesc.filteredOut = filteredOut; @@ -1016,20 +1016,20 @@ function getTestOrigin() { if (origin == null) { - origin = core.opSync("op_get_test_origin"); + origin = ops.op_get_test_origin(); } return origin; } function getBenchOrigin() { if (origin == null) { - origin = core.opSync("op_get_bench_origin"); + origin = ops.op_get_bench_origin(); } return origin; } function benchNow() { - return core.opSync("op_bench_now"); + return ops.op_bench_now(); } // This function is called by Rust side if we're in `deno test` or @@ -1051,7 +1051,7 @@ (desc) => !desc.filteredOut, ); - core.opSync("op_dispatch_test_event", { + ops.op_dispatch_test_event({ plan: { origin, total: filtered.length, @@ -1079,11 +1079,11 @@ } for (const desc of filtered) { - core.opSync("op_dispatch_test_event", { wait: desc.id }); + ops.op_dispatch_test_event({ wait: desc.id }); const earlier = DateNow(); const result = await runTest(desc); const elapsed = DateNow() - earlier; - core.opSync("op_dispatch_test_event", { + ops.op_dispatch_test_event({ result: [desc.id, result, elapsed], }); } @@ -1096,7 +1096,7 @@ const originalConsole = globalThis.console; globalThis.console = new Console((s) => { - core.opSync("op_dispatch_bench_event", { output: s }); + ops.op_dispatch_bench_event({ output: s }); }); const only = ArrayPrototypeFilter(benchDescs, (bench) => bench.only); @@ -1120,7 +1120,7 @@ (a, b) => groups.indexOf(a.group) - groups.indexOf(b.group), ); - core.opSync("op_dispatch_bench_event", { + ops.op_dispatch_bench_event({ plan: { origin, total: filtered.length, @@ -1131,8 +1131,8 @@ for (const desc of filtered) { desc.baseline = !!desc.baseline; - core.opSync("op_dispatch_bench_event", { wait: desc.id }); - core.opSync("op_dispatch_bench_event", { + ops.op_dispatch_bench_event({ wait: desc.id }); + ops.op_dispatch_bench_event({ result: [desc.id, await runBench(desc)], }); } @@ -1173,7 +1173,7 @@ if (state.reportedWait) { return; } - core.opSync("op_dispatch_test_event", { stepWait: desc.id }); + ops.op_dispatch_test_event({ stepWait: desc.id }); state.reportedWait = true; } @@ -1194,7 +1194,7 @@ } else { result = state.status; } - core.opSync("op_dispatch_test_event", { + ops.op_dispatch_test_event({ stepResult: [desc.id, result, state.elapsed], }); state.reportedResult = true; @@ -1293,7 +1293,7 @@ stepDesc.parent = desc; stepDesc.rootId = rootId; stepDesc.rootName = rootName; - const { id } = core.opSync("op_register_test_step", stepDesc); + const { id } = ops.op_register_test_step(stepDesc); stepDesc.id = id; const state = { context: createTestContext(stepDesc), diff --git a/runtime/js/40_tty.js b/runtime/js/40_tty.js index 1abed5f257..9cf351cc01 100644 --- a/runtime/js/40_tty.js +++ b/runtime/js/40_tty.js @@ -3,13 +3,14 @@ ((window) => { const core = window.Deno.core; + const ops = core.ops; function consoleSize(rid) { - return core.opSync("op_console_size", rid); + return ops.op_console_size(rid); } function isatty(rid) { - return core.opSync("op_isatty", rid); + return ops.op_isatty(rid); } const DEFAULT_SET_RAW_OPTIONS = { @@ -18,7 +19,7 @@ function setRaw(rid, mode, options = {}) { const rOptions = { ...DEFAULT_SET_RAW_OPTIONS, ...options }; - core.opSync("op_set_raw", { rid, mode, options: rOptions }); + ops.op_set_raw({ rid, mode, options: rOptions }); } window.__bootstrap.tty = { diff --git a/runtime/js/40_write_file.js b/runtime/js/40_write_file.js index 462d712665..893b8b2c3e 100644 --- a/runtime/js/40_write_file.js +++ b/runtime/js/40_write_file.js @@ -2,6 +2,7 @@ "use strict"; ((window) => { const core = window.__bootstrap.core; + const ops = core.ops; const { abortSignal } = window.__bootstrap; const { pathFromURL } = window.__bootstrap.util; @@ -11,7 +12,7 @@ options = {}, ) { options.signal?.throwIfAborted(); - core.opSync("op_write_file_sync", { + ops.op_write_file_sync({ path: pathFromURL(path), data, mode: options.mode, @@ -29,7 +30,7 @@ let abortHandler; if (options.signal) { options.signal.throwIfAborted(); - cancelRid = core.opSync("op_cancel_handle"); + cancelRid = ops.op_cancel_handle(); abortHandler = () => core.tryClose(cancelRid); options.signal[abortSignal.add](abortHandler); } diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js index b397fcb470..cbc5c1b5b2 100644 --- a/runtime/js/99_main.js +++ b/runtime/js/99_main.js @@ -10,6 +10,7 @@ delete Intl.v8BreakIterator; ((window) => { const core = Deno.core; + const ops = core.ops; const { ArrayPrototypeIndexOf, ArrayPrototypePush, @@ -103,7 +104,7 @@ delete Intl.v8BreakIterator; } isClosing = true; - core.opSync("op_worker_close"); + ops.op_worker_close(); } function postMessage(message, transferOrOptions = {}) { @@ -133,7 +134,7 @@ delete Intl.v8BreakIterator; } const { transfer } = options; const data = serializeJsMessageData(message, transfer); - core.opSync("op_worker_post_message", data); + ops.op_worker_post_message(data); } let isClosing = false; @@ -184,7 +185,7 @@ delete Intl.v8BreakIterator; let loadedMainWorkerScript = false; function importScripts(...urls) { - if (core.opSync("op_worker_get_type") === "module") { + if (ops.op_worker_get_type() === "module") { throw new TypeError("Can't import scripts in a module worker."); } @@ -204,8 +205,7 @@ delete Intl.v8BreakIterator; // imported scripts, so we use `loadedMainWorkerScript` to distinguish them. // TODO(andreubotella) Refactor worker creation so the main script isn't // loaded with `importScripts()`. - const scripts = core.opSync( - "op_worker_sync_fetch", + const scripts = ops.op_worker_sync_fetch( parsedUrls, !loadedMainWorkerScript, ); @@ -220,7 +220,7 @@ delete Intl.v8BreakIterator; } function opMainModule() { - return core.opSync("op_main_module"); + return ops.op_main_module(); } function formatException(error) { @@ -243,7 +243,7 @@ delete Intl.v8BreakIterator; core.setMacrotaskCallback(timers.handleTimerMacrotask); core.setMacrotaskCallback(promiseRejectMacrotaskCallback); core.setWasmStreamingCallback(fetch.handleWasmStreaming); - core.opSync("op_set_format_exception_callback", formatException); + ops.op_set_format_exception_callback(formatException); version.setVersions( runtimeOptions.denoVersion, runtimeOptions.v8Version, @@ -569,13 +569,13 @@ delete Intl.v8BreakIterator; function promiseRejectCallback(type, promise, reason) { switch (type) { case 0: { - core.opSync("op_store_pending_promise_exception", promise, reason); + ops.op_store_pending_promise_exception(promise, reason); ArrayPrototypePush(pendingRejections, promise); WeakMapPrototypeSet(pendingRejectionsReasons, promise, reason); break; } case 1: { - core.opSync("op_remove_pending_promise_exception", promise); + ops.op_remove_pending_promise_exception(promise); const index = ArrayPrototypeIndexOf(pendingRejections, promise); if (index > -1) { ArrayPrototypeSplice(pendingRejections, index, 1); @@ -594,8 +594,7 @@ delete Intl.v8BreakIterator; function promiseRejectMacrotaskCallback() { while (pendingRejections.length > 0) { const promise = ArrayPrototypeShift(pendingRejections); - const hasPendingException = core.opSync( - "op_has_pending_promise_exception", + const hasPendingException = ops.op_has_pending_promise_exception( promise, ); const reason = WeakMapPrototypeGet(pendingRejectionsReasons, promise); @@ -613,7 +612,7 @@ delete Intl.v8BreakIterator; const errorEventCb = (event) => { if (event.error === reason) { - core.opSync("op_remove_pending_promise_exception", promise); + ops.op_remove_pending_promise_exception(promise); } }; // Add a callback for "error" event - it will be dispatched @@ -626,7 +625,7 @@ delete Intl.v8BreakIterator; // If event was not prevented (or "unhandledrejection" listeners didn't // throw) we will let Rust side handle it. if (event.defaultPrevented) { - core.opSync("op_remove_pending_promise_exception", promise); + ops.op_remove_pending_promise_exception(promise); } } return true; diff --git a/test_ffi/tests/bench.js b/test_ffi/tests/bench.js index 0846155756..5342f84ff5 100644 --- a/test_ffi/tests/bench.js +++ b/test_ffi/tests/bench.js @@ -337,6 +337,8 @@ Deno.bench("nop_f64()", () => { const { nop_buffer } = dylib.symbols; const buffer = new Uint8Array(8).fill(5); +// Make sure the buffer does not get collected +globalThis.buffer = buffer; Deno.bench("nop_buffer()", () => { nop_buffer(buffer); }); @@ -539,6 +541,8 @@ Deno.bench("return_buffer_nonblocking()", async () => { const { nop_many_parameters } = dylib.symbols; const buffer2 = new Uint8Array(8).fill(25); +// Make sure the buffer does not get collected +globalThis.buffer2 = buffer2; Deno.bench("nop_many_parameters()", () => { nop_many_parameters( 135, diff --git a/test_ffi/tests/test.js b/test_ffi/tests/test.js index 23b46902a8..062dced761 100644 --- a/test_ffi/tests/test.js +++ b/test_ffi/tests/test.js @@ -18,10 +18,6 @@ const libPath = `${targetDir}/${libPrefix}test_ffi.${libSuffix}`; const resourcesPre = Deno.resources(); -function ptr(v) { - return Deno.UnsafePointer.of(v); -} - // dlopen shouldn't panic assertThrows(() => { Deno.dlopen("cli/src/main.rs", {}); @@ -420,7 +416,7 @@ const throwCallback = new Deno.UnsafeCallback({ assertThrows( () => { - dylib.symbols.call_fn_ptr(ptr(throwCallback)); + dylib.symbols.call_fn_ptr(throwCallback.pointer); }, TypeError, "hi", @@ -428,13 +424,13 @@ assertThrows( const { call_stored_function } = dylib.symbols; -dylib.symbols.call_fn_ptr(ptr(logCallback)); -dylib.symbols.call_fn_ptr_many_parameters(ptr(logManyParametersCallback)); -dylib.symbols.call_fn_ptr_return_u8(ptr(returnU8Callback)); -dylib.symbols.call_fn_ptr_return_buffer(ptr(returnBufferCallback)); -dylib.symbols.store_function(ptr(logCallback)); +dylib.symbols.call_fn_ptr(logCallback.pointer); +dylib.symbols.call_fn_ptr_many_parameters(logManyParametersCallback.pointer); +dylib.symbols.call_fn_ptr_return_u8(returnU8Callback.pointer); +dylib.symbols.call_fn_ptr_return_buffer(returnBufferCallback.pointer); +dylib.symbols.store_function(logCallback.pointer); call_stored_function(); -dylib.symbols.store_function_2(ptr(add10Callback)); +dylib.symbols.store_function_2(add10Callback.pointer); dylib.symbols.call_stored_function_2(20); const nestedCallback = new Deno.UnsafeCallback( @@ -443,7 +439,7 @@ const nestedCallback = new Deno.UnsafeCallback( dylib.symbols.call_stored_function_2(10); }, ); -dylib.symbols.store_function(ptr(nestedCallback)); +dylib.symbols.store_function(nestedCallback.pointer); dylib.symbols.store_function(null); dylib.symbols.store_function_2(null); @@ -457,14 +453,14 @@ const addToFooCallback = new Deno.UnsafeCallback({ // Test thread safe callbacks console.log("Thread safe call counter:", counter); addToFooCallback.ref(); -await dylib.symbols.call_fn_ptr_thread_safe(ptr(addToFooCallback)); +await dylib.symbols.call_fn_ptr_thread_safe(addToFooCallback.pointer); addToFooCallback.unref(); logCallback.ref(); -await dylib.symbols.call_fn_ptr_thread_safe(ptr(logCallback)); +await dylib.symbols.call_fn_ptr_thread_safe(logCallback.pointer); logCallback.unref(); console.log("Thread safe call counter:", counter); returnU8Callback.ref(); -await dylib.symbols.call_fn_ptr_return_u8_thread_safe(ptr(returnU8Callback)); +await dylib.symbols.call_fn_ptr_return_u8_thread_safe(returnU8Callback.pointer); // Test statics console.log("Static u32:", dylib.symbols.static_u32);