From f57a2c1e85387afe48b7bdb57176dafb156bb86e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 6 Sep 2020 21:44:29 +0200 Subject: [PATCH] refactor(core): rename CoreIsolate to JsRuntime (#7373) deno_core/ - rename core_isolate.rs to runtime.rs - rename CoreIsolate to JsRuntime - rename JSError to JsError - rename JSStackFrame to JsStackFrame cli/ - update references from deno_core::CoreIsolate to deno_core::JsRuntime - rename deno_core::JSError to deno_core::JsError - rename fmt_errors::JSError to fmt_errors::JsError --- cli/build.rs | 8 +- cli/errors.rs | 6 +- cli/fmt_errors.rs | 16 +- cli/global_state.rs | 4 +- cli/inspector.rs | 4 +- cli/js.rs | 4 +- cli/main.rs | 4 +- cli/op_fetch_asset.rs | 2 +- cli/ops/worker_host.rs | 6 +- cli/source_maps.rs | 12 +- cli/tsc.rs | 6 +- cli/worker.rs | 14 +- core/README.md | 6 +- core/bindings.rs | 28 +-- core/core.js | 2 +- core/errors.rs | 20 +- core/examples/http_bench_bin_ops.rs | 6 +- core/examples/http_bench_json_ops.rs | 6 +- core/lib.rs | 20 +- core/modules.rs | 51 +++-- core/{core_isolate.rs => runtime.rs} | 317 +++++++++++++-------------- op_crates/web/lib.rs | 10 +- 22 files changed, 274 insertions(+), 278 deletions(-) rename core/{core_isolate.rs => runtime.rs} (88%) diff --git a/cli/build.rs b/cli/build.rs index 40b803979f..dcc6b41873 100644 --- a/cli/build.rs +++ b/cli/build.rs @@ -4,7 +4,7 @@ mod op_fetch_asset; use deno_core::js_check; use deno_core::BasicState; -use deno_core::CoreIsolate; +use deno_core::JsRuntime; use deno_core::OpRegistry; use deno_core::StartupData; use std::collections::HashMap; @@ -13,7 +13,7 @@ use std::path::Path; use std::path::PathBuf; fn create_snapshot( - mut isolate: CoreIsolate, + mut isolate: JsRuntime, snapshot_path: &Path, files: Vec, ) { @@ -32,7 +32,7 @@ fn create_snapshot( fn create_runtime_snapshot(snapshot_path: &Path, files: Vec) { let state = BasicState::new(); - let isolate = CoreIsolate::new(state, StartupData::None, true); + let isolate = JsRuntime::new(state, StartupData::None, true); create_snapshot(isolate, snapshot_path, files); } @@ -71,7 +71,7 @@ fn create_compiler_snapshot( op_fetch_asset::op_fetch_asset(custom_libs), ); - let isolate = CoreIsolate::new(state, StartupData::None, true); + let isolate = JsRuntime::new(state, StartupData::None, true); create_snapshot(isolate, snapshot_path, files); } diff --git a/cli/errors.rs b/cli/errors.rs index 327bcfb588..ffa0b95e47 100644 --- a/cli/errors.rs +++ b/cli/errors.rs @@ -3,11 +3,11 @@ //! There are many types of errors in Deno: //! - ErrBox: a generic boxed object. This is the super type of all //! errors handled in Rust. -//! - JSError: a container for the error message and stack trace for exceptions +//! - JsError: a container for the error message and stack trace for exceptions //! thrown in JavaScript code. We use this to pretty-print stack traces. //! - Diagnostic: these are errors that originate in TypeScript's compiler. -//! They're similar to JSError, in that they have line numbers. -//! But Diagnostics are compile-time type errors, whereas JSErrors are runtime +//! They're similar to JsError, in that they have line numbers. +//! But Diagnostics are compile-time type errors, whereas JsErrors are runtime //! exceptions. use crate::import_map::ImportMapError; diff --git a/cli/fmt_errors.rs b/cli/fmt_errors.rs index b2925f6257..afbf560d0b 100644 --- a/cli/fmt_errors.rs +++ b/cli/fmt_errors.rs @@ -103,13 +103,13 @@ fn format_maybe_source_line( format!("\n{}{}\n{}{}", indent, source_line, indent, color_underline) } -/// Wrapper around deno_core::JSError which provides color to_string. +/// Wrapper around deno_core::JsError which provides color to_string. #[derive(Debug)] -pub struct JSError(deno_core::JSError); +pub struct JsError(deno_core::JsError); -impl JSError { +impl JsError { pub fn create( - core_js_error: deno_core::JSError, + core_js_error: deno_core::JsError, source_map_getter: &impl SourceMapGetter, ) -> ErrBox { let core_js_error = apply_source_map(&core_js_error, source_map_getter); @@ -118,14 +118,14 @@ impl JSError { } } -impl Deref for JSError { - type Target = deno_core::JSError; +impl Deref for JsError { + type Target = deno_core::JsError; fn deref(&self) -> &Self::Target { &self.0 } } -impl fmt::Display for JSError { +impl fmt::Display for JsError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let mut formatted_frames = self.0.formatted_frames.clone(); @@ -170,7 +170,7 @@ impl fmt::Display for JSError { } } -impl Error for JSError {} +impl Error for JsError {} #[cfg(test)] mod tests { diff --git a/cli/global_state.rs b/cli/global_state.rs index 79618b741a..6add7b7b4f 100644 --- a/cli/global_state.rs +++ b/cli/global_state.rs @@ -96,7 +96,7 @@ impl GlobalState { } /// This function is called when new module load is - /// initialized by the CoreIsolate. Its resposibility is to collect + /// initialized by the JsRuntime. Its resposibility is to collect /// all dependencies and if it is required then also perform TS typecheck /// and traspilation. pub async fn prepare_module_load( @@ -180,7 +180,7 @@ impl GlobalState { } // TODO(bartlomieju): this method doesn't need to be async anymore - /// This method is used after `prepare_module_load` finishes and CoreIsolate + /// This method is used after `prepare_module_load` finishes and JsRuntime /// starts loading source and executing source code. This method shouldn't /// perform any IO (besides $DENO_DIR) and only operate on sources collected /// during `prepare_module_load`. diff --git a/cli/inspector.rs b/cli/inspector.rs index 9a8693ec77..baaa96ec90 100644 --- a/cli/inspector.rs +++ b/cli/inspector.rs @@ -373,10 +373,10 @@ impl DenoInspector { const CONTEXT_GROUP_ID: i32 = 1; pub fn new( - isolate: &mut deno_core::CoreIsolate, + isolate: &mut deno_core::JsRuntime, host: SocketAddr, ) -> Box { - let core_state_rc = deno_core::CoreIsolate::state(isolate); + let core_state_rc = deno_core::JsRuntime::state(isolate); let core_state = core_state_rc.borrow(); let scope = &mut v8::HandleScope::new(&mut **isolate); diff --git a/cli/js.rs b/cli/js.rs index 8b19ca6add..6e67678735 100644 --- a/cli/js.rs +++ b/cli/js.rs @@ -13,7 +13,7 @@ pub static UNSTABLE_NS_LIB: &str = include_str!("dts/lib.deno.unstable.d.ts"); #[test] fn cli_snapshot() { - let mut isolate = deno_core::CoreIsolate::new( + let mut isolate = deno_core::JsRuntime::new( deno_core::BasicState::new(), deno_core::StartupData::Snapshot(deno_core::Snapshot::Static(CLI_SNAPSHOT)), false, @@ -31,7 +31,7 @@ fn cli_snapshot() { #[test] fn compiler_snapshot() { - let mut isolate = deno_core::CoreIsolate::new( + let mut isolate = deno_core::JsRuntime::new( deno_core::BasicState::new(), deno_core::StartupData::Snapshot(deno_core::Snapshot::Static( COMPILER_SNAPSHOT, diff --git a/cli/main.rs b/cli/main.rs index 2e2dc71a26..11b12f3faf 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -79,9 +79,9 @@ use crate::permissions::Permissions; use crate::tsc::TargetLib; use crate::worker::MainWorker; use deno_core::v8_set_flags; -use deno_core::CoreIsolate; use deno_core::Deps; use deno_core::ErrBox; +use deno_core::JsRuntime; use deno_core::ModuleSpecifier; use deno_doc as doc; use deno_doc::parser::DocFileLoader; @@ -217,7 +217,7 @@ async fn print_file_info( { output.map = source_map.filename.to_str().map(|s| s.to_owned()); } - let es_state_rc = CoreIsolate::state(&worker.isolate); + let es_state_rc = JsRuntime::state(&worker.isolate); let es_state = es_state_rc.borrow(); if let Some(deps) = es_state.modules.deps(&module_specifier) { diff --git a/cli/op_fetch_asset.rs b/cli/op_fetch_asset.rs index 3becc43d70..c936a9370f 100644 --- a/cli/op_fetch_asset.rs +++ b/cli/op_fetch_asset.rs @@ -81,7 +81,7 @@ fn get_asset(name: &str) -> Option<&'static str> { } /// Warning: Returns a non-JSON op dispatcher. Must be manually attached to -/// CoreIsolate. +/// JsRuntime. pub fn op_fetch_asset( custom_assets: HashMap, ) -> impl Fn(Rc, BufVec) -> Op { diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs index d2c33f0050..83f84064ba 100644 --- a/cli/ops/worker_host.rs +++ b/cli/ops/worker_host.rs @@ -1,6 +1,6 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use crate::fmt_errors::JSError; +use crate::fmt_errors::JsError; use crate::global_state::GlobalState; use crate::ops::io::get_stdio; use crate::permissions::Permissions; @@ -249,7 +249,7 @@ fn serialize_worker_event(event: WorkerEvent) -> Value { } }); - if let Ok(js_error) = error.downcast::() { + if let Ok(js_error) = error.downcast::() { serialized_error = json!({ "type": "terminalError", "error": { @@ -271,7 +271,7 @@ fn serialize_worker_event(event: WorkerEvent) -> Value { } }); - if let Ok(js_error) = error.downcast::() { + if let Ok(js_error) = error.downcast::() { serialized_error = json!({ "type": "error", "error": { diff --git a/cli/source_maps.rs b/cli/source_maps.rs index c42d3edc9a..9f57814d48 100644 --- a/cli/source_maps.rs +++ b/cli/source_maps.rs @@ -1,5 +1,5 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -//! This mod provides functions to remap a deno_core::deno_core::JSError based on a source map +//! This mod provides functions to remap a deno_core::deno_core::JsError based on a source map use sourcemap::SourceMap; use std::collections::HashMap; use std::str; @@ -18,13 +18,13 @@ pub trait SourceMapGetter { /// find a SourceMap. pub type CachedMaps = HashMap>; -/// Apply a source map to a deno_core::JSError, returning a JSError where file +/// Apply a source map to a deno_core::JsError, returning a JsError where file /// names and line/column numbers point to the location in the original source, /// rather than the transpiled source code. pub fn apply_source_map( - js_error: &deno_core::JSError, + js_error: &deno_core::JsError, getter: &G, -) -> deno_core::JSError { +) -> deno_core::JsError { // Note that js_error.frames has already been source mapped in // prepareStackTrace(). let mut mappings_map: CachedMaps = HashMap::new(); @@ -67,7 +67,7 @@ pub fn apply_source_map( _ => js_error.source_line.clone(), }; - deno_core::JSError { + deno_core::JsError { message: js_error.message.clone(), source_line, script_resource_name, @@ -194,7 +194,7 @@ mod tests { #[test] fn apply_source_map_line() { - let e = deno_core::JSError { + let e = deno_core::JsError { message: "TypeError: baz".to_string(), source_line: Some("foo".to_string()), script_resource_name: Some("foo_bar.ts".to_string()), diff --git a/cli/tsc.rs b/cli/tsc.rs index 118dc86ae8..ec2a5c43e0 100644 --- a/cli/tsc.rs +++ b/cli/tsc.rs @@ -7,7 +7,7 @@ use crate::disk_cache::DiskCache; use crate::file_fetcher::SourceFile; use crate::file_fetcher::SourceFileFetcher; use crate::flags::Flags; -use crate::fmt_errors::JSError; +use crate::fmt_errors::JsError; use crate::global_state::GlobalState; use crate::module_graph::ModuleGraph; use crate::module_graph::ModuleGraphLoader; @@ -1191,9 +1191,9 @@ async fn create_runtime_module_graph( } /// Because TS compiler can raise runtime error, we need to -/// manually convert formatted JSError into and ErrBox. +/// manually convert formatted JsError into and ErrBox. fn js_error_to_errbox(error: ErrBox) -> ErrBox { - match error.downcast::() { + match error.downcast::() { Ok(js_error) => { let msg = format!("Error in TS compiler:\n{}", js_error); ErrBox::error(msg) diff --git a/cli/worker.rs b/cli/worker.rs index ac0ef0d26f..9ac3bbead0 100644 --- a/cli/worker.rs +++ b/cli/worker.rs @@ -1,14 +1,14 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use crate::fmt_errors::JSError; +use crate::fmt_errors::JsError; use crate::global_state::GlobalState; use crate::inspector::DenoInspector; use crate::ops; use crate::ops::io::get_stdio; use crate::startup_data; use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; +use deno_core::JsRuntime; use deno_core::ModuleId; use deno_core::ModuleSpecifier; use deno_core::StartupData; @@ -91,7 +91,7 @@ fn create_channels() -> (WorkerChannelsInternal, WorkerHandle) { /// - `WebWorker` pub struct Worker { pub name: String, - pub isolate: deno_core::CoreIsolate, + pub isolate: deno_core::JsRuntime, pub inspector: Option>, pub state: Rc, pub waker: AtomicWaker, @@ -105,7 +105,7 @@ impl Worker { startup_data: StartupData, state: &Rc, ) -> Self { - let mut isolate = deno_core::CoreIsolate::new_with_loader( + let mut isolate = deno_core::JsRuntime::new_with_loader( state.clone(), state.clone(), startup_data, @@ -114,10 +114,10 @@ impl Worker { { let global_state = state.global_state.clone(); - let core_state_rc = CoreIsolate::state(&isolate); + let core_state_rc = JsRuntime::state(&isolate); let mut core_state = core_state_rc.borrow_mut(); core_state.set_js_error_create_fn(move |core_js_error| { - JSError::create(core_js_error, &global_state.ts_compiler) + JsError::create(core_js_error, &global_state.ts_compiler) }); } @@ -235,7 +235,7 @@ impl Future for Worker { } impl Deref for Worker { - type Target = deno_core::CoreIsolate; + type Target = deno_core::JsRuntime; fn deref(&self) -> &Self::Target { &self.isolate } diff --git a/core/README.md b/core/README.md index 94fe29de9d..f6b429bb83 100644 --- a/core/README.md +++ b/core/README.md @@ -8,9 +8,9 @@ The main dependency of this crate is bindings. This Rust crate contains the essential V8 bindings for Deno's command-line -interface (Deno CLI). The main abstraction here is the Isolate which provides a -way to execute JavaScript. The Isolate is modeled as a -`Future` which completes once all of its ops have +interface (Deno CLI). The main abstraction here is the JsRuntime which provides +a way to execute JavaScript. The JsRuntime is modeled as a +`Future` which completes once all of its ops have completed. In order to bind Rust functions into JavaScript, use the `Deno.core.dispatch()` diff --git a/core/bindings.rs b/core/bindings.rs index c399f265fa..55cb080f6e 100644 --- a/core/bindings.rs +++ b/core/bindings.rs @@ -1,9 +1,9 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use crate::CoreIsolate; -use crate::CoreIsolateState; use crate::ErrBox; -use crate::JSError; +use crate::JsError; +use crate::JsRuntime; +use crate::JsRuntimeState; use crate::Op; use crate::OpId; use crate::ZeroCopyBuf; @@ -239,7 +239,7 @@ pub extern "C" fn host_import_module_dynamically_callback( let resolver_handle = v8::Global::new(scope, resolver); { - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); state.dyn_import_cb(resolver_handle, &specifier_str, &referrer_name_str); } @@ -253,7 +253,7 @@ pub extern "C" fn host_initialize_import_meta_object_callback( meta: v8::Local, ) { let scope = &mut unsafe { v8::CallbackScope::new(context) }; - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let state = state_rc.borrow(); let id = module.get_identity_hash(); @@ -273,7 +273,7 @@ pub extern "C" fn host_initialize_import_meta_object_callback( pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) { let scope = &mut unsafe { v8::CallbackScope::new(&message) }; - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); let promise = message.get_promise(); @@ -355,7 +355,7 @@ fn recv( args: v8::FunctionCallbackArguments, _rv: v8::ReturnValue, ) { - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); let cb = match v8::Local::::try_from(args.get(0)) { @@ -376,7 +376,7 @@ fn send<'s>( args: v8::FunctionCallbackArguments, mut rv: v8::ReturnValue, ) { - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let state = state_rc.borrow_mut(); let op_id = match v8::Local::::try_from(args.get(0)) @@ -443,7 +443,7 @@ fn set_macrotask_callback( args: v8::FunctionCallbackArguments, _rv: v8::ReturnValue, ) { - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); let cb = match v8::Local::::try_from(args.get(0)) { @@ -592,8 +592,8 @@ fn format_error( args: v8::FunctionCallbackArguments, mut rv: v8::ReturnValue, ) { - let e = JSError::from_v8_exception(scope, args.get(0)); - let state_rc = CoreIsolate::state(scope); + let e = JsError::from_v8_exception(scope, args.get(0)); + let state_rc = JsRuntime::state(scope); let state = state_rc.borrow(); let e = (state.js_error_create_fn)(e); let e = e.to_string(); @@ -684,9 +684,9 @@ fn shared_getter( _args: v8::PropertyCallbackArguments, mut rv: v8::ReturnValue, ) { - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); - let CoreIsolateState { + let JsRuntimeState { shared_ab, shared, .. } = &mut *state; @@ -712,7 +712,7 @@ pub fn module_resolve_callback<'s>( ) -> Option> { let scope = &mut unsafe { v8::CallbackScope::new(context) }; - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); let referrer_id = referrer.get_identity_hash(); diff --git a/core/core.js b/core/core.js index bf80528717..b84cb2e99d 100644 --- a/core/core.js +++ b/core/core.js @@ -170,7 +170,7 @@ SharedQueue Binary Layout function handleAsyncMsgFromRust(opId, buf) { if (buf) { - // This is the overflow_response case of deno::Isolate::poll(). + // This is the overflow_response case of deno::JsRuntime::poll(). asyncHandlers[opId](buf); } else { while (true) { diff --git a/core/errors.rs b/core/errors.rs index 2ce12689ab..3e42fb9376 100644 --- a/core/errors.rs +++ b/core/errors.rs @@ -110,23 +110,23 @@ impl From> for ErrBox { } } -/// A `JSError` represents an exception coming from V8, with stack frames and -/// line numbers. The deno_cli crate defines another `JSError` type, which wraps +/// A `JsError` represents an exception coming from V8, with stack frames and +/// line numbers. The deno_cli crate defines another `JsError` type, which wraps /// the one defined here, that adds source map support and colorful formatting. #[derive(Debug, PartialEq, Clone)] -pub struct JSError { +pub struct JsError { pub message: String, pub source_line: Option, pub script_resource_name: Option, pub line_number: Option, pub start_column: Option, // 0-based pub end_column: Option, // 0-based - pub frames: Vec, + pub frames: Vec, pub formatted_frames: Vec, } #[derive(Debug, PartialEq, Clone)] -pub struct JSStackFrame { +pub struct JsStackFrame { pub type_name: Option, pub function_name: Option, pub method_name: Option, @@ -152,7 +152,7 @@ fn get_property<'a>( object.get(scope, key.into()) } -impl JSError { +impl JsError { pub(crate) fn create(js_error: Self) -> ErrBox { js_error.into() } @@ -199,7 +199,7 @@ impl JSError { formatted_frames_v8.and_then(|a| a.try_into().ok()); // Convert them into Vec and Vec respectively. - let mut frames: Vec = vec![]; + let mut frames: Vec = vec![]; let mut formatted_frames: Vec = vec![]; if let (Some(frames_v8), Some(formatted_frames_v8)) = (frames_v8, formatted_frames_v8) @@ -292,7 +292,7 @@ impl JSError { .try_into() .ok(); let promise_index = promise_index.map(|n| n.value()); - frames.push(JSStackFrame { + frames.push(JsStackFrame { type_name, function_name, method_name, @@ -343,7 +343,7 @@ impl JSError { } } -impl Error for JSError {} +impl Error for JsError {} fn format_source_loc( file_name: &str, @@ -355,7 +355,7 @@ fn format_source_loc( format!("{}:{}:{}", file_name, line_number, column_number) } -impl fmt::Display for JSError { +impl fmt::Display for JsError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(script_resource_name) = &self.script_resource_name { if self.line_number.is_some() && self.start_column.is_some() { diff --git a/core/examples/http_bench_bin_ops.rs b/core/examples/http_bench_bin_ops.rs index f93b8b079c..00eb95f44c 100644 --- a/core/examples/http_bench_bin_ops.rs +++ b/core/examples/http_bench_bin_ops.rs @@ -4,7 +4,7 @@ extern crate log; use deno_core::js_check; use deno_core::BasicState; use deno_core::BufVec; -use deno_core::CoreIsolate; +use deno_core::JsRuntime; use deno_core::Op; use deno_core::OpRegistry; use deno_core::Script; @@ -77,7 +77,7 @@ impl From for RecordBuf { } } -fn create_isolate() -> CoreIsolate { +fn create_isolate() -> JsRuntime { let state = BasicState::new(); register_op_bin_sync(&state, "listen", op_listen); register_op_bin_sync(&state, "close", op_close); @@ -90,7 +90,7 @@ fn create_isolate() -> CoreIsolate { filename: "http_bench_bin_ops.js", }); - CoreIsolate::new(state, startup_data, false) + JsRuntime::new(state, startup_data, false) } fn op_listen( diff --git a/core/examples/http_bench_json_ops.rs b/core/examples/http_bench_json_ops.rs index 6e3063a0fe..de467b8adc 100644 --- a/core/examples/http_bench_json_ops.rs +++ b/core/examples/http_bench_json_ops.rs @@ -4,8 +4,8 @@ extern crate log; use deno_core::js_check; use deno_core::BasicState; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; +use deno_core::JsRuntime; use deno_core::OpRegistry; use deno_core::Script; use deno_core::StartupData; @@ -41,7 +41,7 @@ impl log::Log for Logger { fn flush(&self) {} } -fn create_isolate() -> CoreIsolate { +fn create_isolate() -> JsRuntime { let state = BasicState::new(); state.register_op_json_sync("listen", op_listen); state.register_op_json_sync("close", op_close); @@ -54,7 +54,7 @@ fn create_isolate() -> CoreIsolate { filename: "http_bench_json_ops.js", }); - CoreIsolate::new(state, startup_data, false) + JsRuntime::new(state, startup_data, false) } fn op_listen( diff --git a/core/lib.rs b/core/lib.rs index f09278b2f6..2c70f0f87e 100644 --- a/core/lib.rs +++ b/core/lib.rs @@ -10,7 +10,6 @@ extern crate log; mod basic_state; mod bindings; -mod core_isolate; mod errors; mod flags; mod module_specifier; @@ -19,23 +18,16 @@ mod normalize_path; mod ops; pub mod plugin_api; mod resources; +mod runtime; mod shared_queue; mod zero_copy_buf; pub use rusty_v8 as v8; pub use crate::basic_state::BasicState; -pub use crate::core_isolate::js_check; -pub use crate::core_isolate::CoreIsolate; -pub use crate::core_isolate::CoreIsolateState; -pub use crate::core_isolate::GetErrorClassFn; -pub use crate::core_isolate::HeapLimits; -pub use crate::core_isolate::Script; -pub use crate::core_isolate::Snapshot; -pub use crate::core_isolate::StartupData; pub use crate::errors::AnyError; pub use crate::errors::ErrBox; -pub use crate::errors::JSError; +pub use crate::errors::JsError; pub use crate::flags::v8_set_flags; pub use crate::module_specifier::ModuleResolutionError; pub use crate::module_specifier::ModuleSpecifier; @@ -55,6 +47,14 @@ pub use crate::ops::OpRegistry; pub use crate::ops::OpRouter; pub use crate::ops::OpTable; pub use crate::resources::ResourceTable; +pub use crate::runtime::js_check; +pub use crate::runtime::GetErrorClassFn; +pub use crate::runtime::HeapLimits; +pub use crate::runtime::JsRuntime; +pub use crate::runtime::JsRuntimeState; +pub use crate::runtime::Script; +pub use crate::runtime::Snapshot; +pub use crate::runtime::StartupData; pub use crate::zero_copy_buf::BufVec; pub use crate::zero_copy_buf::ZeroCopyBuf; pub use serde_json; diff --git a/core/modules.rs b/core/modules.rs index 7b1e0c5a3c..2b914fd1ec 100644 --- a/core/modules.rs +++ b/core/modules.rs @@ -84,7 +84,7 @@ pub trait ModuleLoader { /// /// For example implementor might download multiple modules in /// parallel and transpile them to final JS sources before - /// yielding control back to Isolate. + /// yielding control back to the runtime. /// /// It's not required to implement this method. fn prepare_load( @@ -99,7 +99,7 @@ pub trait ModuleLoader { } /// Placeholder structure used when creating -/// isolate that doesn't support module loading. +/// a runtime that doesn't support module loading. pub(crate) struct NoopModuleLoader; impl ModuleLoader for NoopModuleLoader { @@ -138,8 +138,7 @@ pub enum LoadState { Done, } -/// This future is used to implement parallel async module loading without -/// that is consumed by the isolate. +/// This future is used to implement parallel async module loading. pub struct RecursiveModuleLoad { kind: Kind, // TODO(bartlomieju): in future this value should @@ -547,7 +546,7 @@ mod tests { use super::*; use crate::js_check; use crate::BasicState; - use crate::CoreIsolate; + use crate::JsRuntime; use crate::StartupData; use futures::future::FutureExt; use std::error::Error; @@ -560,7 +559,7 @@ mod tests { // even though we are only using poll() in these tests and not Tokio, we must // nevertheless run it in the tokio executor. Ideally run_in_task can be // removed in the future. - use crate::core_isolate::tests::run_in_task; + use crate::runtime::tests::run_in_task; #[derive(Default)] struct MockLoader { @@ -725,17 +724,17 @@ mod tests { fn test_recursive_load() { let loader = MockLoader::new(); let loads = loader.loads.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, false, ); let spec = ModuleSpecifier::resolve_url("file:///a.js").unwrap(); - let a_id_fut = isolate.load_module(&spec, None); + let a_id_fut = runtime.load_module(&spec, None); let a_id = futures::executor::block_on(a_id_fut).expect("Failed to load"); - js_check(isolate.mod_evaluate(a_id)); + js_check(runtime.mod_evaluate(a_id)); let l = loads.lock().unwrap(); assert_eq!( l.to_vec(), @@ -747,7 +746,7 @@ mod tests { ] ); - let state_rc = CoreIsolate::state(&isolate); + let state_rc = JsRuntime::state(&runtime); let state = state_rc.borrow(); let modules = &state.modules; assert_eq!(modules.get_id("file:///a.js"), Some(a_id)); @@ -792,7 +791,7 @@ mod tests { fn test_circular_load() { let loader = MockLoader::new(); let loads = loader.loads.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, @@ -801,10 +800,10 @@ mod tests { let fut = async move { let spec = ModuleSpecifier::resolve_url("file:///circular1.js").unwrap(); - let result = isolate.load_module(&spec, None).await; + let result = runtime.load_module(&spec, None).await; assert!(result.is_ok()); let circular1_id = result.unwrap(); - js_check(isolate.mod_evaluate(circular1_id)); + js_check(runtime.mod_evaluate(circular1_id)); let l = loads.lock().unwrap(); assert_eq!( @@ -816,7 +815,7 @@ mod tests { ] ); - let state_rc = CoreIsolate::state(&isolate); + let state_rc = JsRuntime::state(&runtime); let state = state_rc.borrow(); let modules = &state.modules; @@ -870,7 +869,7 @@ mod tests { fn test_redirect_load() { let loader = MockLoader::new(); let loads = loader.loads.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, @@ -879,11 +878,11 @@ mod tests { let fut = async move { let spec = ModuleSpecifier::resolve_url("file:///redirect1.js").unwrap(); - let result = isolate.load_module(&spec, None).await; + let result = runtime.load_module(&spec, None).await; println!(">> result {:?}", result); assert!(result.is_ok()); let redirect1_id = result.unwrap(); - js_check(isolate.mod_evaluate(redirect1_id)); + js_check(runtime.mod_evaluate(redirect1_id)); let l = loads.lock().unwrap(); assert_eq!( l.to_vec(), @@ -894,7 +893,7 @@ mod tests { ] ); - let state_rc = CoreIsolate::state(&isolate); + let state_rc = JsRuntime::state(&runtime); let state = state_rc.borrow(); let modules = &state.modules; @@ -939,14 +938,14 @@ mod tests { run_in_task(|mut cx| { let loader = MockLoader::new(); let loads = loader.loads.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, false, ); let spec = ModuleSpecifier::resolve_url("file:///main.js").unwrap(); - let mut recursive_load = isolate.load_module(&spec, None).boxed_local(); + let mut recursive_load = runtime.load_module(&spec, None).boxed_local(); let result = recursive_load.poll_unpin(&mut cx); assert!(result.is_pending()); @@ -989,14 +988,14 @@ mod tests { fn loader_disappears_after_error() { run_in_task(|mut cx| { let loader = MockLoader::new(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, false, ); let spec = ModuleSpecifier::resolve_url("file:///bad_import.js").unwrap(); - let mut load_fut = isolate.load_module(&spec, None).boxed_local(); + let mut load_fut = runtime.load_module(&spec, None).boxed_local(); let result = load_fut.poll_unpin(&mut cx); if let Poll::Ready(Err(err)) = result { assert_eq!( @@ -1022,7 +1021,7 @@ mod tests { fn recursive_load_main_with_code() { let loader = MockLoader::new(); let loads = loader.loads.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, @@ -1033,13 +1032,13 @@ mod tests { // The behavior should be very similar to /a.js. let spec = ModuleSpecifier::resolve_url("file:///main_with_code.js").unwrap(); - let main_id_fut = isolate + let main_id_fut = runtime .load_module(&spec, Some(MAIN_WITH_CODE_SRC.to_owned())) .boxed_local(); let main_id = futures::executor::block_on(main_id_fut).expect("Failed to load"); - js_check(isolate.mod_evaluate(main_id)); + js_check(runtime.mod_evaluate(main_id)); let l = loads.lock().unwrap(); assert_eq!( @@ -1047,7 +1046,7 @@ mod tests { vec!["file:///b.js", "file:///c.js", "file:///d.js"] ); - let state_rc = CoreIsolate::state(&isolate); + let state_rc = JsRuntime::state(&runtime); let state = state_rc.borrow(); let modules = &state.modules; diff --git a/core/core_isolate.rs b/core/runtime.rs similarity index 88% rename from core/core_isolate.rs rename to core/runtime.rs index b8922b982e..2f574b1954 100644 --- a/core/core_isolate.rs +++ b/core/runtime.rs @@ -1,10 +1,5 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -// Do not add any dependency to modules.rs! -// modules.rs is complex and should remain decoupled from isolate.rs to keep the -// Isolate struct from becoming too bloating for users who do not need -// asynchronous module loading. - use rusty_v8 as v8; use crate::bindings; @@ -25,7 +20,7 @@ use crate::ops::*; use crate::shared_queue::SharedQueue; use crate::shared_queue::RECOMMENDED_SIZE; use crate::ErrBox; -use crate::JSError; +use crate::JsError; use crate::OpRouter; use futures::stream::FuturesUnordered; use futures::stream::StreamExt; @@ -97,7 +92,7 @@ impl StartupData<'_> { } } -type JSErrorCreateFn = dyn Fn(JSError) -> ErrBox; +type JsErrorCreateFn = dyn Fn(JsError) -> ErrBox; pub type GetErrorClassFn = dyn for<'e> Fn(&'e ErrBox) -> &'static str; @@ -109,16 +104,18 @@ struct IsolateAllocations { } /// A single execution context of JavaScript. Corresponds roughly to the "Web -/// Worker" concept in the DOM. An CoreIsolate is a Future that can be used with -/// Tokio. The CoreIsolate future completes when there is an error or when all +/// Worker" concept in the DOM. A JsRuntime is a Future that can be used with +/// an event loop (Tokio, async_std). +//// +/// The JsRuntime future completes when there is an error or when all /// pending ops have completed. /// /// Ops are created in JavaScript by calling Deno.core.dispatch(), and in Rust /// by implementing dispatcher function that takes control buffer and optional zero copy buffer /// as arguments. An async Op corresponds exactly to a Promise in JavaScript. -pub struct CoreIsolate { +pub struct JsRuntime { // This is an Option instead of just OwnedIsolate to workaround - // an safety issue with SnapshotCreator. See CoreIsolate::drop. + // an safety issue with SnapshotCreator. See JsRuntime::drop. v8_isolate: Option, snapshot_creator: Option, has_snapshotted: bool, @@ -127,15 +124,15 @@ pub struct CoreIsolate { allocations: IsolateAllocations, } -/// Internal state for CoreIsolate which is stored in one of v8::Isolate's +/// Internal state for JsRuntime which is stored in one of v8::Isolate's /// embedder slots. -pub struct CoreIsolateState { +pub struct JsRuntimeState { pub global_context: Option>, pub(crate) shared_ab: Option>, pub(crate) js_recv_cb: Option>, pub(crate) js_macrotask_cb: Option>, pub(crate) pending_promise_exceptions: HashMap>, - pub(crate) js_error_create_fn: Box, + pub(crate) js_error_create_fn: Box, pub(crate) shared: SharedQueue, pub(crate) pending_ops: FuturesUnordered, pub(crate) pending_unref_ops: FuturesUnordered, @@ -150,20 +147,20 @@ pub struct CoreIsolateState { waker: AtomicWaker, } -impl Deref for CoreIsolate { +impl Deref for JsRuntime { type Target = v8::Isolate; fn deref(&self) -> &v8::Isolate { self.v8_isolate.as_ref().unwrap() } } -impl DerefMut for CoreIsolate { +impl DerefMut for JsRuntime { fn deref_mut(&mut self) -> &mut v8::Isolate { self.v8_isolate.as_mut().unwrap() } } -impl Drop for CoreIsolate { +impl Drop for JsRuntime { fn drop(&mut self) { if let Some(creator) = self.snapshot_creator.take() { // TODO(ry): in rusty_v8, `SnapShotCreator::get_owned_isolate()` returns @@ -229,7 +226,7 @@ pub(crate) struct IsolateOptions { heap_limits: Option, } -impl CoreIsolate { +impl JsRuntime { /// startup_data defines the snapshot or script used at startup to initialize /// the isolate. pub fn new( @@ -308,7 +305,7 @@ impl CoreIsolate { let mut creator = v8::SnapshotCreator::new(Some(&bindings::EXTERNAL_REFERENCES)); let isolate = unsafe { creator.get_owned_isolate() }; - let mut isolate = CoreIsolate::setup_isolate(isolate); + let mut isolate = JsRuntime::setup_isolate(isolate); { let scope = &mut v8::HandleScope::new(&mut isolate); let context = bindings::initialize_context(scope); @@ -335,7 +332,7 @@ impl CoreIsolate { } let isolate = v8::Isolate::new(params); - let mut isolate = CoreIsolate::setup_isolate(isolate); + let mut isolate = JsRuntime::setup_isolate(isolate); { let scope = &mut v8::HandleScope::new(&mut isolate); let context = if snapshot_loaded { @@ -350,13 +347,13 @@ impl CoreIsolate { (isolate, None) }; - isolate.set_slot(Rc::new(RefCell::new(CoreIsolateState { + isolate.set_slot(Rc::new(RefCell::new(JsRuntimeState { global_context: Some(global_context), pending_promise_exceptions: HashMap::new(), shared_ab: None, js_recv_cb: None, js_macrotask_cb: None, - js_error_create_fn: Box::new(JSError::create), + js_error_create_fn: Box::new(JsError::create), shared: SharedQueue::new(RECOMMENDED_SIZE), pending_ops: FuturesUnordered::new(), pending_unref_ops: FuturesUnordered::new(), @@ -392,8 +389,8 @@ impl CoreIsolate { isolate } - pub fn state(isolate: &v8::Isolate) -> Rc> { - let s = isolate.get_slot::>>().unwrap(); + pub fn state(isolate: &v8::Isolate) -> Rc> { + let s = isolate.get_slot::>>().unwrap(); s.clone() } @@ -412,8 +409,8 @@ impl CoreIsolate { /// Executes traditional JavaScript code (traditional = not ES modules) /// /// ErrBox can be downcast to a type that exposes additional information about - /// the V8 exception. By default this type is JSError, however it may be a - /// different type if CoreIsolate::set_js_error_create_fn() has been used. + /// the V8 exception. By default this type is JsError, however it may be a + /// different type if JsRuntime::set_js_error_create_fn() has been used. pub fn execute( &mut self, js_filename: &str, @@ -459,8 +456,8 @@ impl CoreIsolate { /// set to true. /// /// ErrBox can be downcast to a type that exposes additional information about - /// the V8 exception. By default this type is JSError, however it may be a - /// different type if CoreIsolate::set_js_error_create_fn() has been used. + /// the V8 exception. By default this type is JsError, however it may be a + /// different type if JsRuntime::set_js_error_create_fn() has been used. pub fn snapshot(&mut self) -> v8::StartupData { assert!(self.snapshot_creator.is_some()); let state = Self::state(self); @@ -535,14 +532,14 @@ where callback(current_heap_limit, initial_heap_limit) } -impl Future for CoreIsolate { +impl Future for JsRuntime { type Output = Result<(), ErrBox>; fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll { - let core_isolate = self.get_mut(); - core_isolate.shared_init(); + let runtime = self.get_mut(); + runtime.shared_init(); - let state_rc = Self::state(core_isolate); + let state_rc = Self::state(runtime); { let state = state_rc.borrow(); state.waker.register(cx.waker()); @@ -553,7 +550,7 @@ impl Future for CoreIsolate { !state.preparing_dyn_imports.is_empty() }; if has_preparing { - let poll_imports = core_isolate.prepare_dyn_imports(cx)?; + let poll_imports = runtime.prepare_dyn_imports(cx)?; assert!(poll_imports.is_ready()); } @@ -562,12 +559,12 @@ impl Future for CoreIsolate { !state.pending_dyn_imports.is_empty() }; if has_pending { - let poll_imports = core_isolate.poll_dyn_imports(cx)?; + let poll_imports = runtime.poll_dyn_imports(cx)?; assert!(poll_imports.is_ready()); } let scope = &mut v8::HandleScope::with_context( - &mut **core_isolate, + &mut **runtime, state_rc.borrow().global_context.as_ref().unwrap(), ); @@ -654,13 +651,13 @@ impl Future for CoreIsolate { } } -impl CoreIsolateState { +impl JsRuntimeState { /// Allows a callback to be set whenever a V8 exception is made. This allows - /// the caller to wrap the JSError into an error. By default this callback - /// is set to JSError::create. + /// the caller to wrap the JsError into an error. By default this callback + /// is set to JsError::create. pub fn set_js_error_create_fn( &mut self, - f: impl Fn(JSError) -> ErrBox + 'static, + f: impl Fn(JsError) -> ErrBox + 'static, ) { self.js_error_create_fn = Box::new(f); } @@ -706,7 +703,7 @@ fn async_op_response<'s>( ) -> Result<(), ErrBox> { let context = scope.get_current_context(); let global: v8::Local = context.global(scope).into(); - let js_recv_cb = CoreIsolate::state(scope) + let js_recv_cb = JsRuntime::state(scope) .borrow() .js_recv_cb .as_ref() @@ -736,7 +733,7 @@ fn drain_macrotasks<'s>(scope: &mut v8::HandleScope<'s>) -> Result<(), ErrBox> { let context = scope.get_current_context(); let global: v8::Local = context.global(scope).into(); - let js_macrotask_cb = match CoreIsolate::state(scope) + let js_macrotask_cb = match JsRuntime::state(scope) .borrow_mut() .js_macrotask_cb .as_ref() @@ -790,9 +787,9 @@ pub(crate) fn exception_to_err_result<'s, T>( } } - let js_error = JSError::from_v8_exception(scope, exception); + let js_error = JsError::from_v8_exception(scope, exception); - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let state = state_rc.borrow(); let js_error = (state.js_error_create_fn)(js_error); @@ -809,7 +806,7 @@ pub(crate) fn exception_to_err_result<'s, T>( fn check_promise_exceptions<'s>( scope: &mut v8::HandleScope<'s>, ) -> Result<(), ErrBox> { - let state_rc = CoreIsolate::state(scope); + let state_rc = JsRuntime::state(scope); let mut state = state_rc.borrow_mut(); if let Some(&key) = state.pending_promise_exceptions.keys().next() { @@ -843,7 +840,7 @@ fn boxed_slice_to_uint8array<'sc>( } // Related to module loading -impl CoreIsolate { +impl JsRuntime { /// Low-level module creation. /// /// Called during module loading or dynamic import loading. @@ -902,8 +899,8 @@ impl CoreIsolate { /// Instantiates a ES module /// /// ErrBox can be downcast to a type that exposes additional information about - /// the V8 exception. By default this type is JSError, however it may be a - /// different type if CoreIsolate::set_js_error_create_fn() has been used. + /// the V8 exception. By default this type is JsError, however it may be a + /// different type if JsRuntime::set_js_error_create_fn() has been used. fn mod_instantiate(&mut self, id: ModuleId) -> Result<(), ErrBox> { let state_rc = Self::state(self); let state = state_rc.borrow(); @@ -938,8 +935,8 @@ impl CoreIsolate { /// Evaluates an already instantiated ES module. /// /// ErrBox can be downcast to a type that exposes additional information about - /// the V8 exception. By default this type is JSError, however it may be a - /// different type if CoreIsolate::set_js_error_create_fn() has been used. + /// the V8 exception. By default this type is JsError, however it may be a + /// different type if JsRuntime::set_js_error_create_fn() has been used. pub fn mod_evaluate(&mut self, id: ModuleId) -> Result<(), ErrBox> { self.shared_init(); @@ -965,7 +962,7 @@ impl CoreIsolate { // Because that promise is created internally by V8, when error occurs during // module evaluation the promise is rejected, and since the promise has no rejection // handler it will result in call to `bindings::promise_reject_callback` adding - // the promise to pending promise rejection table - meaning Isolate will return + // the promise to pending promise rejection table - meaning JsRuntime will return // error on next poll(). // // This situation is not desirable as we want to manually return error at the @@ -1253,7 +1250,7 @@ impl CoreIsolate { /// Asynchronously load specified module and all of it's dependencies /// - /// User must call `Isolate::mod_evaluate` with returned `ModuleId` + /// User must call `JsRuntime::mod_evaluate` with returned `ModuleId` /// manually after load is finished. pub async fn load_module( &mut self, @@ -1316,7 +1313,7 @@ pub mod tests { } } panic!( - "CoreIsolate still not ready after polling {} times.", + "JsRuntime still not ready after polling {} times.", max_poll_count ) } @@ -1407,15 +1404,15 @@ pub mod tests { } } - fn setup(mode: Mode) -> (CoreIsolate, Arc) { + fn setup(mode: Mode) -> (JsRuntime, Arc) { let dispatch_count = Arc::new(AtomicUsize::new(0)); let test_state = Rc::new(TestOpRouter { mode, dispatch_count: dispatch_count.clone(), }); - let mut isolate = CoreIsolate::new(test_state, StartupData::None, false); + let mut runtime = JsRuntime::new(test_state, StartupData::None, false); - js_check(isolate.execute( + js_check(runtime.execute( "setup.js", r#" function assert(cond) { @@ -1426,13 +1423,13 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 0); - (isolate, dispatch_count) + (runtime, dispatch_count) } #[test] fn test_dispatch() { - let (mut isolate, dispatch_count) = setup(Mode::Async); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::Async); + js_check(runtime.execute( "filename.js", r#" let control = new Uint8Array([42]); @@ -1448,8 +1445,8 @@ pub mod tests { #[test] fn test_dispatch_no_zero_copy_buf() { - let (mut isolate, dispatch_count) = setup(Mode::AsyncZeroCopy(0)); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::AsyncZeroCopy(0)); + js_check(runtime.execute( "filename.js", r#" Deno.core.send(1); @@ -1460,8 +1457,8 @@ pub mod tests { #[test] fn test_dispatch_stack_zero_copy_bufs() { - let (mut isolate, dispatch_count) = setup(Mode::AsyncZeroCopy(2)); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::AsyncZeroCopy(2)); + js_check(runtime.execute( "filename.js", r#" let zero_copy_a = new Uint8Array([0]); @@ -1474,8 +1471,8 @@ pub mod tests { #[test] fn test_dispatch_heap_zero_copy_bufs() { - let (mut isolate, dispatch_count) = setup(Mode::AsyncZeroCopy(5)); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::AsyncZeroCopy(5)); + js_check(runtime.execute( "filename.js", r#" let zero_copy_a = new Uint8Array([0]); @@ -1492,9 +1489,9 @@ pub mod tests { #[test] fn test_poll_async_delayed_ops() { run_in_task(|cx| { - let (mut isolate, dispatch_count) = setup(Mode::Async); + let (mut runtime, dispatch_count) = setup(Mode::Async); - js_check(isolate.execute( + js_check(runtime.execute( "setup2.js", r#" let nrecv = 0; @@ -1504,7 +1501,7 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 0); - js_check(isolate.execute( + js_check(runtime.execute( "check1.js", r#" assert(nrecv == 0); @@ -1514,9 +1511,9 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 1); - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); assert_eq!(dispatch_count.load(Ordering::Relaxed), 1); - js_check(isolate.execute( + js_check(runtime.execute( "check2.js", r#" assert(nrecv == 1); @@ -1525,19 +1522,19 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 2); - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); - js_check(isolate.execute("check3.js", "assert(nrecv == 2)")); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); + js_check(runtime.execute("check3.js", "assert(nrecv == 2)")); assert_eq!(dispatch_count.load(Ordering::Relaxed), 2); // We are idle, so the next poll should be the last. - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); }); } #[test] fn test_poll_async_optional_ops() { run_in_task(|cx| { - let (mut isolate, dispatch_count) = setup(Mode::AsyncUnref); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::AsyncUnref); + js_check(runtime.execute( "check1.js", r#" Deno.core.setAsyncHandler(1, (buf) => { @@ -1549,9 +1546,9 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 1); - // The above op never finish, but isolate can finish + // The above op never finish, but runtime can finish // because the op is an unreffed async op. - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); }) } @@ -1604,10 +1601,10 @@ pub mod tests { fn dangling_shared_isolate() { let v8_isolate_handle = { // isolate is dropped at the end of this block - let (mut isolate, _dispatch_count) = setup(Mode::Async); + let (mut runtime, _dispatch_count) = setup(Mode::Async); // TODO(piscisaureus): in rusty_v8, the `thread_safe_handle()` method // should not require a mutable reference to `struct rusty_v8::Isolate`. - isolate.v8_isolate.as_mut().unwrap().thread_safe_handle() + runtime.v8_isolate.as_mut().unwrap().thread_safe_handle() }; // this should not SEGFAULT @@ -1616,8 +1613,8 @@ pub mod tests { #[test] fn overflow_req_sync() { - let (mut isolate, dispatch_count) = setup(Mode::OverflowReqSync); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::OverflowReqSync); + js_check(runtime.execute( "overflow_req_sync.js", r#" let asyncRecv = 0; @@ -1638,8 +1635,8 @@ pub mod tests { fn overflow_res_sync() { // TODO(ry) This test is quite slow due to memcpy-ing 100MB into JS. We // should optimize this. - let (mut isolate, dispatch_count) = setup(Mode::OverflowResSync); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::OverflowResSync); + js_check(runtime.execute( "overflow_res_sync.js", r#" let asyncRecv = 0; @@ -1659,8 +1656,8 @@ pub mod tests { #[test] fn overflow_req_async() { run_in_task(|cx| { - let (mut isolate, dispatch_count) = setup(Mode::OverflowReqAsync); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::OverflowReqAsync); + js_check(runtime.execute( "overflow_req_async.js", r#" let asyncRecv = 0; @@ -1678,8 +1675,8 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 1); - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); - js_check(isolate.execute("check.js", "assert(asyncRecv == 1);")); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); + js_check(runtime.execute("check.js", "assert(asyncRecv == 1);")); }); } @@ -1688,8 +1685,8 @@ pub mod tests { run_in_task(|_cx| { // TODO(ry) This test is quite slow due to memcpy-ing 100MB into JS. We // should optimize this. - let (mut isolate, dispatch_count) = setup(Mode::OverflowResAsync); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::OverflowResAsync); + js_check(runtime.execute( "overflow_res_async.js", r#" let asyncRecv = 0; @@ -1706,8 +1703,8 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 1); - poll_until_ready(&mut isolate, 3).unwrap(); - js_check(isolate.execute("check.js", "assert(asyncRecv == 1);")); + poll_until_ready(&mut runtime, 3).unwrap(); + js_check(runtime.execute("check.js", "assert(asyncRecv == 1);")); }); } @@ -1716,8 +1713,8 @@ pub mod tests { // TODO(ry) This test is quite slow due to memcpy-ing 100MB into JS. We // should optimize this. run_in_task(|_cx| { - let (mut isolate, dispatch_count) = setup(Mode::OverflowResAsync); - js_check(isolate.execute( + let (mut runtime, dispatch_count) = setup(Mode::OverflowResAsync); + js_check(runtime.execute( "overflow_res_multiple_dispatch_async.js", r#" let asyncRecv = 0; @@ -1737,16 +1734,16 @@ pub mod tests { "#, )); assert_eq!(dispatch_count.load(Ordering::Relaxed), 2); - poll_until_ready(&mut isolate, 3).unwrap(); - js_check(isolate.execute("check.js", "assert(asyncRecv == 2);")); + poll_until_ready(&mut runtime, 3).unwrap(); + js_check(runtime.execute("check.js", "assert(asyncRecv == 2);")); }); } #[test] fn test_pre_dispatch() { run_in_task(|mut cx| { - let (mut isolate, _dispatch_count) = setup(Mode::OverflowResAsync); - js_check(isolate.execute( + let (mut runtime, _dispatch_count) = setup(Mode::OverflowResAsync); + js_check(runtime.execute( "bad_op_id.js", r#" let thrown; @@ -1758,7 +1755,7 @@ pub mod tests { assert(String(thrown) === "TypeError: Unknown op id: 100"); "#, )); - if let Poll::Ready(Err(_)) = isolate.poll_unpin(&mut cx) { + if let Poll::Ready(Err(_)) = runtime.poll_unpin(&mut cx) { unreachable!(); } }); @@ -1767,9 +1764,9 @@ pub mod tests { #[test] fn core_test_js() { run_in_task(|mut cx| { - let (mut isolate, _dispatch_count) = setup(Mode::Async); - js_check(isolate.execute("core_test.js", include_str!("core_test.js"))); - if let Poll::Ready(Err(_)) = isolate.poll_unpin(&mut cx) { + let (mut runtime, _dispatch_count) = setup(Mode::Async); + js_check(runtime.execute("core_test.js", include_str!("core_test.js"))); + if let Poll::Ready(Err(_)) = runtime.poll_unpin(&mut cx) { unreachable!(); } }); @@ -1777,24 +1774,24 @@ pub mod tests { #[test] fn syntax_error() { - let mut isolate = - CoreIsolate::new(BasicState::new(), StartupData::None, false); + let mut runtime = + JsRuntime::new(BasicState::new(), StartupData::None, false); let src = "hocuspocus("; - let r = isolate.execute("i.js", src); + let r = runtime.execute("i.js", src); let e = r.unwrap_err(); - let js_error = e.downcast::().unwrap(); + let js_error = e.downcast::().unwrap(); assert_eq!(js_error.end_column, Some(11)); } #[test] fn test_encode_decode() { run_in_task(|mut cx| { - let (mut isolate, _dispatch_count) = setup(Mode::Async); - js_check(isolate.execute( + let (mut runtime, _dispatch_count) = setup(Mode::Async); + js_check(runtime.execute( "encode_decode_test.js", include_str!("encode_decode_test.js"), )); - if let Poll::Ready(Err(_)) = isolate.poll_unpin(&mut cx) { + if let Poll::Ready(Err(_)) = runtime.poll_unpin(&mut cx) { unreachable!(); } }); @@ -1803,30 +1800,30 @@ pub mod tests { #[test] fn will_snapshot() { let snapshot = { - let mut isolate = - CoreIsolate::new(BasicState::new(), StartupData::None, true); - js_check(isolate.execute("a.js", "a = 1 + 2")); - isolate.snapshot() + let mut runtime = + JsRuntime::new(BasicState::new(), StartupData::None, true); + js_check(runtime.execute("a.js", "a = 1 + 2")); + runtime.snapshot() }; let startup_data = StartupData::Snapshot(Snapshot::JustCreated(snapshot)); - let mut isolate2 = CoreIsolate::new(BasicState::new(), startup_data, false); - js_check(isolate2.execute("check.js", "if (a != 3) throw Error('x')")); + let mut runtime2 = JsRuntime::new(BasicState::new(), startup_data, false); + js_check(runtime2.execute("check.js", "if (a != 3) throw Error('x')")); } #[test] fn test_from_boxed_snapshot() { let snapshot = { - let mut isolate = - CoreIsolate::new(BasicState::new(), StartupData::None, true); - js_check(isolate.execute("a.js", "a = 1 + 2")); - let snap: &[u8] = &*isolate.snapshot(); + let mut runtime = + JsRuntime::new(BasicState::new(), StartupData::None, true); + js_check(runtime.execute("a.js", "a = 1 + 2")); + let snap: &[u8] = &*runtime.snapshot(); Vec::from(snap).into_boxed_slice() }; let startup_data = StartupData::Snapshot(Snapshot::Boxed(snapshot)); - let mut isolate2 = CoreIsolate::new(BasicState::new(), startup_data, false); - js_check(isolate2.execute("check.js", "if (a != 3) throw Error('x')")); + let mut runtime2 = JsRuntime::new(BasicState::new(), startup_data, false); + js_check(runtime2.execute("check.js", "if (a != 3) throw Error('x')")); } #[test] @@ -1835,24 +1832,24 @@ pub mod tests { initial: 0, max: 20 * 1024, // 20 kB }; - let mut isolate = CoreIsolate::with_heap_limits( + let mut runtime = JsRuntime::with_heap_limits( BasicState::new(), StartupData::None, heap_limits, ); - let cb_handle = isolate.thread_safe_handle(); + let cb_handle = runtime.thread_safe_handle(); let callback_invoke_count = Rc::new(AtomicUsize::default()); let inner_invoke_count = Rc::clone(&callback_invoke_count); - isolate.add_near_heap_limit_callback( + runtime.add_near_heap_limit_callback( move |current_limit, _initial_limit| { inner_invoke_count.fetch_add(1, Ordering::SeqCst); cb_handle.terminate_execution(); current_limit * 2 }, ); - let err = isolate + let err = runtime .execute( "script name", r#"let s = ""; while(true) { s += "Hello"; }"#, @@ -1860,21 +1857,21 @@ pub mod tests { .expect_err("script should fail"); assert_eq!( "Uncaught Error: execution terminated", - err.downcast::().unwrap().message + err.downcast::().unwrap().message ); assert!(callback_invoke_count.load(Ordering::SeqCst) > 0) } #[test] fn test_heap_limit_cb_remove() { - let mut isolate = - CoreIsolate::new(BasicState::new(), StartupData::None, false); + let mut runtime = + JsRuntime::new(BasicState::new(), StartupData::None, false); - isolate.add_near_heap_limit_callback(|current_limit, _initial_limit| { + runtime.add_near_heap_limit_callback(|current_limit, _initial_limit| { current_limit * 2 }); - isolate.remove_near_heap_limit_callback(20 * 1024); - assert!(isolate.allocations.near_heap_limit_callback_data.is_none()); + runtime.remove_near_heap_limit_callback(20 * 1024); + assert!(runtime.allocations.near_heap_limit_callback_data.is_none()); } #[test] @@ -1883,16 +1880,16 @@ pub mod tests { initial: 0, max: 20 * 1024, // 20 kB }; - let mut isolate = CoreIsolate::with_heap_limits( + let mut runtime = JsRuntime::with_heap_limits( BasicState::new(), StartupData::None, heap_limits, ); - let cb_handle = isolate.thread_safe_handle(); + let cb_handle = runtime.thread_safe_handle(); let callback_invoke_count_first = Rc::new(AtomicUsize::default()); let inner_invoke_count_first = Rc::clone(&callback_invoke_count_first); - isolate.add_near_heap_limit_callback( + runtime.add_near_heap_limit_callback( move |current_limit, _initial_limit| { inner_invoke_count_first.fetch_add(1, Ordering::SeqCst); current_limit * 2 @@ -1901,7 +1898,7 @@ pub mod tests { let callback_invoke_count_second = Rc::new(AtomicUsize::default()); let inner_invoke_count_second = Rc::clone(&callback_invoke_count_second); - isolate.add_near_heap_limit_callback( + runtime.add_near_heap_limit_callback( move |current_limit, _initial_limit| { inner_invoke_count_second.fetch_add(1, Ordering::SeqCst); cb_handle.terminate_execution(); @@ -1909,7 +1906,7 @@ pub mod tests { }, ); - let err = isolate + let err = runtime .execute( "script name", r#"let s = ""; while(true) { s += "Hello"; }"#, @@ -1917,7 +1914,7 @@ pub mod tests { .expect_err("script should fail"); assert_eq!( "Uncaught Error: execution terminated", - err.downcast::().unwrap().message + err.downcast::().unwrap().message ); assert_eq!(0, callback_invoke_count_first.load(Ordering::SeqCst)); assert!(callback_invoke_count_second.load(Ordering::SeqCst) > 0); @@ -1971,10 +1968,10 @@ pub mod tests { }; state.register_op("test", dispatcher); - let mut isolate = - CoreIsolate::new_with_loader(loader, state, StartupData::None, false); + let mut runtime = + JsRuntime::new_with_loader(loader, state, StartupData::None, false); - js_check(isolate.execute( + js_check(runtime.execute( "setup.js", r#" function assert(cond) { @@ -1988,7 +1985,7 @@ pub mod tests { assert_eq!(dispatch_count.load(Ordering::Relaxed), 0); let specifier_a = "file:///a.js".to_string(); - let mod_a = isolate + let mod_a = runtime .mod_new( true, &specifier_a, @@ -2002,7 +1999,7 @@ pub mod tests { .unwrap(); assert_eq!(dispatch_count.load(Ordering::Relaxed), 0); - let state_rc = CoreIsolate::state(&isolate); + let state_rc = JsRuntime::state(&runtime); { let state = state_rc.borrow(); let imports = state.modules.get_children(mod_a); @@ -2011,7 +2008,7 @@ pub mod tests { Some(&vec![ModuleSpecifier::resolve_url("file:///b.js").unwrap()]) ); } - let mod_b = isolate + let mod_b = runtime .mod_new(false, "file:///b.js", "export function b() { return 'b' }") .unwrap(); { @@ -2020,14 +2017,14 @@ pub mod tests { assert_eq!(imports.len(), 0); } - js_check(isolate.mod_instantiate(mod_b)); + js_check(runtime.mod_instantiate(mod_b)); assert_eq!(dispatch_count.load(Ordering::Relaxed), 0); assert_eq!(resolve_count.load(Ordering::SeqCst), 1); - js_check(isolate.mod_instantiate(mod_a)); + js_check(runtime.mod_instantiate(mod_a)); assert_eq!(dispatch_count.load(Ordering::Relaxed), 0); - js_check(isolate.mod_evaluate(mod_a)); + js_check(runtime.mod_evaluate(mod_a)); assert_eq!(dispatch_count.load(Ordering::Relaxed), 1); } @@ -2066,14 +2063,14 @@ pub mod tests { run_in_task(|cx| { let loader = Rc::new(DynImportErrLoader::default()); let count = loader.count.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, false, ); - js_check(isolate.execute( + js_check(runtime.execute( "file:///dyn_import2.js", r#" (async () => { @@ -2084,7 +2081,7 @@ pub mod tests { assert_eq!(count.load(Ordering::Relaxed), 0); // We should get an error here. - let result = isolate.poll_unpin(cx); + let result = runtime.poll_unpin(cx); if let Poll::Ready(Ok(_)) = result { unreachable!(); } @@ -2148,7 +2145,7 @@ pub mod tests { let prepare_load_count = loader.prepare_load_count.clone(); let resolve_count = loader.resolve_count.clone(); let load_count = loader.load_count.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, @@ -2156,7 +2153,7 @@ pub mod tests { ); // Dynamically import mod_b - js_check(isolate.execute( + js_check(runtime.execute( "file:///dyn_import3.js", r#" (async () => { @@ -2174,14 +2171,14 @@ pub mod tests { )); // First poll runs `prepare_load` hook. - assert!(matches!(isolate.poll_unpin(cx), Poll::Pending)); + assert!(matches!(runtime.poll_unpin(cx), Poll::Pending)); assert_eq!(prepare_load_count.load(Ordering::Relaxed), 1); // Second poll actually loads modules into the isolate. - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); assert_eq!(resolve_count.load(Ordering::Relaxed), 4); assert_eq!(load_count.load(Ordering::Relaxed), 2); - assert!(matches!(isolate.poll_unpin(cx), Poll::Ready(Ok(_)))); + assert!(matches!(runtime.poll_unpin(cx), Poll::Ready(Ok(_)))); assert_eq!(resolve_count.load(Ordering::Relaxed), 4); assert_eq!(load_count.load(Ordering::Relaxed), 2); }) @@ -2193,13 +2190,13 @@ pub mod tests { run_in_task(|cx| { let loader = Rc::new(DynImportOkLoader::default()); let prepare_load_count = loader.prepare_load_count.clone(); - let mut isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, false, ); - js_check(isolate.execute( + js_check(runtime.execute( "file:///dyn_import3.js", r#" (async () => { @@ -2213,10 +2210,10 @@ pub mod tests { "#, )); // First poll runs `prepare_load` hook. - let _ = isolate.poll_unpin(cx); + let _ = runtime.poll_unpin(cx); assert_eq!(prepare_load_count.load(Ordering::Relaxed), 1); // Second poll triggers error - let _ = isolate.poll_unpin(cx); + let _ = runtime.poll_unpin(cx); }) } @@ -2249,7 +2246,7 @@ pub mod tests { } let loader = std::rc::Rc::new(ModsLoader::default()); - let mut runtime_isolate = CoreIsolate::new_with_loader( + let mut runtime = JsRuntime::new_with_loader( loader, BasicState::new(), StartupData::None, @@ -2260,12 +2257,12 @@ pub mod tests { let source_code = "Deno.core.print('hello\\n')".to_string(); let module_id = futures::executor::block_on( - runtime_isolate.load_module(&specifier, Some(source_code)), + runtime.load_module(&specifier, Some(source_code)), ) .unwrap(); - js_check(runtime_isolate.mod_evaluate(module_id)); + js_check(runtime.mod_evaluate(module_id)); - let _snapshot = runtime_isolate.snapshot(); + let _snapshot = runtime.snapshot(); } } diff --git a/op_crates/web/lib.rs b/op_crates/web/lib.rs index 674eddbb22..a1ad31a61b 100644 --- a/op_crates/web/lib.rs +++ b/op_crates/web/lib.rs @@ -1,10 +1,10 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. use deno_core::js_check; -use deno_core::CoreIsolate; +use deno_core::JsRuntime; use std::path::PathBuf; -pub fn init(isolate: &mut CoreIsolate) { +pub fn init(isolate: &mut JsRuntime) { let files = vec![ get_path("00_dom_exception.js"), get_path("01_event.js"), @@ -32,7 +32,7 @@ fn get_path(file_name: &str) -> PathBuf { mod tests { use deno_core::js_check; use deno_core::BasicState; - use deno_core::CoreIsolate; + use deno_core::JsRuntime; use deno_core::StartupData; use futures::future::lazy; use futures::future::FutureExt; @@ -46,9 +46,9 @@ mod tests { futures::executor::block_on(lazy(move |cx| f(cx))); } - fn setup() -> CoreIsolate { + fn setup() -> JsRuntime { let mut isolate = - CoreIsolate::new(BasicState::new(), StartupData::None, false); + JsRuntime::new(BasicState::new(), StartupData::None, false); crate::init(&mut isolate); isolate }