Revert "perf(core): preserve ops between snapshots (#18080)" (#18267)

This reverts commit 4b6305f4f2.

cli/build.rs

@@ -5,6 +5,7 @@ use std::path::PathBuf;
 
 use deno_core::snapshot_util::*;
 use deno_core::Extension;
+use deno_core::ExtensionBuilder;
 use deno_core::ExtensionFileSource;
 use deno_core::ExtensionFileSourceCode;
 use deno_runtime::deno_cache::SqliteBackedCache;
@@ -317,7 +318,7 @@ deno_core::extension!(
     dir "js",
     "40_testing.js"
   ],
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
+  customizer = |ext: &mut ExtensionBuilder| {
     ext.esm(vec![ExtensionFileSource {
       specifier: "ext:cli/runtime/js/99_main.js",
       code: ExtensionFileSourceCode::LoadedFromFsDuringSnapshot(

cli/lsp/tsc.rs

@@ -2843,9 +2843,6 @@ deno_core::extension!(deno_tsc,
       options.performance,
     ));
   },
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 /// Instruct a language server runtime to start the language server and provide

cli/ops/bench.rs

@@ -38,9 +38,6 @@ deno_core::extension!(deno_bench,
     state.put(options.sender);
     state.put(options.filter);
   },
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[derive(Clone)]

cli/ops/mod.rs

@@ -21,9 +21,6 @@ deno_core::extension!(deno_cli,
   state = |state, options| {
     state.put(options.ps);
   },
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[op]

cli/ops/testing.rs

@@ -44,9 +44,6 @@ deno_core::extension!(deno_test,
     state.put(options.fail_fast_tracker);
     state.put(options.filter);
   },
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[derive(Clone)]

cli/tsc/mod.rs

@@ -114,13 +114,7 @@ pub fn get_types_declaration_file_text(unstable: bool) -> String {
 }
 
 fn get_asset_texts_from_new_runtime() -> Result<Vec<AssetText>, AnyError> {
-  deno_core::extension!(
+  deno_core::extension!(deno_cli_tsc, ops_fn = deno_ops,);
-    deno_cli_tsc,
-    ops_fn = deno_ops,
-    customizer = |ext: &mut deno_core::ExtensionBuilder| {
-      ext.force_op_registration();
-    },
-  );
 
   // the assets are stored within the typescript isolate, so take them out of there
   let mut runtime = JsRuntime::new(RuntimeOptions {
@@ -852,9 +846,6 @@ pub fn exec(request: Request) -> Result<Response, AnyError> {
           .unwrap(),
       ));
     },
-    customizer = |ext: &mut deno_core::ExtensionBuilder| {
-      ext.force_op_registration();
-    },
   );
 
   let startup_source = "globalThis.startup({ legacyFlag: false })";

core/bindings.rs

@@ -19,22 +19,24 @@ use crate::snapshot_util::SnapshotOptions;
 use crate::JsRealm;
 use crate::JsRuntime;
 
-pub(crate) fn external_references(ops: &[OpCtx]) -> v8::ExternalReferences {
+pub(crate) fn external_references(
-  // Overallocate a bit, it's better than having to resize the vector.
+  ops: &[OpCtx],
-  let mut references = Vec::with_capacity(4 + ops.len() * 4);
+  snapshot_options: SnapshotOptions,
-
+) -> v8::ExternalReferences {
-  references.push(v8::ExternalReference {
+  let mut references = vec![
-    function: call_console.map_fn_to(),
+    v8::ExternalReference {
-  });
+      function: call_console.map_fn_to(),
-  references.push(v8::ExternalReference {
+    },
-    function: import_meta_resolve.map_fn_to(),
+    v8::ExternalReference {
-  });
+      function: import_meta_resolve.map_fn_to(),
-  references.push(v8::ExternalReference {
+    },
-    function: catch_dynamic_import_promise_error.map_fn_to(),
+    v8::ExternalReference {
-  });
+      function: catch_dynamic_import_promise_error.map_fn_to(),
-  references.push(v8::ExternalReference {
+    },
-    function: empty_fn.map_fn_to(),
+    v8::ExternalReference {
-  });
+      function: empty_fn.map_fn_to(),
+    },
+  ];
 
   for ctx in ops {
     let ctx_ptr = ctx as *const OpCtx as _;
@@ -42,13 +44,12 @@ pub(crate) fn external_references(ops: &[OpCtx]) -> v8::ExternalReferences {
     references.push(v8::ExternalReference {
       function: ctx.decl.v8_fn_ptr,
     });
-    if let Some(fast_fn) = &ctx.decl.fast_fn {
+    if !snapshot_options.will_snapshot() {
-      references.push(v8::ExternalReference {
+      if let Some(fast_fn) = &ctx.decl.fast_fn {
-        pointer: fast_fn.function() as _,
+        references.push(v8::ExternalReference {
-      });
+          pointer: fast_fn.function() as _,
-      references.push(v8::ExternalReference {
+        });
-        pointer: ctx.fast_fn_c_info.unwrap().as_ptr() as _,
+      }
-      });
     }
   }
 
@@ -113,9 +114,9 @@ pub(crate) fn initialize_context<'s>(
     v8::String::new_external_onebyte_static(scope, b"core").unwrap();
   let ops_str = v8::String::new_external_onebyte_static(scope, b"ops").unwrap();
 
-  let ops_obj = if snapshot_options.loaded() {
+  // Snapshot already registered `Deno.core.ops` but
-    // Snapshot already registered `Deno.core.ops` but
+  // extensions may provide ops that aren't part of the snapshot.
-    // extensions may provide ops that aren't part of the snapshot.
+  if snapshot_options.loaded() {
     // Grab the Deno.core.ops object & init it
     let deno_obj: v8::Local<v8::Object> = global
       .get(scope, deno_str.into())
@@ -132,58 +133,34 @@ pub(crate) fn initialize_context<'s>(
       .expect("Deno.core.ops to exist")
       .try_into()
       .unwrap();
-    ops_obj
+    for ctx in op_ctxs {
-  } else {
+      add_op_to_deno_core_ops(scope, ops_obj, ctx, snapshot_options);
-    // globalThis.Deno = { core: { } };
-    let deno_obj = v8::Object::new(scope);
-    global.set(scope, deno_str.into(), deno_obj.into());
-
-    let core_obj = v8::Object::new(scope);
-    deno_obj.set(scope, core_str.into(), core_obj.into());
-
-    // Bind functions to Deno.core.*
-    set_func(scope, core_obj, "callConsole", call_console);
-
-    // Bind v8 console object to Deno.core.console
-    let extra_binding_obj = context.get_extras_binding_object(scope);
-    let console_str =
-      v8::String::new_external_onebyte_static(scope, b"console").unwrap();
-    let console_obj = extra_binding_obj.get(scope, console_str.into()).unwrap();
-    core_obj.set(scope, console_str.into(), console_obj);
-
-    // Bind functions to Deno.core.ops.*
-    let ops_obj = v8::Object::new(scope);
-    core_obj.set(scope, ops_str.into(), ops_obj.into());
-    ops_obj
-  };
-
-  if matches!(snapshot_options, SnapshotOptions::Load) {
-    // Only register ops that have `force_registration` flag set to true,
-    // the remaining ones should already be in the snapshot.
-    for op_ctx in op_ctxs
-      .iter()
-      .filter(|op_ctx| op_ctx.decl.force_registration)
-    {
-      add_op_to_deno_core_ops(scope, ops_obj, op_ctx);
-    }
-  } else if matches!(snapshot_options, SnapshotOptions::CreateFromExisting) {
-    // Register all ops, probing for which ones are already registered.
-    for op_ctx in op_ctxs {
-      let key = v8::String::new_external_onebyte_static(
-        scope,
-        op_ctx.decl.name.as_bytes(),
-      )
-      .unwrap();
-      if ops_obj.get(scope, key.into()).is_some() {
-        continue;
-      }
-      add_op_to_deno_core_ops(scope, ops_obj, op_ctx);
-    }
-  } else {
-    // In other cases register all ops unconditionally.
-    for op_ctx in op_ctxs {
-      add_op_to_deno_core_ops(scope, ops_obj, op_ctx);
     }
+    return context;
+  }
+
+  // global.Deno = { core: { } };
+  let deno_obj = v8::Object::new(scope);
+  global.set(scope, deno_str.into(), deno_obj.into());
+
+  let core_obj = v8::Object::new(scope);
+  deno_obj.set(scope, core_str.into(), core_obj.into());
+
+  // Bind functions to Deno.core.*
+  set_func(scope, core_obj, "callConsole", call_console);
+
+  // Bind v8 console object to Deno.core.console
+  let extra_binding_obj = context.get_extras_binding_object(scope);
+  let console_str =
+    v8::String::new_external_onebyte_static(scope, b"console").unwrap();
+  let console_obj = extra_binding_obj.get(scope, console_str.into()).unwrap();
+  core_obj.set(scope, console_str.into(), console_obj);
+
+  // Bind functions to Deno.core.ops.*
+  let ops_obj = v8::Object::new(scope);
+  core_obj.set(scope, ops_str.into(), ops_obj.into());
+  for ctx in op_ctxs {
+    add_op_to_deno_core_ops(scope, ops_obj, ctx, snapshot_options);
   }
 
   context
@@ -206,6 +183,7 @@ fn add_op_to_deno_core_ops(
   scope: &mut v8::HandleScope<'_>,
   obj: v8::Local<v8::Object>,
   op_ctx: &OpCtx,
+  snapshot_options: SnapshotOptions,
 ) {
   let op_ctx_ptr = op_ctx as *const OpCtx as *const c_void;
   let key =
@@ -215,14 +193,24 @@ fn add_op_to_deno_core_ops(
   let builder = v8::FunctionTemplate::builder_raw(op_ctx.decl.v8_fn_ptr)
     .data(external.into());
 
-  let templ = if let Some(fast_function) = &op_ctx.decl.fast_fn {
+  // TODO(bartlomieju): this should be cleaned up once we update Fast Calls API
-    builder.build_fast(
+  // If this is a fast op, we don't want it to be in the snapshot.
-      scope,
+  // Only initialize once snapshot is loaded.
-      &**fast_function,
+  let maybe_fast_fn =
-      Some(op_ctx.fast_fn_c_info.unwrap().as_ptr()),
+    if op_ctx.decl.fast_fn.is_some() && snapshot_options.loaded() {
-      None,
+      &op_ctx.decl.fast_fn
-      None,
+    } else {
-    )
+      &None
+    };
+
+  let templ = if let Some(fast_function) = maybe_fast_fn {
+    // Don't initialize fast ops when snapshotting, the external references count mismatch.
+    if !snapshot_options.will_snapshot() {
+      // TODO(@littledivy): Support fast api overloads in ops.
+      builder.build_fast(scope, &**fast_function, None, None, None)
+    } else {
+      builder.build(scope)
+    }
   } else {
     builder.build(scope)
   };

core/extensions.rs

@@ -53,7 +53,6 @@ pub struct OpDecl {
   pub is_unstable: bool,
   pub is_v8: bool,
   pub fast_fn: Option<Box<dyn FastFunction>>,
-  pub force_registration: bool,
 }
 
 impl OpDecl {
@@ -241,7 +240,6 @@ macro_rules! extension {
 
       #[inline(always)]
       #[allow(unused_variables)]
-      #[allow(clippy::redundant_closure_call)]
       fn with_customizer(ext: &mut $crate::ExtensionBuilder) {
         $( ($customizer_fn)(ext); )?
       }
@@ -327,7 +325,6 @@ pub struct Extension {
   enabled: bool,
   name: &'static str,
   deps: Option<&'static [&'static str]>,
-  force_op_registration: bool,
 }
 
 // Note: this used to be a trait, but we "downgraded" it to a single concrete type
@@ -397,7 +394,6 @@ impl Extension {
     let mut ops = self.ops.take()?;
     for op in ops.iter_mut() {
       op.enabled = self.enabled && op.enabled;
-      op.force_registration = self.force_op_registration;
     }
     Some(ops)
   }
@@ -451,7 +447,6 @@ pub struct ExtensionBuilder {
   event_loop_middleware: Option<Box<OpEventLoopFn>>,
   name: &'static str,
   deps: &'static [&'static str],
-  force_op_registration: bool,
 }
 
 impl ExtensionBuilder {
@@ -499,15 +494,6 @@ impl ExtensionBuilder {
     self
   }
 
-  /// Mark that ops from this extension should be added to `Deno.core.ops`
-  /// unconditionally. This is useful is some ops are not available
-  /// during snapshotting, as ops are not registered by default when a
-  /// `JsRuntime` is created with an existing snapshot.
-  pub fn force_op_registration(&mut self) -> &mut Self {
-    self.force_op_registration = true;
-    self
-  }
-
   /// Consume the [`ExtensionBuilder`] and return an [`Extension`].
   pub fn take(self) -> Extension {
     let js_files = Some(self.js);
@@ -525,7 +511,6 @@ impl ExtensionBuilder {
       initialized: false,
       enabled: true,
       name: self.name,
-      force_op_registration: self.force_op_registration,
       deps,
     }
   }
@@ -547,7 +532,6 @@ impl ExtensionBuilder {
       enabled: true,
       name: self.name,
       deps,
-      force_op_registration: self.force_op_registration,
     }
   }
 }

core/ops.rs

@@ -19,13 +19,10 @@ use std::cell::RefCell;
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::pin::Pin;
-use std::ptr::NonNull;
 use std::rc::Rc;
 use std::rc::Weak;
 use std::task::Context;
 use std::task::Poll;
-use v8::fast_api::CFunctionInfo;
-use v8::fast_api::CTypeInfo;
 
 /// Wrapper around a Future, which causes that Future to be polled immediately.
 ///
@@ -158,45 +155,11 @@ pub struct OpCtx {
   pub id: OpId,
   pub state: Rc<RefCell<OpState>>,
   pub decl: Rc<OpDecl>,
-  pub fast_fn_c_info: Option<NonNull<v8::fast_api::CFunctionInfo>>,
   pub runtime_state: Weak<RefCell<JsRuntimeState>>,
   // Index of the current realm into `JsRuntimeState::known_realms`.
   pub realm_idx: RealmIdx,
 }
 
-impl OpCtx {
-  pub fn new(
-    id: OpId,
-    realm_idx: RealmIdx,
-    decl: Rc<OpDecl>,
-    state: Rc<RefCell<OpState>>,
-    runtime_state: Weak<RefCell<JsRuntimeState>>,
-  ) -> Self {
-    let mut fast_fn_c_info = None;
-
-    if let Some(fast_fn) = &decl.fast_fn {
-      let args = CTypeInfo::new_from_slice(fast_fn.args());
-      let ret = CTypeInfo::new(fast_fn.return_type());
-
-      // SAFETY: all arguments are coming from the trait and they have
-      // static lifetime
-      let c_fn = unsafe {
-        CFunctionInfo::new(args.as_ptr(), fast_fn.args().len(), ret.as_ptr())
-      };
-      fast_fn_c_info = Some(c_fn);
-    }
-
-    OpCtx {
-      id,
-      state,
-      runtime_state,
-      decl,
-      realm_idx,
-      fast_fn_c_info,
-    }
-  }
-}
-
 /// Maintains the resources and ops inside a JS runtime.
 pub struct OpState {
   pub resource_table: ResourceTable,

core/runtime.rs

@@ -319,7 +319,6 @@ impl JsRuntime {
     DENO_INIT.call_once(move || v8_init(v8_platform, options.will_snapshot));
 
     // Add builtins extension
-    // TODO(bartlomieju): remove this in favor of `SnapshotOptions`.
     let has_startup_snapshot = options.startup_snapshot.is_some();
     if !has_startup_snapshot {
       options
@@ -376,8 +375,12 @@ impl JsRuntime {
     let op_ctxs = ops
       .into_iter()
       .enumerate()
-      .map(|(id, decl)| {
+      .map(|(id, decl)| OpCtx {
-        OpCtx::new(id, 0, Rc::new(decl), op_state.clone(), weak.clone())
+        id,
+        state: op_state.clone(),
+        runtime_state: weak.clone(),
+        decl: Rc::new(decl),
+        realm_idx: 0,
       })
       .collect::<Vec<_>>()
       .into_boxed_slice();
@@ -386,7 +389,7 @@ impl JsRuntime {
       options.startup_snapshot.is_some(),
       options.will_snapshot,
     );
-    let refs = bindings::external_references(&op_ctxs);
+    let refs = bindings::external_references(&op_ctxs, snapshot_options);
     // V8 takes ownership of external_references.
     let refs: &'static v8::ExternalReferences = Box::leak(Box::new(refs));
     let global_context;
@@ -395,7 +398,7 @@ impl JsRuntime {
     let (mut isolate, snapshot_options) = if snapshot_options.will_snapshot() {
       let snapshot_creator =
         snapshot_util::create_snapshot_creator(refs, options.startup_snapshot);
-      eprintln!("create snapshot {:#?}", snapshot_options);
+
       let mut isolate = JsRuntime::setup_isolate(snapshot_creator);
       {
         let scope = &mut v8::HandleScope::new(&mut isolate);
@@ -457,7 +460,6 @@ impl JsRuntime {
       isolate_ptr.write(isolate);
       isolate_ptr.read()
     };
-
     global_context.open(&mut isolate).set_slot(
       &mut isolate,
       Rc::new(RefCell::new(ContextState {
@@ -618,14 +620,12 @@ impl JsRuntime {
         .borrow()
         .op_ctxs
         .iter()
-        .map(|op_ctx| {
+        .map(|op_ctx| OpCtx {
-          OpCtx::new(
+          id: op_ctx.id,
-            op_ctx.id,
+          state: op_ctx.state.clone(),
-            realm_idx,
+          decl: op_ctx.decl.clone(),
-            op_ctx.decl.clone(),
+          runtime_state: op_ctx.runtime_state.clone(),
-            op_ctx.state.clone(),
+          realm_idx,
-            op_ctx.runtime_state.clone(),
-          )
         })
         .collect();
 
@@ -927,6 +927,18 @@ impl JsRuntime {
   ///
   /// `Error` can usually be downcast to `JsError`.
   pub fn snapshot(mut self) -> v8::StartupData {
+    // Nuke Deno.core.ops.* to avoid ExternalReference snapshotting issues
+    // TODO(@AaronO): make ops stable across snapshots
+    {
+      let scope = &mut self.handle_scope();
+      let o = Self::eval::<v8::Object>(scope, "Deno.core.ops").unwrap();
+      let names = o.get_own_property_names(scope, Default::default()).unwrap();
+      for i in 0..names.length() {
+        let key = names.get_index(scope, i).unwrap();
+        o.delete(scope, key);
+      }
+    }
+
     self.state.borrow_mut().inspector.take();
 
     // Serialize the module map and store its data in the snapshot.
@@ -3544,18 +3556,10 @@ pub mod tests {
       }
     }
 
-    #[op]
-    fn op_test() -> Result<String, Error> {
-      Ok(String::from("test"))
-    }
-
     let loader = Rc::new(ModsLoader::default());
     let mut runtime = JsRuntime::new(RuntimeOptions {
       module_loader: Some(loader.clone()),
       will_snapshot: true,
-      extensions: vec![Extension::builder("text_ext")
-        .ops(vec![op_test::decl()])
-        .build()],
       ..Default::default()
     });
 
@@ -3590,9 +3594,6 @@ pub mod tests {
       module_loader: Some(loader.clone()),
       will_snapshot: true,
       startup_snapshot: Some(Snapshot::JustCreated(snapshot)),
-      extensions: vec![Extension::builder("text_ext")
-        .ops(vec![op_test::decl()])
-        .build()],
       ..Default::default()
     });
 
@@ -3608,9 +3609,6 @@ pub mod tests {
     let mut runtime3 = JsRuntime::new(RuntimeOptions {
       module_loader: Some(loader),
       startup_snapshot: Some(Snapshot::JustCreated(snapshot2)),
-      extensions: vec![Extension::builder("text_ext")
-        .ops(vec![op_test::decl()])
-        .build()],
       ..Default::default()
     });
 
@@ -3618,7 +3616,7 @@ pub mod tests {
 
     let source_code = r#"(async () => {
       const mod = await import("file:///400.js");
-      return mod.f400() + " " + Deno.core.ops.op_test();
+      return mod.f400();
     })();"#
       .to_string();
     let val = runtime3.execute_script(".", &source_code).unwrap();
@@ -3627,7 +3625,7 @@ pub mod tests {
       let scope = &mut runtime3.handle_scope();
       let value = v8::Local::new(scope, val);
       let str_ = value.to_string(scope).unwrap().to_rust_string_lossy(scope);
-      assert_eq!(str_, "hello world test");
+      assert_eq!(str_, "hello world");
     }
   }
 
@@ -4602,13 +4600,7 @@ Deno.core.opAsync("op_async_serialize_object_with_numbers_as_keys", {
       Ok(String::from("Test"))
     }
 
-    deno_core::extension!(
+    deno_core::extension!(test_ext, ops = [op_test]);
-      test_ext,
-      ops = [op_test],
-      customizer = |ext: &mut deno_core::ExtensionBuilder| {
-        ext.force_op_registration();
-      },
-    );
     let mut runtime = JsRuntime::new(RuntimeOptions {
       startup_snapshot: Some(Snapshot::Boxed(snapshot)),
       extensions: vec![test_ext::init_ops()],

core/snapshot_util.rs

@@ -121,7 +121,7 @@ fn data_error_to_panic(err: v8::DataError) -> ! {
   }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub(crate) enum SnapshotOptions {
   Load,
   CreateFromExisting,

ext/node/polyfills/internal/readline/utils.mjs

@@ -38,10 +38,10 @@ export function CSI(strings, ...args) {
 }
 
 CSI.kEscape = kEscape;
-CSI.kClearToLineBeginning = `${kEscape}[1K`;
+CSI.kClearToLineBeginning = CSI`1K`;
-CSI.kClearToLineEnd = `${kEscape}[0K`;
+CSI.kClearToLineEnd = CSI`0K`;
-CSI.kClearLine = `${kEscape}[2K`;
+CSI.kClearLine = CSI`2K`;
-CSI.kClearScreenDown = `${kEscape}[0J`;
+CSI.kClearScreenDown = CSI`0J`;
 
 // TODO(BridgeAR): Treat combined characters as single character, i.e,
 // 'a\u0301' and '\u0301a' (both have the same visual output).

ops/lib.rs

@@ -145,7 +145,6 @@ impl Op {
               is_async: #is_async,
               is_unstable: #is_unstable,
               is_v8: #is_v8,
-              force_registration: false,
             }
           }
 
@@ -202,7 +201,6 @@ impl Op {
             is_async: #is_async,
             is_unstable: #is_unstable,
             is_v8: #is_v8,
-            force_registration: false,
           }
         }
 

ops/optimizer_tests/async_nop.out

@@ -26,7 +26,6 @@ impl op_void_async {
             is_async: true,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/async_result.out

@@ -26,7 +26,6 @@ impl op_async_result {
             is_async: true,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/callback_options.out

@@ -26,7 +26,6 @@ impl op_fallback {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/cow_str.out

@@ -26,7 +26,6 @@ impl op_cow_str {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/f64_slice.out

@@ -26,7 +26,6 @@ impl op_f64_buf {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/incompatible_1.out

@@ -22,7 +22,6 @@ impl op_sync_serialize_object_with_numbers_as_keys {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/issue16934.out

@@ -22,7 +22,6 @@ impl send_stdin {
             is_async: true,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/issue16934_fast.out

@@ -22,7 +22,6 @@ impl send_stdin {
             is_async: true,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_blob_revoke_object_url.out

@@ -22,7 +22,6 @@ impl op_blob_revoke_object_url {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_ffi_ptr_value.out

@@ -26,7 +26,6 @@ impl op_ffi_ptr_value {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_print.out

@@ -22,7 +22,6 @@ impl op_print {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_state.out

@@ -26,7 +26,6 @@ impl op_set_exit_code {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_state_basic1.out

@@ -26,7 +26,6 @@ impl foo {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_state_generics.out

@@ -32,7 +32,6 @@ impl op_foo {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_state_result.out

@@ -26,7 +26,6 @@ impl foo {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_state_warning.out

@@ -26,7 +26,6 @@ impl op_listen {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/op_state_with_transforms.out

@@ -32,7 +32,6 @@ impl op_now {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/opstate_with_arity.out

@@ -26,7 +26,6 @@ impl op_add_4 {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/option_arg.out

@@ -22,7 +22,6 @@ impl op_try_close {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/owned_string.out

@@ -26,7 +26,6 @@ impl op_string_length {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/param_mut_binding_warning.out

@@ -22,7 +22,6 @@ impl op_read_sync {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/raw_ptr.out

@@ -32,7 +32,6 @@ impl op_ffi_ptr_of {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/serde_v8_value.out

@@ -26,7 +26,6 @@ impl op_is_proxy {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/strings.out

@@ -26,7 +26,6 @@ impl op_string_length {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/strings_result.out

@@ -22,7 +22,6 @@ impl op_string_length {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/u64_result.out

@@ -22,7 +22,6 @@ impl op_bench_now {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/uint8array.out

@@ -26,7 +26,6 @@ impl op_import_spki_x25519 {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/unit_result.out

@@ -26,7 +26,6 @@ impl op_unit_result {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/unit_result2.out

@@ -26,7 +26,6 @@ impl op_set_nodelay {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/unit_ret.out

@@ -26,7 +26,6 @@ impl op_unit {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

ops/optimizer_tests/wasm_op.out

@@ -26,7 +26,6 @@ impl op_wasm {
             is_async: false,
             is_unstable: false,
             is_v8: false,
-            force_registration: false,
         }
     }
     #[inline]

runtime/ops/fs_events.rs

@@ -30,10 +30,7 @@ use tokio::sync::mpsc;
 
 deno_core::extension!(
   deno_fs_events,
-  ops = [op_fs_events_open, op_fs_events_poll],
+  ops = [op_fs_events_open, op_fs_events_poll]
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 struct FsEventsResource {

runtime/ops/http.rs

@@ -30,9 +30,6 @@ use tokio::net::UnixStream;
 deno_core::extension!(
   deno_http_runtime,
   ops = [op_http_start, op_http_upgrade, op_flash_upgrade_http],
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[op]

runtime/ops/os/mod.rs

@@ -48,23 +48,23 @@ deno_core::extension!(
   state = |state, options| {
     state.put::<ExitCode>(options.exit_code);
   },
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  }
 );
 
 deno_core::extension!(
   deno_os_worker,
   ops_fn = deno_ops,
   middleware = |op| match op.name {
-    "op_exit" | "op_set_exit_code" => op.disable(),
+    "op_exit" => noop_op::decl(),
+    "op_set_exit_code" => noop_op::decl(),
     _ => op,
   },
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  }
 );
 
+#[op]
+fn noop_op() -> Result<(), AnyError> {
+  Ok(())
+}
+
 #[op]
 fn op_exec_path(state: &mut OpState) -> Result<String, AnyError> {
   let current_exe = env::current_exe().unwrap();

runtime/ops/permissions.rs

@@ -17,10 +17,7 @@ deno_core::extension!(
     op_query_permission,
     op_revoke_permission,
     op_request_permission,
-  ],
+  ]
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[derive(Deserialize)]

runtime/ops/process.rs

@@ -107,10 +107,7 @@ deno_core::extension!(
     deprecated::op_run,
     deprecated::op_run_status,
     deprecated::op_kill,
-  ],
+  ]
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 struct ChildResource(tokio::process::Child);

runtime/ops/runtime.rs

@@ -12,10 +12,7 @@ deno_core::extension!(
   options = { main_module: ModuleSpecifier },
   state = |state, options| {
     state.put::<ModuleSpecifier>(options.main_module);
-  },
+  }
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[op]

runtime/ops/signal.rs

@@ -31,10 +31,7 @@ use tokio::signal::windows::CtrlC;
 
 deno_core::extension!(
   deno_signal,
-  ops = [op_signal_bind, op_signal_unbind, op_signal_poll],
+  ops = [op_signal_bind, op_signal_unbind, op_signal_poll]
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[cfg(unix)]

runtime/ops/tty.rs

@@ -34,10 +34,7 @@ fn get_windows_handle(
 
 deno_core::extension!(
   deno_tty,
-  ops = [op_stdin_set_raw, op_isatty, op_console_size],
+  ops = [op_stdin_set_raw, op_isatty, op_console_size]
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 // ref: <https://learn.microsoft.com/en-us/windows/console/setconsolemode>

runtime/ops/web_worker.rs

@@ -24,10 +24,7 @@ deno_core::extension!(
     op_worker_close,
     op_worker_get_type,
     op_worker_sync_fetch,
-  ],
+  ]
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[op]

runtime/ops/worker_host.rs

@@ -118,10 +118,7 @@ deno_core::extension!(
     let format_js_error_fn_holder =
       FormatJsErrorFnHolder(options.format_js_error_fn);
     state.put::<FormatJsErrorFnHolder>(format_js_error_fn_holder);
-  },
+  }
-  customizer = |ext: &mut deno_core::ExtensionBuilder| {
-    ext.force_op_registration();
-  },
 );
 
 #[derive(Deserialize)]