Restore old init_ops/init_ops_and_esm names

denoland · mmastrac · Mar 17, 2023 · Mar 14, 2023 · Mar 15, 2023 · Mar 15, 2023
commit 07044e7e32256c837202e90a4aef32751d86d50f
diff --git a/bench_util/benches/op_baseline.rs b/bench_util/benches/op_baseline.rs
@@ -14,7 +14,7 @@ deno_core::ops!(deno_ops, [op_pi_json, op_pi_async, op_nop,]);
 deno_core::extension!(bench_setup, ops = deno_ops,);
 
 fn setup() -> Vec<Extension> {
-  vec![bench_setup::init_runtime()]
+  vec![bench_setup::init_ops()]
 }
 
 #[op]

diff --git a/cli/build.rs b/cli/build.rs
@@ -269,7 +269,11 @@ mod ts {
       cargo_manifest_dir: env!("CARGO_MANIFEST_DIR"),
       snapshot_path,
       startup_snapshot: None,
-      extensions: vec![deno_tsc::init_esm_and_state(op_crate_libs, build_libs, path_dts)],
+      extensions: vec![deno_tsc::init_ops_and_esm(
+        op_crate_libs,
+        build_libs,
+        path_dts,
+      )],
 
       // NOTE(bartlomieju): Compressing the TSC snapshot in debug build took
       // ~45s on M1 MacBook Pro; without compression it took ~1s.
@@ -314,42 +318,40 @@ mod ts {
 
 fn create_cli_snapshot(snapshot_path: PathBuf) {
   let mut extensions: Vec<Extension> = vec![
-    deno_webidl::deno_webidl::init_runtime(),
-    deno_console::deno_console::init_runtime(),
-    deno_url::deno_url::init_runtime(),
+    deno_webidl::deno_webidl::init_ops(),
+    deno_console::deno_console::init_ops(),
+    deno_url::deno_url::init_ops(),
     deno_tls::init_ops(),
     deno_web::init_ops::<PermissionsContainer>(
       deno_web::BlobStore::default(),
       Default::default(),
     ),
-    deno_fetch::deno_fetch::init_runtime::<PermissionsContainer>(
-      Default::default(),
-    ),
-    deno_cache::deno_cache::init_runtime::<SqliteBackedCache>(None),
-    deno_websocket::deno_websocket::init_runtime::<PermissionsContainer>(
+    deno_fetch::deno_fetch::init_ops::<PermissionsContainer>(Default::default()),
+    deno_cache::deno_cache::init_ops::<SqliteBackedCache>(None),
+    deno_websocket::deno_websocket::init_ops::<PermissionsContainer>(
       "".to_owned(),
       None,
       None,
     ),
-    deno_webstorage::deno_webstorage::init_runtime(None),
-    deno_crypto::deno_crypto::init_runtime(None),
-    deno_webgpu::deno_webgpu::init_runtime(false),
-    deno_broadcast_channel::deno_broadcast_channel::init_runtime(
+    deno_webstorage::deno_webstorage::init_ops(None),
+    deno_crypto::deno_crypto::init_ops(None),
+    deno_webgpu::deno_webgpu::init_ops(false),
+    deno_broadcast_channel::deno_broadcast_channel::init_ops(
       deno_broadcast_channel::InMemoryBroadcastChannel::default(),
       false, // No --unstable.
     ),
     deno_io::init_ops(Default::default()),
     deno_fs::init_ops::<PermissionsContainer>(false),
     deno_node::init_ops::<PermissionsContainer>(None), // No --unstable.
     deno_node::init_polyfill_ops(),
-    deno_ffi::deno_ffi::init_runtime::<PermissionsContainer>(false),
+    deno_ffi::deno_ffi::init_ops::<PermissionsContainer>(false),
     deno_net::init_ops::<PermissionsContainer>(
       None, false, // No --unstable.
       None,
     ),
-    deno_napi::deno_napi::init_runtime::<PermissionsContainer>(),
+    deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
     deno_http::init_ops(),
-    deno_flash::deno_flash::init_runtime::<PermissionsContainer>(false), // No --unstable
+    deno_flash::deno_flash::init_ops::<PermissionsContainer>(false), // No --unstable
   ];
 
   let mut esm_files = include_js_files!(

diff --git a/cli/lsp/testing/execution.rs b/cli/lsp/testing/execution.rs
@@ -165,7 +165,7 @@ async fn test_specifier(
       &ps,
       specifier.clone(),
       PermissionsContainer::new(permissions),
-      vec![ops::testing::deno_test::init_runtime(
+      vec![ops::testing::deno_test::init_ops(
         sender,
         fail_fast_tracker,
         filter,

diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs
@@ -2818,7 +2818,7 @@ fn op_script_version(
 /// server.
 fn js_runtime(performance: Arc<Performance>) -> JsRuntime {
   JsRuntime::new(RuntimeOptions {
-    extensions: vec![deno_tsc::init_runtime(performance)],
+    extensions: vec![deno_tsc::init_ops(performance)],
     startup_snapshot: Some(tsc::compiler_snapshot()),
     ..Default::default()
   })

diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs
@@ -10,7 +10,7 @@ pub mod bench;
 pub mod testing;
 
 pub fn cli_exts(ps: ProcState) -> Vec<Extension> {
-  vec![deno_cli::init_runtime(ps)]
+  vec![deno_cli::init_ops(ps)]
 }
 
 deno_core::ops!(deno_ops, [op_npm_process_state]);

diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs
@@ -441,7 +441,7 @@ async fn bench_specifier(
     &ps,
     specifier,
     PermissionsContainer::new(permissions),
-    vec![ops::bench::deno_bench::init_runtime(channel, filter)],
+    vec![ops::bench::deno_bench::init_ops(channel, filter)],
     Default::default(),
   )
   .await?;

diff --git a/cli/tools/test.rs b/cli/tools/test.rs
@@ -723,7 +723,7 @@ async fn test_specifier(
     ps,
     specifier,
     PermissionsContainer::new(permissions),
-    vec![ops::testing::deno_test::init_runtime(
+    vec![ops::testing::deno_test::init_ops(
       sender,
       fail_fast_tracker,
       options.filter,

diff --git a/cli/tsc/mod.rs b/cli/tsc/mod.rs
@@ -121,7 +121,7 @@ fn get_asset_texts_from_new_runtime() -> Result<Vec<AssetText>, AnyError> {
   // the assets are stored within the typescript isolate, so take them out of there
   let mut runtime = JsRuntime::new(RuntimeOptions {
     startup_snapshot: Some(compiler_snapshot()),
-    extensions: vec![deno_cli_tsc::init_runtime()],
+    extensions: vec![deno_cli_tsc::init_ops()],
     ..Default::default()
   });
   let global =
@@ -861,7 +861,7 @@ pub fn exec(request: Request) -> Result<Response, AnyError> {
 
   let mut runtime = JsRuntime::new(RuntimeOptions {
     startup_snapshot: Some(compiler_snapshot()),
-    extensions: vec![deno_cli_tsc::init_runtime(
+    extensions: vec![deno_cli_tsc::init_ops(
       Rc::new(request),
       root_map,
       remapped_specifiers,

diff --git a/core/extensions.rs b/core/extensions.rs
@@ -232,7 +232,7 @@ macro_rules! extension {
       }
 
       #[allow(dead_code)]
-      pub fn init_esm $( <  $( $param : $type + Clone + 'static ),+ > )? () -> $crate::Extension {
+      pub fn init_js_only $( <  $( $param : $type + Clone + 'static ),+ > )? () -> $crate::Extension {
         let mut ext = ext();
         // If esm or JS was specified, add JS files
         with_js(&mut ext);
@@ -241,7 +241,7 @@ macro_rules! extension {
       }
 
       #[allow(dead_code)]
-      pub fn init_esm_and_state $( <  $( $param : $type + Clone + 'static ),+ > )? ( $( $( $config_id : $config_type ),* )? ) -> $crate::Extension {
+      pub fn init_ops_and_esm $( <  $( $param : $type + Clone + 'static ),+ > )? ( $( $( $config_id : $config_type ),* )? ) -> $crate::Extension {
         let mut ext = ext();
         // If esm or JS was specified, add JS files
         with_js(&mut ext);
@@ -251,7 +251,7 @@ macro_rules! extension {
       }
 
       #[allow(dead_code)]
-      pub fn init_runtime $( <  $( $param : $type + Clone + 'static ),+ > )? ( $( $( $config_id : $config_type ),* )? ) -> $crate::Extension {
+      pub fn init_ops $( <  $( $param : $type + Clone + 'static ),+ > )? ( $( $( $config_id : $config_type ),* )? ) -> $crate::Extension {
         let mut ext = ext();
         with_ops $( ::<($( $param ),+)> )?(&mut ext);
         with_state_and_middleware $( ::<($( $param ),+)> )?(&mut ext, $( $( $config_id , )* )? );

diff --git a/core/runtime.rs b/core/runtime.rs
@@ -323,11 +323,11 @@ impl JsRuntime {
     if !has_startup_snapshot {
       options
         .extensions
-        .insert(0, crate::ops_builtin::core::init_esm());
+        .insert(0, crate::ops_builtin::core::init_ops_and_esm());
     } else {
       options
         .extensions
-        .insert(0, crate::ops_builtin::core::init_runtime());
+        .insert(0, crate::ops_builtin::core::init_ops());
     }
 
     let ops = Self::collect_ops(&mut options.extensions);

diff --git a/ext/url/benches/url_ops.rs b/ext/url/benches/url_ops.rs
@@ -11,8 +11,8 @@ use deno_core::ExtensionFileSourceCode;
 
 fn setup() -> Vec<Extension> {
   vec![
-    deno_webidl::deno_webidl::init_esm(),
-    deno_url::deno_url::init_esm(),
+    deno_webidl::deno_webidl::init_ops_and_esm(),
+    deno_url::deno_url::init_ops_and_esm(),
     Extension::builder("bench_setup")
       .esm(vec![ExtensionFileSource {
         specifier: "ext:setup".to_string(),

diff --git a/ext/web/benches/encoding.rs b/ext/web/benches/encoding.rs
@@ -23,9 +23,9 @@ impl deno_web::TimersPermission for Permissions {
 
 fn setup() -> Vec<Extension> {
   vec![
-    deno_webidl::deno_webidl::init_esm(),
-    deno_url::deno_url::init_esm(),
-    deno_console::deno_console::init_esm(),
+    deno_webidl::deno_webidl::init_ops_and_esm(),
+    deno_url::deno_url::init_ops_and_esm(),
+    deno_console::deno_console::init_ops_and_esm(),
     deno_web::init_ops_and_esm::<Permissions>(BlobStore::default(), None),
     Extension::builder("bench_setup")
       .esm(vec![ExtensionFileSource {

diff --git a/ext/web/benches/timers_ops.rs b/ext/web/benches/timers_ops.rs
@@ -21,9 +21,9 @@ impl deno_web::TimersPermission for Permissions {
 
 fn setup() -> Vec<Extension> {
   vec![
-    deno_webidl::deno_webidl::init_esm(),
-    deno_url::deno_url::init_esm(),
-    deno_console::deno_console::init_esm(),
+    deno_webidl::deno_webidl::init_ops_and_esm(),
+    deno_url::deno_url::init_ops_and_esm(),
+    deno_console::deno_console::init_ops_and_esm(),
     deno_web::init_ops_and_esm::<Permissions>(BlobStore::default(), None),
     Extension::builder("bench_setup")
     .esm(vec![

diff --git a/ext/webgpu/lib.rs b/ext/webgpu/lib.rs
@@ -3,7 +3,10 @@
 #![warn(unsafe_op_in_unsafe_fn)]
 
 use deno_core::error::AnyError;
+use deno_core::include_js_files;
 use deno_core::op;
+use deno_core::Extension;
+use deno_core::ExtensionBuilder;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
@@ -114,20 +117,45 @@ impl Resource for WebGpuQuerySet {
   }
 }
 
-deno_core::extension!(deno_webgpu,
-  deps = [ deno_webidl, deno_web ],
-  esm = [ "01_webgpu.js", "02_idl_types.js" ],
-  config = {
-    unstable: bool,
-  },
-  state = |state, unstable| {
+// TODO: The WebGPU extension fails with the extension! macro
+pub mod deno_webgpu {
+  use super::*;
+
+  pub fn init_ops_and_esm(unstable: bool) -> Extension {
+    super::init_ops_and_esm(unstable)
+  }
+
+  pub fn init_ops(unstable: bool) -> Extension {
+    super::init_ops(unstable)
+  }
+}
+
+fn ext() -> ExtensionBuilder {
+  Extension::builder_with_deps(
+    env!("CARGO_PKG_NAME"),
+    &["deno_webidl", "deno_web"],
+  )
+}
+
+fn ops(ext: &mut ExtensionBuilder, unstable: bool) -> &mut ExtensionBuilder {
+  ext.ops(deno_ops()).state(move |state| {
     // TODO: check & possibly streamline this
     // Unstable might be able to be OpMiddleware
     // let unstable_checker = state.borrow::<super::UnstableChecker>();
     // let unstable = unstable_checker.unstable;
     state.put(Unstable(unstable));
-  },
-);
+  })
+}
+
+pub fn init_ops_and_esm(unstable: bool) -> Extension {
+  ops(&mut ext(), unstable)
+    .esm(include_js_files!("01_webgpu.js", "02_idl_types.js",))
+    .build()
+}
+
+pub fn init_ops(unstable: bool) -> Extension {
+  ops(&mut ext(), unstable).build()
+}
 
 fn deserialize_features(features: &wgpu_types::Features) -> Vec<&'static str> {
   let mut return_features: Vec<&'static str> = vec![];

diff --git a/ext/webidl/benches/dict.rs b/ext/webidl/benches/dict.rs
@@ -11,7 +11,7 @@ use deno_core::ExtensionFileSourceCode;
 
 fn setup() -> Vec<Extension> {
   vec![
-    deno_webidl::deno_webidl::init_esm(),
+    deno_webidl::deno_webidl::init_ops_and_esm(),
     Extension::builder("deno_webidl_bench")
       .esm(vec![ExtensionFileSource {
         specifier: "ext:setup".to_string(),

diff --git a/runtime/build.rs b/runtime/build.rs
@@ -253,33 +253,42 @@ mod startup_snapshot {
     .build();
 
     let mut extensions: Vec<Extension> = vec![
-      deno_webidl::deno_webidl::init_esm(),
-      deno_console::deno_console::init_esm(),
-      deno_url::deno_url::init_esm(),
+      deno_webidl::deno_webidl::init_ops_and_esm(),
+      deno_console::deno_console::init_ops_and_esm(),
+      deno_url::deno_url::init_ops_and_esm(),
       deno_tls::init_ops(),
       deno_web::init_ops_and_esm::<Permissions>(
         deno_web::BlobStore::default(),
         Default::default(),
       ),
-      deno_fetch::deno_fetch::init_esm::<Permissions>(),
-      deno_cache::deno_cache::init_esm::<SqliteBackedCache>(),
-      deno_websocket::deno_websocket::init_esm::<Permissions>(),
-      deno_webstorage::deno_webstorage::init_esm(),
-      deno_crypto::deno_crypto::init_esm(),
-      deno_webgpu::deno_webgpu::init_esm(),
-      deno_broadcast_channel::deno_broadcast_channel::init_esm::<
+      deno_fetch::deno_fetch::init_ops_and_esm::<Permissions>(
+        Default::default(),
+      ),
+      deno_cache::deno_cache::init_ops_and_esm::<SqliteBackedCache>(None),
+      deno_websocket::deno_websocket::init_ops_and_esm::<Permissions>(
+        "".to_owned(),
+        None,
+        None,
+      ),
+      deno_webstorage::deno_webstorage::init_ops_and_esm(None),
+      deno_crypto::deno_crypto::init_ops_and_esm(None),
+      deno_webgpu::deno_webgpu::init_ops_and_esm(false),
+      deno_broadcast_channel::deno_broadcast_channel::init_ops_and_esm::<
         InMemoryBroadcastChannel,
-      >(),
-      deno_ffi::deno_ffi::init_esm::<Permissions>(),
+      >(
+        deno_broadcast_channel::InMemoryBroadcastChannel::default(),
+        false,
+      ), // No --unstable.
+      deno_ffi::deno_ffi::init_ops_and_esm::<Permissions>(false),
       deno_net::init_ops_and_esm::<Permissions>(
         None, false, // No --unstable.
         None,
       ),
-      deno_napi::deno_napi::init_esm::<Permissions>(),
+      deno_napi::deno_napi::init_ops_and_esm::<Permissions>(),
       deno_http::init_ops_and_esm(),
       deno_io::init_ops_and_esm(Default::default()),
       deno_fs::init_ops_and_esm::<Permissions>(false),
-      deno_flash::deno_flash::init_esm::<Permissions>(), // No --unstable
+      deno_flash::deno_flash::init_ops_and_esm::<Permissions>(false), // No --unstable
       runtime_extension,
       // FIXME(bartlomieju): these extensions are specified last, because they
       // depend on `runtime`, even though it should be other way around