From cd61c015450c921c0b54b03830a34c481002f937 Mon Sep 17 00:00:00 2001 From: Nayeem Rahman Date: Tue, 13 Jun 2023 16:45:06 +0100 Subject: [PATCH] refactor(core): cleanup feature flags for js source inclusion (#19463) Remove `ExtensionFileSourceCode::LoadedFromFsDuringSnapshot` and feature `include_js_for_snapshotting` since they leak paths that are only applicable in this repo to embedders. Replace with feature `exclude_js_sources`. Additionally the feature `force_include_js_sources` allows negating it, if both features are set. We need both of these because features are additive and there must be a way of force including sources for snapshot creation while still having the `exclude_js_sources` feature. `force_include_js_sources` is only set for build deps, so sources are still excluded from the final binary. You can also specify `force_include_js_sources` on any extension to override the above features for that extension. Towards #19398. But there was still the snapshot-from-snapshot situation where code could be executed twice, I addressed that by making `mod_evaluate()` and scripts like `core/01_core.js` behave idempotently. This allowed unifying `ext::init_ops()` and `ext::init_ops_and_esm()` into `ext::init()`. --- Cargo.lock | 1 + bench_util/benches/op_baseline.rs | 2 +- bench_util/benches/utf8.rs | 5 +- cli/Cargo.toml | 8 +- cli/build.rs | 64 ++++------ cli/lsp/tsc.rs | 2 +- cli/ops/mod.rs | 2 +- cli/tools/bench.rs | 2 +- cli/tools/test.rs | 2 +- cli/tsc/mod.rs | 4 +- core/00_primordials.js | 3 + core/01_core.js | 3 + core/02_error.js | 3 + core/Cargo.toml | 6 +- core/extensions.rs | 135 +++++++------------- core/inspector.rs | 3 + core/lib.rs | 1 - core/modules.rs | 27 +--- core/runtime.rs | 80 ++++++------ core/snapshot_util.rs | 30 +---- ext/fs/lib.rs | 1 - ext/net/ops.rs | 2 +- ext/url/benches/url_ops.rs | 9 +- ext/web/benches/encoding.rs | 16 +-- ext/web/benches/timers_ops.rs | 15 +-- ext/webidl/benches/dict.rs | 7 +- runtime/Cargo.toml | 11 +- runtime/build.rs | 59 ++++----- runtime/examples/extension_with_esm/main.rs | 2 +- runtime/examples/extension_with_ops/main.rs | 2 +- runtime/js.rs | 7 - runtime/web_worker.rs | 60 ++++----- runtime/worker.rs | 58 ++++----- 33 files changed, 251 insertions(+), 381 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index edb0a6e124..72b0011483 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -949,6 +949,7 @@ dependencies = [ "anyhow", "bytes", "deno_ast", + "deno_core", "deno_ops", "futures", "indexmap", diff --git a/bench_util/benches/op_baseline.rs b/bench_util/benches/op_baseline.rs index 4b3bc0203c..a8aadda013 100644 --- a/bench_util/benches/op_baseline.rs +++ b/bench_util/benches/op_baseline.rs @@ -19,7 +19,7 @@ deno_core::extension!( ); fn setup() -> Vec { - vec![bench_setup::init_ops()] + vec![bench_setup::init()] } #[op] diff --git a/bench_util/benches/utf8.rs b/bench_util/benches/utf8.rs index 9bc7cdaee4..6d0a5977e8 100644 --- a/bench_util/benches/utf8.rs +++ b/bench_util/benches/utf8.rs @@ -7,14 +7,12 @@ use deno_bench_util::bencher::Bencher; use deno_bench_util::BenchOptions; use deno_core::Extension; use deno_core::ExtensionFileSource; -use deno_core::ExtensionFileSourceCode; fn setup() -> Vec { vec![Extension::builder("bench_setup") .js(vec![ExtensionFileSource { specifier: "ext:bench_setup/setup.js", - code: ExtensionFileSourceCode::IncludedInBinary( - r#" + code: r#" const hello = "hello world\n"; const hello1k = hello.repeat(1e3); const hello1m = hello.repeat(1e6); @@ -22,7 +20,6 @@ fn setup() -> Vec { const hello1kEncoded = Deno.core.encode(hello1k); const hello1mEncoded = Deno.core.encode(hello1m); "#, - ), }]) .build()] } diff --git a/cli/Cargo.toml b/cli/Cargo.toml index fe9f358445..41194bfcde 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -27,8 +27,8 @@ harness = false path = "./bench/lsp_bench_standalone.rs" [build-dependencies] -deno_runtime = { workspace = true, features = ["snapshot_from_snapshot", "include_js_files_for_snapshotting"] } -deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] } +deno_runtime = { workspace = true, features = ["exclude_js_main_from_snapshot"] } +deno_core.workspace = true lazy-regex.workspace = true serde.workspace = true serde_json.workspace = true @@ -41,14 +41,14 @@ winres.workspace = true [dependencies] deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "dep_graph", "module_specifier", "proposal", "react", "sourcemap", "transforms", "typescript", "view", "visit"] } -deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] } +deno_core = { workspace = true, features = ["exclude_js_sources"] } deno_doc = "=0.63.1" deno_emit = "=0.24.0" deno_graph = "=0.49.0" deno_lint = { version = "=0.47.0", features = ["docs"] } deno_lockfile.workspace = true deno_npm.workspace = true -deno_runtime = { workspace = true, features = ["dont_create_runtime_snapshot", "include_js_files_for_snapshotting"] } +deno_runtime = { workspace = true, features = ["dont_create_runtime_snapshot"] } deno_semver.workspace = true deno_task_shell = "=0.12.0" eszip = "=0.44.0" diff --git a/cli/build.rs b/cli/build.rs index 5ff86fa20c..77e0ee1de8 100644 --- a/cli/build.rs +++ b/cli/build.rs @@ -7,7 +7,6 @@ use std::sync::Arc; use deno_core::snapshot_util::*; use deno_core::Extension; use deno_core::ExtensionFileSource; -use deno_core::ExtensionFileSourceCode; use deno_runtime::deno_cache::SqliteBackedCache; use deno_runtime::deno_http::DefaultHttpPropertyExtractor; use deno_runtime::deno_kv::sqlite::SqliteDbHandler; @@ -262,15 +261,11 @@ mod ts { ) .unwrap(); - let output = create_snapshot(CreateSnapshotOptions { + create_snapshot(CreateSnapshotOptions { cargo_manifest_dir: env!("CARGO_MANIFEST_DIR"), snapshot_path, startup_snapshot: None, - extensions: vec![deno_tsc::init_ops_and_esm( - op_crate_libs, - build_libs, - path_dts, - )], + extensions: vec![deno_tsc::init(op_crate_libs, build_libs, path_dts)], // NOTE(bartlomieju): Compressing the TSC snapshot in debug build took // ~45s on M1 MacBook Pro; without compression it took ~1s. @@ -289,9 +284,6 @@ mod ts { })), snapshot_module_load_cb: None, }); - for path in output.files_loaded_during_snapshot { - println!("cargo:rerun-if-changed={}", path.display()); - } } pub(crate) fn version() -> String { @@ -322,55 +314,52 @@ deno_core::extension!( customizer = |ext: &mut deno_core::ExtensionBuilder| { ext.esm(vec![ExtensionFileSource { specifier: "ext:cli/runtime/js/99_main.js", - code: ExtensionFileSourceCode::LoadedFromFsDuringSnapshot( - std::path::PathBuf::from(deno_runtime::js::PATH_FOR_99_MAIN_JS), - ), + code: include_str!("../runtime/js/99_main.js"), }]); } ); -#[must_use = "The files listed by create_cli_snapshot should be printed as 'cargo:rerun-if-changed' lines"] -fn create_cli_snapshot(snapshot_path: PathBuf) -> CreateSnapshotOutput { +fn create_cli_snapshot(snapshot_path: PathBuf) { // NOTE(bartlomieju): ordering is important here, keep it in sync with // `runtime/worker.rs`, `runtime/web_worker.rs` and `runtime/build.rs`! let fs = Arc::new(deno_fs::RealFs); let extensions: Vec = vec![ - deno_webidl::deno_webidl::init_ops(), - deno_console::deno_console::init_ops(), - deno_url::deno_url::init_ops(), - deno_web::deno_web::init_ops::( + deno_webidl::deno_webidl::init(), + deno_console::deno_console::init(), + deno_url::deno_url::init(), + deno_web::deno_web::init::( deno_web::BlobStore::default(), Default::default(), ), - deno_fetch::deno_fetch::init_ops::(Default::default()), - deno_cache::deno_cache::init_ops::(None), - deno_websocket::deno_websocket::init_ops::( + deno_fetch::deno_fetch::init::(Default::default()), + deno_cache::deno_cache::init::(None), + deno_websocket::deno_websocket::init::( "".to_owned(), None, None, ), - deno_webstorage::deno_webstorage::init_ops(None), - deno_crypto::deno_crypto::init_ops(None), - deno_broadcast_channel::deno_broadcast_channel::init_ops( + deno_webstorage::deno_webstorage::init(None), + deno_crypto::deno_crypto::init(None), + deno_broadcast_channel::deno_broadcast_channel::init( deno_broadcast_channel::InMemoryBroadcastChannel::default(), false, // No --unstable. ), - deno_ffi::deno_ffi::init_ops::(false), - deno_net::deno_net::init_ops::( + deno_ffi::deno_ffi::init::(false), + deno_net::deno_net::init::( None, false, // No --unstable. None, ), - deno_tls::deno_tls::init_ops(), - deno_kv::deno_kv::init_ops( + deno_tls::deno_tls::init(), + deno_kv::deno_kv::init( SqliteDbHandler::::new(None), false, // No --unstable. ), - deno_napi::deno_napi::init_ops::(), - deno_http::deno_http::init_ops::(), - deno_io::deno_io::init_ops(Default::default()), - deno_fs::deno_fs::init_ops::(false, fs.clone()), - deno_node::deno_node::init_ops::(None, fs), - cli::init_ops_and_esm(), // NOTE: This needs to be init_ops_and_esm! + deno_napi::deno_napi::init::(), + deno_http::deno_http::init::(), + deno_io::deno_io::init(Default::default()), + deno_fs::deno_fs::init::(false, fs.clone()), + deno_node::deno_node::init::(None, fs), + cli::init(), ]; create_snapshot(CreateSnapshotOptions { @@ -485,10 +474,7 @@ fn main() { ts::create_compiler_snapshot(compiler_snapshot_path, &c); let cli_snapshot_path = o.join("CLI_SNAPSHOT.bin"); - let output = create_cli_snapshot(cli_snapshot_path); - for path in output.files_loaded_during_snapshot { - println!("cargo:rerun-if-changed={}", path.display()) - } + create_cli_snapshot(cli_snapshot_path); #[cfg(target_os = "windows")] { diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs index 66687789bf..4c26abdc11 100644 --- a/cli/lsp/tsc.rs +++ b/cli/lsp/tsc.rs @@ -3236,7 +3236,7 @@ fn op_script_version( /// server. fn js_runtime(performance: Arc) -> JsRuntime { JsRuntime::new(RuntimeOptions { - extensions: vec![deno_tsc::init_ops(performance)], + extensions: vec![deno_tsc::init(performance)], startup_snapshot: Some(tsc::compiler_snapshot()), ..Default::default() }) diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs index 5066c44b9f..d0d668bfb7 100644 --- a/cli/ops/mod.rs +++ b/cli/ops/mod.rs @@ -12,7 +12,7 @@ pub mod bench; pub mod testing; pub fn cli_exts(npm_resolver: Arc) -> Vec { - vec![deno_cli::init_ops(npm_resolver)] + vec![deno_cli::init(npm_resolver)] } deno_core::extension!(deno_cli, diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs index a7b75d8be8..4e7e90ba79 100644 --- a/cli/tools/bench.rs +++ b/cli/tools/bench.rs @@ -447,7 +447,7 @@ async fn bench_specifier( .create_custom_worker( specifier.clone(), PermissionsContainer::new(permissions), - vec![ops::bench::deno_bench::init_ops(sender.clone())], + vec![ops::bench::deno_bench::init(sender.clone())], Default::default(), ) .await?; diff --git a/cli/tools/test.rs b/cli/tools/test.rs index 6f32d69e49..6181ebac0a 100644 --- a/cli/tools/test.rs +++ b/cli/tools/test.rs @@ -935,7 +935,7 @@ pub async fn test_specifier( .create_custom_worker( specifier.clone(), PermissionsContainer::new(permissions), - vec![ops::testing::deno_test::init_ops(sender.clone())], + vec![ops::testing::deno_test::init(sender.clone())], Stdio { stdin: StdioPipe::Inherit, stdout, diff --git a/cli/tsc/mod.rs b/cli/tsc/mod.rs index a4d6640f7c..edc64e8ef3 100644 --- a/cli/tsc/mod.rs +++ b/cli/tsc/mod.rs @@ -122,7 +122,7 @@ fn get_asset_texts_from_new_runtime() -> Result, AnyError> { // the assets are stored within the typescript isolate, so take them out of there let mut runtime = JsRuntime::new(RuntimeOptions { startup_snapshot: Some(compiler_snapshot()), - extensions: vec![deno_cli_tsc::init_ops()], + extensions: vec![deno_cli_tsc::init()], ..Default::default() }); let global = runtime @@ -787,7 +787,7 @@ pub fn exec(request: Request) -> Result { let mut runtime = JsRuntime::new(RuntimeOptions { startup_snapshot: Some(compiler_snapshot()), - extensions: vec![deno_cli_tsc::init_ops( + extensions: vec![deno_cli_tsc::init( request, root_map, remapped_specifiers, diff --git a/core/00_primordials.js b/core/00_primordials.js index 60474e649d..b85aa6673b 100644 --- a/core/00_primordials.js +++ b/core/00_primordials.js @@ -34,6 +34,9 @@ "use strict"; (() => { + if (globalThis.__bootstrap) { + return; + } const primordials = {}; const { diff --git a/core/01_core.js b/core/01_core.js index 13aa17c7ed..8b5a4ff667 100644 --- a/core/01_core.js +++ b/core/01_core.js @@ -2,6 +2,9 @@ "use strict"; ((window) => { + if (globalThis.__bootstrap.core) { + return; + } const { Array, ArrayPrototypeFill, diff --git a/core/02_error.js b/core/02_error.js index b29dc9b4ee..ffca10a321 100644 --- a/core/02_error.js +++ b/core/02_error.js @@ -2,6 +2,9 @@ "use strict"; ((window) => { + if (globalThis.__bootstrap.core.prepareStackTrace) { + return; + } const core = Deno.core; const ops = core.ops; const { diff --git a/core/Cargo.toml b/core/Cargo.toml index b9cb265e88..251f15429e 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -16,7 +16,10 @@ path = "lib.rs" [features] default = ["v8_use_custom_libcxx"] v8_use_custom_libcxx = ["v8/use_custom_libcxx"] -include_js_files_for_snapshotting = [] +# Enable to exclude JS sources from the binary (e.g. if they are already snapshotted). +exclude_js_sources = [] +# Enable to override `exclude_js_sources` (e.g. for snapshot creation in `build.rs`). +force_include_js_sources = ["exclude_js_sources"] [dependencies] anyhow.workspace = true @@ -47,3 +50,4 @@ path = "examples/http_bench_json_ops/main.rs" # These dependencies are only used for the 'http_bench_*_ops' examples. [dev-dependencies] deno_ast.workspace = true +deno_core = { workspace = true, features = ["force_include_js_sources"] } diff --git a/core/extensions.rs b/core/extensions.rs index fa6d7851e7..ab05781064 100644 --- a/core/extensions.rs +++ b/core/extensions.rs @@ -1,32 +1,15 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use crate::modules::ModuleCode; use crate::OpState; -use anyhow::Context as _; -use anyhow::Error; use std::cell::RefCell; -use std::path::PathBuf; use std::rc::Rc; use std::task::Context; use v8::fast_api::FastFunction; -#[derive(Clone, Debug)] -pub enum ExtensionFileSourceCode { - /// Source code is included in the binary produced. Either by being defined - /// inline, or included using `include_str!()`. If you are snapshotting, this - /// will result in two copies of the source code being included - one in the - /// snapshot, the other the static string in the `Extension`. - IncludedInBinary(&'static str), - - // Source code is loaded from a file on disk. It's meant to be used if the - // embedder is creating snapshots. Files will be loaded from the filesystem - // during the build time and they will only be present in the V8 snapshot. - LoadedFromFsDuringSnapshot(PathBuf), -} - #[derive(Clone, Debug)] pub struct ExtensionFileSource { pub specifier: &'static str, - pub code: ExtensionFileSourceCode, + pub code: &'static str, } impl ExtensionFileSource { @@ -34,29 +17,14 @@ impl ExtensionFileSource { s.chars().filter(|c| !c.is_ascii()).collect::() } - pub fn load(&self) -> Result { - match &self.code { - ExtensionFileSourceCode::IncludedInBinary(code) => { - debug_assert!( - code.is_ascii(), - "Extension code must be 7-bit ASCII: {} (found {})", - self.specifier, - Self::find_non_ascii(code) - ); - Ok(ModuleCode::from_static(code)) - } - ExtensionFileSourceCode::LoadedFromFsDuringSnapshot(path) => { - let msg = || format!("Failed to read \"{}\"", path.display()); - let s = std::fs::read_to_string(path).with_context(msg)?; - debug_assert!( - s.is_ascii(), - "Extension code must be 7-bit ASCII: {} (found {})", - self.specifier, - Self::find_non_ascii(&s) - ); - Ok(s.into()) - } - } + pub fn load(&self) -> ModuleCode { + debug_assert!( + self.code.is_ascii(), + "Extension code must be 7-bit ASCII: {} (found {})", + self.specifier, + Self::find_non_ascii(self.code) + ); + ModuleCode::from_static(self.code) } } @@ -187,6 +155,7 @@ macro_rules! extension { $(, esm = [ $( dir $dir_esm:literal , )? $( $esm:literal ),* $(,)? ] )? $(, esm_setup_script = $esm_setup_script:expr )? $(, js = [ $( dir $dir_js:literal , )? $( $js:literal ),* $(,)? ] )? + $(, force_include_js_sources $($force_include_js_sources:block)? )? // dummy variable $(, options = { $( $options_id:ident : $options_type:ty ),* $(,)? } )? $(, middleware = $middleware_fn:expr )? $(, state = $state_fn:expr )? @@ -211,9 +180,9 @@ macro_rules! extension { #[inline(always)] #[allow(unused_variables)] fn with_js(ext: &mut $crate::ExtensionBuilder) { - $( ext.esm( - $crate::include_js_files!( $name $( dir $dir_esm , )? $( $esm , )* ) - ); )? + ext.esm( + $crate::include_js_files!( $name $( force_include_js_sources $($force_include_js_sources)?, )? $( $( dir $dir_esm , )? $( $esm , )* )? ) + ); $( ext.esm(vec![ExtensionFileSource { specifier: "ext:setup", @@ -223,9 +192,9 @@ macro_rules! extension { $( ext.esm_entry_point($esm_entry_point); )? - $( ext.js( - $crate::include_js_files!( $name $( dir $dir_js , )? $( $js , )* ) - ); )? + ext.js( + $crate::include_js_files!( $name $( force_include_js_sources $($force_include_js_sources)?, )? $( $( dir $dir_js , )? $( $js , )* )? ) + ); } // If ops were specified, add those ops to the extension. @@ -285,7 +254,7 @@ macro_rules! extension { } #[allow(dead_code)] - pub fn init_ops_and_esm $( < $( $param : $type + 'static ),+ > )? ( $( $( $options_id : $options_type ),* )? ) -> $crate::Extension + pub fn init $( < $( $param : $type + 'static ),+ > )? ( $( $( $options_id : $options_type ),* )? ) -> $crate::Extension $( where $( $bound : $bound_type ),+ )? { let mut ext = Self::ext(); @@ -296,17 +265,6 @@ macro_rules! extension { Self::with_customizer(&mut ext); ext.take() } - - #[allow(dead_code)] - pub fn init_ops $( < $( $param : $type + 'static ),+ > )? ( $( $( $options_id : $options_type ),* )? ) -> $crate::Extension - $( where $( $bound : $bound_type ),+ )? - { - let mut ext = Self::ext(); - Self::with_ops $( ::< $( $param ),+ > )?(&mut ext); - Self::with_state_and_middleware $( ::< $( $param ),+ > )?(&mut ext, $( $( $options_id , )* )? ); - Self::with_customizer(&mut ext); - ext.take() - } } }; @@ -608,54 +566,49 @@ impl ExtensionBuilder { /// - "ext:my_extension/js/01_hello.js" /// - "ext:my_extension/js/02_goodbye.js" /// ``` -#[cfg(not(feature = "include_js_files_for_snapshotting"))] +#[cfg(not(all( + feature = "exclude_js_sources", + not(feature = "force_include_js_sources") +)))] #[macro_export] macro_rules! include_js_files { - ($name:ident dir $dir:literal, $($file:literal,)+) => { - vec![ - $($crate::ExtensionFileSource { - specifier: concat!("ext:", stringify!($name), "/", $file), - code: $crate::ExtensionFileSourceCode::IncludedInBinary( - include_str!(concat!($dir, "/", $file) - )), - },)+ - ] - }; - - ($name:ident $($file:literal,)+) => { - vec![ - $($crate::ExtensionFileSource { - specifier: concat!("ext:", stringify!($name), "/", $file), - code: $crate::ExtensionFileSourceCode::IncludedInBinary( - include_str!($file) - ), - },)+ - ] + ($name:ident $(force_include_js_sources $($dummy:block)?,)? $(dir $dir:literal,)? $($file:literal,)*) => { + $crate::force_include_js_files!($name $(dir $dir,)? $($file,)*) }; } -#[cfg(feature = "include_js_files_for_snapshotting")] +#[cfg(all( + feature = "exclude_js_sources", + not(feature = "force_include_js_sources") +))] #[macro_export] macro_rules! include_js_files { - ($name:ident dir $dir:literal, $($file:literal,)+) => { + ($name:ident force_include_js_sources $($dummy:block)?, $(dir $dir:literal,)? $($file:literal,)*) => { + $crate::force_include_js_files!($name $(dir $dir,)? $($file,)*) + }; + + ($name:ident $(dir $dir:literal,)? $($file:literal,)*) => { + vec![] + }; +} + +#[macro_export] +macro_rules! force_include_js_files { + ($name:ident dir $dir:literal, $($file:literal,)*) => { vec![ $($crate::ExtensionFileSource { specifier: concat!("ext:", stringify!($name), "/", $file), - code: $crate::ExtensionFileSourceCode::LoadedFromFsDuringSnapshot( - std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join($dir).join($file) - ), - },)+ + code: include_str!(concat!($dir, "/", $file)), + },)* ] }; - ($name:ident $($file:literal,)+) => { + ($name:ident $($file:literal,)*) => { vec![ $($crate::ExtensionFileSource { specifier: concat!("ext:", stringify!($name), "/", $file), - code: $crate::ExtensionFileSourceCode::LoadedFromFsDuringSnapshot( - std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join($file) - ), - },)+ + code: include_str!($file), + },)* ] }; } diff --git a/core/inspector.rs b/core/inspector.rs index d7c84608f5..d7592fbe45 100644 --- a/core/inspector.rs +++ b/core/inspector.rs @@ -365,6 +365,9 @@ impl JsRuntimeInspector { w.poll_state = PollState::Parked; w.parked_thread.replace(thread::current()); } + PollState::Parked => { + w.parked_thread.replace(thread::current()); + } _ => unreachable!(), }; w.poll_state diff --git a/core/lib.rs b/core/lib.rs index 336d9c2b98..729182a4f0 100644 --- a/core/lib.rs +++ b/core/lib.rs @@ -60,7 +60,6 @@ pub use crate::async_cell::RcRef; pub use crate::extensions::Extension; pub use crate::extensions::ExtensionBuilder; pub use crate::extensions::ExtensionFileSource; -pub use crate::extensions::ExtensionFileSourceCode; pub use crate::extensions::OpDecl; pub use crate::extensions::OpMiddlewareFn; pub use crate::fast_string::FastString; diff --git a/core/modules.rs b/core/modules.rs index 4f1875ae59..5d9fe2fc45 100644 --- a/core/modules.rs +++ b/core/modules.rs @@ -438,7 +438,7 @@ impl ModuleLoader for ExtModuleLoader { let result = if let Some(load_callback) = &self.maybe_load_callback { load_callback(source) } else { - source.load() + Ok(source.load()) }; match result { Ok(code) => { @@ -459,29 +459,6 @@ impl ModuleLoader for ExtModuleLoader { } } -impl Drop for ExtModuleLoader { - fn drop(&mut self) { - let sources = self.sources.get_mut(); - let used_specifiers = self.used_specifiers.get_mut(); - let unused_modules: Vec<_> = sources - .iter() - .filter(|(k, _)| !used_specifiers.contains(k.as_str())) - .collect(); - - if !unused_modules.is_empty() { - let mut msg = - "Following modules were passed to ExtModuleLoader but never used:\n" - .to_string(); - for m in unused_modules { - msg.push_str(" - "); - msg.push_str(m.0); - msg.push('\n'); - } - panic!("{}", msg); - } - } -} - /// Basic file system module loader. /// /// Note that this loader will **block** event loop @@ -2044,7 +2021,7 @@ import "/a.js"; deno_core::extension!(test_ext, ops = [op_test]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], module_loader: Some(loader), ..Default::default() }); diff --git a/core/runtime.rs b/core/runtime.rs index ecfd0bd571..29064df635 100644 --- a/core/runtime.rs +++ b/core/runtime.rs @@ -510,7 +510,7 @@ impl JsRuntime { maybe_load_callback: Option, ) -> JsRuntime { let init_mode = InitMode::from_options(&options); - let (op_state, ops) = Self::create_opstate(&mut options, init_mode); + let (op_state, ops) = Self::create_opstate(&mut options); let op_state = Rc::new(RefCell::new(op_state)); // Collect event-loop middleware @@ -860,7 +860,7 @@ impl JsRuntime { realm.execute_script( self.v8_isolate(), file_source.specifier, - file_source.load()?, + file_source.load(), )?; } } @@ -963,20 +963,11 @@ impl JsRuntime { } /// Initializes ops of provided Extensions - fn create_opstate( - options: &mut RuntimeOptions, - init_mode: InitMode, - ) -> (OpState, Vec) { + fn create_opstate(options: &mut RuntimeOptions) -> (OpState, Vec) { // Add built-in extension - if init_mode == InitMode::FromSnapshot { - options - .extensions - .insert(0, crate::ops_builtin::core::init_ops()); - } else { - options - .extensions - .insert(0, crate::ops_builtin::core::init_ops_and_esm()); - } + options + .extensions + .insert(0, crate::ops_builtin::core::init()); let ops = Self::collect_ops(&mut options.extensions); @@ -1858,6 +1849,19 @@ impl JsRuntime { .map(|handle| v8::Local::new(tc_scope, handle)) .expect("ModuleInfo not found"); let mut status = module.get_status(); + if status == v8::ModuleStatus::Evaluated { + let (sender, receiver) = oneshot::channel(); + sender.send(Ok(())).unwrap(); + return receiver; + } + if status == v8::ModuleStatus::Errored { + let (sender, receiver) = oneshot::channel(); + let exception = module.get_exception(); + sender + .send(exception_to_err_result(tc_scope, exception, false)) + .unwrap(); + return receiver; + } assert_eq!( status, v8::ModuleStatus::Instantiated, @@ -2703,7 +2707,7 @@ pub mod tests { } ); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops(mode, dispatch_count.clone())], + extensions: vec![test_ext::init(mode, dispatch_count.clone())], get_error_class_fn: Some(&|error| { crate::error::get_custom_error_class(error).unwrap() }), @@ -3118,7 +3122,7 @@ pub mod tests { deno_core::extension!(test_ext, ops = [op_err]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], get_error_class_fn: Some(&get_error_class_name), ..Default::default() }); @@ -3724,7 +3728,7 @@ main(); deno_core::extension!(test_ext, ops = [op_err_sync, op_err_async]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -3886,7 +3890,7 @@ assertEquals(1, notify_return_value); state = |state| state.put(InnerState(42)) ); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -3917,7 +3921,7 @@ assertEquals(1, notify_return_value); ops = [op_sync_serialize_object_with_numbers_as_keys] ); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -3959,7 +3963,7 @@ Deno.core.ops.op_sync_serialize_object_with_numbers_as_keys({ ops = [op_async_serialize_object_with_numbers_as_keys] ); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -3995,7 +3999,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_async_sleep]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -4050,7 +4054,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_macrotask, op_next_tick]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -4191,7 +4195,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_promise_reject]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -4334,7 +4338,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { } let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], module_loader: Some(Rc::new(ModsLoader)), ..Default::default() }); @@ -4359,7 +4363,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_err]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); assert!(runtime @@ -4384,7 +4388,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_add_4]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); let r = runtime @@ -4407,7 +4411,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops_fn = ops); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); let err = runtime @@ -4436,7 +4440,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_sum_take, op_boomerang]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -4505,7 +4509,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { middleware = |op| if op.is_unstable { op.disable() } else { op } ); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); runtime @@ -4553,7 +4557,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_test]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); let realm = runtime.create_realm().unwrap(); @@ -4586,7 +4590,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_test]); let mut runtime = JsRuntime::new(RuntimeOptions { startup_snapshot: Some(Snapshot::Boxed(snapshot)), - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); let realm = runtime.create_realm().unwrap(); @@ -4620,7 +4624,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_test]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], get_error_class_fn: Some(&|error| { crate::error::get_custom_error_class(error).unwrap() }), @@ -4668,7 +4672,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_test]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], get_error_class_fn: Some(&|error| { crate::error::get_custom_error_class(error).unwrap() }), @@ -4745,7 +4749,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_pending]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -4792,7 +4796,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_pending]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); @@ -4892,7 +4896,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [a::op_test, op_test]); JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); } @@ -4911,7 +4915,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", { deno_core::extension!(test_ext, ops = [op_test_sync, op_test_async]); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); diff --git a/core/snapshot_util.rs b/core/snapshot_util.rs index 88c2731477..200a81d150 100644 --- a/core/snapshot_util.rs +++ b/core/snapshot_util.rs @@ -22,16 +22,7 @@ pub struct CreateSnapshotOptions { pub snapshot_module_load_cb: Option, } -pub struct CreateSnapshotOutput { - /// Any files marked as LoadedFromFsDuringSnapshot are collected here and should be - /// printed as 'cargo:rerun-if-changed' lines from your build script. - pub files_loaded_during_snapshot: Vec, -} - -#[must_use = "The files listed by create_snapshot should be printed as 'cargo:rerun-if-changed' lines"] -pub fn create_snapshot( - create_snapshot_options: CreateSnapshotOptions, -) -> CreateSnapshotOutput { +pub fn create_snapshot(create_snapshot_options: CreateSnapshotOptions) { let mut mark = Instant::now(); let js_runtime = JsRuntimeForSnapshot::new( @@ -51,22 +42,6 @@ pub fn create_snapshot( ); mark = Instant::now(); - let mut files_loaded_during_snapshot = vec![]; - for source in js_runtime - .extensions() - .iter() - .flat_map(|e| vec![e.get_esm_sources(), e.get_js_sources()]) - .flatten() - .flatten() - { - use crate::ExtensionFileSourceCode; - if let ExtensionFileSourceCode::LoadedFromFsDuringSnapshot(path) = - &source.code - { - files_loaded_during_snapshot.push(path.clone()); - } - } - let snapshot = js_runtime.snapshot(); let snapshot_slice: &[u8] = &snapshot; println!( @@ -112,9 +87,6 @@ pub fn create_snapshot( Instant::now().saturating_duration_since(mark), create_snapshot_options.snapshot_path.display(), ); - CreateSnapshotOutput { - files_loaded_during_snapshot, - } } pub type FilterFn = Box bool>; diff --git a/ext/fs/lib.rs b/ext/fs/lib.rs index 7ba6cd7cac..d277129271 100644 --- a/ext/fs/lib.rs +++ b/ext/fs/lib.rs @@ -19,7 +19,6 @@ use crate::ops::*; use deno_core::error::AnyError; use deno_core::OpState; use std::cell::RefCell; -use std::convert::From; use std::path::Path; use std::rc::Rc; diff --git a/ext/net/ops.rs b/ext/net/ops.rs index 05aa416b4b..354acb3bdf 100644 --- a/ext/net/ops.rs +++ b/ext/net/ops.rs @@ -1034,7 +1034,7 @@ mod tests { ); let mut runtime = JsRuntime::new(RuntimeOptions { - extensions: vec![test_ext::init_ops()], + extensions: vec![test_ext::init()], ..Default::default() }); diff --git a/ext/url/benches/url_ops.rs b/ext/url/benches/url_ops.rs index 835dfea2ec..1e3d201f62 100644 --- a/ext/url/benches/url_ops.rs +++ b/ext/url/benches/url_ops.rs @@ -7,20 +7,17 @@ use deno_bench_util::bencher::Bencher; use deno_core::Extension; use deno_core::ExtensionFileSource; -use deno_core::ExtensionFileSourceCode; fn setup() -> Vec { vec![ - deno_webidl::deno_webidl::init_ops_and_esm(), - deno_url::deno_url::init_ops_and_esm(), + deno_webidl::deno_webidl::init(), + deno_url::deno_url::init(), Extension::builder("bench_setup") .esm(vec![ExtensionFileSource { specifier: "ext:bench_setup/setup", - code: ExtensionFileSourceCode::IncludedInBinary( - r#"import { URL } from "ext:deno_url/00_url.js"; + code: r#"import { URL } from "ext:deno_url/00_url.js"; globalThis.URL = URL; "#, - ), }]) .esm_entry_point("ext:bench_setup/setup") .build(), diff --git a/ext/web/benches/encoding.rs b/ext/web/benches/encoding.rs index 5b147f00c8..9d12d9c2c9 100644 --- a/ext/web/benches/encoding.rs +++ b/ext/web/benches/encoding.rs @@ -6,7 +6,6 @@ use deno_bench_util::bencher::benchmark_group; use deno_bench_util::bencher::Bencher; use deno_core::Extension; use deno_core::ExtensionFileSource; -use deno_core::ExtensionFileSourceCode; use deno_core::OpState; use deno_web::BlobStore; @@ -24,23 +23,18 @@ impl deno_web::TimersPermission for Permissions { fn setup() -> Vec { vec![ - deno_webidl::deno_webidl::init_ops_and_esm(), - deno_url::deno_url::init_ops_and_esm(), - deno_console::deno_console::init_ops_and_esm(), - deno_web::deno_web::init_ops_and_esm::( - BlobStore::default(), - None, - ), + deno_webidl::deno_webidl::init(), + deno_url::deno_url::init(), + deno_console::deno_console::init(), + deno_web::deno_web::init::(BlobStore::default(), None), Extension::builder("bench_setup") .esm(vec![ExtensionFileSource { specifier: "ext:bench_setup/setup", - code: ExtensionFileSourceCode::IncludedInBinary( - r#" + code: r#" import { TextDecoder } from "ext:deno_web/08_text_encoding.js"; globalThis.TextDecoder = TextDecoder; globalThis.hello12k = Deno.core.encode("hello world\n".repeat(1e3)); "#, - ), }]) .state(|state| { state.put(Permissions {}); diff --git a/ext/web/benches/timers_ops.rs b/ext/web/benches/timers_ops.rs index 084fac98ba..c6afea9c1f 100644 --- a/ext/web/benches/timers_ops.rs +++ b/ext/web/benches/timers_ops.rs @@ -6,7 +6,6 @@ use deno_bench_util::bencher::benchmark_group; use deno_bench_util::bencher::Bencher; use deno_core::Extension; use deno_core::ExtensionFileSource; -use deno_core::ExtensionFileSourceCode; use deno_core::OpState; use deno_web::BlobStore; @@ -22,19 +21,19 @@ impl deno_web::TimersPermission for Permissions { fn setup() -> Vec { vec![ - deno_webidl::deno_webidl::init_ops_and_esm(), - deno_url::deno_url::init_ops_and_esm(), - deno_console::deno_console::init_ops_and_esm(), - deno_web::deno_web::init_ops_and_esm::(BlobStore::default(), None), + deno_webidl::deno_webidl::init(), + deno_url::deno_url::init(), + deno_console::deno_console::init(), + deno_web::deno_web::init::(BlobStore::default(), None), Extension::builder("bench_setup") .esm(vec![ ExtensionFileSource { - specifier: "ext:bench_setup/setup", - code: ExtensionFileSourceCode::IncludedInBinary(r#" + specifier: "ext:bench_setup/setup", + code: r#" import { setTimeout, handleTimerMacrotask } from "ext:deno_web/02_timers.js"; globalThis.setTimeout = setTimeout; Deno.core.setMacrotaskCallback(handleTimerMacrotask); - "#) + "# }, ]) .state(|state| { diff --git a/ext/webidl/benches/dict.rs b/ext/webidl/benches/dict.rs index b3d95c8a32..bf5c0554b7 100644 --- a/ext/webidl/benches/dict.rs +++ b/ext/webidl/benches/dict.rs @@ -7,17 +7,14 @@ use deno_bench_util::bencher::Bencher; use deno_core::Extension; use deno_core::ExtensionFileSource; -use deno_core::ExtensionFileSourceCode; fn setup() -> Vec { vec![ - deno_webidl::deno_webidl::init_ops_and_esm(), + deno_webidl::deno_webidl::init(), Extension::builder("deno_webidl_bench") .esm(vec![ExtensionFileSource { specifier: "ext:deno_webidl_bench/setup.js", - code: ExtensionFileSourceCode::IncludedInBinary(include_str!( - "dict.js" - )), + code: include_str!("dict.js"), }]) .esm_entry_point("ext:deno_webidl_bench/setup.js") .build(), diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 77571b2102..e66698a019 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -14,15 +14,8 @@ description = "Provides the deno runtime library" docsrs = [] # A feature that disables creation of startup snapshot during in the build script. dont_create_runtime_snapshot = [] -# A feature that changes how startup snapshot is generated, that allows -# extending it in embedder crates. -snapshot_from_snapshot = [] -# A feature that disables embedding of the JavaScript source files in the binary. -# With this feature enabled, the sources must be consumed during build time, -# by creating a startup snapshot. -include_js_files_for_snapshotting = [ - "deno_core/include_js_files_for_snapshotting", -] +# Enable to exclude `js/99_main.js` from the generated snapshot. +exclude_js_main_from_snapshot = [] [lib] name = "deno_runtime" diff --git a/runtime/build.rs b/runtime/build.rs index f656682a1d..d7b4018fb3 100644 --- a/runtime/build.rs +++ b/runtime/build.rs @@ -35,7 +35,7 @@ mod startup_snapshot { file_source.specifier ), }; - let code = file_source.load()?; + let code = file_source.load(); if !should_transpile { return Ok(code); @@ -264,22 +264,20 @@ mod startup_snapshot { ], ); - #[cfg(not(feature = "snapshot_from_snapshot"))] + #[cfg(not(feature = "exclude_js_main_from_snapshot"))] deno_core::extension!( runtime_main, deps = [runtime], customizer = |ext: &mut deno_core::ExtensionBuilder| { ext.esm(vec![ExtensionFileSource { specifier: "ext:runtime_main/js/99_main.js", - code: deno_core::ExtensionFileSourceCode::IncludedInBinary( - include_str!("js/99_main.js"), - ), + code: include_str!("js/99_main.js"), }]); ext.esm_entry_point("ext:runtime_main/js/99_main.js"); } ); - #[cfg(feature = "snapshot_from_snapshot")] + #[cfg(feature = "exclude_js_main_from_snapshot")] deno_core::extension!( runtime_main, deps = [runtime], @@ -294,50 +292,48 @@ mod startup_snapshot { // `runtime/worker.rs`, `runtime/web_worker.rs` and `cli/build.rs`! let fs = std::sync::Arc::new(deno_fs::RealFs); let extensions: Vec = vec![ - deno_webidl::deno_webidl::init_ops_and_esm(), - deno_console::deno_console::init_ops_and_esm(), - deno_url::deno_url::init_ops_and_esm(), - deno_web::deno_web::init_ops_and_esm::( + deno_webidl::deno_webidl::init(), + deno_console::deno_console::init(), + deno_url::deno_url::init(), + deno_web::deno_web::init::( deno_web::BlobStore::default(), Default::default(), ), - deno_fetch::deno_fetch::init_ops_and_esm::( - Default::default(), - ), - deno_cache::deno_cache::init_ops_and_esm::(None), - deno_websocket::deno_websocket::init_ops_and_esm::( + deno_fetch::deno_fetch::init::(Default::default()), + deno_cache::deno_cache::init::(None), + deno_websocket::deno_websocket::init::( "".to_owned(), None, None, ), - deno_webstorage::deno_webstorage::init_ops_and_esm(None), - deno_crypto::deno_crypto::init_ops_and_esm(None), - deno_broadcast_channel::deno_broadcast_channel::init_ops_and_esm( + deno_webstorage::deno_webstorage::init(None), + deno_crypto::deno_crypto::init(None), + deno_broadcast_channel::deno_broadcast_channel::init( deno_broadcast_channel::InMemoryBroadcastChannel::default(), false, // No --unstable. ), - deno_ffi::deno_ffi::init_ops_and_esm::(false), - deno_net::deno_net::init_ops_and_esm::( + deno_ffi::deno_ffi::init::(false), + deno_net::deno_net::init::( None, false, // No --unstable. None, ), - deno_tls::deno_tls::init_ops_and_esm(), - deno_kv::deno_kv::init_ops_and_esm( + deno_tls::deno_tls::init(), + deno_kv::deno_kv::init( deno_kv::sqlite::SqliteDbHandler::::new(None), false, // No --unstable ), - deno_napi::deno_napi::init_ops_and_esm::(), - deno_http::deno_http::init_ops_and_esm::(), - deno_io::deno_io::init_ops_and_esm(Default::default()), - deno_fs::deno_fs::init_ops_and_esm::(false, fs.clone()), - runtime::init_ops_and_esm(), + deno_napi::deno_napi::init::(), + deno_http::deno_http::init::(), + deno_io::deno_io::init(Default::default()), + deno_fs::deno_fs::init::(false, fs.clone()), + runtime::init(), // FIXME(bartlomieju): these extensions are specified last, because they // depend on `runtime`, even though it should be other way around - deno_node::deno_node::init_ops_and_esm::(None, fs), - runtime_main::init_ops_and_esm(), + deno_node::deno_node::init::(None, fs), + runtime_main::init(), ]; - let output = create_snapshot(CreateSnapshotOptions { + create_snapshot(CreateSnapshotOptions { cargo_manifest_dir: env!("CARGO_MANIFEST_DIR"), snapshot_path, startup_snapshot: None, @@ -345,9 +341,6 @@ mod startup_snapshot { compression_cb: None, snapshot_module_load_cb: Some(Box::new(transpile_ts_for_snapshotting)), }); - for path in output.files_loaded_during_snapshot { - println!("cargo:rerun-if-changed={}", path.display()); - } } } diff --git a/runtime/examples/extension_with_esm/main.rs b/runtime/examples/extension_with_esm/main.rs index 6b21460a3f..e2b7fccd1e 100644 --- a/runtime/examples/extension_with_esm/main.rs +++ b/runtime/examples/extension_with_esm/main.rs @@ -26,7 +26,7 @@ async fn main() -> Result<(), AnyError> { PermissionsContainer::allow_all(), WorkerOptions { module_loader: Rc::new(FsModuleLoader), - extensions: vec![hello_runtime::init_ops_and_esm()], + extensions: vec![hello_runtime::init()], ..Default::default() }, ); diff --git a/runtime/examples/extension_with_ops/main.rs b/runtime/examples/extension_with_ops/main.rs index 1feb4ba279..53b6ca4fca 100644 --- a/runtime/examples/extension_with_ops/main.rs +++ b/runtime/examples/extension_with_ops/main.rs @@ -28,7 +28,7 @@ async fn main() -> Result<(), AnyError> { PermissionsContainer::allow_all(), WorkerOptions { module_loader: Rc::new(FsModuleLoader), - extensions: vec![hello_runtime::init_ops()], + extensions: vec![hello_runtime::init()], ..Default::default() }, ); diff --git a/runtime/js.rs b/runtime/js.rs index def2724ce3..6aaa32f5f1 100644 --- a/runtime/js.rs +++ b/runtime/js.rs @@ -13,10 +13,3 @@ pub fn deno_isolate_init() -> Snapshot { debug!("Deno isolate init with snapshots."); Snapshot::Static(RUNTIME_SNAPSHOT) } - -#[cfg(not(feature = "include_js_files_for_snapshotting"))] -pub static SOURCE_CODE_FOR_99_MAIN_JS: &str = include_str!("js/99_main.js"); - -#[cfg(feature = "include_js_files_for_snapshotting")] -pub static PATH_FOR_99_MAIN_JS: &str = - concat!(env!("CARGO_MANIFEST_DIR"), "/js/99_main.js"); diff --git a/runtime/web_worker.rs b/runtime/web_worker.rs index 36f9718b51..796e23c3c8 100644 --- a/runtime/web_worker.rs +++ b/runtime/web_worker.rs @@ -399,14 +399,14 @@ impl WebWorker { // `runtime/build.rs`, `runtime/worker.rs` and `cli/build.rs`! let mut extensions: Vec = vec![ // Web APIs - deno_webidl::deno_webidl::init_ops(), - deno_console::deno_console::init_ops(), - deno_url::deno_url::init_ops(), - deno_web::deno_web::init_ops::( + deno_webidl::deno_webidl::init(), + deno_console::deno_console::init(), + deno_url::deno_url::init(), + deno_web::deno_web::init::( options.blob_store.clone(), Some(main_module.clone()), ), - deno_fetch::deno_fetch::init_ops::( + deno_fetch::deno_fetch::init::( deno_fetch::Options { user_agent: options.bootstrap.user_agent.clone(), root_cert_store_provider: options.root_cert_store_provider.clone(), @@ -417,57 +417,57 @@ impl WebWorker { ..Default::default() }, ), - deno_cache::deno_cache::init_ops::(create_cache), - deno_websocket::deno_websocket::init_ops::( + deno_cache::deno_cache::init::(create_cache), + deno_websocket::deno_websocket::init::( options.bootstrap.user_agent.clone(), options.root_cert_store_provider.clone(), options.unsafely_ignore_certificate_errors.clone(), ), - deno_webstorage::deno_webstorage::init_ops(None).disable(), - deno_crypto::deno_crypto::init_ops(options.seed), - deno_broadcast_channel::deno_broadcast_channel::init_ops( + deno_webstorage::deno_webstorage::init(None).disable(), + deno_crypto::deno_crypto::init(options.seed), + deno_broadcast_channel::deno_broadcast_channel::init( options.broadcast_channel.clone(), unstable, ), - deno_ffi::deno_ffi::init_ops::(unstable), - deno_net::deno_net::init_ops::( + deno_ffi::deno_ffi::init::(unstable), + deno_net::deno_net::init::( options.root_cert_store_provider.clone(), unstable, options.unsafely_ignore_certificate_errors.clone(), ), - deno_tls::deno_tls::init_ops(), - deno_kv::deno_kv::init_ops( + deno_tls::deno_tls::init(), + deno_kv::deno_kv::init( SqliteDbHandler::::new(None), unstable, ), - deno_napi::deno_napi::init_ops::(), - deno_http::deno_http::init_ops::(), - deno_io::deno_io::init_ops(Some(options.stdio)), - deno_fs::deno_fs::init_ops::( + deno_napi::deno_napi::init::(), + deno_http::deno_http::init::(), + deno_io::deno_io::init(Some(options.stdio)), + deno_fs::deno_fs::init::( unstable, options.fs.clone(), ), - deno_node::deno_node::init_ops::( + deno_node::deno_node::init::( options.npm_resolver, options.fs, ), // Runtime ops that are always initialized for WebWorkers - ops::web_worker::deno_web_worker::init_ops(), - ops::runtime::deno_runtime::init_ops(main_module.clone()), - ops::worker_host::deno_worker_host::init_ops( + ops::web_worker::deno_web_worker::init(), + ops::runtime::deno_runtime::init(main_module.clone()), + ops::worker_host::deno_worker_host::init( options.create_web_worker_cb.clone(), options.preload_module_cb.clone(), options.pre_execute_module_cb.clone(), options.format_js_error_fn.clone(), ), - ops::fs_events::deno_fs_events::init_ops(), - ops::os::deno_os_worker::init_ops(), - ops::permissions::deno_permissions::init_ops(), - ops::process::deno_process::init_ops(), - ops::signal::deno_signal::init_ops(), - ops::tty::deno_tty::init_ops(), - ops::http::deno_http_runtime::init_ops(), - deno_permissions_web_worker::init_ops( + ops::fs_events::deno_fs_events::init(), + ops::os::deno_os_worker::init(), + ops::permissions::deno_permissions::init(), + ops::process::deno_process::init(), + ops::signal::deno_signal::init(), + ops::tty::deno_tty::init(), + ops::http::deno_http_runtime::init(), + deno_permissions_web_worker::init( permissions, unstable, enable_testing_features, diff --git a/runtime/worker.rs b/runtime/worker.rs index 10375818d0..4b78c1a949 100644 --- a/runtime/worker.rs +++ b/runtime/worker.rs @@ -235,14 +235,14 @@ impl MainWorker { // `runtime/build.rs`, `runtime/web_worker.rs` and `cli/build.rs`! let mut extensions = vec![ // Web APIs - deno_webidl::deno_webidl::init_ops(), - deno_console::deno_console::init_ops(), - deno_url::deno_url::init_ops(), - deno_web::deno_web::init_ops::( + deno_webidl::deno_webidl::init(), + deno_console::deno_console::init(), + deno_url::deno_url::init(), + deno_web::deno_web::init::( options.blob_store.clone(), options.bootstrap.location.clone(), ), - deno_fetch::deno_fetch::init_ops::( + deno_fetch::deno_fetch::init::( deno_fetch::Options { user_agent: options.bootstrap.user_agent.clone(), root_cert_store_provider: options.root_cert_store_provider.clone(), @@ -253,60 +253,60 @@ impl MainWorker { ..Default::default() }, ), - deno_cache::deno_cache::init_ops::(create_cache), - deno_websocket::deno_websocket::init_ops::( + deno_cache::deno_cache::init::(create_cache), + deno_websocket::deno_websocket::init::( options.bootstrap.user_agent.clone(), options.root_cert_store_provider.clone(), options.unsafely_ignore_certificate_errors.clone(), ), - deno_webstorage::deno_webstorage::init_ops( + deno_webstorage::deno_webstorage::init( options.origin_storage_dir.clone(), ), - deno_crypto::deno_crypto::init_ops(options.seed), - deno_broadcast_channel::deno_broadcast_channel::init_ops( + deno_crypto::deno_crypto::init(options.seed), + deno_broadcast_channel::deno_broadcast_channel::init( options.broadcast_channel.clone(), unstable, ), - deno_ffi::deno_ffi::init_ops::(unstable), - deno_net::deno_net::init_ops::( + deno_ffi::deno_ffi::init::(unstable), + deno_net::deno_net::init::( options.root_cert_store_provider.clone(), unstable, options.unsafely_ignore_certificate_errors.clone(), ), - deno_tls::deno_tls::init_ops(), - deno_kv::deno_kv::init_ops( + deno_tls::deno_tls::init(), + deno_kv::deno_kv::init( SqliteDbHandler::::new( options.origin_storage_dir.clone(), ), unstable, ), - deno_napi::deno_napi::init_ops::(), - deno_http::deno_http::init_ops::(), - deno_io::deno_io::init_ops(Some(options.stdio)), - deno_fs::deno_fs::init_ops::( + deno_napi::deno_napi::init::(), + deno_http::deno_http::init::(), + deno_io::deno_io::init(Some(options.stdio)), + deno_fs::deno_fs::init::( unstable, options.fs.clone(), ), - deno_node::deno_node::init_ops::( + deno_node::deno_node::init::( options.npm_resolver, options.fs, ), // Ops from this crate - ops::runtime::deno_runtime::init_ops(main_module.clone()), - ops::worker_host::deno_worker_host::init_ops( + ops::runtime::deno_runtime::init(main_module.clone()), + ops::worker_host::deno_worker_host::init( options.create_web_worker_cb.clone(), options.web_worker_preload_module_cb.clone(), options.web_worker_pre_execute_module_cb.clone(), options.format_js_error_fn.clone(), ), - ops::fs_events::deno_fs_events::init_ops(), - ops::os::deno_os::init_ops(exit_code.clone()), - ops::permissions::deno_permissions::init_ops(), - ops::process::deno_process::init_ops(), - ops::signal::deno_signal::init_ops(), - ops::tty::deno_tty::init_ops(), - ops::http::deno_http_runtime::init_ops(), - deno_permissions_worker::init_ops( + ops::fs_events::deno_fs_events::init(), + ops::os::deno_os::init(exit_code.clone()), + ops::permissions::deno_permissions::init(), + ops::process::deno_process::init(), + ops::signal::deno_signal::init(), + ops::tty::deno_tty::init(), + ops::http::deno_http_runtime::init(), + deno_permissions_worker::init( permissions, unstable, enable_testing_features,