refactor: Split isolate and state using safe get_slot() (#5929)

22 files changed, 163 insertions, 133 deletions

diff --git a/cli/inspector.rs b/cli/inspector.rs
index b67bb89f5..94114addb 100644
--- a/cli/inspector.rs
+++ b/cli/inspector.rs
@@ -375,14 +375,10 @@ impl DenoInspector {
     isolate: &mut deno_core::CoreIsolate,
     host: SocketAddr,
   ) -> Box<Self> {
-    let deno_core::CoreIsolate {
-      v8_isolate,
-      global_context,
-      ..
-    } = isolate;
-
-    let v8_isolate = v8_isolate.as_mut().unwrap();
-    let mut hs = v8::HandleScope::new(v8_isolate);
+    let core_state_rc = deno_core::CoreIsolate::state(isolate);
+    let core_state = core_state_rc.borrow();
+
+    let mut hs = v8::HandleScope::new(isolate);
     let scope = hs.enter();
 
     let (new_websocket_tx, new_websocket_rx) =
@@ -420,7 +416,7 @@ impl DenoInspector {
     });
 
     // Tell the inspector about the global context.
-    let context = global_context.get(scope).unwrap();
+    let context = core_state.global_context.get(scope).unwrap();
     let context_name = v8::inspector::StringView::from(&b"global context"[..]);
     self_.context_created(context, Self::CONTEXT_GROUP_ID, context_name);
 
diff --git a/cli/main.rs b/cli/main.rs
index 1e90729d1..d947088d2 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -80,7 +80,9 @@ use crate::state::State;
 use crate::tsc::TargetLib;
 use crate::worker::MainWorker;
 use deno_core::v8_set_flags;
+use deno_core::CoreIsolate;
 use deno_core::ErrBox;
+use deno_core::EsIsolate;
 use deno_core::ModuleSpecifier;
 use flags::DenoSubcommand;
 use flags::Flags;
@@ -170,7 +172,9 @@ fn create_main_worker(
 
   {
     let (stdin, stdout, stderr) = get_stdio();
-    let mut t = worker.resource_table.borrow_mut();
+    let state_rc = CoreIsolate::state(&worker.isolate);
+    let state = state_rc.borrow();
+    let mut t = state.resource_table.borrow_mut();
     t.add("stdin", Box::new(stdin));
     t.add("stdout", Box::new(stdout));
     t.add("stderr", Box::new(stderr));
@@ -268,7 +272,10 @@ async fn print_file_info(
     );
   }
 
-  if let Some(deps) = worker.isolate.modules.deps(&module_specifier) {
+  let es_state_rc = EsIsolate::state(&worker.isolate);
+  let es_state = es_state_rc.borrow();
+
+  if let Some(deps) = es_state.modules.deps(&module_specifier) {
     println!("{}{}", colors::bold("deps:\n".to_string()), deps.name);
     if let Some(ref depsdeps) = deps.deps {
       for d in depsdeps {
diff --git a/cli/ops/dispatch_json.rs b/cli/ops/dispatch_json.rs
index 6125ea39b..c2c103f69 100644
--- a/cli/ops/dispatch_json.rs
+++ b/cli/ops/dispatch_json.rs
@@ -1,7 +1,7 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 use crate::op_error::OpError;
 use deno_core::Buf;
-use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::Op;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
@@ -46,12 +46,15 @@ struct AsyncArgs {
 
 pub fn json_op<D>(
   d: D,
-) -> impl Fn(&mut CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op
+) -> impl Fn(&mut CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
 where
-  D:
-    Fn(&mut CoreIsolate, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>,
+  D: Fn(
+    &mut CoreIsolateState,
+    Value,
+    Option<ZeroCopyBuf>,
+  ) -> Result<JsonOp, OpError>,
 {
-  move |isolate: &mut CoreIsolate,
+  move |isolate_state: &mut CoreIsolateState,
         control: &[u8],
         zero_copy: Option<ZeroCopyBuf>| {
     let async_args: AsyncArgs = match serde_json::from_slice(control) {
@@ -66,7 +69,7 @@ where
 
     let result = serde_json::from_slice(control)
       .map_err(OpError::from)
-      .and_then(|args| d(isolate, args, zero_copy));
+      .and_then(|args| d(isolate_state, args, zero_copy));
 
     // Convert to Op
     match result {
diff --git a/cli/ops/dispatch_minimal.rs b/cli/ops/dispatch_minimal.rs
index ac98ea589..3da8305a1 100644
--- a/cli/ops/dispatch_minimal.rs
+++ b/cli/ops/dispatch_minimal.rs
@@ -7,7 +7,7 @@
 use crate::op_error::OpError;
 use byteorder::{LittleEndian, WriteBytesExt};
 use deno_core::Buf;
-use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::Op;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
@@ -116,11 +116,11 @@ fn test_parse_min_record() {
 
 pub fn minimal_op<D>(
   d: D,
-) -> impl Fn(&mut CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op
+) -> impl Fn(&mut CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
 where
-  D: Fn(&mut CoreIsolate, bool, i32, Option<ZeroCopyBuf>) -> MinimalOp,
+  D: Fn(&mut CoreIsolateState, bool, i32, Option<ZeroCopyBuf>) -> MinimalOp,
 {
-  move |isolate: &mut CoreIsolate,
+  move |isolate_state: &mut CoreIsolateState,
         control: &[u8],
         zero_copy: Option<ZeroCopyBuf>| {
     let mut record = match parse_min_record(control) {
@@ -138,7 +138,7 @@ where
     };
     let is_sync = record.promise_id == 0;
     let rid = record.arg;
-    let min_op = d(isolate, is_sync, rid, zero_copy);
+    let min_op = d(isolate_state, is_sync, rid, zero_copy);
 
     match min_op {
       MinimalOp::Sync(sync_result) => Op::Sync(match sync_result {
diff --git a/cli/ops/fetch.rs b/cli/ops/fetch.rs
index 596c9a2fd..927bc5f64 100644
--- a/cli/ops/fetch.rs
+++ b/cli/ops/fetch.rs
@@ -5,6 +5,7 @@ use crate::http_util::{create_http_client, HttpBody};
 use crate::op_error::OpError;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
 use http::header::HeaderName;
@@ -24,7 +25,7 @@ struct FetchArgs {
 }
 
 pub fn op_fetch(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   data: Option<ZeroCopyBuf>,
@@ -67,7 +68,7 @@ pub fn op_fetch(
   }
   debug!("Before fetch {}", url);
 
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   let future = async move {
     let res = request.send().await?;
     debug!("Fetch response {}", url);
diff --git a/cli/ops/fs.rs b/cli/ops/fs.rs
index ce7045e21..204549d00 100644
--- a/cli/ops/fs.rs
+++ b/cli/ops/fs.rs
@@ -7,6 +7,7 @@ use crate::op_error::OpError;
 use crate::ops::dispatch_json::JsonResult;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
 use std::convert::From;
@@ -68,14 +69,14 @@ struct OpenOptions {
 }
 
 fn op_open(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   let args: OpenArgs = serde_json::from_value(args)?;
   let path = Path::new(&args.path).to_path_buf();
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let mut open_options = std::fs::OpenOptions::new();
 
@@ -151,7 +152,7 @@ struct SeekArgs {
 }
 
 fn op_seek(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -174,7 +175,7 @@ fn op_seek(
     }
   };
 
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   let is_sync = args.promise_id.is_none();
 
   if is_sync {
diff --git a/cli/ops/fs_events.rs b/cli/ops/fs_events.rs
index 56ed556f4..8e1831aa2 100644
--- a/cli/ops/fs_events.rs
+++ b/cli/ops/fs_events.rs
@@ -3,6 +3,7 @@ use super::dispatch_json::{Deserialize, JsonOp, Value};
 use crate::op_error::OpError;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ErrBox;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
@@ -62,7 +63,7 @@ impl From<NotifyEvent> for FsEvent {
 }
 
 pub fn op_fs_events_open(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -94,13 +95,13 @@ pub fn op_fs_events_open(
     watcher.watch(path, recursive_mode).map_err(ErrBox::from)?;
   }
   let resource = FsEventsResource { watcher, receiver };
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let rid = resource_table.add("fsEvents", Box::new(resource));
   Ok(JsonOp::Sync(json!(rid)))
 }
 
 pub fn op_fs_events_poll(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -110,7 +111,7 @@ pub fn op_fs_events_poll(
     rid: u32,
   }
   let PollArgs { rid } = serde_json::from_value(args)?;
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   let f = poll_fn(move |cx| {
     let mut resource_table = resource_table.borrow_mut();
     let watcher = resource_table
diff --git a/cli/ops/io.rs b/cli/ops/io.rs
index 705083e15..5769d74ed 100644
--- a/cli/ops/io.rs
+++ b/cli/ops/io.rs
@@ -3,6 +3,7 @@ use crate::http_util::HttpBody;
 use crate::op_error::OpError;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ResourceTable;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
@@ -206,7 +207,7 @@ impl DenoAsyncRead for StreamResource {
 }
 
 pub fn op_read(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   is_sync: bool,
   rid: i32,
@@ -216,7 +217,7 @@ pub fn op_read(
   if zero_copy.is_none() {
     return MinimalOp::Sync(Err(no_buffer_specified()));
   }
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let mut buf = zero_copy.unwrap();
 
@@ -330,7 +331,7 @@ impl DenoAsyncWrite for StreamResource {
 }
 
 pub fn op_write(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   is_sync: bool,
   rid: i32,
@@ -346,7 +347,7 @@ pub fn op_write(
   if is_sync {
     MinimalOp::Sync({
       // First we look up the rid in the resource table.
-      let mut resource_table = isolate.resource_table.borrow_mut();
+      let mut resource_table = isolate_state.resource_table.borrow_mut();
       std_file_resource(&mut resource_table, rid as u32, move |r| match r {
         Ok(std_file) => {
           use std::io::Write;
@@ -361,7 +362,7 @@ pub fn op_write(
       })
     })
   } else {
-    let resource_table = isolate.resource_table.clone();
+    let resource_table = isolate_state.resource_table.clone();
     MinimalOp::Async(
       async move {
         let nwritten = poll_fn(|cx| {
diff --git a/cli/ops/net.rs b/cli/ops/net.rs
index ae5bcb9bb..3d524d3f1 100644
--- a/cli/ops/net.rs
+++ b/cli/ops/net.rs
@@ -5,6 +5,7 @@ use crate::op_error::OpError;
 use crate::resolve_addr::resolve_addr;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ResourceTable;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
@@ -37,12 +38,12 @@ struct AcceptArgs {
 }
 
 fn accept_tcp(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   args: AcceptArgs,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   let rid = args.rid as u32;
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let op = async move {
     let accept_fut = poll_fn(|cx| {
@@ -97,16 +98,16 @@ fn accept_tcp(
 }
 
 fn op_accept(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   let args: AcceptArgs = serde_json::from_value(args)?;
   match args.transport.as_str() {
-    "tcp" => accept_tcp(isolate, args, zero_copy),
+    "tcp" => accept_tcp(isolate_state, args, zero_copy),
     #[cfg(unix)]
-    "unix" => net_unix::accept_unix(isolate, args.rid as u32, zero_copy),
+    "unix" => net_unix::accept_unix(isolate_state, args.rid as u32, zero_copy),
     _ => Err(OpError::other(format!(
       "Unsupported transport protocol {}",
       args.transport
@@ -121,7 +122,7 @@ struct ReceiveArgs {
 }
 
 fn receive_udp(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: ReceiveArgs,
   zero_copy: Option<ZeroCopyBuf>,
@@ -130,7 +131,7 @@ fn receive_udp(
 
   let rid = args.rid as u32;
 
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let op = async move {
     let receive_fut = poll_fn(|cx| {
@@ -158,7 +159,7 @@ fn receive_udp(
 }
 
 fn op_receive(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   zero_copy: Option<ZeroCopyBuf>,
@@ -166,10 +167,10 @@ fn op_receive(
   assert!(zero_copy.is_some());
   let args: ReceiveArgs = serde_json::from_value(args)?;
   match args.transport.as_str() {
-    "udp" => receive_udp(isolate, state, args, zero_copy),
+    "udp" => receive_udp(isolate_state, state, args, zero_copy),
     #[cfg(unix)]
     "unixpacket" => {
-      net_unix::receive_unix_packet(isolate, args.rid as u32, zero_copy)
+      net_unix::receive_unix_packet(isolate_state, args.rid as u32, zero_copy)
     }
     _ => Err(OpError::other(format!(
       "Unsupported transport protocol {}",
@@ -187,14 +188,14 @@ struct SendArgs {
 }
 
 fn op_send(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   assert!(zero_copy.is_some());
   let buf = zero_copy.unwrap();
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   match serde_json::from_value(args)? {
     SendArgs {
       rid,
@@ -256,12 +257,12 @@ struct ConnectArgs {
 }
 
 fn op_connect(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   match serde_json::from_value(args)? {
     ConnectArgs {
       transport,
@@ -342,7 +343,7 @@ struct ShutdownArgs {
 }
 
 fn op_shutdown(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -360,7 +361,7 @@ fn op_shutdown(
     _ => unimplemented!(),
   };
 
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let resource_holder = resource_table
     .get_mut::<StreamResourceHolder>(rid)
     .ok_or_else(OpError::bad_resource_id)?;
@@ -484,12 +485,12 @@ fn listen_udp(
 }
 
 fn op_listen(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   match serde_json::from_value(args)? {
     ListenArgs {
       transport,
diff --git a/cli/ops/net_unix.rs b/cli/ops/net_unix.rs
index 4b09c2fdb..a207eaba8 100644
--- a/cli/ops/net_unix.rs
+++ b/cli/ops/net_unix.rs
@@ -1,7 +1,7 @@
 use super::dispatch_json::{Deserialize, JsonOp};
 use super::io::{StreamResource, StreamResourceHolder};
 use crate::op_error::OpError;
-use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ResourceTable;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
@@ -27,11 +27,11 @@ pub struct UnixListenArgs {
 }
 
 pub fn accept_unix(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   rid: u32,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   {
     let _ = resource_table
       .borrow()
@@ -78,12 +78,12 @@ pub fn accept_unix(
 }
 
 pub fn receive_unix_packet(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   rid: u32,
   zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   let mut buf = zero_copy.unwrap();
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let op = async move {
     let mut resource_table_ = resource_table.borrow_mut();
diff --git a/cli/ops/plugin.rs b/cli/ops/plugin.rs
index f55c91df8..fde34ea58 100644
--- a/cli/ops/plugin.rs
+++ b/cli/ops/plugin.rs
@@ -7,6 +7,7 @@ use crate::ops::json_op;
 use crate::state::State;
 use deno_core::plugin_api;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::Op;
 use deno_core::OpAsyncFuture;
 use deno_core::OpId;
@@ -33,7 +34,7 @@ struct OpenPluginArgs {
 }
 
 pub fn op_open_plugin(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -50,7 +51,7 @@ pub fn op_open_plugin(
     .map_err(OpError::from)?;
   let plugin_resource = PluginResource::new(&plugin_lib);
 
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let rid = resource_table.add("plugin", Box::new(plugin_resource));
   let plugin_resource = resource_table.get::<PluginResource>(rid).unwrap();
 
@@ -62,7 +63,7 @@ pub fn op_open_plugin(
   .unwrap();
   drop(resource_table);
 
-  let mut interface = PluginInterface::new(isolate, &plugin_lib);
+  let mut interface = PluginInterface::new(isolate_state, &plugin_lib);
   deno_plugin_init(&mut interface);
 
   Ok(JsonOp::Sync(json!(rid)))
@@ -79,14 +80,17 @@ impl PluginResource {
 }
 
 struct PluginInterface<'a> {
-  isolate: &'a mut CoreIsolate,
+  isolate_state: &'a mut CoreIsolateState,
   plugin_lib: &'a Rc<Library>,
 }
 
 impl<'a> PluginInterface<'a> {
-  fn new(isolate: &'a mut CoreIsolate, plugin_lib: &'a Rc<Library>) -> Self {
+  fn new(
+    isolate_state: &'a mut CoreIsolateState,
+    plugin_lib: &'a Rc<Library>,
+  ) -> Self {
     Self {
-      isolate,
+      isolate_state,
       plugin_lib,
     }
   }
@@ -104,10 +108,10 @@ impl<'a> plugin_api::Interface for PluginInterface<'a> {
     dispatch_op_fn: plugin_api::DispatchOpFn,
   ) -> OpId {
     let plugin_lib = self.plugin_lib.clone();
-    self.isolate.op_registry.register(
+    self.isolate_state.op_registry.register(
       name,
-      move |isolate, control, zero_copy| {
-        let mut interface = PluginInterface::new(isolate, &plugin_lib);
+      move |isolate_state, control, zero_copy| {
+        let mut interface = PluginInterface::new(isolate_state, &plugin_lib);
         let op = dispatch_op_fn(&mut interface, control, zero_copy);
         match op {
           sync_op @ Op::Sync(..) => sync_op,
diff --git a/cli/ops/process.rs b/cli/ops/process.rs
index 125aa136b..eefabd49f 100644
--- a/cli/ops/process.rs
+++ b/cli/ops/process.rs
@@ -5,6 +5,7 @@ use crate::op_error::OpError;
 use crate::signal::kill;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ResourceTable;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
@@ -60,7 +61,7 @@ struct ChildResource {
 }
 
 fn op_run(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -68,7 +69,7 @@ fn op_run(
   let run_args: RunArgs = serde_json::from_value(args)?;
 
   state.check_run()?;
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
 
   let args = run_args.cmd;
   let env = run_args.env;
@@ -174,7 +175,7 @@ struct RunStatusArgs {
 }
 
 fn op_run_status(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -183,7 +184,7 @@ fn op_run_status(
   let rid = args.rid as u32;
 
   state.check_run()?;
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let future = async move {
     let run_status = poll_fn(|cx| {
diff --git a/cli/ops/repl.rs b/cli/ops/repl.rs
index 7dc0d0263..40bc9653e 100644
--- a/cli/ops/repl.rs
+++ b/cli/ops/repl.rs
@@ -5,6 +5,7 @@ use crate::repl;
 use crate::repl::Repl;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -23,7 +24,7 @@ struct ReplStartArgs {
 }
 
 fn op_repl_start(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -34,7 +35,7 @@ fn op_repl_start(
     repl::history_path(&state.borrow().global_state.dir, &args.history_file);
   let repl = repl::Repl::new(history_path);
   let resource = ReplResource(Arc::new(Mutex::new(repl)));
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let rid = resource_table.add("repl", Box::new(resource));
   Ok(JsonOp::Sync(json!(rid)))
 }
@@ -46,7 +47,7 @@ struct ReplReadlineArgs {
 }
 
 fn op_repl_readline(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -55,7 +56,7 @@ fn op_repl_readline(
   let rid = args.rid as u32;
   let prompt = args.prompt;
   debug!("op_repl_readline {} {}", rid, prompt);
-  let resource_table = isolate.resource_table.borrow();
+  let resource_table = isolate_state.resource_table.borrow();
   let resource = resource_table
     .get::<ReplResource>(rid)
     .ok_or_else(OpError::bad_resource_id)?;
diff --git a/cli/ops/resources.rs b/cli/ops/resources.rs
index 1aa8dd4dc..be09598a9 100644
--- a/cli/ops/resources.rs
+++ b/cli/ops/resources.rs
@@ -3,6 +3,7 @@ use super::dispatch_json::{Deserialize, JsonOp, Value};
 use crate::op_error::OpError;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 
 pub fn init(i: &mut CoreIsolate, s: &State) {
@@ -11,18 +12,18 @@ pub fn init(i: &mut CoreIsolate, s: &State) {
 }
 
 fn op_resources(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
-  let serialized_resources = isolate.resource_table.borrow().entries();
+  let serialized_resources = isolate_state.resource_table.borrow().entries();
   Ok(JsonOp::Sync(json!(serialized_resources)))
 }
 
 /// op_close removes a resource from the resource table.
 fn op_close(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -32,7 +33,7 @@ fn op_close(
     rid: i32,
   }
   let args: CloseArgs = serde_json::from_value(args)?;
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   resource_table
     .close(args.rid as u32)
     .ok_or_else(OpError::bad_resource_id)?;
diff --git a/cli/ops/signal.rs b/cli/ops/signal.rs
index ef652bc67..7a0c29ab0 100644
--- a/cli/ops/signal.rs
+++ b/cli/ops/signal.rs
@@ -3,6 +3,7 @@ use super::dispatch_json::{JsonOp, Value};
 use crate::op_error::OpError;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 
 #[cfg(unix)]
@@ -39,14 +40,14 @@ struct SignalArgs {
 
 #[cfg(unix)]
 fn op_signal_bind(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.signal");
   let args: BindSignalArgs = serde_json::from_value(args)?;
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let rid = resource_table.add(
     "signal",
     Box::new(SignalStreamResource(
@@ -61,7 +62,7 @@ fn op_signal_bind(
 
 #[cfg(unix)]
 fn op_signal_poll(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -69,7 +70,7 @@ fn op_signal_poll(
   state.check_unstable("Deno.signal");
   let args: SignalArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let future = poll_fn(move |cx| {
     let mut resource_table = resource_table.borrow_mut();
@@ -88,7 +89,7 @@ fn op_signal_poll(
 
 #[cfg(unix)]
 pub fn op_signal_unbind(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -96,7 +97,7 @@ pub fn op_signal_unbind(
   state.check_unstable("Deno.signal");
   let args: SignalArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let resource = resource_table.get::<SignalStreamResource>(rid);
   if let Some(signal) = resource {
     if let Some(waker) = &signal.1 {
@@ -113,7 +114,7 @@ pub fn op_signal_unbind(
 
 #[cfg(not(unix))]
 pub fn op_signal_bind(
-  _isolate: &mut CoreIsolate,
+  _isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -123,7 +124,7 @@ pub fn op_signal_bind(
 
 #[cfg(not(unix))]
 fn op_signal_unbind(
-  _isolate: &mut CoreIsolate,
+  _isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -133,7 +134,7 @@ fn op_signal_unbind(
 
 #[cfg(not(unix))]
 fn op_signal_poll(
-  _isolate: &mut CoreIsolate,
+  _isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
diff --git a/cli/ops/tls.rs b/cli/ops/tls.rs
index 5cbdff300..d4252d9ca 100644
--- a/cli/ops/tls.rs
+++ b/cli/ops/tls.rs
@@ -5,6 +5,7 @@ use crate::op_error::OpError;
 use crate::resolve_addr::resolve_addr;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
 use futures::future::FutureExt;
@@ -53,7 +54,7 @@ struct StartTLSArgs {
 }
 
 pub fn op_start_tls(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -62,7 +63,7 @@ pub fn op_start_tls(
   let args: StartTLSArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
   let cert_file = args.cert_file.clone();
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
 
   let mut domain = args.hostname;
   if domain.is_empty() {
@@ -132,14 +133,14 @@ pub fn op_start_tls(
 }
 
 pub fn op_connect_tls(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   let args: ConnectTLSArgs = serde_json::from_value(args)?;
   let cert_file = args.cert_file.clone();
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   state.check_net(&args.hostname, args.port)?;
   if let Some(path) = cert_file.clone() {
     state.check_read(Path::new(&path))?;
@@ -306,7 +307,7 @@ struct ListenTlsArgs {
 }
 
 fn op_listen_tls(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -337,7 +338,7 @@ fn op_listen_tls(
     local_addr,
   };
 
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let rid = resource_table.add("tlsListener", Box::new(tls_listener_resource));
 
   Ok(JsonOp::Sync(json!({
@@ -356,14 +357,14 @@ struct AcceptTlsArgs {
 }
 
 fn op_accept_tls(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
 ) -> Result<JsonOp, OpError> {
   let args: AcceptTlsArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let resource_table = isolate.resource_table.clone();
+  let resource_table = isolate_state.resource_table.clone();
   let op = async move {
     let accept_fut = poll_fn(|cx| {
       let mut resource_table = resource_table.borrow_mut();
diff --git a/cli/ops/tty.rs b/cli/ops/tty.rs
index cf7f62ed8..00a5870e9 100644
--- a/cli/ops/tty.rs
+++ b/cli/ops/tty.rs
@@ -4,6 +4,7 @@ use super::io::{StreamResource, StreamResourceHolder};
 use crate::op_error::OpError;
 use crate::state::State;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 #[cfg(unix)]
 use nix::sys::termios;
@@ -46,7 +47,7 @@ struct SetRawArgs {
 }
 
 pub fn op_set_raw(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -67,7 +68,7 @@ pub fn op_set_raw(
     use winapi::shared::minwindef::FALSE;
     use winapi::um::{consoleapi, handleapi};
 
-    let mut resource_table = isolate.resource_table.borrow_mut();
+    let mut resource_table = isolate_state.resource_table.borrow_mut();
     let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid);
     if resource_holder.is_none() {
       return Err(OpError::bad_resource_id());
@@ -133,7 +134,7 @@ pub fn op_set_raw(
   {
     use std::os::unix::io::AsRawFd;
 
-    let mut resource_table = isolate.resource_table.borrow_mut();
+    let mut resource_table = isolate_state.resource_table.borrow_mut();
     let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid);
     if resource_holder.is_none() {
       return Err(OpError::bad_resource_id());
@@ -215,7 +216,7 @@ struct IsattyArgs {
 }
 
 pub fn op_isatty(
-  isolate: &mut CoreIsolate,
+  isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
   _zero_copy: Option<ZeroCopyBuf>,
@@ -223,7 +224,7 @@ pub fn op_isatty(
   let args: IsattyArgs = serde_json::from_value(args)?;
   let rid = args.rid;
 
-  let mut resource_table = isolate.resource_table.borrow_mut();
+  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let isatty: bool =
     std_file_resource(&mut resource_table, rid as u32, move |r| match r {
       Ok(std_file) => {
diff --git a/cli/ops/web_worker.rs b/cli/ops/web_worker.rs
index e95eb8fe1..d2d202e91 100644
--- a/cli/ops/web_worker.rs
+++ b/cli/ops/web_worker.rs
@@ -6,6 +6,7 @@ use crate::state::State;
 use crate::web_worker::WebWorkerHandle;
 use crate::worker::WorkerEvent;
 use deno_core::CoreIsolate;
+use deno_core::CoreIsolateState;
 use deno_core::ZeroCopyBuf;
 use futures::channel::mpsc;
 use std::convert::From;
@@ -13,7 +14,11 @@ use std::convert::From;
 pub fn web_worker_op<D>(
   sender: mpsc::Sender<WorkerEvent>,
   dispatcher: D,
-) -> impl Fn(&mut CoreIsolate, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>
+) -> impl Fn(
+  &mut CoreIsolateState,
+  Value,
+  Option<ZeroCopyBuf>,
+) -> Result<JsonOp, OpError>
 where
   D: Fn(
     &mpsc::Sender<WorkerEvent>,
@@ -21,7 +26,7 @@ where
     Option<ZeroCopyBuf>,
   ) -> Result<JsonOp, OpError>,
 {
-  move |_isolate: &mut CoreIsolate,
+  move |_isolate_state: &mut CoreIsolateState,
         args: Value,
         zero_copy: Option<ZeroCopyBuf>|
         -> Result<JsonOp, OpError> { dispatcher(&sender, args, zero_copy) }
@@ -31,7 +36,11 @@ pub fn web_worker_op2<D>(
   handle: WebWorkerHandle,
   sender: mpsc::Sender<WorkerEvent>,
   dispatcher: D,
-) -> impl Fn(&mut CoreIsolate, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>
+) -> impl Fn(
+  &mut CoreIsolateState,
+  Value,
+  Option<ZeroCopyBuf>,
+) -> Result<JsonOp, OpError>
 where
   D: Fn(
     WebWorkerHandle,
@@ -40,7 +49,7 @@ where
     Option<ZeroCopyBuf>,
   ) -> Result<JsonOp, OpError>,
 {
-  move |_isolate: &mut CoreIsolate,
+  move |_isolate_state: &mut CoreIsolateState,
         args: Value,
         zero_copy: Option<ZeroCopyBuf>|
         -> Result<JsonOp, OpError> {
diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs
index d1b4bb80f..ad3752ffa 100644
--- a/cli/ops/worker_host.rs
+++ b/cli/ops/worker_host.rs
@@ -54,7 +54,9 @@ fn create_web_worker(
   );
 
   if has_deno_namespace {
-    let mut resource_table = worker.resource_table.borrow_mut();
+    let state_rc = CoreIsolate::state(&worker.isolate);
+    let state = state_rc.borrow();
+    let mut resource_table = state.resource_table.borrow_mut();
     let (stdin, stdout, stderr) = get_stdio();
     resource_table.add("stdin", Box::new(stdin));
     resource_table.add("stdout", Box::new(stdout));
diff --git a/cli/state.rs b/cli/state.rs
index a15d113c8..77a268fab 100644
--- a/cli/state.rs
+++ b/cli/state.rs
@@ -65,7 +65,7 @@ impl State {
   pub fn stateful_json_op<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
   where
     D: Fn(&State, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>,
   {
@@ -76,10 +76,10 @@ impl State {
   pub fn stateful_json_op2<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
   where
     D: Fn(
-      &mut deno_core::CoreIsolate,
+      &mut deno_core::CoreIsolateState,
       &State,
       Value,
       Option<ZeroCopyBuf>,
@@ -95,13 +95,13 @@ impl State {
   pub fn core_op<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
   where
-    D: Fn(&mut deno_core::CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op,
+    D: Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op,
   {
     let state = self.clone();
 
-    move |isolate: &mut deno_core::CoreIsolate,
+    move |isolate_state: &mut deno_core::CoreIsolateState,
           control: &[u8],
           zero_copy: Option<ZeroCopyBuf>|
           -> Op {
@@ -109,7 +109,7 @@ impl State {
       let bytes_sent_zero_copy =
         zero_copy.as_ref().map(|b| b.len()).unwrap_or(0) as u64;
 
-      let op = dispatcher(isolate, control, zero_copy);
+      let op = dispatcher(isolate_state, control, zero_copy);
 
       match op {
         Op::Sync(buf) => {
@@ -155,10 +155,10 @@ impl State {
   pub fn stateful_minimal_op2<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolate, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
   where
     D: Fn(
-      &mut deno_core::CoreIsolate,
+      &mut deno_core::CoreIsolateState,
       &State,
       bool,
       i32,
@@ -167,12 +167,12 @@ impl State {
   {
     let state = self.clone();
     self.core_op(crate::ops::minimal_op(
-      move |isolate: &mut deno_core::CoreIsolate,
+      move |isolate_state: &mut deno_core::CoreIsolateState,
             is_sync: bool,
             rid: i32,
             zero_copy: Option<ZeroCopyBuf>|
             -> MinimalOp {
-        dispatcher(isolate, &state, is_sync, rid, zero_copy)
+        dispatcher(isolate_state, &state, is_sync, rid, zero_copy)
       },
     ))
   }
@@ -186,7 +186,7 @@ impl State {
     &self,
     dispatcher: D,
   ) -> impl Fn(
-    &mut deno_core::CoreIsolate,
+    &mut deno_core::CoreIsolateState,
     Value,
     Option<ZeroCopyBuf>,
   ) -> Result<JsonOp, OpError>
@@ -194,7 +194,7 @@ impl State {
     D: Fn(&State, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>,
   {
     let state = self.clone();
-    move |_isolate: &mut deno_core::CoreIsolate,
+    move |_isolate_state: &mut deno_core::CoreIsolateState,
           args: Value,
           zero_copy: Option<ZeroCopyBuf>|
           -> Result<JsonOp, OpError> { dispatcher(&state, args, zero_copy) }
@@ -204,24 +204,24 @@ impl State {
     &self,
     dispatcher: D,
   ) -> impl Fn(
-    &mut deno_core::CoreIsolate,
+    &mut deno_core::CoreIsolateState,
     Value,
     Option<ZeroCopyBuf>,
   ) -> Result<JsonOp, OpError>
   where
     D: Fn(
-      &mut deno_core::CoreIsolate,
+      &mut deno_core::CoreIsolateState,
       &State,
       Value,
       Option<ZeroCopyBuf>,
     ) -> Result<JsonOp, OpError>,
   {
     let state = self.clone();
-    move |isolate: &mut deno_core::CoreIsolate,
+    move |isolate_state: &mut deno_core::CoreIsolateState,
           args: Value,
           zero_copy: Option<ZeroCopyBuf>|
           -> Result<JsonOp, OpError> {
-      dispatcher(isolate, &state, args, zero_copy)
+      dispatcher(isolate_state, &state, args, zero_copy)
     }
   }
 
diff --git a/cli/web_worker.rs b/cli/web_worker.rs
index 46f03da36..e060a157d 100644
--- a/cli/web_worker.rs
+++ b/cli/web_worker.rs
@@ -91,12 +91,7 @@ impl WebWorker {
     let mut worker = Worker::new(name, startup_data, state_);
 
     let terminated = Arc::new(AtomicBool::new(false));
-    let isolate_handle = worker
-      .isolate
-      .v8_isolate
-      .as_mut()
-      .unwrap()
-      .thread_safe_handle();
+    let isolate_handle = worker.isolate.thread_safe_handle();
     let (terminate_tx, terminate_rx) = mpsc::channel::<()>(1);
 
     let handle = WebWorkerHandle {
diff --git a/cli/worker.rs b/cli/worker.rs
index 3e338d933..524091422 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -4,6 +4,7 @@ use crate::inspector::DenoInspector;
 use crate::ops;
 use crate::state::State;
 use deno_core::Buf;
+use deno_core::CoreIsolate;
 use deno_core::ErrBox;
 use deno_core::ModuleId;
 use deno_core::ModuleSpecifier;
@@ -86,7 +87,7 @@ fn create_channels() -> (WorkerChannelsInternal, WorkerHandle) {
 ///  - `WebWorker`
 pub struct Worker {
   pub name: String,
-  pub isolate: Box<deno_core::EsIsolate>,
+  pub isolate: deno_core::EsIsolate,
   pub inspector: Option<Box<DenoInspector>>,
   pub state: State,
   pub waker: AtomicWaker,
@@ -101,7 +102,9 @@ impl Worker {
 
     {
       let global_state = state.borrow().global_state.clone();
-      isolate.set_js_error_create_fn(move |core_js_error| {
+      let core_state_rc = CoreIsolate::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)
       });
     }