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

1 files changed, 25 insertions, 26 deletions

diff --git a/core/modules.rs b/core/modules.rs
index 7b1e0c5a3..2b914fd1e 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;