refactor(core): cleanup feature flags for js source inclusion (#19463)

Remove `ExtensionFileSourceCode::LoadedFromFsDuringSnapshot` and feature
`include_js_for_snapshotting` since they leak paths that are only
applicable in this repo to embedders. Replace with feature
`exclude_js_sources`. Additionally the feature
`force_include_js_sources` allows negating it, if both features are set.
We need both of these because features are additive and there must be a
way of force including sources for snapshot creation while still having
the `exclude_js_sources` feature. `force_include_js_sources` is only set
for build deps, so sources are still excluded from the final binary.

You can also specify `force_include_js_sources` on any extension to
override the above features for that extension. Towards #19398.

But there was still the snapshot-from-snapshot situation where code
could be executed twice, I addressed that by making `mod_evaluate()` and
scripts like `core/01_core.js` behave idempotently. This allowed
unifying `ext::init_ops()` and `ext::init_ops_and_esm()` into
`ext::init()`.

1 files changed, 26 insertions, 33 deletions

diff --git a/runtime/build.rs b/runtime/build.rs
index f656682a1..d7b4018fb 100644
--- a/runtime/build.rs
+++ b/runtime/build.rs
@@ -35,7 +35,7 @@ mod startup_snapshot {
         file_source.specifier
       ),
     };
-    let code = file_source.load()?;
+    let code = file_source.load();
 
     if !should_transpile {
       return Ok(code);
@@ -264,22 +264,20 @@ mod startup_snapshot {
     ],
   );
 
-  #[cfg(not(feature = "snapshot_from_snapshot"))]
+  #[cfg(not(feature = "exclude_js_main_from_snapshot"))]
   deno_core::extension!(
     runtime_main,
     deps = [runtime],
     customizer = |ext: &mut deno_core::ExtensionBuilder| {
       ext.esm(vec![ExtensionFileSource {
         specifier: "ext:runtime_main/js/99_main.js",
-        code: deno_core::ExtensionFileSourceCode::IncludedInBinary(
-          include_str!("js/99_main.js"),
-        ),
+        code: include_str!("js/99_main.js"),
       }]);
       ext.esm_entry_point("ext:runtime_main/js/99_main.js");
     }
   );
 
-  #[cfg(feature = "snapshot_from_snapshot")]
+  #[cfg(feature = "exclude_js_main_from_snapshot")]
   deno_core::extension!(
     runtime_main,
     deps = [runtime],
@@ -294,50 +292,48 @@ mod startup_snapshot {
     // `runtime/worker.rs`, `runtime/web_worker.rs` and `cli/build.rs`!
     let fs = std::sync::Arc::new(deno_fs::RealFs);
     let extensions: Vec<Extension> = vec![
-      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_web::deno_web::init_ops_and_esm::<Permissions>(
+      deno_webidl::deno_webidl::init(),
+      deno_console::deno_console::init(),
+      deno_url::deno_url::init(),
+      deno_web::deno_web::init::<Permissions>(
         deno_web::BlobStore::default(),
         Default::default(),
       ),
-      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>(
+      deno_fetch::deno_fetch::init::<Permissions>(Default::default()),
+      deno_cache::deno_cache::init::<SqliteBackedCache>(None),
+      deno_websocket::deno_websocket::init::<Permissions>(
         "".to_owned(),
         None,
         None,
       ),
-      deno_webstorage::deno_webstorage::init_ops_and_esm(None),
-      deno_crypto::deno_crypto::init_ops_and_esm(None),
-      deno_broadcast_channel::deno_broadcast_channel::init_ops_and_esm(
+      deno_webstorage::deno_webstorage::init(None),
+      deno_crypto::deno_crypto::init(None),
+      deno_broadcast_channel::deno_broadcast_channel::init(
         deno_broadcast_channel::InMemoryBroadcastChannel::default(),
         false, // No --unstable.
       ),
-      deno_ffi::deno_ffi::init_ops_and_esm::<Permissions>(false),
-      deno_net::deno_net::init_ops_and_esm::<Permissions>(
+      deno_ffi::deno_ffi::init::<Permissions>(false),
+      deno_net::deno_net::init::<Permissions>(
         None, false, // No --unstable.
         None,
       ),
-      deno_tls::deno_tls::init_ops_and_esm(),
-      deno_kv::deno_kv::init_ops_and_esm(
+      deno_tls::deno_tls::init(),
+      deno_kv::deno_kv::init(
         deno_kv::sqlite::SqliteDbHandler::<Permissions>::new(None),
         false, // No --unstable
       ),
-      deno_napi::deno_napi::init_ops_and_esm::<Permissions>(),
-      deno_http::deno_http::init_ops_and_esm::<DefaultHttpPropertyExtractor>(),
-      deno_io::deno_io::init_ops_and_esm(Default::default()),
-      deno_fs::deno_fs::init_ops_and_esm::<Permissions>(false, fs.clone()),
-      runtime::init_ops_and_esm(),
+      deno_napi::deno_napi::init::<Permissions>(),
+      deno_http::deno_http::init::<DefaultHttpPropertyExtractor>(),
+      deno_io::deno_io::init(Default::default()),
+      deno_fs::deno_fs::init::<Permissions>(false, fs.clone()),
+      runtime::init(),
       // FIXME(bartlomieju): these extensions are specified last, because they
       // depend on `runtime`, even though it should be other way around
-      deno_node::deno_node::init_ops_and_esm::<Permissions>(None, fs),
-      runtime_main::init_ops_and_esm(),
+      deno_node::deno_node::init::<Permissions>(None, fs),
+      runtime_main::init(),
     ];
 
-    let output = create_snapshot(CreateSnapshotOptions {
+    create_snapshot(CreateSnapshotOptions {
       cargo_manifest_dir: env!("CARGO_MANIFEST_DIR"),
       snapshot_path,
       startup_snapshot: None,
@@ -345,9 +341,6 @@ mod startup_snapshot {
       compression_cb: None,
       snapshot_module_load_cb: Some(Box::new(transpile_ts_for_snapshotting)),
     });
-    for path in output.files_loaded_during_snapshot {
-      println!("cargo:rerun-if-changed={}", path.display());
-    }
   }
 }