Use gotham-like state for ops (#7385)

Provides a concrete state type that can be dynamically added. This is necessary for op crates.
* renames BasicState to OpState
* async ops take `Rc<RefCell<OpState>>`
* sync ops take `&mut OpState`
* removes `OpRegistry`, `OpRouter` traits
* `get_error_class_fn` moved to OpState
* ResourceTable moved to OpState

1 files changed, 39 insertions, 37 deletions

diff --git a/cli/worker.rs b/cli/worker.rs
index 9ac3bbead..baab81ff6 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -91,7 +91,7 @@ fn create_channels() -> (WorkerChannelsInternal, WorkerHandle) {
 ///  - `WebWorker`
 pub struct Worker {
   pub name: String,
-  pub isolate: deno_core::JsRuntime,
+  pub isolate: JsRuntime,
   pub inspector: Option<Box<DenoInspector>>,
   pub state: Rc<State>,
   pub waker: AtomicWaker,
@@ -105,22 +105,22 @@ impl Worker {
     startup_data: StartupData,
     state: &Rc<State>,
   ) -> Self {
-    let mut isolate = deno_core::JsRuntime::new_with_loader(
-      state.clone(),
-      state.clone(),
-      startup_data,
-      false,
-    );
-
+    let mut isolate =
+      JsRuntime::new_with_loader(state.clone(), startup_data, false);
     {
       let global_state = state.global_state.clone();
-      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| {
+      let js_runtime_state = JsRuntime::state(&isolate);
+      let mut js_runtime_state = js_runtime_state.borrow_mut();
+      js_runtime_state.set_js_error_create_fn(move |core_js_error| {
         JsError::create(core_js_error, &global_state.ts_compiler)
       });
     }
-
+    {
+      let op_state = isolate.op_state();
+      let mut op_state = op_state.borrow_mut();
+      op_state.get_error_class_fn = &crate::errors::get_error_class_name;
+      op_state.put(state.clone());
+    }
     let inspector = {
       let global_state = &state.global_state;
       global_state
@@ -235,7 +235,7 @@ impl Future for Worker {
 }
 
 impl Deref for Worker {
-  type Target = deno_core::JsRuntime;
+  type Target = JsRuntime;
   fn deref(&self) -> &Self::Target {
     &self.isolate
   }
@@ -258,30 +258,30 @@ pub struct MainWorker(Worker);
 impl MainWorker {
   // TODO(ry) combine MainWorker::new and MainWorker::create.
   fn new(name: String, startup_data: StartupData, state: &Rc<State>) -> Self {
-    let worker = Worker::new(name, startup_data, state);
+    let mut worker = Worker::new(name, startup_data, state);
     {
-      ops::runtime::init(&state);
-      ops::runtime_compiler::init(&state);
-      ops::errors::init(&state);
-      ops::fetch::init(&state);
-      ops::websocket::init(&state);
-      ops::fs::init(&state);
-      ops::fs_events::init(&state);
-      ops::idna::init(&state);
-      ops::io::init(&state);
-      ops::plugin::init(&state);
-      ops::net::init(&state);
-      ops::tls::init(&state);
-      ops::os::init(&state);
-      ops::permissions::init(&state);
-      ops::process::init(&state);
-      ops::random::init(&state);
-      ops::repl::init(&state);
-      ops::resources::init(&state);
-      ops::signal::init(&state);
-      ops::timers::init(&state);
-      ops::tty::init(&state);
-      ops::worker_host::init(&state);
+      ops::runtime::init(&mut worker);
+      ops::runtime_compiler::init(&mut worker);
+      ops::errors::init(&mut worker);
+      ops::fetch::init(&mut worker);
+      ops::websocket::init(&mut worker);
+      ops::fs::init(&mut worker);
+      ops::fs_events::init(&mut worker);
+      ops::idna::init(&mut worker);
+      ops::io::init(&mut worker);
+      ops::plugin::init(&mut worker);
+      ops::net::init(&mut worker);
+      ops::tls::init(&mut worker);
+      ops::os::init(&mut worker);
+      ops::permissions::init(&mut worker);
+      ops::process::init(&mut worker);
+      ops::random::init(&mut worker);
+      ops::repl::init(&mut worker);
+      ops::resources::init(&mut worker);
+      ops::signal::init(&mut worker);
+      ops::timers::init(&mut worker);
+      ops::tty::init(&mut worker);
+      ops::worker_host::init(&mut worker);
     }
     Self(worker)
   }
@@ -303,7 +303,9 @@ impl MainWorker {
       &state,
     );
     {
-      let mut t = state.resource_table.borrow_mut();
+      let op_state = worker.op_state();
+      let mut op_state = op_state.borrow_mut();
+      let t = &mut op_state.resource_table;
       let (stdin, stdout, stderr) = get_stdio();
       if let Some(stream) = stdin {
         t.add("stdin", Box::new(stream));