language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-08-04 10:59:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Revert "Reland "refactor(core): cleanup feature flags for js source i… (#19611)

Browse source 
…nclusion" (#19519)"

This reverts commit 28a4f3d0f5.

This change causes failures when used outside Deno repo:
```
============================================================
Deno has panicked. This is a bug in Deno. Please report this
at https://github.com/denoland/deno/issues/new.
If you can reliably reproduce this panic, include the
reproduction steps and re-run with the RUST_BACKTRACE=1 env
var set and include the backtrace in your report.

Platform: linux x86_64
Version: 1.34.3+b37b286
Args: ["/opt/hostedtoolcache/deno/0.0.0-b37b286f7fa68d5656f7c180f6127bdc38cf2cf5/x64/deno", "test", "--doc", "--unstable", "--allow-all", "--coverage=./cov"]

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Failed to read "/home/runner/work/deno/deno/core/00_primordials.js"

Caused by:
    No such file or directory (os error 2)', core/runtime/jsruntime.rs:699:8
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
```
This commit is contained in:
Bartek Iwańczuk 2023-06-26 13:54:10 +02:00 • committed by GitHub
parent c7d38e593f
commit ad3c494b46
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
33 changed files with 326 additions and 290 deletions
Download patch file Download diff file Expand all files Collapse all files

13
runtime/Cargo.toml
View file

@ -14,8 +14,15 @@ description = "Provides the deno runtime library"
docsrs = []
# A feature that disables creation of startup snapshot during in the build script.
dont_create_runtime_snapshot = []
# Enable to exclude `js/99_main.js` from the generated snapshot.
exclude_js_main_from_snapshot = []
# A feature that changes how startup snapshot is generated, that allows
# extending it in embedder crates.
snapshot_from_snapshot = []
# A feature that disables embedding of the JavaScript source files in the binary.
# With this feature enabled, the sources must be consumed during build time,
# by creating a startup snapshot.
include_js_files_for_snapshotting = [
"deno_core/include_js_files_for_snapshotting",
]
[lib]
name = "deno_runtime"
@ -34,7 +41,7 @@ deno_ast.workspace = true
deno_broadcast_channel.workspace = true
deno_cache.workspace = true
deno_console.workspace = true
deno_core = { workspace = true, features = ["runtime_js_sources"] }
deno_core.workspace = true
deno_crypto.workspace = true
deno_fetch.workspace = true
deno_ffi.workspace = true

54
runtime/build.rs
View file

@ -264,22 +264,22 @@ mod startup_snapshot {
],
);
#[cfg(not(feature = "exclude_js_main_from_snapshot"))]
#[cfg(not(feature = "snapshot_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: ExtensionFileSourceCode::LoadAtRuntime(PathBuf::from(
"js/99_main.js",
)),
code: deno_core::ExtensionFileSourceCode::IncludedInBinary(
include_str!("js/99_main.js"),
),
}]);
ext.esm_entry_point("ext:runtime_main/js/99_main.js");
}
);
#[cfg(feature = "exclude_js_main_from_snapshot")]
#[cfg(feature = "snapshot_from_snapshot")]
deno_core::extension!(
runtime_main,
deps = [runtime],
@ -294,45 +294,47 @@ 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_ext(),
deno_console::deno_console::init_ext(),
deno_url::deno_url::init_ext(),
deno_web::deno_web::init_ext::<Permissions>(
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_web::BlobStore::default(),
Default::default(),
),
deno_fetch::deno_fetch::init_ext::<Permissions>(Default::default()),
deno_cache::deno_cache::init_ext::<SqliteBackedCache>(None),
deno_websocket::deno_websocket::init_ext::<Permissions>(
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_ext(None),
deno_crypto::deno_crypto::init_ext(None),
deno_broadcast_channel::deno_broadcast_channel::init_ext(
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_broadcast_channel::InMemoryBroadcastChannel::default(),
false, // No --unstable.
),
deno_ffi::deno_ffi::init_ext::<Permissions>(false),
deno_net::deno_net::init_ext::<Permissions>(
deno_ffi::deno_ffi::init_ops_and_esm::<Permissions>(false),
deno_net::deno_net::init_ops_and_esm::<Permissions>(
None, false, // No --unstable.
None,
),
deno_tls::deno_tls::init_ext(),
deno_kv::deno_kv::init_ext(
deno_tls::deno_tls::init_ops_and_esm(),
deno_kv::deno_kv::init_ops_and_esm(
deno_kv::sqlite::SqliteDbHandler::<Permissions>::new(None),
false, // No --unstable
),
deno_napi::deno_napi::init_ext::<Permissions>(),
deno_http::deno_http::init_ext::<DefaultHttpPropertyExtractor>(),
deno_io::deno_io::init_ext(Default::default()),
deno_fs::deno_fs::init_ext::<Permissions>(false, fs.clone()),
runtime::init_ext(),
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(),
// 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_ext::<Permissions>(None, fs),
runtime_main::init_ext(),
deno_node::deno_node::init_ops_and_esm::<Permissions>(None, fs),
runtime_main::init_ops_and_esm(),
];
let output = create_snapshot(CreateSnapshotOptions {

2
runtime/examples/extension_with_esm/main.rs
View file

@ -26,7 +26,7 @@ async fn main() -> Result<(), AnyError> {
PermissionsContainer::allow_all(),
WorkerOptions {
module_loader: Rc::new(FsModuleLoader),
extensions: vec![hello_runtime::init_ext()],
extensions: vec![hello_runtime::init_ops_and_esm()],
..Default::default()
},
);

2
runtime/examples/extension_with_ops/main.rs
View file

@ -28,7 +28,7 @@ async fn main() -> Result<(), AnyError> {
PermissionsContainer::allow_all(),
WorkerOptions {
module_loader: Rc::new(FsModuleLoader),
extensions: vec![hello_runtime::init_ext()],
extensions: vec![hello_runtime::init_ops()],
..Default::default()
},
);

3
runtime/js.rs
View file

@ -14,8 +14,9 @@ pub fn deno_isolate_init() -> Snapshot {
Snapshot::Static(RUNTIME_SNAPSHOT)
}
/// Depends on LTO to be excluded from production binaries if unused.
#[cfg(not(feature = "include_js_files_for_snapshotting"))]
pub static SOURCE_CODE_FOR_99_MAIN_JS: &str = include_str!("js/99_main.js");
#[cfg(feature = "include_js_files_for_snapshotting")]
pub static PATH_FOR_99_MAIN_JS: &str =
concat!(env!("CARGO_MANIFEST_DIR"), "/js/99_main.js");

60
runtime/web_worker.rs
View file

@ -398,14 +398,14 @@ impl WebWorker {
// `runtime/build.rs`, `runtime/worker.rs` and `cli/build.rs`!
let mut extensions: Vec<Extension> = vec![
// Web APIs
deno_webidl::deno_webidl::init_ext(),
deno_console::deno_console::init_ext(),
deno_url::deno_url::init_ext(),
deno_web::deno_web::init_ext::<PermissionsContainer>(
deno_webidl::deno_webidl::init_ops(),
deno_console::deno_console::init_ops(),
deno_url::deno_url::init_ops(),
deno_web::deno_web::init_ops::<PermissionsContainer>(
options.blob_store.clone(),
Some(main_module.clone()),
),
deno_fetch::deno_fetch::init_ext::<PermissionsContainer>(
deno_fetch::deno_fetch::init_ops::<PermissionsContainer>(
deno_fetch::Options {
user_agent: options.bootstrap.user_agent.clone(),
root_cert_store_provider: options.root_cert_store_provider.clone(),
@ -416,57 +416,57 @@ impl WebWorker {
..Default::default()
},
),
deno_cache::deno_cache::init_ext::<SqliteBackedCache>(create_cache),
deno_websocket::deno_websocket::init_ext::<PermissionsContainer>(
deno_cache::deno_cache::init_ops::<SqliteBackedCache>(create_cache),
deno_websocket::deno_websocket::init_ops::<PermissionsContainer>(
options.bootstrap.user_agent.clone(),
options.root_cert_store_provider.clone(),
options.unsafely_ignore_certificate_errors.clone(),
),
deno_webstorage::deno_webstorage::init_ext(None).disable(),
deno_crypto::deno_crypto::init_ext(options.seed),
deno_broadcast_channel::deno_broadcast_channel::init_ext(
deno_webstorage::deno_webstorage::init_ops(None).disable(),
deno_crypto::deno_crypto::init_ops(options.seed),
deno_broadcast_channel::deno_broadcast_channel::init_ops(
options.broadcast_channel.clone(),
unstable,
),
deno_ffi::deno_ffi::init_ext::<PermissionsContainer>(unstable),
deno_net::deno_net::init_ext::<PermissionsContainer>(
deno_ffi::deno_ffi::init_ops::<PermissionsContainer>(unstable),
deno_net::deno_net::init_ops::<PermissionsContainer>(
options.root_cert_store_provider.clone(),
unstable,
options.unsafely_ignore_certificate_errors.clone(),
),
deno_tls::deno_tls::init_ext(),
deno_kv::deno_kv::init_ext(
deno_tls::deno_tls::init_ops(),
deno_kv::deno_kv::init_ops(
SqliteDbHandler::<PermissionsContainer>::new(None),
unstable,
),
deno_napi::deno_napi::init_ext::<PermissionsContainer>(),
deno_http::deno_http::init_ext::<DefaultHttpPropertyExtractor>(),
deno_io::deno_io::init_ext(Some(options.stdio)),
deno_fs::deno_fs::init_ext::<PermissionsContainer>(
deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
deno_http::deno_http::init_ops::<DefaultHttpPropertyExtractor>(),
deno_io::deno_io::init_ops(Some(options.stdio)),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(
unstable,
options.fs.clone(),
),
deno_node::deno_node::init_ext::<PermissionsContainer>(
deno_node::deno_node::init_ops::<PermissionsContainer>(
options.npm_resolver,
options.fs,
),
// Runtime ops that are always initialized for WebWorkers
ops::web_worker::deno_web_worker::init_ext(),
ops::runtime::deno_runtime::init_ext(main_module.clone()),
ops::worker_host::deno_worker_host::init_ext(
ops::web_worker::deno_web_worker::init_ops(),
ops::runtime::deno_runtime::init_ops(main_module.clone()),
ops::worker_host::deno_worker_host::init_ops(
options.create_web_worker_cb.clone(),
options.preload_module_cb.clone(),
options.pre_execute_module_cb.clone(),
options.format_js_error_fn.clone(),
),
ops::fs_events::deno_fs_events::init_ext(),
ops::os::deno_os_worker::init_ext(),
ops::permissions::deno_permissions::init_ext(),
ops::process::deno_process::init_ext(),
ops::signal::deno_signal::init_ext(),
ops::tty::deno_tty::init_ext(),
ops::http::deno_http_runtime::init_ext(),
deno_permissions_web_worker::init_ext(
ops::fs_events::deno_fs_events::init_ops(),
ops::os::deno_os_worker::init_ops(),
ops::permissions::deno_permissions::init_ops(),
ops::process::deno_process::init_ops(),
ops::signal::deno_signal::init_ops(),
ops::tty::deno_tty::init_ops(),
ops::http::deno_http_runtime::init_ops(),
deno_permissions_web_worker::init_ops(
permissions,
unstable,
enable_testing_features,

58
runtime/worker.rs
View file

@ -225,14 +225,14 @@ impl MainWorker {
// `runtime/build.rs`, `runtime/web_worker.rs` and `cli/build.rs`!
let mut extensions = vec![
// Web APIs
deno_webidl::deno_webidl::init_ext(),
deno_console::deno_console::init_ext(),
deno_url::deno_url::init_ext(),
deno_web::deno_web::init_ext::<PermissionsContainer>(
deno_webidl::deno_webidl::init_ops(),
deno_console::deno_console::init_ops(),
deno_url::deno_url::init_ops(),
deno_web::deno_web::init_ops::<PermissionsContainer>(
options.blob_store.clone(),
options.bootstrap.location.clone(),
),
deno_fetch::deno_fetch::init_ext::<PermissionsContainer>(
deno_fetch::deno_fetch::init_ops::<PermissionsContainer>(
deno_fetch::Options {
user_agent: options.bootstrap.user_agent.clone(),
root_cert_store_provider: options.root_cert_store_provider.clone(),
@ -243,60 +243,60 @@ impl MainWorker {
..Default::default()
},
),
deno_cache::deno_cache::init_ext::<SqliteBackedCache>(create_cache),
deno_websocket::deno_websocket::init_ext::<PermissionsContainer>(
deno_cache::deno_cache::init_ops::<SqliteBackedCache>(create_cache),
deno_websocket::deno_websocket::init_ops::<PermissionsContainer>(
options.bootstrap.user_agent.clone(),
options.root_cert_store_provider.clone(),
options.unsafely_ignore_certificate_errors.clone(),
),
deno_webstorage::deno_webstorage::init_ext(
deno_webstorage::deno_webstorage::init_ops(
options.origin_storage_dir.clone(),
),
deno_crypto::deno_crypto::init_ext(options.seed),
deno_broadcast_channel::deno_broadcast_channel::init_ext(
deno_crypto::deno_crypto::init_ops(options.seed),
deno_broadcast_channel::deno_broadcast_channel::init_ops(
options.broadcast_channel.clone(),
unstable,
),
deno_ffi::deno_ffi::init_ext::<PermissionsContainer>(unstable),
deno_net::deno_net::init_ext::<PermissionsContainer>(
deno_ffi::deno_ffi::init_ops::<PermissionsContainer>(unstable),
deno_net::deno_net::init_ops::<PermissionsContainer>(
options.root_cert_store_provider.clone(),
unstable,
options.unsafely_ignore_certificate_errors.clone(),
),
deno_tls::deno_tls::init_ext(),
deno_kv::deno_kv::init_ext(
deno_tls::deno_tls::init_ops(),
deno_kv::deno_kv::init_ops(
SqliteDbHandler::<PermissionsContainer>::new(
options.origin_storage_dir.clone(),
),
unstable,
),
deno_napi::deno_napi::init_ext::<PermissionsContainer>(),
deno_http::deno_http::init_ext::<DefaultHttpPropertyExtractor>(),
deno_io::deno_io::init_ext(Some(options.stdio)),
deno_fs::deno_fs::init_ext::<PermissionsContainer>(
deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
deno_http::deno_http::init_ops::<DefaultHttpPropertyExtractor>(),
deno_io::deno_io::init_ops(Some(options.stdio)),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(
unstable,
options.fs.clone(),
),
deno_node::deno_node::init_ext::<PermissionsContainer>(
deno_node::deno_node::init_ops::<PermissionsContainer>(
options.npm_resolver,
options.fs,
),
// Ops from this crate
ops::runtime::deno_runtime::init_ext(main_module.clone()),
ops::worker_host::deno_worker_host::init_ext(
ops::runtime::deno_runtime::init_ops(main_module.clone()),
ops::worker_host::deno_worker_host::init_ops(
options.create_web_worker_cb.clone(),
options.web_worker_preload_module_cb.clone(),
options.web_worker_pre_execute_module_cb.clone(),
options.format_js_error_fn.clone(),
),
ops::fs_events::deno_fs_events::init_ext(),
ops::os::deno_os::init_ext(exit_code.clone()),
ops::permissions::deno_permissions::init_ext(),
ops::process::deno_process::init_ext(),
ops::signal::deno_signal::init_ext(),
ops::tty::deno_tty::init_ext(),
ops::http::deno_http_runtime::init_ext(),
deno_permissions_worker::init_ext(
ops::fs_events::deno_fs_events::init_ops(),
ops::os::deno_os::init_ops(exit_code.clone()),
ops::permissions::deno_permissions::init_ops(),
ops::process::deno_process::init_ops(),
ops::signal::deno_signal::init_ops(),
ops::tty::deno_tty::init_ops(),
ops::http::deno_http_runtime::init_ops(),
deno_permissions_worker::init_ops(
permissions,
unstable,
enable_testing_features,