3 files changed, 62 insertions, 3 deletions

diff --git a/core/examples/disable_ops.rs b/core/examples/disable_ops.rs
index 7421961d4..c1473b193 100644
--- a/core/examples/disable_ops.rs
+++ b/core/examples/disable_ops.rs
@@ -9,7 +9,7 @@ use deno_core::RuntimeOptions;
 fn main() {
   let my_ext = Extension::builder()
     .middleware(|op| match op.name {
-      "op_print" => deno_core::op_void_sync::decl(),
+      "op_print" => op.disable(),
       _ => op,
     })
     .build();
diff --git a/core/extensions.rs b/core/extensions.rs
index ae4537af4..10de66dd2 100644
--- a/core/extensions.rs
+++ b/core/extensions.rs
@@ -14,6 +14,18 @@ pub type OpEventLoopFn = dyn Fn(&mut OpState, &mut Context) -> bool;
 pub struct OpDecl {
   pub name: &'static str,
   pub v8_fn_ptr: OpFnRef,
+  pub enabled: bool,
+  pub is_async: bool, // TODO(@AaronO): enum sync/async/fast ?
+}
+
+impl OpDecl {
+  pub fn enabled(self, enabled: bool) -> Self {
+    Self { enabled, ..self }
+  }
+
+  pub fn disable(self) -> Self {
+    self.enabled(false)
+  }
 }
 
 #[derive(Default)]
@@ -24,6 +36,7 @@ pub struct Extension {
   middleware_fn: Option<Box<OpMiddlewareFn>>,
   event_loop_middleware: Option<Box<OpEventLoopFn>>,
   initialized: bool,
+  enabled: bool,
 }
 
 // Note: this used to be a trait, but we "downgraded" it to a single concrete type
@@ -50,7 +63,11 @@ impl Extension {
     }
     self.initialized = true;
 
-    self.ops.take()
+    let mut ops = self.ops.take()?;
+    for op in ops.iter_mut() {
+      op.enabled = self.enabled && op.enabled;
+    }
+    Some(ops)
   }
 
   /// Allows setting up the initial op-state of an isolate at startup.
@@ -81,6 +98,14 @@ impl Extension {
       .map(|f| f(op_state, cx))
       .unwrap_or(false)
   }
+
+  pub fn enabled(self, enabled: bool) -> Self {
+    Self { enabled, ..self }
+  }
+
+  pub fn disable(self) -> Self {
+    self.enabled(false)
+  }
 }
 
 // Provides a convenient builder pattern to declare Extensions
@@ -138,6 +163,7 @@ impl ExtensionBuilder {
       middleware_fn: self.middleware.take(),
       event_loop_middleware: self.event_loop_middleware.take(),
       initialized: false,
+      enabled: true,
     }
   }
 }
diff --git a/core/runtime.rs b/core/runtime.rs
index 8c781bf24..c2c2f4b92 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -14,6 +14,8 @@ use crate::modules::ModuleLoadId;
 use crate::modules::ModuleLoader;
 use crate::modules::ModuleMap;
 use crate::modules::NoopModuleLoader;
+use crate::op_void_async;
+use crate::op_void_sync;
 use crate::ops::*;
 use crate::Extension;
 use crate::OpMiddlewareFn;
@@ -472,7 +474,7 @@ impl JsRuntime {
     // macroware wraps an opfn in all the middleware
     let macroware = move |d| middleware.iter().fold(d, |d, m| m(d));
 
-    // Flatten ops & apply middlware
+    // Flatten ops, apply middlware & override disabled ops
     extensions
       .iter_mut()
       .filter_map(|e| e.init_ops())
@@ -481,6 +483,16 @@ impl JsRuntime {
         name: d.name,
         ..macroware(d)
       })
+      .map(|op| match op.enabled {
+        true => op,
+        false => OpDecl {
+          v8_fn_ptr: match op.is_async {
+            true => op_void_async::v8_fn_ptr(),
+            false => op_void_sync::v8_fn_ptr(),
+          },
+          ..op
+        },
+      })
       .collect()
   }
 
@@ -3019,4 +3031,25 @@ assertEquals(1, notify_return_value);
     let scope = &mut runtime.handle_scope();
     assert_eq!(r.open(scope).integer_value(scope), Some(10));
   }
+
+  #[test]
+  fn test_op_disabled() {
+    #[op]
+    fn op_foo() -> Result<i64, anyhow::Error> {
+      Ok(42)
+    }
+
+    let ext = Extension::builder()
+      .ops(vec![op_foo::decl().disable()])
+      .build();
+    let mut runtime = JsRuntime::new(RuntimeOptions {
+      extensions: vec![ext],
+      ..Default::default()
+    });
+    let r = runtime
+      .execute_script("test.js", "Deno.core.opSync('op_foo')")
+      .unwrap();
+    let scope = &mut runtime.handle_scope();
+    assert!(r.open(scope).is_undefined());
+  }
 }