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

chore: update to edition 2024 (#29923)
Some checks are pending
ci / publish canary (push) Blocked by required conditions
Details
ci / pre-build (push) Waiting to run
Details
ci / test debug linux-aarch64 (push) Blocked by required conditions
Details
ci / test release linux-aarch64 (push) Blocked by required conditions
Details
ci / test debug macos-aarch64 (push) Blocked by required conditions
Details
ci / test release macos-aarch64 (push) Blocked by required conditions
Details
ci / bench release linux-x86_64 (push) Blocked by required conditions
Details
ci / lint debug linux-x86_64 (push) Blocked by required conditions
Details
ci / lint debug macos-x86_64 (push) Blocked by required conditions
Details
ci / lint debug windows-x86_64 (push) Blocked by required conditions
Details
ci / test debug linux-x86_64 (push) Blocked by required conditions
Details
ci / test release linux-x86_64 (push) Blocked by required conditions
Details
ci / test debug macos-x86_64 (push) Blocked by required conditions
Details
ci / test release macos-x86_64 (push) Blocked by required conditions
Details
ci / test debug windows-x86_64 (push) Blocked by required conditions
Details
ci / test release windows-x86_64 (push) Blocked by required conditions
Details
ci / build libs (push) Blocked by required conditions
Details

Browse source
This commit is contained in:
Nathan Whitaker 2025-07-02 17:59:39 -07:00 • committed by GitHub
parent efac7cd67a
commit 9379a74e08
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
395 changed files with 5532 additions and 4439 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.rustfmt.toml
View file

@ -1,3 +1,3 @@
max_width = 80
tab_spaces = 2
edition = "2021"
edition = "2024"

2
Cargo.toml
View file

@ -53,7 +53,7 @@ exclude = ["tests/util/std/hash/_wasm"]
[workspace.package]
authors = ["the Deno authors"]
edition = "2021"
edition = "2024"
license = "MIT"
repository = "https://github.com/denoland/deno"

2
bench_util/README.md
View file

@ -5,8 +5,8 @@ Example:
```rust
use deno_bench_util::bench_js_sync;
use deno_bench_util::bench_or_profile;
use deno_bench_util::bencher::benchmark_group;
use deno_bench_util::bencher::Bencher;
use deno_bench_util::bencher::benchmark_group;
use deno_core::Extension;
#[op2]

4
bench_util/benches/utf8.rs
View file

@ -1,10 +1,10 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use deno_bench_util::BenchOptions;
use deno_bench_util::bench_js_sync_with;
use deno_bench_util::bench_or_profile;
use deno_bench_util::bencher::benchmark_group;
use deno_bench_util::bencher::Bencher;
use deno_bench_util::BenchOptions;
use deno_bench_util::bencher::benchmark_group;
use deno_core::Extension;
fn setup() -> Vec<Extension> {

2
bench_util/js_runtime.rs
View file

@ -1,10 +1,10 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use bencher::Bencher;
use deno_core::v8;
use deno_core::Extension;
use deno_core::JsRuntime;
use deno_core::PollEventLoopOptions;
use deno_core::RuntimeOptions;
use deno_core::v8;
use crate::profiling::is_profiling;

415
cli/args/flags.rs
View file

@ -4,29 +4,29 @@ use std::collections::HashSet;
use std::env;
use std::ffi::OsString;
use std::net::SocketAddr;
use std::num::NonZeroU32;
use std::num::NonZeroU8;
use std::num::NonZeroU32;
use std::num::NonZeroUsize;
use std::path::Path;
use std::path::PathBuf;
use std::str::FromStr;
use clap::builder::styling::AnsiColor;
use clap::builder::FalseyValueParser;
use clap::error::ErrorKind;
use clap::value_parser;
use clap::Arg;
use clap::ArgAction;
use clap::ArgMatches;
use clap::ColorChoice;
use clap::Command;
use clap::ValueHint;
use clap::builder::FalseyValueParser;
use clap::builder::styling::AnsiColor;
use clap::error::ErrorKind;
use clap::value_parser;
use color_print::cstr;
use deno_config::deno_json::NodeModulesDirMode;
use deno_config::glob::FilePatterns;
use deno_config::glob::PathOrPatternSet;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::resolve_url_or_path;
use deno_core::url::Url;
@ -38,13 +38,13 @@ use deno_npm::NpmSystemInfo;
use deno_npm_installer::PackagesAllowedScripts;
use deno_path_util::normalize_path;
use deno_path_util::url_to_file_path;
use deno_runtime::deno_permissions::SysDescriptor;
use deno_runtime::UnstableFeatureKind;
use deno_runtime::deno_permissions::SysDescriptor;
use deno_telemetry::OtelConfig;
use deno_telemetry::OtelConsoleConfig;
use deno_telemetry::OtelPropagators;
use log::debug;
use log::Level;
use log::debug;
use serde::Deserialize;
use serde::Serialize;
@ -700,7 +700,10 @@ impl Default for TypeCheckMode {
fn parse_packages_allowed_scripts(s: &str) -> Result<String, AnyError> {
if !s.starts_with("npm:") {
bail!("Invalid package for --allow-scripts: '{}'. An 'npm:' specifier is required", s);
bail!(
"Invalid package for --allow-scripts: '{}'. An 'npm:' specifier is required",
s
);
} else {
Ok(s.into())
}
@ -1030,7 +1033,9 @@ impl Flags {
Ok(s) if s.eq_ignore_ascii_case("true") => Some(true),
Ok(s) if s.eq_ignore_ascii_case("false") => Some(false),
Ok(_) => {
log::warn!("'{name}' env var value not recognized, only 'true' and 'false' are accepted");
log::warn!(
"'{name}' env var value not recognized, only 'true' and 'false' are accepted"
);
None
}
Err(_) => None,
@ -1403,10 +1408,9 @@ pub fn flags_from_vec(args: Vec<OsString>) -> clap::error::Result<Flags> {
}
if let Some(help_expansion) = matches.get_one::<String>("help").cloned() {
let mut subcommand = if let Some((sub, _)) = matches.remove_subcommand() {
app.find_subcommand(sub).unwrap().clone()
} else {
app
let mut subcommand = match matches.remove_subcommand() {
Some((sub, _)) => app.find_subcommand(sub).unwrap().clone(),
_ => app,
};
if help_expansion == "full" {
@ -1422,10 +1426,9 @@ pub fn flags_from_vec(args: Vec<OsString>) -> clap::error::Result<Flags> {
help_parse(&mut flags, subcommand);
return Ok(flags);
} else if matches.contains_id("help") {
let subcommand = if let Some((sub, _)) = matches.remove_subcommand() {
app.find_subcommand(sub).unwrap().clone()
} else {
app
let subcommand = match matches.remove_subcommand() {
Some((sub, _)) => app.find_subcommand(sub).unwrap().clone(),
_ => app,
};
help_parse(&mut flags, subcommand);
@ -1452,108 +1455,116 @@ pub fn flags_from_vec(args: Vec<OsString>) -> clap::error::Result<Flags> {
return Ok(flags);
}
if let Some((subcommand, mut m)) = matches.remove_subcommand() {
let pre_subcommand_arg = app
.get_arguments()
.filter(|arg| !arg.is_global_set())
.find(|arg| {
matches
.value_source(arg.get_id().as_str())
.is_some_and(|value| value == clap::parser::ValueSource::CommandLine)
})
.map(|arg| {
format!(
"--{}",
arg.get_long().unwrap_or_else(|| arg.get_id().as_str())
match matches.remove_subcommand() {
Some((subcommand, mut m)) => {
let pre_subcommand_arg = app
.get_arguments()
.filter(|arg| !arg.is_global_set())
.find(|arg| {
matches
.value_source(arg.get_id().as_str())
.is_some_and(|value| {
value == clap::parser::ValueSource::CommandLine
})
})
.map(|arg| {
format!(
"--{}",
arg.get_long().unwrap_or_else(|| arg.get_id().as_str())
)
});
if let Some(arg) = pre_subcommand_arg {
let usage =
app.find_subcommand_mut(&subcommand).unwrap().render_usage();
let mut err =
clap::error::Error::new(ErrorKind::UnknownArgument).with_cmd(&app);
err.insert(
clap::error::ContextKind::InvalidArg,
clap::error::ContextValue::String(arg.clone()),
);
let valid = app.get_styles().get_valid();
let styled_suggestion = clap::builder::StyledStr::from(format!(
"'{}{subcommand} {arg}{}' exists",
valid.render(),
valid.render_reset()
));
err.insert(
clap::error::ContextKind::Suggested,
clap::error::ContextValue::StyledStrs(vec![styled_suggestion]),
);
err.insert(
clap::error::ContextKind::Usage,
clap::error::ContextValue::StyledStr(usage),
);
return Err(err);
}
match subcommand.as_str() {
"add" => add_parse(&mut flags, &mut m)?,
"remove" => remove_parse(&mut flags, &mut m),
"bench" => bench_parse(&mut flags, &mut m)?,
"bundle" => bundle_parse(&mut flags, &mut m)?,
"cache" => cache_parse(&mut flags, &mut m)?,
"check" => check_parse(&mut flags, &mut m)?,
"clean" => clean_parse(&mut flags, &mut m),
"compile" => compile_parse(&mut flags, &mut m)?,
"completions" => completions_parse(&mut flags, &mut m, app),
"coverage" => coverage_parse(&mut flags, &mut m)?,
"doc" => doc_parse(&mut flags, &mut m)?,
"eval" => eval_parse(&mut flags, &mut m)?,
"fmt" => fmt_parse(&mut flags, &mut m)?,
"init" => init_parse(&mut flags, &mut m)?,
"info" => info_parse(&mut flags, &mut m)?,
"install" => install_parse(&mut flags, &mut m, app)?,
"json_reference" => json_reference_parse(&mut flags, &mut m, app),
"jupyter" => jupyter_parse(&mut flags, &mut m),
"lint" => lint_parse(&mut flags, &mut m)?,
"lsp" => lsp_parse(&mut flags, &mut m),
"outdated" => outdated_parse(&mut flags, &mut m, false)?,
"repl" => repl_parse(&mut flags, &mut m)?,
"run" => run_parse(&mut flags, &mut m, app, false)?,
"serve" => serve_parse(&mut flags, &mut m, app)?,
"task" => task_parse(&mut flags, &mut m, app)?,
"test" => test_parse(&mut flags, &mut m)?,
"types" => types_parse(&mut flags, &mut m),
"uninstall" => uninstall_parse(&mut flags, &mut m),
"update" => outdated_parse(&mut flags, &mut m, true)?,
"upgrade" => upgrade_parse(&mut flags, &mut m),
"vendor" => vendor_parse(&mut flags, &mut m),
"publish" => publish_parse(&mut flags, &mut m)?,
_ => unreachable!(),
}
}
_ => {
let has_non_globals = app
.get_arguments()
.filter(|arg| !arg.is_global_set())
.any(|arg| {
matches
.value_source(arg.get_id().as_str())
.is_some_and(|value| {
value != clap::parser::ValueSource::DefaultValue
})
});
if has_non_globals || matches.contains_id("script_arg") {
run_parse(&mut flags, &mut matches, app, true)?;
} else {
handle_repl_flags(
&mut flags,
ReplFlags {
eval_files: None,
eval: None,
is_default_command: true,
},
)
});
if let Some(arg) = pre_subcommand_arg {
let usage = app.find_subcommand_mut(&subcommand).unwrap().render_usage();
let mut err =
clap::error::Error::new(ErrorKind::UnknownArgument).with_cmd(&app);
err.insert(
clap::error::ContextKind::InvalidArg,
clap::error::ContextValue::String(arg.clone()),
);
let valid = app.get_styles().get_valid();
let styled_suggestion = clap::builder::StyledStr::from(format!(
"'{}{subcommand} {arg}{}' exists",
valid.render(),
valid.render_reset()
));
err.insert(
clap::error::ContextKind::Suggested,
clap::error::ContextValue::StyledStrs(vec![styled_suggestion]),
);
err.insert(
clap::error::ContextKind::Usage,
clap::error::ContextValue::StyledStr(usage),
);
return Err(err);
}
match subcommand.as_str() {
"add" => add_parse(&mut flags, &mut m)?,
"remove" => remove_parse(&mut flags, &mut m),
"bench" => bench_parse(&mut flags, &mut m)?,
"bundle" => bundle_parse(&mut flags, &mut m)?,
"cache" => cache_parse(&mut flags, &mut m)?,
"check" => check_parse(&mut flags, &mut m)?,
"clean" => clean_parse(&mut flags, &mut m),
"compile" => compile_parse(&mut flags, &mut m)?,
"completions" => completions_parse(&mut flags, &mut m, app),
"coverage" => coverage_parse(&mut flags, &mut m)?,
"doc" => doc_parse(&mut flags, &mut m)?,
"eval" => eval_parse(&mut flags, &mut m)?,
"fmt" => fmt_parse(&mut flags, &mut m)?,
"init" => init_parse(&mut flags, &mut m)?,
"info" => info_parse(&mut flags, &mut m)?,
"install" => install_parse(&mut flags, &mut m, app)?,
"json_reference" => json_reference_parse(&mut flags, &mut m, app),
"jupyter" => jupyter_parse(&mut flags, &mut m),
"lint" => lint_parse(&mut flags, &mut m)?,
"lsp" => lsp_parse(&mut flags, &mut m),
"outdated" => outdated_parse(&mut flags, &mut m, false)?,
"repl" => repl_parse(&mut flags, &mut m)?,
"run" => run_parse(&mut flags, &mut m, app, false)?,
"serve" => serve_parse(&mut flags, &mut m, app)?,
"task" => task_parse(&mut flags, &mut m, app)?,
"test" => test_parse(&mut flags, &mut m)?,
"types" => types_parse(&mut flags, &mut m),
"uninstall" => uninstall_parse(&mut flags, &mut m),
"update" => outdated_parse(&mut flags, &mut m, true)?,
"upgrade" => upgrade_parse(&mut flags, &mut m),
"vendor" => vendor_parse(&mut flags, &mut m),
"publish" => publish_parse(&mut flags, &mut m)?,
_ => unreachable!(),
}
} else {
let has_non_globals = app
.get_arguments()
.filter(|arg| !arg.is_global_set())
.any(|arg| {
matches
.value_source(arg.get_id().as_str())
.is_some_and(|value| value != clap::parser::ValueSource::DefaultValue)
});
if has_non_globals || matches.contains_id("script_arg") {
run_parse(&mut flags, &mut matches, app, true)?;
} else {
handle_repl_flags(
&mut flags,
ReplFlags {
eval_files: None,
eval: None,
is_default_command: true,
},
)
}
}
}
@ -4995,10 +5006,9 @@ fn bench_parse(
.extend(matches.remove_many::<String>("script_arg").unwrap());
}
let include = if let Some(files) = matches.remove_many::<String>("files") {
files.collect()
} else {
Vec::new()
let include = match matches.remove_many::<String>("files") {
Some(files) => files.collect(),
_ => Vec::new(),
};
let no_run = matches.get_flag("no-run");
@ -5147,11 +5157,11 @@ fn completions_parse(
matches: &mut ArgMatches,
mut app: Command,
) {
use clap_complete::aot::generate;
use clap_complete::aot::Bash;
use clap_complete::aot::Fish;
use clap_complete::aot::PowerShell;
use clap_complete::aot::Zsh;
use clap_complete::aot::generate;
use clap_complete_fig::Fig;
let mut buf: Vec<u8> = vec![];
@ -5729,25 +5739,30 @@ fn run_parse(
flags.code_cache_enabled = !matches.get_flag("no-code-cache");
let coverage_dir = matches.remove_one::<String>("coverage");
if let Some(mut script_arg) = matches.remove_many::<String>("script_arg") {
let script = script_arg.next().unwrap();
flags.argv.extend(script_arg);
flags.subcommand = DenoSubcommand::Run(RunFlags {
script,
watch: watch_arg_parse_with_paths(matches)?,
bare,
coverage_dir,
});
} else if bare {
return Err(app.override_usage("deno [OPTIONS] [COMMAND] [SCRIPT_ARG]...").error(
match matches.remove_many::<String>("script_arg") {
Some(mut script_arg) => {
let script = script_arg.next().unwrap();
flags.argv.extend(script_arg);
flags.subcommand = DenoSubcommand::Run(RunFlags {
script,
watch: watch_arg_parse_with_paths(matches)?,
bare,
coverage_dir,
});
}
_ => {
if bare {
return Err(app.override_usage("deno [OPTIONS] [COMMAND] [SCRIPT_ARG]...").error(
clap::error::ErrorKind::MissingRequiredArgument,
"[SCRIPT_ARG] may only be omitted with --v8-flags=--help, else to use the repl with arguments, please use the `deno repl` subcommand",
));
} else {
return Err(app.find_subcommand_mut("run").unwrap().error(
clap::error::ErrorKind::MissingRequiredArgument,
"[SCRIPT_ARG] may only be omitted with --v8-flags=--help",
));
} else {
return Err(app.find_subcommand_mut("run").unwrap().error(
clap::error::ErrorKind::MissingRequiredArgument,
"[SCRIPT_ARG] may only be omitted with --v8-flags=--help",
));
}
}
}
Ok(())
@ -5847,21 +5862,26 @@ fn task_parse(
eval: matches.get_flag("eval"),
};
if let Some((task, mut matches)) = matches.remove_subcommand() {
task_flags.task = Some(task);
match matches.remove_subcommand() {
Some((task, mut matches)) => {
task_flags.task = Some(task);
flags.argv.extend(
matches
.remove_many::<std::ffi::OsString>("")
.into_iter()
.flatten()
.filter_map(|arg| arg.into_string().ok()),
);
} else if task_flags.eval {
return Err(app.find_subcommand_mut("task").unwrap().error(
clap::error::ErrorKind::MissingRequiredArgument,
"[TASK] must be specified when using --eval",
));
flags.argv.extend(
matches
.remove_many::<std::ffi::OsString>("")
.into_iter()
.flatten()
.filter_map(|arg| arg.into_string().ok()),
);
}
_ => {
if task_flags.eval {
return Err(app.find_subcommand_mut("task").unwrap().error(
clap::error::ErrorKind::MissingRequiredArgument,
"[TASK] must be specified when using --eval",
));
}
}
}
flags.subcommand = DenoSubcommand::Task(task_flags);
@ -5917,10 +5937,9 @@ fn test_parse(
flags.argv.extend(script_arg);
}
let include = if let Some(files) = matches.remove_many::<String>("files") {
files.collect()
} else {
Vec::new()
let include = match matches.remove_many::<String>("files") {
Some(files) => files.collect(),
_ => Vec::new(),
};
let junit_path = matches.remove_one::<String>("junit-path");
@ -9647,7 +9666,8 @@ mod tests {
let r = flags_from_vec(svec![
"deno",
"repl",
"--unsafely-ignore-certificate-errors=deno.land,localhost,[::],127.0.0.1,[::1],1.2.3.4"]);
"--unsafely-ignore-certificate-errors=deno.land,localhost,[::],127.0.0.1,[::1],1.2.3.4"
]);
assert_eq!(
r.unwrap(),
Flags {
@ -11107,10 +11127,11 @@ mod tests {
#[rustfmt::skip]
let r = flags_from_vec(svec!["deno", "run", "--location", "foo:", "mod.ts"]);
assert!(r.is_err());
assert!(r
.unwrap_err()
.to_string()
.contains("Expected protocol \"http\" or \"https\""));
assert!(
r.unwrap_err()
.to_string()
.contains("Expected protocol \"http\" or \"https\"")
);
}
#[test]
@ -11165,8 +11186,10 @@ mod tests {
let r = flags_from_vec(svec!["deno", "run", "--no-clear-screen", "foo.js"]);
assert!(r.is_err());
let error_message = r.unwrap_err().to_string();
assert!(&error_message
.contains("error: the following required arguments were not provided:"));
assert!(
&error_message
.contains("error: the following required arguments were not provided:")
);
assert!(&error_message.contains("--watch[=<FILES>...]"));
}
@ -12236,9 +12259,11 @@ mod tests {
let err = r.unwrap_err();
assert!(err.to_string().contains("error: [SCRIPT_ARG] may only be omitted with --v8-flags=--help, else to use the repl with arguments, please use the `deno repl` subcommand"));
assert!(err
.to_string()
.contains("Usage: deno [OPTIONS] [COMMAND] [SCRIPT_ARG]..."));
assert!(
err
.to_string()
.contains("Usage: deno [OPTIONS] [COMMAND] [SCRIPT_ARG]...")
);
}
#[test]
@ -12248,33 +12273,36 @@ mod tests {
continue;
}
let long_flag = if let DenoSubcommand::Help(help) =
flags_from_vec(svec!["deno", command.get_name(), "--help"])
let long_flag =
match flags_from_vec(svec!["deno", command.get_name(), "--help"])
.unwrap()
.subcommand
{
help.help.to_string()
} else {
unreachable!()
};
let short_flag = if let DenoSubcommand::Help(help) =
flags_from_vec(svec!["deno", command.get_name(), "-h"])
{
DenoSubcommand::Help(help) => help.help.to_string(),
_ => {
unreachable!()
}
};
let short_flag =
match flags_from_vec(svec!["deno", command.get_name(), "-h"])
.unwrap()
.subcommand
{
help.help.to_string()
} else {
unreachable!()
};
let subcommand = if let DenoSubcommand::Help(help) =
flags_from_vec(svec!["deno", "help", command.get_name()])
{
DenoSubcommand::Help(help) => help.help.to_string(),
_ => {
unreachable!()
}
};
let subcommand =
match flags_from_vec(svec!["deno", "help", command.get_name()])
.unwrap()
.subcommand
{
help.help.to_string()
} else {
unreachable!()
};
{
DenoSubcommand::Help(help) => help.help.to_string(),
_ => {
unreachable!()
}
};
assert_eq!(long_flag, short_flag, "{} subcommand", command.get_name());
assert_eq!(long_flag, subcommand, "{} subcommand", command.get_name());
}
@ -12285,10 +12313,11 @@ mod tests {
let r =
flags_from_vec(svec!["deno", "install", "--allow-net", "jsr:@std/fs"]);
assert!(r
.unwrap_err()
.to_string()
.contains("Note: Permission flags can only be used in a global setting"));
assert!(
r.unwrap_err().to_string().contains(
"Note: Permission flags can only be used in a global setting"
)
);
}
#[test]

46
cli/args/mod.rs
View file

@ -35,20 +35,20 @@ use deno_core::error::AnyError;
use deno_core::resolve_url_or_path;
use deno_core::url::Url;
use deno_graph::GraphKind;
use deno_lib::args::CaData;
use deno_lib::args::has_flag_env_var;
use deno_lib::args::npm_pkg_req_ref_to_binary_command;
use deno_lib::args::npm_process_state;
use deno_lib::args::CaData;
use deno_lib::version::DENO_VERSION_INFO;
use deno_lib::worker::StorageKeyResolver;
use deno_npm::NpmSystemInfo;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_npm_installer::LifecycleScriptsConfig;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_resolver::factory::resolve_jsr_url;
use deno_runtime::deno_permissions::PermissionsOptions;
use deno_runtime::inspector_server::InspectorServer;
use deno_semver::npm::NpmPackageReqReference;
use deno_semver::StackString;
use deno_semver::npm::NpmPackageReqReference;
use deno_telemetry::OtelConfig;
use deno_terminal::colors;
use dotenvy::from_filename;
@ -448,7 +448,7 @@ impl WorkspaceMainModuleResolver {
deno_resolver::DenoResolveErrorKind::UnsupportedPackageJsonJsrReq
.into_box()
.into(),
)
);
}
}
}
@ -574,7 +574,11 @@ impl CliOptions {
let maybe_node_channel_fd = std::env::var("NODE_CHANNEL_FD").ok();
if let Some(node_channel_fd) = maybe_node_channel_fd {
// Remove so that child processes don't inherit this environment variable.
std::env::remove_var("NODE_CHANNEL_FD");
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
std::env::remove_var("NODE_CHANNEL_FD")
};
node_channel_fd.parse::<i64>().ok()
} else {
None
@ -1142,7 +1146,11 @@ impl CliOptions {
match std::env::var(NPM_CMD_NAME_ENV_VAR_NAME) {
Ok(var) => {
// remove the env var so that child sub processes won't pick this up
std::env::remove_var(NPM_CMD_NAME_ENV_VAR_NAME);
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
std::env::remove_var(NPM_CMD_NAME_ENV_VAR_NAME)
};
Some(var)
}
Err(_) => NpmPackageReqReference::from_str(&flags.script).ok().map(
@ -1416,10 +1424,28 @@ pub fn load_env_variables_from_env_file(
.unwrap_or(true)
{
match error {
dotenvy::Error::LineParse(line, index)=> eprintln!("{} Parsing failed within the specified environment file: {} at index: {} of the value: {}", colors::yellow("Warning"), env_file_name, index, line),
dotenvy::Error::Io(_)=> eprintln!("{} The `--env-file` flag was used, but the environment file specified '{}' was not found.", colors::yellow("Warning"), env_file_name),
dotenvy::Error::EnvVar(_)=> eprintln!("{} One or more of the environment variables isn't present or not unicode within the specified environment file: {}", colors::yellow("Warning"), env_file_name),
_ => eprintln!("{} Unknown failure occurred with the specified environment file: {}", colors::yellow("Warning"), env_file_name),
dotenvy::Error::LineParse(line, index) => eprintln!(
"{} Parsing failed within the specified environment file: {} at index: {} of the value: {}",
colors::yellow("Warning"),
env_file_name,
index,
line
),
dotenvy::Error::Io(_) => eprintln!(
"{} The `--env-file` flag was used, but the environment file specified '{}' was not found.",
colors::yellow("Warning"),
env_file_name
),
dotenvy::Error::EnvVar(_) => eprintln!(
"{} One or more of the environment variables isn't present or not unicode within the specified environment file: {}",
colors::yellow("Warning"),
env_file_name
),
_ => eprintln!(
"{} Unknown failure occurred with the specified environment file: {}",
colors::yellow("Warning"),
env_file_name
),
}
}
}

4
cli/bench/lsp.rs
View file

@ -7,11 +7,11 @@ use std::time::Duration;
use deno_core::serde::Deserialize;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use lsp_types::Uri;
use test_util::lsp::LspClientBuilder;
use test_util::PathRef;
use test_util::lsp::LspClientBuilder;
use tower_lsp::lsp_types as lsp;
static FIXTURE_CODE_LENS_TS: &str = include_str!("testdata/code_lens.ts");

4
cli/bench/lsp_bench_standalone.rs
View file

@ -1,10 +1,10 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use deno_bench_util::bencher::Bencher;
use deno_bench_util::bencher::benchmark_group;
use deno_bench_util::bencher::benchmark_main;
use deno_bench_util::bencher::Bencher;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use test_util::lsp::LspClient;
use test_util::lsp::LspClientBuilder;

8
cli/cache/cache_db.rs vendored
View file

@ -427,7 +427,11 @@ fn open_connection(
// Failed, try deleting it
let is_tty = std::io::stderr().is_terminal();
log::log!(
if is_tty { log::Level::Warn } else { log::Level::Trace },
if is_tty {
log::Level::Warn
} else {
log::Level::Trace
},
"Could not initialize cache database '{}', deleting and retrying... ({err:?})",
path.to_string_lossy()
);
@ -605,9 +609,9 @@ mod tests {
}
fn assert_same_serialize_deserialize(original_hash: CacheDBHash) {
use rusqlite::ToSql;
use rusqlite::types::FromSql;
use rusqlite::types::ValueRef;
use rusqlite::ToSql;
let value = original_hash.to_sql().unwrap();
match value {

36
cli/cache/code_cache.rs vendored
View file

@ -178,14 +178,16 @@ mod test {
let conn = CacheDB::in_memory(&CODE_CACHE_DB, "1.0.0");
let cache = CodeCacheInner::new(conn);
assert!(cache
.get_sync(
"file:///foo/bar.js",
code_cache::CodeCacheType::EsModule,
CacheDBHash::new(1),
)
.unwrap()
.is_none());
assert!(
cache
.get_sync(
"file:///foo/bar.js",
code_cache::CodeCacheType::EsModule,
CacheDBHash::new(1),
)
.unwrap()
.is_none()
);
let data_esm = vec![1, 2, 3];
cache
.set_sync(
@ -207,14 +209,16 @@ mod test {
data_esm
);
assert!(cache
.get_sync(
"file:///foo/bar.js",
code_cache::CodeCacheType::Script,
CacheDBHash::new(1),
)
.unwrap()
.is_none());
assert!(
cache
.get_sync(
"file:///foo/bar.js",
code_cache::CodeCacheType::Script,
CacheDBHash::new(1),
)
.unwrap()
.is_none()
);
let data_script = vec![4, 5, 6];
cache
.set_sync(

2
cli/cache/incremental.rs vendored
View file

@ -6,8 +6,8 @@ use std::path::PathBuf;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
use deno_core::unsync::spawn;
use deno_core::unsync::JoinHandle;
use deno_core::unsync::spawn;
use deno_runtime::deno_webstorage::rusqlite::params;
use super::cache_db::CacheDB;

2
cli/cache/module_info.rs vendored
View file

@ -316,9 +316,9 @@ fn serialize_media_type(media_type: MediaType) -> i64 {
#[cfg(test)]
mod test {
use deno_graph::PositionRange;
use deno_graph::analysis::JsDocImportInfo;
use deno_graph::analysis::SpecifierWithRange;
use deno_graph::PositionRange;
use super::*;

32
cli/cache/node.rs vendored
View file

@ -7,10 +7,10 @@ use deno_resolver::cjs::analyzer::NodeAnalysisCache;
use deno_resolver::cjs::analyzer::NodeAnalysisCacheSourceHash;
use deno_runtime::deno_webstorage::rusqlite::params;
use super::CacheDBHash;
use super::cache_db::CacheDB;
use super::cache_db::CacheDBConfiguration;
use super::cache_db::CacheFailure;
use super::CacheDBHash;
pub static NODE_ANALYSIS_CACHE_DB: CacheDBConfiguration =
CacheDBConfiguration {
@ -156,10 +156,12 @@ mod test {
let conn = CacheDB::in_memory(&NODE_ANALYSIS_CACHE_DB, "1.0.0");
let cache = NodeAnalysisCacheInner::new(conn);
assert!(cache
.get_cjs_analysis("file.js", CacheDBHash::new(2))
.unwrap()
.is_none());
assert!(
cache
.get_cjs_analysis("file.js", CacheDBHash::new(2))
.unwrap()
.is_none()
);
let cjs_analysis = DenoCjsAnalysis::Cjs(ModuleExportsAndReExports {
exports: vec!["export1".to_string()],
reexports: vec!["re-export1".to_string()],
@ -167,10 +169,12 @@ mod test {
cache
.set_cjs_analysis("file.js", CacheDBHash::new(2), &cjs_analysis)
.unwrap();
assert!(cache
.get_cjs_analysis("file.js", CacheDBHash::new(3))
.unwrap()
.is_none()); // different hash
assert!(
cache
.get_cjs_analysis("file.js", CacheDBHash::new(3))
.unwrap()
.is_none()
); // different hash
let actual_cjs_analysis = cache
.get_cjs_analysis("file.js", CacheDBHash::new(2))
.unwrap()
@ -194,9 +198,11 @@ mod test {
// now changing the cli version should clear it
let conn = cache.conn.recreate_with_version("2.0.0");
let cache = NodeAnalysisCacheInner::new(conn);
assert!(cache
.get_cjs_analysis("file.js", CacheDBHash::new(2))
.unwrap()
.is_none());
assert!(
cache
.get_cjs_analysis("file.js", CacheDBHash::new(2))
.unwrap()
.is_none()
);
}
}

18
cli/factory.rs
View file

@ -6,8 +6,8 @@ use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use deno_cache_dir::npm::NpmCacheDir;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_cache_dir::npm::NpmCacheDir;
use deno_config::workspace::WorkspaceDirectory;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
@ -15,22 +15,22 @@ use deno_core::futures::FutureExt;
use deno_core::serde_json;
use deno_core::url::Url;
use deno_error::JsErrorBox;
use deno_lib::args::CaData;
use deno_lib::args::get_root_cert_store;
use deno_lib::args::npm_process_state;
use deno_lib::args::CaData;
use deno_lib::loader::NpmModuleLoader;
use deno_lib::npm::create_npm_process_state_provider;
use deno_lib::npm::NpmRegistryReadPermissionChecker;
use deno_lib::npm::NpmRegistryReadPermissionCheckerMode;
use deno_lib::npm::create_npm_process_state_provider;
use deno_lib::worker::LibMainWorkerFactory;
use deno_lib::worker::LibMainWorkerOptions;
use deno_lib::worker::LibWorkerFactoryRoots;
use deno_npm::npm_rc::ResolvedNpmRc;
use deno_npm_cache::NpmCacheSetting;
use deno_npm_installer::NpmInstallerFactoryOptions;
use deno_npm_installer::lifecycle_scripts::LifecycleScriptsExecutor;
use deno_npm_installer::lifecycle_scripts::NullLifecycleScriptsExecutor;
use deno_npm_installer::process_state::NpmProcessStateKind;
use deno_npm_installer::NpmInstallerFactoryOptions;
use deno_resolver::cache::ParsedSourceCache;
use deno_resolver::cjs::IsCjsResolutionMode;
use deno_resolver::deno_json::CompilerOptionsResolver;
@ -42,19 +42,19 @@ use deno_resolver::factory::WorkspaceDirectoryProvider;
use deno_resolver::import_map::WorkspaceExternalImportMapLoader;
use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_resolver::workspace::WorkspaceResolver;
use deno_runtime::FeatureChecker;
use deno_runtime::deno_fs;
use deno_runtime::deno_fs::RealFs;
use deno_runtime::deno_permissions::Permissions;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_tls::RootCertStoreProvider;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_web::BlobStore;
use deno_runtime::inspector_server::InspectorServer;
use deno_runtime::permissions::RuntimePermissionDescriptorParser;
use deno_runtime::FeatureChecker;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use node_resolver::NodeConditionOptions;
use node_resolver::NodeResolverOptions;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use once_cell::sync::OnceCell;
use sys_traits::EnvCurrentDir;
@ -72,10 +72,10 @@ use crate::cache::DenoDir;
use crate::cache::GlobalHttpCache;
use crate::cache::ModuleInfoCache;
use crate::cache::SqliteNodeAnalysisCache;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::file_fetcher::CliFileFetcher;
use crate::file_fetcher::CreateCliFileFetcherOptions;
use crate::file_fetcher::TextDecodedFile;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::graph_container::MainModuleGraphContainer;
use crate::graph_util::FileWatcherReporter;
use crate::graph_util::ModuleGraphBuilder;
@ -94,9 +94,9 @@ use crate::npm::CliNpmInstaller;
use crate::npm::CliNpmInstallerFactory;
use crate::npm::CliNpmResolver;
use crate::npm::DenoTaskLifeCycleScriptsExecutor;
use crate::resolver::on_resolve_diagnostic;
use crate::resolver::CliCjsTracker;
use crate::resolver::CliResolver;
use crate::resolver::on_resolve_diagnostic;
use crate::standalone::binary::DenoCompileBinaryWriter;
use crate::sys::CliSys;
use crate::tools::coverage::CoverageCollector;

18
cli/file_fetcher.rs
View file

@ -3,24 +3,24 @@
use std::sync::Arc;
use deno_ast::MediaType;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_cache_dir::file_fetcher::BlobData;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_cache_dir::file_fetcher::File;
use deno_cache_dir::file_fetcher::SendError;
use deno_cache_dir::file_fetcher::SendResponse;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_resolver::file_fetcher::PermissionedFileFetcherOptions;
use deno_runtime::deno_web::BlobStore;
use http::HeaderMap;
use http::StatusCode;
use crate::colors;
use crate::http_util::get_response_body_with_progress;
use crate::http_util::HttpClientProvider;
use crate::http_util::get_response_body_with_progress;
use crate::sys::CliSys;
use crate::util::progress_bar::ProgressBar;
@ -242,8 +242,8 @@ impl deno_cache_dir::file_fetcher::HttpClient for HttpClientAdapter {
mod tests {
use std::collections::HashMap;
use deno_cache_dir::file_fetcher::HttpClient;
use deno_cache_dir::HttpCache;
use deno_cache_dir::file_fetcher::HttpClient;
use deno_core::resolve_url;
use deno_resolver::file_fetcher::FetchErrorKind;
use deno_resolver::file_fetcher::FetchPermissionsOptionRef;
@ -869,7 +869,10 @@ mod tests {
deno_cache_dir::file_fetcher::FetchNoFollowErrorKind::NoRemote {
..
} => {
assert_eq!(err.to_string(), "A remote specifier was requested: \"http://localhost:4545/run/002_hello.ts\", but --no-remote is specified.");
assert_eq!(
err.to_string(),
"A remote specifier was requested: \"http://localhost:4545/run/002_hello.ts\", but --no-remote is specified."
);
}
_ => unreachable!(),
}
@ -924,7 +927,10 @@ mod tests {
deno_cache_dir::file_fetcher::FetchNoFollowErrorKind::NotCached {
..
} => {
assert_eq!(err.to_string(), "Specifier not found in cache: \"http://localhost:4545/run/002_hello.ts\", --cached-only is specified.");
assert_eq!(
err.to_string(),
"Specifier not found in cache: \"http://localhost:4545/run/002_hello.ts\", --cached-only is specified."
);
}
_ => unreachable!(),
}

153
cli/graph_util.rs
View file

@ -11,14 +11,12 @@ use deno_config::deno_json::CompilerOptionTypesDeserializeError;
use deno_config::deno_json::NodeModulesDirMode;
use deno_config::workspace::JsrPackageConfig;
use deno_config::workspace::ToMaybeJsxImportSourceConfigError;
use deno_core::ModuleSpecifier;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
use deno_core::serde_json;
use deno_core::ModuleSpecifier;
use deno_error::JsErrorBox;
use deno_error::JsErrorClass;
use deno_graph::source::Loader;
use deno_graph::source::ResolveError;
use deno_graph::CheckJsOption;
use deno_graph::FillFromLockfileOptions;
use deno_graph::GraphKind;
@ -31,8 +29,10 @@ use deno_graph::ModuleLoadError;
use deno_graph::ResolutionError;
use deno_graph::SpecifierError;
use deno_graph::WorkspaceFastCheckOption;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_graph::source::Loader;
use deno_graph::source::ResolveError;
use deno_npm_installer::PackageCaching;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_path_util::url_to_file_path;
use deno_resolver::cache::ParsedSourceCache;
use deno_resolver::deno_json::CompilerOptionsResolver;
@ -41,16 +41,16 @@ use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_resolver::workspace::sloppy_imports_resolve;
use deno_runtime::deno_node;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_semver::jsr::JsrDepPackageReq;
use deno_semver::SmallStackString;
use deno_semver::jsr::JsrDepPackageReq;
use indexmap::IndexMap;
use sys_traits::FsMetadata;
use crate::args::config_to_deno_graph_workspace_member;
use crate::args::jsr_url;
use crate::args::CliLockfile;
use crate::args::CliOptions;
use crate::args::DenoSubcommand;
use crate::args::config_to_deno_graph_workspace_member;
use crate::args::jsr_url;
use crate::cache;
use crate::cache::GlobalHttpCache;
use crate::cache::ModuleInfoCache;
@ -111,17 +111,18 @@ pub fn graph_valid(
allow_unknown_jsr_exports: options.allow_unknown_jsr_exports,
},
);
if let Some(error) = errors.next() {
Err(error)
} else {
// finally surface the npm resolution result
if let Err(err) = &graph.npm_dep_graph_result {
return Err(JsErrorBox::new(
err.get_class(),
format_deno_graph_error(err),
));
match errors.next() {
Some(error) => Err(error),
_ => {
// finally surface the npm resolution result
if let Err(err) = &graph.npm_dep_graph_result {
return Err(JsErrorBox::new(
err.get_class(),
format_deno_graph_error(err),
));
}
Ok(())
}
Ok(())
}
}
@ -656,7 +657,9 @@ pub enum BuildGraphWithNpmResolutionError {
#[error(transparent)]
Other(#[from] JsErrorBox),
#[class(generic)]
#[error("Resolving npm specifier entrypoints this way is currently not supported with \"nodeModules\": \"manual\". In the meantime, try with --node-modules-dir=auto instead")]
#[error(
"Resolving npm specifier entrypoints this way is currently not supported with \"nodeModules\": \"manual\". In the meantime, try with --node-modules-dir=auto instead"
)]
UnsupportedNpmSpecifierEntrypointResolutionWay,
}
@ -1059,7 +1062,9 @@ pub fn enhanced_resolution_error_message(error: &ResolutionError) -> String {
let maybe_hint = if let Some(specifier) =
get_resolution_error_bare_node_specifier(error)
{
Some(format!("If you want to use a built-in Node module, add a \"node:\" prefix (ex. \"node:{specifier}\")."))
Some(format!(
"If you want to use a built-in Node module, add a \"node:\" prefix (ex. \"node:{specifier}\")."
))
} else {
get_import_prefix_missing_error(error).map(|specifier| {
format!(
@ -1117,73 +1122,61 @@ fn enhanced_integrity_error_message(err: &ModuleError) -> Option<String> {
match err.as_kind() {
ModuleErrorKind::Load {
specifier,
err: ModuleLoadError::Jsr(JsrLoadError::ContentChecksumIntegrity(
checksum_err,
)),
err:
ModuleLoadError::Jsr(JsrLoadError::ContentChecksumIntegrity(checksum_err)),
..
} => {
Some(format!(
concat!(
"Integrity check failed in package. The package may have been tampered with.\n\n",
" Specifier: {}\n",
" Actual: {}\n",
" Expected: {}\n\n",
"If you modified your global cache, run again with the --reload flag to restore ",
"its state. If you want to modify dependencies locally run again with the ",
"--vendor flag or specify `\"vendor\": true` in a deno.json then modify the contents ",
"of the vendor/ folder."
),
specifier,
checksum_err.actual,
checksum_err.expected,
))
}
ModuleErrorKind::Load {
err: ModuleLoadError::Jsr(
JsrLoadError::PackageVersionManifestChecksumIntegrity(
package_nv,
checksum_err,
),
} => Some(format!(
concat!(
"Integrity check failed in package. The package may have been tampered with.\n\n",
" Specifier: {}\n",
" Actual: {}\n",
" Expected: {}\n\n",
"If you modified your global cache, run again with the --reload flag to restore ",
"its state. If you want to modify dependencies locally run again with the ",
"--vendor flag or specify `\"vendor\": true` in a deno.json then modify the contents ",
"of the vendor/ folder."
),
..
} => {
Some(format!(
concat!(
"Integrity check failed for package. The source code is invalid, as it does not match the expected hash in the lock file.\n\n",
" Package: {}\n",
" Actual: {}\n",
" Expected: {}\n\n",
"This could be caused by:\n",
" * the lock file may be corrupt\n",
" * the source itself may be corrupt\n\n",
"Investigate the lockfile; delete it to regenerate the lockfile or --reload to reload the source code from the server."
specifier, checksum_err.actual, checksum_err.expected,
)),
ModuleErrorKind::Load {
err:
ModuleLoadError::Jsr(
JsrLoadError::PackageVersionManifestChecksumIntegrity(
package_nv,
checksum_err,
),
),
package_nv,
checksum_err.actual,
checksum_err.expected,
))
}
..
} => Some(format!(
concat!(
"Integrity check failed for package. The source code is invalid, as it does not match the expected hash in the lock file.\n\n",
" Package: {}\n",
" Actual: {}\n",
" Expected: {}\n\n",
"This could be caused by:\n",
" * the lock file may be corrupt\n",
" * the source itself may be corrupt\n\n",
"Investigate the lockfile; delete it to regenerate the lockfile or --reload to reload the source code from the server."
),
package_nv, checksum_err.actual, checksum_err.expected,
)),
ModuleErrorKind::Load {
specifier,
err: ModuleLoadError::HttpsChecksumIntegrity(checksum_err),
..
} => {
Some(format!(
concat!(
"Integrity check failed for remote specifier. The source code is invalid, as it does not match the expected hash in the lock file.\n\n",
" Specifier: {}\n",
" Actual: {}\n",
" Expected: {}\n\n",
"This could be caused by:\n",
" * the lock file may be corrupt\n",
" * the source itself may be corrupt\n\n",
"Investigate the lockfile; delete it to regenerate the lockfile or --reload to reload the source code from the server."
),
specifier,
checksum_err.actual,
checksum_err.expected,
))
}
} => Some(format!(
concat!(
"Integrity check failed for remote specifier. The source code is invalid, as it does not match the expected hash in the lock file.\n\n",
" Specifier: {}\n",
" Actual: {}\n",
" Expected: {}\n\n",
"This could be caused by:\n",
" * the lock file may be corrupt\n",
" * the source itself may be corrupt\n\n",
"Investigate the lockfile; delete it to regenerate the lockfile or --reload to reload the source code from the server."
),
specifier, checksum_err.actual, checksum_err.expected,
)),
_ => None,
}
}
@ -1430,11 +1423,11 @@ mod test {
use std::sync::Arc;
use deno_ast::ModuleSpecifier;
use deno_graph::source::ResolveError;
use deno_graph::PositionRange;
use deno_graph::Range;
use deno_graph::ResolutionError;
use deno_graph::SpecifierError;
use deno_graph::source::ResolveError;
use super::*;

62
cli/http_util.rs
View file

@ -16,15 +16,15 @@ use deno_error::JsError;
use deno_error::JsErrorBox;
use deno_lib::version::DENO_VERSION_INFO;
use deno_runtime::deno_fetch;
use deno_runtime::deno_fetch::create_http_client;
use deno_runtime::deno_fetch::CreateHttpClientOptions;
use deno_runtime::deno_fetch::ResBody;
use deno_runtime::deno_fetch::create_http_client;
use deno_runtime::deno_tls::RootCertStoreProvider;
use http::header::HeaderName;
use http::header::HeaderValue;
use http::header::CONTENT_LENGTH;
use http::HeaderMap;
use http::StatusCode;
use http::header::CONTENT_LENGTH;
use http::header::HeaderName;
use http::header::HeaderValue;
use http_body_util::BodyExt;
use thiserror::Error;
@ -508,10 +508,10 @@ mod test {
create_http_client(
DENO_VERSION_INFO.user_agent,
CreateHttpClientOptions {
ca_certs: vec![std::fs::read(
test_util::testdata_path().join("tls/RootCA.pem"),
)
.unwrap()],
ca_certs: vec![
std::fs::read(test_util::testdata_path().join("tls/RootCA.pem"))
.unwrap(),
],
..Default::default()
},
)
@ -574,7 +574,9 @@ mod test {
return;
}
panic!("None of the expected public URLs were available but internet appears to be available");
panic!(
"None of the expected public URLs were available but internet appears to be available"
);
}
#[tokio::test]
@ -614,12 +616,14 @@ mod test {
create_http_client(
DENO_VERSION_INFO.user_agent,
CreateHttpClientOptions {
ca_certs: vec![std::fs::read(
test_util::testdata_path()
.join("tls/RootCA.pem")
.to_string(),
)
.unwrap()],
ca_certs: vec![
std::fs::read(
test_util::testdata_path()
.join("tls/RootCA.pem")
.to_string(),
)
.unwrap(),
],
..Default::default()
},
)
@ -647,12 +651,14 @@ mod test {
create_http_client(
DENO_VERSION_INFO.user_agent,
CreateHttpClientOptions {
ca_certs: vec![std::fs::read(
test_util::testdata_path()
.join("tls/RootCA.pem")
.to_string(),
)
.unwrap()],
ca_certs: vec![
std::fs::read(
test_util::testdata_path()
.join("tls/RootCA.pem")
.to_string(),
)
.unwrap(),
],
..Default::default()
},
)
@ -688,12 +694,14 @@ mod test {
create_http_client(
DENO_VERSION_INFO.user_agent,
CreateHttpClientOptions {
ca_certs: vec![std::fs::read(
test_util::testdata_path()
.join("tls/RootCA.pem")
.to_string(),
)
.unwrap()],
ca_certs: vec![
std::fs::read(
test_util::testdata_path()
.join("tls/RootCA.pem")
.to_string(),
)
.unwrap(),
],
..Default::default()
},
)

10
cli/lib/args.rs
View file

@ -4,20 +4,20 @@ use std::io::BufReader;
use std::io::Cursor;
use std::path::PathBuf;
use base64::prelude::Engine;
use base64::prelude::BASE64_STANDARD;
use base64::prelude::Engine;
use deno_npm::resolution::PackageIdNotFoundError;
use deno_npm::resolution::ValidSerializedNpmResolutionSnapshot;
use deno_npm_installer::process_state::NpmProcessState;
use deno_npm_installer::process_state::NpmProcessStateFromEnvVarSys;
use deno_npm_installer::process_state::NpmProcessStateKind;
use deno_runtime::UNSTABLE_ENV_VAR_NAMES;
use deno_runtime::colors;
use deno_runtime::deno_tls::deno_native_certs::load_native_certs;
use deno_runtime::deno_tls::rustls;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_tls::rustls_pemfile;
use deno_runtime::deno_tls::webpki_roots;
use deno_runtime::UNSTABLE_ENV_VAR_NAMES;
use deno_semver::npm::NpmPackageReqReference;
use serde::Deserialize;
use serde::Serialize;
@ -170,7 +170,11 @@ pub fn npm_process_state(
.get_or_init(|| {
use deno_runtime::deno_process::NPM_RESOLUTION_STATE_FD_ENV_VAR_NAME;
let fd_or_path = std::env::var_os(NPM_RESOLUTION_STATE_FD_ENV_VAR_NAME)?;
std::env::remove_var(NPM_RESOLUTION_STATE_FD_ENV_VAR_NAME);
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
std::env::remove_var(NPM_RESOLUTION_STATE_FD_ENV_VAR_NAME)
};
if fd_or_path.is_empty() {
return None;
}

16
cli/lib/loader.rs
View file

@ -9,11 +9,11 @@ use deno_resolver::cjs::CjsTracker;
use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_runtime::deno_core::ModuleSourceCode;
use deno_runtime::deno_core::ModuleType;
use node_resolver::analyze::CjsCodeAnalyzer;
use node_resolver::analyze::NodeCodeTranslator;
use node_resolver::InNpmPackageChecker;
use node_resolver::IsBuiltInNodeModuleChecker;
use node_resolver::NpmPackageFolderResolver;
use node_resolver::analyze::CjsCodeAnalyzer;
use node_resolver::analyze::NodeCodeTranslator;
use thiserror::Error;
use url::Url;
@ -121,12 +121,12 @@ pub struct NpmModuleLoader<
}
impl<
TCjsCodeAnalyzer: CjsCodeAnalyzer,
TInNpmPackageChecker: InNpmPackageChecker,
TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker,
TNpmPackageFolderResolver: NpmPackageFolderResolver,
TSys: DenoLibSys,
>
TCjsCodeAnalyzer: CjsCodeAnalyzer,
TInNpmPackageChecker: InNpmPackageChecker,
TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker,
TNpmPackageFolderResolver: NpmPackageFolderResolver,
TSys: DenoLibSys,
>
NpmModuleLoader<
TCjsCodeAnalyzer,
TInNpmPackageChecker,

2
cli/lib/shared.rs
View file

@ -62,7 +62,7 @@ impl ReleaseChannel {
"rc" => Self::Rc,
"lts" => Self::Lts,
unknown => {
return Err(UnrecognizedReleaseChannelError(unknown.to_string()))
return Err(UnrecognizedReleaseChannelError(unknown.to_string()));
}
})
}

2
cli/lib/standalone/binary.rs
View file

@ -277,7 +277,7 @@ impl<'a> DenoRtDeserializable<'a> for MediaType {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!("Unknown media type value: {value}"),
))
));
}
};
Ok((input, value))

12
cli/lib/standalone/virtual_fs.rs
View file

@ -1,10 +1,10 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use std::cmp::Ordering;
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use std::collections::hash_map::Entry;
use std::fmt;
use std::io::Read;
use std::path::Path;
@ -14,17 +14,17 @@ use std::time::SystemTime;
use deno_path_util::normalize_path;
use deno_path_util::strip_unc_prefix;
use deno_runtime::colors;
use deno_runtime::deno_core::anyhow::bail;
use deno_runtime::deno_core::anyhow::Context;
use deno_runtime::deno_core::anyhow::bail;
use deno_runtime::deno_core::error::AnyError;
use indexmap::IndexSet;
use serde::de;
use serde::de::SeqAccess;
use serde::de::Visitor;
use serde::Deserialize;
use serde::Deserializer;
use serde::Serialize;
use serde::Serializer;
use serde::de;
use serde::de::SeqAccess;
use serde::de::Visitor;
use crate::util::text_encoding::is_valid_utf8;
@ -422,7 +422,7 @@ impl FilesData {
if data.is_empty() {
return OffsetWithLength { offset: 0, len: 0 };
}
let checksum = crate::util::checksum::gen(&[&data]);
let checksum = crate::util::checksum::r#gen(&[&data]);
match self.file_offsets.entry((checksum, data.len())) {
Entry::Occupied(occupied_entry) => {
let offset_and_len = *occupied_entry.get();

4
cli/lib/util/checksum.rs
View file

@ -4,7 +4,7 @@ use aws_lc_rs::digest::Context;
use aws_lc_rs::digest::SHA256;
/// Generate a SHA256 checksum of a slice of byte-slice-like things.
pub fn gen(v: &[impl AsRef<[u8]>]) -> String {
pub fn r#gen(v: &[impl AsRef<[u8]>]) -> String {
let mut ctx = Context::new(&SHA256);
for src in v {
ctx.update(src.as_ref());
@ -18,7 +18,7 @@ mod tests {
#[test]
fn test_gen() {
let actual = gen(&[b"hello world"]);
let actual = r#gen(&[b"hello world"]);
assert_eq!(
actual,
"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

22
cli/lib/worker.rs
View file

@ -11,17 +11,22 @@ use deno_path_util::url_from_file_path;
use deno_path_util::url_to_file_path;
use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_resolver::npm::NpmResolver;
use deno_runtime::BootstrapOptions;
use deno_runtime::FeatureChecker;
use deno_runtime::UNSTABLE_FEATURES;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::WorkerLogLevel;
use deno_runtime::colors;
use deno_runtime::deno_broadcast_channel::InMemoryBroadcastChannel;
use deno_runtime::deno_core;
use deno_runtime::deno_core::error::CoreError;
use deno_runtime::deno_core::v8;
use deno_runtime::deno_core::CompiledWasmModuleStore;
use deno_runtime::deno_core::Extension;
use deno_runtime::deno_core::JsRuntime;
use deno_runtime::deno_core::LocalInspectorSession;
use deno_runtime::deno_core::ModuleLoader;
use deno_runtime::deno_core::SharedArrayBufferStore;
use deno_runtime::deno_core::error::CoreError;
use deno_runtime::deno_core::v8;
use deno_runtime::deno_fs;
use deno_runtime::deno_napi::DenoRtNativeAddonLoaderRc;
use deno_runtime::deno_node::NodeExtInitServices;
@ -41,13 +46,8 @@ use deno_runtime::web_worker::WebWorkerServiceOptions;
use deno_runtime::worker::MainWorker;
use deno_runtime::worker::WorkerOptions;
use deno_runtime::worker::WorkerServiceOptions;
use deno_runtime::BootstrapOptions;
use deno_runtime::FeatureChecker;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::WorkerLogLevel;
use deno_runtime::UNSTABLE_FEATURES;
use node_resolver::errors::ResolvePkgJsonBinExportError;
use node_resolver::UrlOrPath;
use node_resolver::errors::ResolvePkgJsonBinExportError;
use url::Url;
use crate::args::has_trace_permissions_enabled;
@ -425,7 +425,7 @@ impl<TSys: DenoLibSys> LibWorkerFactorySharedState<TSys> {
.resolve_storage_key(&args.main_module);
let cache_storage_dir = maybe_storage_key.map(|key| {
// TODO(@satyarohith): storage quota management
get_cache_storage_dir().join(checksum::gen(&[key.as_bytes()]))
get_cache_storage_dir().join(checksum::r#gen(&[key.as_bytes()]))
});
// TODO(bartlomieju): this is cruft, update FeatureChecker to spit out
@ -616,11 +616,11 @@ impl<TSys: DenoLibSys> LibMainWorkerFactory<TSys> {
.origin_data_folder_path
.as_ref()
.unwrap() // must be set if storage key resolver returns a value
.join(checksum::gen(&[key.as_bytes()]))
.join(checksum::r#gen(&[key.as_bytes()]))
});
let cache_storage_dir = maybe_storage_key.map(|key| {
// TODO(@satyarohith): storage quota management
get_cache_storage_dir().join(checksum::gen(&[key.as_bytes()]))
get_cache_storage_dir().join(checksum::r#gen(&[key.as_bytes()]))
});
let services = WorkerServiceOptions {

14
cli/lsp/analysis.rs
View file

@ -10,6 +10,7 @@ use std::sync::Arc;
use deno_ast::SourceRange;
use deno_ast::SourceRangedForSpanned;
use deno_ast::SourceTextInfo;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::resolve_url;
@ -18,13 +19,15 @@ use deno_core::serde::Serialize;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_error::JsErrorBox;
use deno_lint::diagnostic::LintDiagnosticRange;
use deno_npm::NpmPackageId;
use deno_path_util::url_to_file_path;
use deno_resolver::npm::managed::NpmResolutionCell;
use deno_runtime::deno_node::PathClean;
use deno_semver::SmallStackString;
use deno_semver::StackString;
use deno_semver::Version;
use deno_semver::jsr::JsrPackageNvReference;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;
@ -32,9 +35,6 @@ use deno_semver::package::PackageNv;
use deno_semver::package::PackageNvReference;
use deno_semver::package::PackageReq;
use deno_semver::package::PackageReqReference;
use deno_semver::SmallStackString;
use deno_semver::StackString;
use deno_semver::Version;
use import_map::ImportMap;
use lsp_types::Uri;
use node_resolver::InNpmPackageChecker;
@ -632,11 +632,7 @@ fn maybe_reverse_definitely_typed(
.filter_map(|(req, nv)| (*nv.name == package_name).then_some(req))
.collect::<Vec<_>>();
if reqs.is_empty() {
None
} else {
Some(reqs)
}
if reqs.is_empty() { None } else { Some(reqs) }
}
fn try_reverse_map_package_json_exports(

2
cli/lsp/cache.rs
View file

@ -6,8 +6,8 @@ use std::path::Path;
use std::sync::Arc;
use std::time::SystemTime;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_core::url::Url;
use deno_path_util::url_to_file_path;
use crate::cache::DenoDir;

4
cli/lsp/capabilities.rs
View file

@ -37,8 +37,8 @@ fn code_action_capabilities(
.unwrap_or(CodeActionProviderCapability::Simple(true))
}
pub fn semantic_tokens_registration_options(
) -> SemanticTokensRegistrationOptions {
pub fn semantic_tokens_registration_options()
-> SemanticTokensRegistrationOptions {
const LANGUAGES: [&str; 4] = [
"javascript",
"javascriptreact",

2
cli/lsp/client.rs
View file

@ -12,8 +12,8 @@ use lsp_types::Uri;
use tower_lsp::lsp_types as lsp;
use tower_lsp::lsp_types::ConfigurationItem;
use super::config::WorkspaceSettings;
use super::config::SETTINGS_SECTION;
use super::config::WorkspaceSettings;
use super::lsp_custom;
use super::testing::lsp_custom as testing_lsp_custom;
use crate::lsp::repl::get_repl_workspace_settings;

8
cli/lsp/code_lens.rs
View file

@ -5,18 +5,18 @@ use std::collections::HashSet;
use std::rc::Rc;
use std::sync::Arc;
use deno_ast::swc::ast;
use deno_ast::swc::ecma_visit::Visit;
use deno_ast::swc::ecma_visit::VisitWith;
use deno_ast::ParsedSource;
use deno_ast::SourceRange;
use deno_ast::SourceRangedForSpanned;
use deno_ast::swc::ast;
use deno_ast::swc::ecma_visit::Visit;
use deno_ast::swc::ecma_visit::VisitWith;
use deno_core::ModuleSpecifier;
use deno_core::error::AnyError;
use deno_core::serde::Deserialize;
use deno_core::serde::Serialize;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::ModuleSpecifier;
use lazy_regex::lazy_regex;
use lsp_types::Uri;
use once_cell::sync::Lazy;

207
cli/lsp/completions.rs
View file

@ -2,13 +2,13 @@
use deno_ast::LineAndColumnIndex;
use deno_ast::SourceTextInfo;
use deno_core::ModuleSpecifier;
use deno_core::resolve_path;
use deno_core::resolve_url;
use deno_core::serde::Deserialize;
use deno_core::serde::Serialize;
use deno_core::serde_json::json;
use deno_core::url::Position;
use deno_core::ModuleSpecifier;
use deno_path_util::url_to_file_path;
use deno_runtime::deno_node::SUPPORTED_BUILTIN_NODE_MODULES;
use deno_semver::jsr::JsrPackageReqReference;
@ -180,7 +180,7 @@ pub async fn get_import_completions(
NodeResolutionKind::Execution,
)
.ok();
if let Some(completion_list) = get_jsr_completions(
match get_jsr_completions(
&module.specifier,
text,
&range,
@ -190,85 +190,128 @@ pub async fn get_import_completions(
)
.await
{
Some(lsp::CompletionResponse::List(completion_list))
} else if let Some(completion_list) =
get_npm_completions(&module.specifier, text, &range, npm_search_api).await
{
Some(lsp::CompletionResponse::List(completion_list))
} else if let Some(completion_list) = get_node_completions(text, &range) {
Some(lsp::CompletionResponse::List(completion_list))
} else if let Some(completion_list) = get_import_map_completions(
&module.specifier,
text,
&range,
maybe_import_map,
) {
// completions for import map specifiers
Some(lsp::CompletionResponse::List(completion_list))
} else if let Some(completion_list) = get_local_completions(
&module.specifier,
resolution_mode,
text,
&range,
resolver,
) {
// completions for local relative modules
Some(lsp::CompletionResponse::List(completion_list))
} else if !text.is_empty() {
// completion of modules from a module registry or cache
check_auto_config_registry(
text,
config.workspace_settings_for_specifier(&module.specifier),
client,
module_registries,
)
.await;
let maybe_list = module_registries
.get_completions(text, &range, resolved.as_ref(), |s| {
document_modules.specifier_exists(s, module.scope.as_deref())
})
.await;
let maybe_list = maybe_list
.or_else(|| module_registries.get_origin_completions(text, &range));
let list = maybe_list.unwrap_or_else(|| CompletionList {
items: get_remote_completions(module, text, &range, document_modules),
is_incomplete: false,
});
Some(lsp::CompletionResponse::List(list))
} else {
// the import specifier is empty, so provide all possible specifiers we are
// aware of
let mut items: Vec<lsp::CompletionItem> = LOCAL_PATHS
.iter()
.map(|s| lsp::CompletionItem {
label: s.to_string(),
kind: Some(lsp::CompletionItemKind::FOLDER),
detail: Some("(local)".to_string()),
sort_text: Some("1".to_string()),
insert_text: Some(s.to_string()),
commit_characters: Some(
IMPORT_COMMIT_CHARS.iter().map(|&c| c.into()).collect(),
),
..Default::default()
})
.collect();
let mut is_incomplete = false;
if let Some(import_map) = maybe_import_map {
items.extend(get_base_import_map_completions(
import_map,
&module.specifier,
));
Some(completion_list) => {
Some(lsp::CompletionResponse::List(completion_list))
}
if let Some(origin_items) =
module_registries.get_origin_completions(text, &range)
{
is_incomplete = origin_items.is_incomplete;
items.extend(origin_items.items);
_ => {
match get_npm_completions(&module.specifier, text, &range, npm_search_api)
.await
{
Some(completion_list) => {
Some(lsp::CompletionResponse::List(completion_list))
}
_ => {
match get_node_completions(text, &range) {
Some(completion_list) => {
Some(lsp::CompletionResponse::List(completion_list))
}
_ => {
match get_import_map_completions(
&module.specifier,
text,
&range,
maybe_import_map,
) {
Some(completion_list) => {
// completions for import map specifiers
Some(lsp::CompletionResponse::List(completion_list))
}
_ => {
match get_local_completions(
&module.specifier,
resolution_mode,
text,
&range,
resolver,
) {
Some(completion_list) => {
// completions for local relative modules
Some(lsp::CompletionResponse::List(completion_list))
}
_ => {
if !text.is_empty() {
// completion of modules from a module registry or cache
check_auto_config_registry(
text,
config.workspace_settings_for_specifier(
&module.specifier,
),
client,
module_registries,
)
.await;
let maybe_list = module_registries
.get_completions(
text,
&range,
resolved.as_ref(),
|s| {
document_modules
.specifier_exists(s, module.scope.as_deref())
},
)
.await;
let maybe_list = maybe_list.or_else(|| {
module_registries.get_origin_completions(text, &range)
});
let list =
maybe_list.unwrap_or_else(|| CompletionList {
items: get_remote_completions(
module,
text,
&range,
document_modules,
),
is_incomplete: false,
});
Some(lsp::CompletionResponse::List(list))
} else {
// the import specifier is empty, so provide all possible specifiers we are
// aware of
let mut items: Vec<lsp::CompletionItem> = LOCAL_PATHS
.iter()
.map(|s| lsp::CompletionItem {
label: s.to_string(),
kind: Some(lsp::CompletionItemKind::FOLDER),
detail: Some("(local)".to_string()),
sort_text: Some("1".to_string()),
insert_text: Some(s.to_string()),
commit_characters: Some(
IMPORT_COMMIT_CHARS
.iter()
.map(|&c| c.into())
.collect(),
),
..Default::default()
})
.collect();
let mut is_incomplete = false;
if let Some(import_map) = maybe_import_map {
items.extend(get_base_import_map_completions(
import_map,
&module.specifier,
));
}
if let Some(origin_items) =
module_registries.get_origin_completions(text, &range)
{
is_incomplete = origin_items.is_incomplete;
items.extend(origin_items.items);
}
Some(lsp::CompletionResponse::List(CompletionList {
is_incomplete,
items,
}))
}
}
}
}
}
}
}
}
}
}
Some(lsp::CompletionResponse::List(CompletionList {
is_incomplete,
items,
}))
}
}
@ -909,8 +952,10 @@ mod tests {
for item in actual.items {
match item.text_edit {
Some(lsp::CompletionTextEdit::Edit(text_edit)) => {
assert!(["./b", "./f.mjs", "./g.json"]
.contains(&text_edit.new_text.as_str()));
assert!(
["./b", "./f.mjs", "./g.json"]
.contains(&text_edit.new_text.as_str())
);
}
_ => unreachable!(),
}

58
cli/lsp/config.rs
View file

@ -28,27 +28,27 @@ use deno_config::workspace::WorkspaceDirLintConfig;
use deno_config::workspace::WorkspaceDirectory;
use deno_config::workspace::WorkspaceDirectoryEmptyOptions;
use deno_config::workspace::WorkspaceDiscoverOptions;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
use deno_core::serde::de::DeserializeOwned;
use deno_core::serde::Deserialize;
use deno_core::serde::Serialize;
use deno_core::serde::de::DeserializeOwned;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_lib::args::has_flag_env_var;
use deno_lib::util::hash::FastInsecureHasher;
use deno_lint::linter::LintConfig as DenoLintConfig;
use deno_npm::npm_rc::ResolvedNpmRc;
use deno_npm_cache::NpmCacheSetting;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_npm_installer::lifecycle_scripts::NullLifecycleScriptsExecutor;
use deno_npm_installer::LifecycleScriptsConfig;
use deno_npm_installer::NpmInstallerFactory;
use deno_npm_installer::NpmInstallerFactoryOptions;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_npm_installer::lifecycle_scripts::NullLifecycleScriptsExecutor;
use deno_package_json::PackageJsonCache;
use deno_path_util::url_to_file_path;
use deno_resolver::factory::ConfigDiscoveryOption;
@ -704,7 +704,9 @@ impl WorkspaceSettings {
let inlay_hints: InlayHintsSettings =
parse_or_default(inlay_hints, "settings under \"deno.inlayHints\"");
if inlay_hints.parameter_names.enabled != Default::default() {
lsp_warn!("\"deno.inlayHints.parameterNames.enabled\" is deprecated. Instead use \"javascript.inlayHints.parameterNames.enabled\" and \"typescript.inlayHints.parameterNames.enabled\".");
lsp_warn!(
"\"deno.inlayHints.parameterNames.enabled\" is deprecated. Instead use \"javascript.inlayHints.parameterNames.enabled\" and \"typescript.inlayHints.parameterNames.enabled\"."
);
settings.javascript.inlay_hints.parameter_names.enabled =
inlay_hints.parameter_names.enabled.clone();
settings.typescript.inlay_hints.parameter_names.enabled =
@ -714,7 +716,9 @@ impl WorkspaceSettings {
.parameter_names
.suppress_when_argument_matches_name
{
lsp_warn!("\"deno.inlayHints.parameterNames.suppressWhenArgumentMatchesName\" is deprecated. Instead use \"javascript.inlayHints.parameterNames.suppressWhenArgumentMatchesName\" and \"typescript.inlayHints.parameterNames.suppressWhenArgumentMatchesName\".");
lsp_warn!(
"\"deno.inlayHints.parameterNames.suppressWhenArgumentMatchesName\" is deprecated. Instead use \"javascript.inlayHints.parameterNames.suppressWhenArgumentMatchesName\" and \"typescript.inlayHints.parameterNames.suppressWhenArgumentMatchesName\"."
);
settings
.javascript
.inlay_hints
@ -731,21 +735,27 @@ impl WorkspaceSettings {
.suppress_when_argument_matches_name;
}
if inlay_hints.parameter_types.enabled {
lsp_warn!("\"deno.inlayHints.parameterTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.parameterTypes.enabled\" and \"typescript.inlayHints.parameterTypes.enabled\".");
lsp_warn!(
"\"deno.inlayHints.parameterTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.parameterTypes.enabled\" and \"typescript.inlayHints.parameterTypes.enabled\"."
);
settings.javascript.inlay_hints.parameter_types.enabled =
inlay_hints.parameter_types.enabled;
settings.typescript.inlay_hints.parameter_types.enabled =
inlay_hints.parameter_types.enabled;
}
if inlay_hints.variable_types.enabled {
lsp_warn!("\"deno.inlayHints.variableTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.variableTypes.enabled\" and \"typescript.inlayHints.variableTypes.enabled\".");
lsp_warn!(
"\"deno.inlayHints.variableTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.variableTypes.enabled\" and \"typescript.inlayHints.variableTypes.enabled\"."
);
settings.javascript.inlay_hints.variable_types.enabled =
inlay_hints.variable_types.enabled;
settings.typescript.inlay_hints.variable_types.enabled =
inlay_hints.variable_types.enabled;
}
if !inlay_hints.variable_types.suppress_when_type_matches_name {
lsp_warn!("\"deno.inlayHints.variableTypes.suppressWhenTypeMatchesName\" is deprecated. Instead use \"javascript.inlayHints.variableTypes.suppressWhenTypeMatchesName\" and \"typescript.inlayHints.variableTypes.suppressWhenTypeMatchesName\".");
lsp_warn!(
"\"deno.inlayHints.variableTypes.suppressWhenTypeMatchesName\" is deprecated. Instead use \"javascript.inlayHints.variableTypes.suppressWhenTypeMatchesName\" and \"typescript.inlayHints.variableTypes.suppressWhenTypeMatchesName\"."
);
settings
.javascript
.inlay_hints
@ -760,7 +770,9 @@ impl WorkspaceSettings {
inlay_hints.variable_types.suppress_when_type_matches_name;
}
if inlay_hints.property_declaration_types.enabled {
lsp_warn!("\"deno.inlayHints.propertyDeclarationTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.propertyDeclarationTypes.enabled\" and \"typescript.inlayHints.propertyDeclarationTypes.enabled\".");
lsp_warn!(
"\"deno.inlayHints.propertyDeclarationTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.propertyDeclarationTypes.enabled\" and \"typescript.inlayHints.propertyDeclarationTypes.enabled\"."
);
settings
.javascript
.inlay_hints
@ -773,7 +785,9 @@ impl WorkspaceSettings {
.enabled = inlay_hints.property_declaration_types.enabled;
}
if inlay_hints.function_like_return_types.enabled {
lsp_warn!("\"deno.inlayHints.functionLikeReturnTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.functionLikeReturnTypes.enabled\" and \"typescript.inlayHints.functionLikeReturnTypes.enabled\".");
lsp_warn!(
"\"deno.inlayHints.functionLikeReturnTypes.enabled\" is deprecated. Instead use \"javascript.inlayHints.functionLikeReturnTypes.enabled\" and \"typescript.inlayHints.functionLikeReturnTypes.enabled\"."
);
settings
.javascript
.inlay_hints
@ -786,7 +800,9 @@ impl WorkspaceSettings {
.enabled = inlay_hints.function_like_return_types.enabled;
}
if inlay_hints.enum_member_values.enabled {
lsp_warn!("\"deno.inlayHints.enumMemberValues.enabled\" is deprecated. Instead use \"javascript.inlayHints.enumMemberValues.enabled\" and \"typescript.inlayHints.enumMemberValues.enabled\".");
lsp_warn!(
"\"deno.inlayHints.enumMemberValues.enabled\" is deprecated. Instead use \"javascript.inlayHints.enumMemberValues.enabled\" and \"typescript.inlayHints.enumMemberValues.enabled\"."
);
settings.javascript.inlay_hints.enum_member_values.enabled =
inlay_hints.enum_member_values.enabled;
settings.typescript.inlay_hints.enum_member_values.enabled =
@ -797,24 +813,32 @@ impl WorkspaceSettings {
let suggest: CompletionSettings =
parse_or_default(suggest, "settings under \"deno.suggest\"");
if suggest.complete_function_calls {
lsp_warn!("\"deno.suggest.completeFunctionCalls\" is deprecated. Instead use \"javascript.suggest.completeFunctionCalls\" and \"typescript.suggest.completeFunctionCalls\".");
lsp_warn!(
"\"deno.suggest.completeFunctionCalls\" is deprecated. Instead use \"javascript.suggest.completeFunctionCalls\" and \"typescript.suggest.completeFunctionCalls\"."
);
settings.javascript.suggest.complete_function_calls =
suggest.complete_function_calls;
settings.typescript.suggest.complete_function_calls =
suggest.complete_function_calls;
}
if !suggest.names {
lsp_warn!("\"deno.suggest.names\" is deprecated. Instead use \"javascript.suggest.names\" and \"typescript.suggest.names\".");
lsp_warn!(
"\"deno.suggest.names\" is deprecated. Instead use \"javascript.suggest.names\" and \"typescript.suggest.names\"."
);
settings.javascript.suggest.names = suggest.names;
settings.typescript.suggest.names = suggest.names;
}
if !suggest.paths {
lsp_warn!("\"deno.suggest.paths\" is deprecated. Instead use \"javascript.suggest.paths\" and \"typescript.suggest.paths\".");
lsp_warn!(
"\"deno.suggest.paths\" is deprecated. Instead use \"javascript.suggest.paths\" and \"typescript.suggest.paths\"."
);
settings.javascript.suggest.paths = suggest.paths;
settings.typescript.suggest.paths = suggest.paths;
}
if !suggest.auto_imports {
lsp_warn!("\"deno.suggest.autoImports\" is deprecated. Instead use \"javascript.suggest.autoImports\" and \"typescript.suggest.autoImports\".");
lsp_warn!(
"\"deno.suggest.autoImports\" is deprecated. Instead use \"javascript.suggest.autoImports\" and \"typescript.suggest.autoImports\"."
);
settings.javascript.suggest.auto_imports = suggest.auto_imports;
settings.typescript.suggest.auto_imports = suggest.auto_imports;
}

229
cli/lsp/diagnostics.rs
View file

@ -5,13 +5,14 @@ use std::collections::HashMap;
use std::collections::HashSet;
use std::path::PathBuf;
use std::str::FromStr;
use std::sync::atomic::AtomicUsize;
use std::sync::Arc;
use std::sync::atomic::AtomicUsize;
use std::thread;
use deno_ast::MediaType;
use deno_config::glob::FilePatterns;
use deno_config::workspace::WorkspaceDirLintConfig;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
@ -20,15 +21,14 @@ use deno_core::resolve_url;
use deno_core::serde::Deserialize;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::unsync::JoinHandle;
use deno_core::unsync::spawn;
use deno_core::unsync::spawn_blocking;
use deno_core::unsync::JoinHandle;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_graph::source::ResolveError;
use deno_graph::Resolution;
use deno_graph::ResolutionError;
use deno_graph::SpecifierError;
use deno_graph::source::ResolveError;
use deno_lint::linter::LintConfig as DenoLintConfig;
use deno_resolver::workspace::sloppy_imports_resolve;
use deno_runtime::deno_node;
@ -41,8 +41,8 @@ use import_map::ImportMapErrorKind;
use log::error;
use lsp_types::Uri;
use node_resolver::NodeResolutionKind;
use tokio::sync::mpsc;
use tokio::sync::Mutex as AsyncMutex;
use tokio::sync::mpsc;
use tokio::time::Duration;
use tokio_util::sync::CancellationToken;
use tower_lsp::lsp_types as lsp;
@ -459,13 +459,13 @@ impl DeferredDiagnostics {
}
let mut regex_string = ambient_modules_to_regex_string(&value);
regex_string.push('$');
if let Ok(regex) = regex::Regex::new(&regex_string).inspect_err(|e| {
match regex::Regex::new(&regex_string).inspect_err(|e| {
lsp_warn!("failed to compile ambient modules pattern: {e} (pattern is {regex_string:?})");
}) {
}) { Ok(regex) => {
ambient.regex = Some(regex);
} else {
} _ => {
ambient.regex = None;
}
}}
}
}
}
@ -1029,15 +1029,12 @@ fn generate_document_lint_diagnostics(
.and_then(|d| d.parsed_source.as_ref())
{
Some(Ok(parsed_source)) => {
if let Ok(references) =
analysis::get_lint_references(parsed_source, linter, token)
{
references
match analysis::get_lint_references(parsed_source, linter, token) {
Ok(references) => references
.into_iter()
.map(|r| r.to_diagnostic())
.collect::<Vec<_>>()
} else {
Vec::new()
.collect::<Vec<_>>(),
_ => Vec::new(),
}
}
Some(Err(_)) => Vec::new(),
@ -1383,7 +1380,7 @@ impl DenoDiagnostic {
return Err(anyhow!(
"Unsupported diagnostic code (\"{}\") provided.",
code
))
));
}
};
Ok(code_action)
@ -1587,105 +1584,127 @@ fn diagnose_resolution(
diagnostics.push(DenoDiagnostic::DenoWarn(message.clone()));
}
}
if let Some(module) = snapshot
match snapshot
.document_modules
.module_for_specifier(specifier, referrer_module.scope.as_deref())
{
if let Some(headers) = &module.headers {
if let Some(message) = headers.get("x-deno-warning") {
diagnostics.push(DenoDiagnostic::DenoWarn(message.clone()));
Some(module) => {
if let Some(headers) = &module.headers {
if let Some(message) = headers.get("x-deno-warning") {
diagnostics.push(DenoDiagnostic::DenoWarn(message.clone()));
}
}
}
if module.media_type == MediaType::Json {
match maybe_assert_type {
// The module has the correct assertion type, no diagnostic
Some("json") => (),
// The dynamic import statement is missing an attribute type, which
// we might not be able to statically detect, therefore we will
// not provide a potentially incorrect diagnostic.
None if is_dynamic => (),
// The module has an incorrect assertion type, diagnostic
Some(assert_type) => diagnostics.push(
DenoDiagnostic::InvalidAttributeType(assert_type.to_string()),
),
// The module is missing an attribute type, diagnostic
None => diagnostics.push(DenoDiagnostic::NoAttributeType),
}
}
} else if let Ok(pkg_ref) =
JsrPackageReqReference::from_specifier(specifier)
{
let req = pkg_ref.into_inner().req;
diagnostics
.push(DenoDiagnostic::NotInstalledJsr(req, specifier.clone()));
} else if let Ok(pkg_ref) =
NpmPackageReqReference::from_specifier(specifier)
{
if let Some(npm_resolver) = managed_npm_resolver {
// show diagnostics for npm package references that aren't cached
let req = pkg_ref.req();
if !npm_resolver.is_pkg_req_folder_cached(req) {
diagnostics.push(DenoDiagnostic::NotInstalledNpm(
req.clone(),
specifier.clone(),
));
} else {
let resolution_kinds =
[NodeResolutionKind::Types, NodeResolutionKind::Execution];
if resolution_kinds.into_iter().all(|k| {
scoped_resolver
.npm_to_file_url(
&pkg_ref,
&referrer_module.specifier,
k,
referrer_module.resolution_mode,
)
.is_none()
}) {
diagnostics.push(DenoDiagnostic::NoExportNpm(pkg_ref.clone()));
if module.media_type == MediaType::Json {
match maybe_assert_type {
// The module has the correct assertion type, no diagnostic
Some("json") => (),
// The dynamic import statement is missing an attribute type, which
// we might not be able to statically detect, therefore we will
// not provide a potentially incorrect diagnostic.
None if is_dynamic => (),
// The module has an incorrect assertion type, diagnostic
Some(assert_type) => diagnostics.push(
DenoDiagnostic::InvalidAttributeType(assert_type.to_string()),
),
// The module is missing an attribute type, diagnostic
None => diagnostics.push(DenoDiagnostic::NoAttributeType),
}
}
}
} else if let Some(module_name) = specifier.as_str().strip_prefix("node:")
{
if !deno_node::is_builtin_node_module(module_name) {
diagnostics
.push(DenoDiagnostic::UnknownNodeSpecifier(specifier.clone()));
} else if module_name == dependency_key {
let mut is_mapped = false;
if let Some(import_map) = import_map {
if let Resolution::Ok(resolved) = &resolution {
if import_map.resolve(module_name, &resolved.specifier).is_ok() {
is_mapped = true;
_ => {
match JsrPackageReqReference::from_specifier(specifier) {
Ok(pkg_ref) => {
let req = pkg_ref.into_inner().req;
diagnostics
.push(DenoDiagnostic::NotInstalledJsr(req, specifier.clone()));
}
_ => {
match NpmPackageReqReference::from_specifier(specifier) {
Ok(pkg_ref) => {
if let Some(npm_resolver) = managed_npm_resolver {
// show diagnostics for npm package references that aren't cached
let req = pkg_ref.req();
if !npm_resolver.is_pkg_req_folder_cached(req) {
diagnostics.push(DenoDiagnostic::NotInstalledNpm(
req.clone(),
specifier.clone(),
));
} else {
let resolution_kinds = [
NodeResolutionKind::Types,
NodeResolutionKind::Execution,
];
if resolution_kinds.into_iter().all(|k| {
scoped_resolver
.npm_to_file_url(
&pkg_ref,
&referrer_module.specifier,
k,
referrer_module.resolution_mode,
)
.is_none()
}) {
diagnostics
.push(DenoDiagnostic::NoExportNpm(pkg_ref.clone()));
}
}
}
}
_ => {
if let Some(module_name) =
specifier.as_str().strip_prefix("node:")
{
if !deno_node::is_builtin_node_module(module_name) {
diagnostics.push(DenoDiagnostic::UnknownNodeSpecifier(
specifier.clone(),
));
} else if module_name == dependency_key {
let mut is_mapped = false;
if let Some(import_map) = import_map {
if let Resolution::Ok(resolved) = &resolution {
if import_map
.resolve(module_name, &resolved.specifier)
.is_ok()
{
is_mapped = true;
}
}
}
// show diagnostics for bare node specifiers that aren't mapped by import map
if !is_mapped {
diagnostics.push(DenoDiagnostic::BareNodeSpecifier(
module_name.to_string(),
));
}
} else if let Some(npm_resolver) = managed_npm_resolver {
// check that a @types/node package exists in the resolver
let types_node_req =
PackageReq::from_str("@types/node").unwrap();
if !npm_resolver.is_pkg_req_folder_cached(&types_node_req)
{
diagnostics.push(DenoDiagnostic::NotInstalledNpm(
types_node_req,
ModuleSpecifier::parse("npm:@types/node").unwrap(),
));
}
}
} else {
// When the document is not available, it means that it cannot be found
// in the cache or locally on the disk, so we want to issue a diagnostic
// about that.
// these may be invalid, however, if this is an ambient module with
// no real source (as in the case of a virtual module).
let deno_diagnostic = match specifier.scheme() {
"file" => DenoDiagnostic::NoLocal(specifier.clone()),
_ => DenoDiagnostic::NoCache(specifier.clone()),
};
deferred_diagnostics.push(deno_diagnostic);
}
}
}
}
}
// show diagnostics for bare node specifiers that aren't mapped by import map
if !is_mapped {
diagnostics
.push(DenoDiagnostic::BareNodeSpecifier(module_name.to_string()));
}
} else if let Some(npm_resolver) = managed_npm_resolver {
// check that a @types/node package exists in the resolver
let types_node_req = PackageReq::from_str("@types/node").unwrap();
if !npm_resolver.is_pkg_req_folder_cached(&types_node_req) {
diagnostics.push(DenoDiagnostic::NotInstalledNpm(
types_node_req,
ModuleSpecifier::parse("npm:@types/node").unwrap(),
));
}
}
} else {
// When the document is not available, it means that it cannot be found
// in the cache or locally on the disk, so we want to issue a diagnostic
// about that.
// these may be invalid, however, if this is an ambient module with
// no real source (as in the case of a virtual module).
let deno_diagnostic = match specifier.scheme() {
"file" => DenoDiagnostic::NoLocal(specifier.clone()),
_ => DenoDiagnostic::NoCache(specifier.clone()),
};
deferred_diagnostics.push(deno_diagnostic);
}
}
// The specifier resolution resulted in an error, so we want to issue a

85
cli/lsp/documents.rs
View file

@ -16,19 +16,19 @@ use std::sync::Weak;
use std::time::SystemTime;
use dashmap::DashMap;
use deno_ast::swc::ecma_visit::VisitWith;
use deno_ast::MediaType;
use deno_ast::ParsedSource;
use deno_ast::SourceTextInfo;
use deno_ast::swc::ecma_visit::VisitWith;
use deno_core::ModuleSpecifier;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt;
use deno_core::futures::future;
use deno_core::futures::future::Shared;
use deno_core::futures::FutureExt;
use deno_core::parking_lot::RwLock;
use deno_core::resolve_url;
use deno_core::url::Position;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_error::JsErrorBox;
use deno_graph::TypesDependency;
use deno_path_util::url_to_file_path;
@ -38,17 +38,17 @@ use deno_semver::npm::NpmPackageReqReference;
use indexmap::IndexMap;
use indexmap::IndexSet;
use lsp_types::Uri;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use node_resolver::NodeResolutionKind;
use node_resolver::ResolutionMode;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use once_cell::sync::Lazy;
use serde::Serialize;
use tower_lsp::lsp_types as lsp;
use weak_table::PtrWeakKeyHashMap;
use weak_table::WeakValueHashMap;
use super::cache::calculate_fs_version_at_path;
use super::cache::LspCache;
use super::cache::calculate_fs_version_at_path;
use super::config::Config;
use super::logging::lsp_warn;
use super::resolver::LspResolver;
@ -59,12 +59,12 @@ use super::testing::TestModule;
use super::text::LineIndex;
use super::tsc::ChangeKind;
use super::tsc::NavigationTree;
use super::urls::COMPONENT;
use super::urls::normalize_uri;
use super::urls::uri_is_file_like;
use super::urls::uri_to_file_path;
use super::urls::uri_to_url;
use super::urls::url_to_uri;
use super::urls::COMPONENT;
use crate::graph_util::CliJsrUrlProvider;
#[derive(Debug)]
@ -197,7 +197,7 @@ fn data_url_to_uri(url: &Url) -> Option<Uri> {
file_name_str.push('?');
file_name_str.push_str(query);
}
let hash = deno_lib::util::checksum::gen(&[file_name_str.as_bytes()]);
let hash = deno_lib::util::checksum::r#gen(&[file_name_str.as_bytes()]);
Uri::from_str(&format!("deno:/data_url/{hash}{extension}",))
.inspect_err(|err| {
lsp_warn!("Couldn't convert data url \"{url}\" to URI: {err}")
@ -702,12 +702,16 @@ impl Documents {
if let Some(doc) = self.server.get(&uri) {
return Some(Document::Server(doc.clone()));
}
let doc = if let Some(doc) = ServerDocument::load(&uri) {
doc
} else if let Some(data_url) = self.data_urls_by_uri.get(&uri) {
ServerDocument::data_url(&uri, data_url.value().clone())?
} else {
return None;
let doc = match ServerDocument::load(&uri) {
Some(doc) => doc,
_ => match self.data_urls_by_uri.get(&uri) {
Some(data_url) => {
ServerDocument::data_url(&uri, data_url.value().clone())?
}
_ => {
return None;
}
},
};
let doc = Arc::new(doc);
self.server.insert(uri.into_owned(), doc.clone());
@ -1221,12 +1225,11 @@ impl DocumentModules {
scope: Option<&Url>,
) -> Option<Arc<DocumentModule>> {
let scoped_resolver = self.resolver.get_scoped_resolver(scope);
let specifier = if let Ok(jsr_req_ref) =
JsrPackageReqReference::from_specifier(specifier)
{
Cow::Owned(scoped_resolver.jsr_to_resource_url(&jsr_req_ref)?)
} else {
Cow::Borrowed(specifier)
let specifier = match JsrPackageReqReference::from_specifier(specifier) {
Ok(jsr_req_ref) => {
Cow::Owned(scoped_resolver.jsr_to_resource_url(&jsr_req_ref)?)
}
_ => Cow::Borrowed(specifier),
};
let specifier = scoped_resolver.resolve_redirects(&specifier)?;
let document =
@ -1322,12 +1325,11 @@ impl DocumentModules {
scope: Option<&Url>,
) -> Option<Arc<DocumentModule>> {
let scoped_resolver = self.resolver.get_scoped_resolver(scope);
let specifier = if let Ok(jsr_req_ref) =
JsrPackageReqReference::from_specifier(specifier)
{
Cow::Owned(scoped_resolver.jsr_to_resource_url(&jsr_req_ref)?)
} else {
Cow::Borrowed(specifier)
let specifier = match JsrPackageReqReference::from_specifier(specifier) {
Ok(jsr_req_ref) => {
Cow::Owned(scoped_resolver.jsr_to_resource_url(&jsr_req_ref)?)
}
_ => Cow::Borrowed(specifier),
};
let specifier = scoped_resolver.resolve_redirects(&specifier)?;
let modules = self.modules_for_scope(scope)?;
@ -1601,21 +1603,26 @@ impl DocumentModules {
} else {
results.push(None);
}
} else if let Ok(specifier) = scoped_resolver.as_cli_resolver().resolve(
raw_specifier,
referrer,
deno_graph::Position::zeroed(),
resolution_mode,
NodeResolutionKind::Types,
) {
results.push(self.resolve_dependency(
&specifier,
referrer,
resolution_mode,
scope,
));
} else {
results.push(None);
match scoped_resolver.as_cli_resolver().resolve(
raw_specifier,
referrer,
deno_graph::Position::zeroed(),
resolution_mode,
NodeResolutionKind::Types,
) {
Ok(specifier) => {
results.push(self.resolve_dependency(
&specifier,
referrer,
resolution_mode,
scope,
));
}
_ => {
results.push(None);
}
}
}
}
results

8
cli/lsp/jsr.rs
View file

@ -9,15 +9,15 @@ use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::url::Url;
use deno_graph::ModuleSpecifier;
use deno_graph::packages::JsrPackageInfo;
use deno_graph::packages::JsrPackageInfoVersion;
use deno_graph::packages::JsrPackageVersionInfo;
use deno_graph::ModuleSpecifier;
use deno_semver::StackString;
use deno_semver::Version;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_semver::StackString;
use deno_semver::Version;
use serde::Deserialize;
use super::config::ConfigData;
@ -26,8 +26,8 @@ use crate::args::jsr_api_url;
use crate::args::jsr_url;
use crate::file_fetcher::CliFileFetcher;
use crate::file_fetcher::TextDecodedFile;
use crate::jsr::partial_jsr_package_version_info_from_slice;
use crate::jsr::JsrFetchResolver;
use crate::jsr::partial_jsr_package_version_info_from_slice;
#[derive(Debug)]
struct WorkspacePackage {

86
cli/lsp/language_server.rs
View file

@ -14,27 +14,27 @@ use std::str::FromStr;
use std::sync::Arc;
use deno_ast::MediaType;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use deno_core::unsync::spawn;
use deno_core::url;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_graph::CheckJsOption;
use deno_graph::GraphKind;
use deno_graph::Resolution;
use deno_lib::args::get_root_cert_store;
use deno_lib::args::CaData;
use deno_lib::args::get_root_cert_store;
use deno_lib::version::DENO_VERSION_INFO;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_path_util::url_to_file_path;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_tls::RootCertStoreProvider;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_semver::jsr::JsrPackageReqReference;
use indexmap::Equivalent;
use indexmap::IndexMap;
@ -44,20 +44,20 @@ use node_resolver::NodeResolutionKind;
use node_resolver::ResolutionMode;
use serde::Deserialize;
use serde_json::from_value;
use tokio::sync::mpsc::unbounded_channel;
use tokio::sync::mpsc::UnboundedReceiver;
use tokio::sync::mpsc::UnboundedSender;
use tokio::sync::mpsc::unbounded_channel;
use tokio_util::sync::CancellationToken;
use tower_lsp::jsonrpc::Error as LspError;
use tower_lsp::jsonrpc::Result as LspResult;
use tower_lsp::lsp_types::request::*;
use tower_lsp::lsp_types::*;
use super::analysis::fix_ts_import_changes;
use super::analysis::ts_changes_to_edit;
use super::analysis::CodeActionCollection;
use super::analysis::CodeActionData;
use super::analysis::TsResponseImportMapper;
use super::analysis::fix_ts_import_changes;
use super::analysis::ts_changes_to_edit;
use super::cache::LspCache;
use super::capabilities;
use super::capabilities::semantic_tokens_registration_options;
@ -65,9 +65,9 @@ use super::client::Client;
use super::code_lens;
use super::completions;
use super::config::Config;
use super::config::SETTINGS_SECTION;
use super::config::UpdateImportsOnFileMoveEnabled;
use super::config::WorkspaceSettings;
use super::config::SETTINGS_SECTION;
use super::diagnostics;
use super::diagnostics::DiagnosticDataSpecifier;
use super::diagnostics::DiagnosticServerUpdateMessage;
@ -100,8 +100,8 @@ use crate::args::Flags;
use crate::args::InternalFlags;
use crate::args::UnstableFmtOptions;
use crate::factory::CliFactory;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::file_fetcher::CreateCliFileFetcherOptions;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::graph_util;
use crate::http_util::HttpClientProvider;
use crate::lsp::config::ConfigWatchedFileType;
@ -1870,35 +1870,48 @@ impl Inner {
.map(|d| &d.dependency)
.unwrap_or(&Resolution::None)
});
let value = match (dep.maybe_code.is_none(), dep.maybe_type.is_none(), &dep_types_dependency) {
let value = match (
dep.maybe_code.is_none(),
dep.maybe_type.is_none(),
&dep_types_dependency,
) {
(false, false, None) => format!(
"**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n",
self.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
),
(false, false, Some(types_dep)) if !types_dep.is_none() => format!(
"**Resolved Dependency**\n\n**Code**: {}\n**Types**: {}\n**Import Types**: {}\n",
self.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
self.resolution_to_hover_text(types_dep, module.scope.as_deref()),
),
(false, false, Some(_)) => format!(
"**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n",
self.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
),
(false, true, Some(types_dep)) if !types_dep.is_none() => format!(
"**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n",
self.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self.resolution_to_hover_text(types_dep, module.scope.as_deref()),
),
(false, true, _) => format!(
"**Resolved Dependency**\n\n**Code**: {}\n",
self.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_code, module.scope.as_deref()),
),
(true, false, _) => format!(
"**Resolved Dependency**\n\n**Types**: {}\n",
self.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
self
.resolution_to_hover_text(&dep.maybe_type, module.scope.as_deref()),
),
(true, true, _) => unreachable!("{}", json!(params)),
};
@ -2363,7 +2376,11 @@ impl Inner {
if token.is_cancelled() {
return Err(LspError::request_cancelled());
} else {
lsp_warn!("Unable to get refactor edit info from TypeScript: {:#}\nCode action data: {:#}", err, json!(&action_data));
lsp_warn!(
"Unable to get refactor edit info from TypeScript: {:#}\nCode action data: {:#}",
err,
json!(&action_data)
);
}
}
}
@ -4784,19 +4801,22 @@ impl Inner {
}
Some(contents)
} else if let Some(document) = self.get_document(
&params.text_document.uri,
Enabled::Ignore,
Exists::Filter,
Diagnosable::Ignore,
)? {
Some(document.text().to_string())
} else {
lsp_warn!(
"The document was not found: {}",
params.text_document.uri.as_str()
);
None
match self.get_document(
&params.text_document.uri,
Enabled::Ignore,
Exists::Filter,
Diagnosable::Ignore,
)? {
Some(document) => Some(document.text().to_string()),
_ => {
lsp_warn!(
"The document was not found: {}",
params.text_document.uri.as_str()
);
None
}
}
};
self.performance.measure(mark);
Ok(contents)

8
cli/lsp/logging.rs
View file

@ -72,9 +72,11 @@ pub fn init_log_file(enabled: bool) {
LOG_FILE.buffer.lock().clear();
return;
};
thread::spawn(move || loop {
LOG_FILE.commit(&path);
thread::sleep(std::time::Duration::from_secs(1));
thread::spawn(move || {
loop {
LOG_FILE.commit(&path);
thread::sleep(std::time::Duration::from_secs(1));
}
});
}

2
cli/lsp/npm.rs
View file

@ -8,8 +8,8 @@ use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::url::Url;
use deno_npm::npm_rc::NpmRc;
use deno_semver::package::PackageNv;
use deno_semver::Version;
use deno_semver::package::PackageNv;
use once_cell::sync::Lazy;
use serde::Deserialize;

10
cli/lsp/parent_process_checker.rs
View file

@ -7,11 +7,13 @@ use std::time::Duration;
/// it will terminate the current process.
pub fn start(parent_process_id: u32) {
// use a separate thread in case the runtime gets hung up
std::thread::spawn(move || loop {
std::thread::sleep(Duration::from_secs(10));
std::thread::spawn(move || {
loop {
std::thread::sleep(Duration::from_secs(10));
if !is_process_active(parent_process_id) {
deno_runtime::exit(1);
if !is_process_active(parent_process_id) {
deno_runtime::exit(1);
}
}
});
}

20
cli/lsp/path_to_regex.rs
View file

@ -875,13 +875,27 @@ mod tests {
);
let actual = result.unwrap();
if let Some((text, start, end)) = *expected {
assert!(actual.is_some(), "Match failure for path \"{path}\" and fixture \"{fixture}\". Expected Some got None");
assert!(
actual.is_some(),
"Match failure for path \"{path}\" and fixture \"{fixture}\". Expected Some got None"
);
let actual = actual.unwrap();
assert_eq!(actual.as_str(), text, "Match failure for path \"{}\" and fixture \"{}\". Expected \"{}\" got \"{}\".", path, fixture, text, actual.as_str());
assert_eq!(
actual.as_str(),
text,
"Match failure for path \"{}\" and fixture \"{}\". Expected \"{}\" got \"{}\".",
path,
fixture,
text,
actual.as_str()
);
assert_eq!(actual.start(), start);
assert_eq!(actual.end(), end);
} else {
assert!(actual.is_none(), "Match failure for path \"{path}\" and fixture \"{fixture}\". Expected None got {actual:?}");
assert!(
actual.is_none(),
"Match failure for path \"{path}\" and fixture \"{fixture}\". Expected None got {actual:?}"
);
}
}
}

46
cli/lsp/registries.rs
View file

@ -6,16 +6,16 @@ use std::path::PathBuf;
use std::sync::Arc;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::serde::Deserialize;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use deno_core::url::ParseError;
use deno_core::url::Position;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_graph::Dependency;
use deno_resolver::file_fetcher::FetchOptions;
use deno_resolver::file_fetcher::FetchPermissionsOptionRef;
@ -25,8 +25,6 @@ use tower_lsp::lsp_types as lsp;
use super::completions::IMPORT_COMMIT_CHARS;
use super::logging::lsp_log;
use super::path_to_regex::parse;
use super::path_to_regex::string_to_regex;
use super::path_to_regex::Compiler;
use super::path_to_regex::Key;
use super::path_to_regex::MatchResult;
@ -34,12 +32,14 @@ use super::path_to_regex::Matcher;
use super::path_to_regex::StringOrNumber;
use super::path_to_regex::StringOrVec;
use super::path_to_regex::Token;
use super::path_to_regex::parse;
use super::path_to_regex::string_to_regex;
use crate::cache::GlobalHttpCache;
use crate::cache::HttpCache;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::file_fetcher::CliFileFetcher;
use crate::file_fetcher::CreateCliFileFetcherOptions;
use crate::file_fetcher::TextDecodedFile;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::http_util::HttpClientProvider;
use crate::sys::CliSys;
@ -322,7 +322,11 @@ fn validate_config(config: &RegistryConfigurationJson) -> Result<(), AnyError> {
.map(|var| var.key.to_owned())
.any(|x| x == *key_name)
{
return Err(anyhow!("Invalid registry configuration. Registry with schema \"{}\" is missing variable declaration for key \"{}\".", registry.schema, key_name));
return Err(anyhow!(
"Invalid registry configuration. Registry with schema \"{}\" is missing variable declaration for key \"{}\".",
registry.schema,
key_name
));
}
}
@ -334,13 +338,27 @@ fn validate_config(config: &RegistryConfigurationJson) -> Result<(), AnyError> {
let limited_keys = key_names.get(0..key_index).unwrap();
for v in replacement_variables {
if variable.key == v && config.version == 1 {
return Err(anyhow!("Invalid registry configuration. Url \"{}\" (for variable \"{}\" in registry with schema \"{}\") uses variable \"{}\", which is not allowed because that would be a self reference.", variable.url, variable.key, registry.schema, v));
return Err(anyhow!(
"Invalid registry configuration. Url \"{}\" (for variable \"{}\" in registry with schema \"{}\") uses variable \"{}\", which is not allowed because that would be a self reference.",
variable.url,
variable.key,
registry.schema,
v
));
}
let key_index = limited_keys.iter().position(|key| key == &v);
if key_index.is_none() && variable.key != v {
return Err(anyhow!("Invalid registry configuration. Url \"{}\" (for variable \"{}\" in registry with schema \"{}\") uses variable \"{}\", which is not allowed because the schema defines \"{}\" to the right of \"{}\".", variable.url, variable.key, registry.schema, v, v, variable.key));
return Err(anyhow!(
"Invalid registry configuration. Url \"{}\" (for variable \"{}\" in registry with schema \"{}\") uses variable \"{}\", which is not allowed because the schema defines \"{}\" to the right of \"{}\".",
variable.url,
variable.key,
registry.schema,
v,
v,
variable.key
));
}
}
}
@ -1113,11 +1131,13 @@ mod tests {
#[test]
fn test_validate_registry_configuration() {
assert!(validate_config(&RegistryConfigurationJson {
version: 3,
registries: vec![],
})
.is_err());
assert!(
validate_config(&RegistryConfigurationJson {
version: 3,
registries: vec![],
})
.is_err()
);
let cfg = RegistryConfigurationJson {
version: 1,

2
cli/lsp/repl.rs
View file

@ -10,6 +10,7 @@ use deno_core::error::AnyError;
use deno_core::serde_json;
use lsp_types::Uri;
use tokio_util::sync::CancellationToken;
use tower_lsp::LanguageServer;
use tower_lsp::lsp_types::ClientCapabilities;
use tower_lsp::lsp_types::ClientInfo;
use tower_lsp::lsp_types::CompletionContext;
@ -31,7 +32,6 @@ use tower_lsp::lsp_types::TextDocumentItem;
use tower_lsp::lsp_types::TextDocumentPositionParams;
use tower_lsp::lsp_types::VersionedTextDocumentIdentifier;
use tower_lsp::lsp_types::WorkDoneProgressParams;
use tower_lsp::LanguageServer;
use super::client::Client;
use super::config::ClassMemberSnippets;

20
cli/lsp/resolver.rs
View file

@ -9,8 +9,8 @@ use std::sync::Arc;
use dashmap::DashMap;
use deno_ast::MediaType;
use deno_cache_dir::npm::NpmCacheDir;
use deno_cache_dir::HttpCache;
use deno_cache_dir::npm::NpmCacheDir;
use deno_config::workspace::JsxImportSourceConfig;
use deno_core::parking_lot::Mutex;
use deno_core::url::Url;
@ -20,27 +20,27 @@ use deno_graph::ModuleSpecifier;
use deno_graph::Range;
use deno_npm::NpmSystemInfo;
use deno_npm_cache::TarballCache;
use deno_npm_installer::LifecycleScriptsConfig;
use deno_npm_installer::initializer::NpmResolutionInitializer;
use deno_npm_installer::initializer::NpmResolverManagedSnapshotOption;
use deno_npm_installer::lifecycle_scripts::NullLifecycleScriptsExecutor;
use deno_npm_installer::package_json::NpmInstallDepsProvider;
use deno_npm_installer::resolution::NpmResolutionInstaller;
use deno_npm_installer::LifecycleScriptsConfig;
use deno_path_util::url_to_file_path;
use deno_resolver::DenoResolverOptions;
use deno_resolver::NodeAndNpmResolvers;
use deno_resolver::cjs::IsCjsResolutionMode;
use deno_resolver::graph::FoundPackageJsonDepFlag;
use deno_resolver::npm::managed::ManagedInNpmPkgCheckerCreateOptions;
use deno_resolver::npm::managed::ManagedNpmResolverCreateOptions;
use deno_resolver::npm::managed::NpmResolutionCell;
use deno_resolver::npm::CreateInNpmPkgCheckerOptions;
use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_resolver::npm::NpmReqResolverOptions;
use deno_resolver::npm::managed::ManagedInNpmPkgCheckerCreateOptions;
use deno_resolver::npm::managed::ManagedNpmResolverCreateOptions;
use deno_resolver::npm::managed::NpmResolutionCell;
use deno_resolver::npmrc::create_default_npmrc;
use deno_resolver::workspace::PackageJsonDepResolution;
use deno_resolver::workspace::WorkspaceNpmLinkPackages;
use deno_resolver::workspace::WorkspaceResolver;
use deno_resolver::DenoResolverOptions;
use deno_resolver::NodeAndNpmResolvers;
use deno_runtime::tokio_util::create_basic_runtime;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;
@ -48,14 +48,14 @@ use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use import_map::ImportMap;
use indexmap::IndexMap;
use node_resolver::cache::NodeResolutionSys;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use node_resolver::NodeResolutionKind;
use node_resolver::NodeResolverOptions;
use node_resolver::PackageJson;
use node_resolver::PackageJsonThreadLocalCache;
use node_resolver::ResolutionMode;
use node_resolver::cache::NodeResolutionSys;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use once_cell::sync::Lazy;
use super::cache::LspCache;
@ -78,10 +78,10 @@ use crate::npm::CliNpmInstaller;
use crate::npm::CliNpmRegistryInfoProvider;
use crate::npm::CliNpmResolver;
use crate::npm::CliNpmResolverCreateOptions;
use crate::resolver::on_resolve_diagnostic;
use crate::resolver::CliIsCjsResolver;
use crate::resolver::CliNpmReqResolver;
use crate::resolver::CliResolver;
use crate::resolver::on_resolve_diagnostic;
use crate::sys::CliSys;
use crate::tsc::into_specifier_and_media_type;
use crate::util::progress_bar::ProgressBar;

4
cli/lsp/search.rs
View file

@ -3,15 +3,15 @@
use std::sync::Arc;
use deno_core::error::AnyError;
use deno_semver::package::PackageNv;
use deno_semver::Version;
use deno_semver::package::PackageNv;
#[async_trait::async_trait(?Send)]
pub trait PackageSearchApi {
async fn search(&self, query: &str) -> Result<Arc<Vec<String>>, AnyError>;
async fn versions(&self, name: &str) -> Result<Arc<Vec<Version>>, AnyError>;
async fn exports(&self, nv: &PackageNv)
-> Result<Arc<Vec<String>>, AnyError>;
-> Result<Arc<Vec<String>>, AnyError>;
}
#[cfg(test)]

4
cli/lsp/testing/collectors.rs
View file

@ -3,11 +3,11 @@
use std::collections::HashMap;
use std::collections::HashSet;
use deno_ast::SourceRangedForSpanned;
use deno_ast::SourceTextInfo;
use deno_ast::swc::ast;
use deno_ast::swc::ecma_visit::Visit;
use deno_ast::swc::ecma_visit::VisitWith;
use deno_ast::SourceRangedForSpanned;
use deno_ast::SourceTextInfo;
use deno_core::ModuleSpecifier;
use lsp::Range;
use tower_lsp::lsp_types as lsp;

10
cli/lsp/testing/definitions.rs
View file

@ -3,8 +3,8 @@
use std::collections::HashMap;
use std::collections::HashSet;
use deno_core::error::AnyError;
use deno_core::ModuleSpecifier;
use deno_core::error::AnyError;
use deno_lib::util::checksum;
use lsp::Range;
use tower_lsp::lsp_types as lsp;
@ -56,7 +56,11 @@ impl TestModule {
let parent = match self.defs.get(parent_id) {
Some(d) => d,
None => {
lsp_warn!("Internal Error: parent_id \"{}\" of test \"{}\" was not registered.", parent_id, &name);
lsp_warn!(
"Internal Error: parent_id \"{}\" of test \"{}\" was not registered.",
parent_id,
&name
);
id_components.push("<unknown>".as_bytes());
break;
}
@ -66,7 +70,7 @@ impl TestModule {
}
id_components.push(self.specifier.as_str().as_bytes());
id_components.reverse();
let id = checksum::gen(&id_components);
let id = checksum::r#gen(&id_components);
if self.defs.contains_key(&id) {
return (id, false);
}

13
cli/lsp/testing/execution.rs
View file

@ -7,16 +7,16 @@ use std::sync::Arc;
use std::time::Duration;
use std::time::Instant;
use deno_core::ModuleSpecifier;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::error::JsError;
use deno_core::futures::StreamExt;
use deno_core::futures::future;
use deno_core::futures::stream;
use deno_core::futures::StreamExt;
use deno_core::parking_lot::RwLock;
use deno_core::unsync::spawn;
use deno_core::unsync::spawn_blocking;
use deno_core::ModuleSpecifier;
use deno_runtime::deno_permissions::Permissions;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::tokio_util::create_and_run_current_thread;
@ -28,9 +28,9 @@ use super::definitions::TestDefinition;
use super::definitions::TestModule;
use super::lsp_custom;
use super::server::TestServerTests;
use crate::args::DenoSubcommand;
use crate::args::flags_from_vec;
use crate::args::parallelism_count;
use crate::args::DenoSubcommand;
use crate::factory::CliFactory;
use crate::lsp::client::Client;
use crate::lsp::client::TestingNotification;
@ -40,10 +40,10 @@ use crate::lsp::urls::uri_parse_unencoded;
use crate::lsp::urls::uri_to_url;
use crate::lsp::urls::url_to_uri;
use crate::tools::test;
use crate::tools::test::create_test_event_channel;
use crate::tools::test::FailFastTracker;
use crate::tools::test::TestFailure;
use crate::tools::test::TestFailureFormatOptions;
use crate::tools::test::create_test_event_channel;
/// Logic to convert a test request into a set of test modules to be tested and
/// any filters to be applied to those tests
@ -700,7 +700,10 @@ impl LspTestReporter {
let err_string = format!(
"Uncaught error from {}: {}\nThis error was not caught from a test and caused the test runner to fail on the referenced module.\nIt most likely originated from a dangling promise, event/timeout handler or top-level code.",
origin,
test::fmt::format_test_error(js_error, &TestFailureFormatOptions::default())
test::fmt::format_test_error(
js_error,
&TestFailureFormatOptions::default()
)
);
let messages = vec![lsp_custom::TestMessage {
message: lsp::MarkupContent {

4
cli/lsp/testing/server.rs
View file

@ -5,12 +5,12 @@ use std::collections::HashSet;
use std::sync::Arc;
use std::thread;
use deno_core::ModuleSpecifier;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use deno_core::url::Url;
use deno_core::ModuleSpecifier;
use deno_runtime::tokio_util::create_basic_runtime;
use tokio::sync::mpsc;
use tower_lsp::jsonrpc::Error as LspError;

2
cli/lsp/text.rs
View file

@ -1,8 +1,8 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use deno_core::error::AnyError;
use dissimilar::diff;
use dissimilar::Chunk;
use dissimilar::diff;
use text_size::TextRange;
use text_size::TextSize;
use tower_lsp::jsonrpc;

4
cli/lsp/trace.rs
View file

@ -29,15 +29,15 @@ impl fmt::Debug for TracingGuard {
#[cfg(feature = "lsp-tracing")]
mod real_tracing {
use deno_core::anyhow;
use opentelemetry::trace::TracerProvider;
pub use opentelemetry::Context;
use opentelemetry::KeyValue;
use opentelemetry::trace::TracerProvider;
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::Resource;
use opentelemetry_semantic_conventions::resource::SERVICE_NAME;
pub use tracing::Span;
use tracing::level_filters::LevelFilter;
pub use tracing::span::EnteredSpan;
pub use tracing::Span;
use tracing_opentelemetry::OpenTelemetryLayer;
pub use tracing_opentelemetry::OpenTelemetrySpanExt as SpanExt;
use tracing_subscriber::fmt::format::FmtSpan;

24
cli/lsp/tsc.rs
View file

@ -12,12 +12,17 @@ use std::net::SocketAddr;
use std::ops::Range;
use std::path::Path;
use std::rc::Rc;
use std::sync::atomic::AtomicBool;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::thread;
use dashmap::DashMap;
use deno_ast::MediaType;
use deno_core::JsRuntime;
use deno_core::ModuleSpecifier;
use deno_core::OpState;
use deno_core::PollEventLoopOptions;
use deno_core::RuntimeOptions;
use deno_core::anyhow::anyhow;
use deno_core::convert::Smi;
use deno_core::convert::ToV8;
@ -26,20 +31,15 @@ use deno_core::futures::FutureExt;
use deno_core::op2;
use deno_core::parking_lot::Mutex;
use deno_core::resolve_url;
use deno_core::serde::de;
use deno_core::serde::Deserialize;
use deno_core::serde::Serialize;
use deno_core::serde::de;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::serde_json::json;
use deno_core::serde_v8;
use deno_core::url::Url;
use deno_core::v8;
use deno_core::JsRuntime;
use deno_core::ModuleSpecifier;
use deno_core::OpState;
use deno_core::PollEventLoopOptions;
use deno_core::RuntimeOptions;
use deno_lib::util::result::InfallibleResultExt;
use deno_lib::worker::create_isolate_create_params;
use deno_path_util::url_to_file_path;
@ -51,9 +51,9 @@ use indexmap::IndexSet;
use lazy_regex::lazy_regex;
use log::error;
use lsp_types::Uri;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use node_resolver::NodeResolutionKind;
use node_resolver::ResolutionMode;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use once_cell::sync::Lazy;
use regex::Captures;
use regex::Regex;
@ -80,22 +80,22 @@ use super::language_server::StateSnapshot;
use super::logging::lsp_log;
use super::performance::Performance;
use super::performance::PerformanceMark;
use super::refactor::RefactorCodeActionData;
use super::refactor::ALL_KNOWN_REFACTOR_ACTION_KINDS;
use super::refactor::EXTRACT_CONSTANT;
use super::refactor::EXTRACT_INTERFACE;
use super::refactor::EXTRACT_TYPE;
use super::refactor::RefactorCodeActionData;
use super::semantic_tokens;
use super::semantic_tokens::SemanticTokensBuilder;
use super::text::LineIndex;
use super::urls::uri_to_url;
use super::urls::url_to_uri;
use crate::args::jsr_url;
use crate::args::FmtOptionsConfig;
use crate::args::jsr_url;
use crate::lsp::documents::Document;
use crate::lsp::logging::lsp_warn;
use crate::tsc::ResolveArgs;
use crate::tsc::MISSING_DEPENDENCY_SPECIFIER;
use crate::tsc::ResolveArgs;
use crate::util::path::relative_specifier;
use crate::util::path::to_percent_decoded_str;
use crate::util::v8::convert;

190
cli/main.rs
View file

@ -46,10 +46,10 @@ use deno_lib::util::result::any_and_jserrorbox_downcast_ref;
use deno_lib::worker::LibWorkerFactoryRoots;
use deno_resolver::npm::ByonmResolvePkgFolderFromDenoReqError;
use deno_resolver::npm::ResolvePkgFolderFromDenoReqError;
use deno_runtime::fmt_errors::format_js_error;
use deno_runtime::tokio_util::create_and_run_current_thread_with_maybe_metrics;
use deno_runtime::UnconfiguredRuntime;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::fmt_errors::format_js_error;
use deno_runtime::tokio_util::create_and_run_current_thread_with_maybe_metrics;
use deno_telemetry::OtelConfig;
use deno_terminal::colors;
use factory::CliFactory;
@ -59,10 +59,10 @@ const UNSUPPORTED_SCHEME: &str = "Unsupported scheme";
use self::args::load_env_variables_from_env_file;
use self::util::draw_thread::DrawThread;
use crate::args::flags_from_vec;
use crate::args::get_default_v8_flags;
use crate::args::DenoSubcommand;
use crate::args::Flags;
use crate::args::flags_from_vec;
use crate::args::get_default_v8_flags;
use crate::util::display;
use crate::util::v8::get_v8_flags_from_env;
use crate::util::v8::init_v8_flags;
@ -116,25 +116,25 @@ async fn run_subcommand(
DenoSubcommand::Add(add_flags) => spawn_subcommand(async {
tools::pm::add(flags, add_flags, tools::pm::AddCommandName::Add).await
}),
DenoSubcommand::Remove(remove_flags) => spawn_subcommand(async {
tools::pm::remove(flags, remove_flags).await
}),
DenoSubcommand::Remove(remove_flags) => {
spawn_subcommand(async { tools::pm::remove(flags, remove_flags).await })
}
DenoSubcommand::Bench(bench_flags) => spawn_subcommand(async {
if bench_flags.watch.is_some() {
tools::bench::run_benchmarks_with_watch(flags, bench_flags).boxed_local().await
tools::bench::run_benchmarks_with_watch(flags, bench_flags)
.boxed_local()
.await
} else {
tools::bench::run_benchmarks(flags, bench_flags).await
}
}),
DenoSubcommand::Bundle(bundle_flags) => {
spawn_subcommand(async {
log::warn!(
"⚠️ {} is experimental and subject to changes",
colors::cyan("deno bundle")
);
tools::bundle::bundle(flags, bundle_flags).await
})
},
DenoSubcommand::Bundle(bundle_flags) => spawn_subcommand(async {
log::warn!(
"⚠️ {} is experimental and subject to changes",
colors::cyan("deno bundle")
);
tools::bundle::bundle(flags, bundle_flags).await
}),
DenoSubcommand::Deploy => {
spawn_subcommand(async { tools::deploy::deploy(flags, roots).await })
}
@ -145,23 +145,31 @@ async fn run_subcommand(
tools::run::eval_command(flags, eval_flags).await
}),
DenoSubcommand::Cache(cache_flags) => spawn_subcommand(async move {
tools::installer::install_from_entrypoints(flags, &cache_flags.files).await
}),
DenoSubcommand::Check(check_flags) => spawn_subcommand(async move {
tools::check::check(flags, check_flags).await
}),
DenoSubcommand::Clean(clean_flags) => spawn_subcommand(async move {
tools::clean::clean(flags, clean_flags).await
tools::installer::install_from_entrypoints(flags, &cache_flags.files)
.await
}),
DenoSubcommand::Check(check_flags) => {
spawn_subcommand(
async move { tools::check::check(flags, check_flags).await },
)
}
DenoSubcommand::Clean(clean_flags) => {
spawn_subcommand(
async move { tools::clean::clean(flags, clean_flags).await },
)
}
DenoSubcommand::Compile(compile_flags) => spawn_subcommand(async {
if compile_flags.eszip {
tools::compile::compile_eszip(flags, compile_flags).boxed_local().await
tools::compile::compile_eszip(flags, compile_flags)
.boxed_local()
.await
} else {
tools::compile::compile(flags, compile_flags).await
}
}),
DenoSubcommand::Coverage(coverage_flags) => spawn_subcommand(async move {
let reporter = crate::tools::coverage::reporter::create(coverage_flags.r#type.clone());
let reporter =
crate::tools::coverage::reporter::create(coverage_flags.r#type.clone());
tools::coverage::cover_files(
flags,
coverage_flags.files.include,
@ -169,7 +177,7 @@ async fn run_subcommand(
coverage_flags.include,
coverage_flags.exclude,
coverage_flags.output,
&[&*reporter]
&[&*reporter],
)
}),
DenoSubcommand::Fmt(fmt_flags) => {
@ -178,9 +186,7 @@ async fn run_subcommand(
)
}
DenoSubcommand::Init(init_flags) => {
spawn_subcommand(async {
tools::init::init_project(init_flags).await
})
spawn_subcommand(async { tools::init::init_project(init_flags).await })
}
DenoSubcommand::Info(info_flags) => {
spawn_subcommand(async { tools::info::info(flags, info_flags).await })
@ -188,9 +194,13 @@ async fn run_subcommand(
DenoSubcommand::Install(install_flags) => spawn_subcommand(async {
tools::installer::install_command(flags, install_flags).await
}),
DenoSubcommand::JSONReference(json_reference) => spawn_subcommand(async move {
display::write_to_stdout_ignore_sigpipe(&deno_core::serde_json::to_vec_pretty(&json_reference.json).unwrap())
}),
DenoSubcommand::JSONReference(json_reference) => {
spawn_subcommand(async move {
display::write_to_stdout_ignore_sigpipe(
&deno_core::serde_json::to_vec_pretty(&json_reference.json).unwrap(),
)
})
}
DenoSubcommand::Jupyter(jupyter_flags) => spawn_subcommand(async {
tools::jupyter::kernel(flags, jupyter_flags).await
}),
@ -222,9 +232,9 @@ async fn run_subcommand(
}
}),
DenoSubcommand::Outdated(update_flags) => {
spawn_subcommand(async move {
tools::pm::outdated(flags, update_flags).await
})
spawn_subcommand(
async move { tools::pm::outdated(flags, update_flags).await },
)
}
DenoSubcommand::Repl(repl_flags) => {
spawn_subcommand(async move { tools::repl::run(flags, repl_flags).await })
@ -232,38 +242,77 @@ async fn run_subcommand(
DenoSubcommand::Run(run_flags) => spawn_subcommand(async move {
if run_flags.is_stdin() {
// these futures are boxed to prevent stack overflows on Windows
tools::run::run_from_stdin(flags.clone(), unconfigured_runtime, roots).boxed_local().await
tools::run::run_from_stdin(flags.clone(), unconfigured_runtime, roots)
.boxed_local()
.await
} else if flags.eszip {
tools::run::run_eszip(flags, run_flags, unconfigured_runtime, roots).boxed_local().await
tools::run::run_eszip(flags, run_flags, unconfigured_runtime, roots)
.boxed_local()
.await
} else {
let result = tools::run::run_script(WorkerExecutionMode::Run, flags.clone(), run_flags.watch, unconfigured_runtime, roots.clone()).await;
let result = tools::run::run_script(
WorkerExecutionMode::Run,
flags.clone(),
run_flags.watch,
unconfigured_runtime,
roots.clone(),
)
.await;
match result {
Ok(v) => Ok(v),
Err(script_err) => {
if let Some(worker::CreateCustomWorkerError::ResolvePkgFolderFromDenoReq(ResolvePkgFolderFromDenoReqError::Byonm(ByonmResolvePkgFolderFromDenoReqError::UnmatchedReq(_)))) = any_and_jserrorbox_downcast_ref::<worker::CreateCustomWorkerError>(&script_err) {
if let Some(
worker::CreateCustomWorkerError::ResolvePkgFolderFromDenoReq(
ResolvePkgFolderFromDenoReqError::Byonm(
ByonmResolvePkgFolderFromDenoReqError::UnmatchedReq(_),
),
),
) = any_and_jserrorbox_downcast_ref::<
worker::CreateCustomWorkerError,
>(&script_err)
{
if flags.node_modules_dir.is_none() {
let mut flags = flags.deref().clone();
let watch = match &flags.subcommand {
DenoSubcommand::Run(run_flags) => run_flags.watch.clone(),
_ => unreachable!(),
};
flags.node_modules_dir = Some(deno_config::deno_json::NodeModulesDirMode::None);
flags.node_modules_dir =
Some(deno_config::deno_json::NodeModulesDirMode::None);
// use the current lockfile, but don't write it out
if flags.frozen_lockfile.is_none() {
flags.internal.lockfile_skip_write = true;
}
return tools::run::run_script(WorkerExecutionMode::Run, Arc::new(flags), watch, None, roots).boxed_local().await;
return tools::run::run_script(
WorkerExecutionMode::Run,
Arc::new(flags),
watch,
None,
roots,
)
.boxed_local()
.await;
}
}
let script_err_msg = script_err.to_string();
if script_err_msg.starts_with(MODULE_NOT_FOUND) || script_err_msg.starts_with(UNSUPPORTED_SCHEME) {
if script_err_msg.starts_with(MODULE_NOT_FOUND)
|| script_err_msg.starts_with(UNSUPPORTED_SCHEME)
{
if run_flags.bare {
let mut cmd = args::clap_root();
cmd.build();
let command_names = cmd.get_subcommands().map(|command| command.get_name()).collect::<Vec<_>>();
let suggestions = args::did_you_mean(&run_flags.script, command_names);
let command_names = cmd
.get_subcommands()
.map(|command| command.get_name())
.collect::<Vec<_>>();
let suggestions =
args::did_you_mean(&run_flags.script, command_names);
if !suggestions.is_empty() && !run_flags.script.contains('.') {
let mut error = clap::error::Error::<clap::error::DefaultFormatter>::new(clap::error::ErrorKind::InvalidSubcommand).with_cmd(&cmd);
let mut error =
clap::error::Error::<clap::error::DefaultFormatter>::new(
clap::error::ErrorKind::InvalidSubcommand,
)
.with_cmd(&cmd);
error.insert(
clap::error::ContextKind::SuggestedSubcommand,
clap::error::ContextValue::Strings(suggestions),
@ -284,7 +333,11 @@ async fn run_subcommand(
eval: false,
};
new_flags.subcommand = DenoSubcommand::Task(task_flags.clone());
let result = tools::task::execute_script(Arc::new(new_flags), task_flags.clone()).await;
let result = tools::task::execute_script(
Arc::new(new_flags),
task_flags.clone(),
)
.await;
match result {
Ok(v) => Ok(v),
Err(_) => {
@ -317,10 +370,14 @@ async fn run_subcommand(
.with_context(|| format!("Failed creating: {coverage_dir}"))?;
// this is set in order to ensure spawned processes use the same
// coverage directory
env::set_var(
"DENO_COVERAGE_DIR",
PathBuf::from(coverage_dir).canonicalize()?,
);
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
env::set_var(
"DENO_COVERAGE_DIR",
PathBuf::from(coverage_dir).canonicalize()?,
)
};
}
if test_flags.watch.is_some() {
@ -348,18 +405,24 @@ async fn run_subcommand(
"This deno was built without the \"upgrade\" feature. Please upgrade using the installation method originally used to install Deno.",
1,
),
DenoSubcommand::Vendor => exit_with_message("⚠️ `deno vendor` was removed in Deno 2.\n\nSee the Deno 1.x to 2.x Migration Guide for migration instructions: https://docs.deno.com/runtime/manual/advanced/migrate_deprecations", 1),
DenoSubcommand::Vendor => exit_with_message(
"⚠️ `deno vendor` was removed in Deno 2.\n\nSee the Deno 1.x to 2.x Migration Guide for migration instructions: https://docs.deno.com/runtime/manual/advanced/migrate_deprecations",
1,
),
DenoSubcommand::Publish(publish_flags) => spawn_subcommand(async {
tools::publish::publish(flags, publish_flags).await
}),
DenoSubcommand::Help(help_flags) => spawn_subcommand(async move {
use std::io::Write;
let mut stream = anstream::AutoStream::new(std::io::stdout(), if colors::use_color() {
anstream::ColorChoice::Auto
} else {
anstream::ColorChoice::Never
});
let mut stream = anstream::AutoStream::new(
std::io::stdout(),
if colors::use_color() {
anstream::ColorChoice::Auto
} else {
anstream::ColorChoice::Never
},
);
match stream.write_all(help_flags.help.ansi().to_string().as_bytes()) {
Ok(()) => Ok(()),
@ -637,11 +700,15 @@ fn wait_for_start(
Option<(UnconfiguredRuntime, Vec<std::ffi::OsString>)>,
AnyError,
>,
>,
> + use<>,
> {
let startup_snapshot = deno_snapshots::CLI_SNAPSHOT?;
let addr = std::env::var("DENO_UNSTABLE_CONTROL_SOCK").ok()?;
std::env::remove_var("DENO_UNSTABLE_CONTROL_SOCK");
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
std::env::remove_var("DENO_UNSTABLE_CONTROL_SOCK")
};
let argv0 = args[0].clone();
@ -741,7 +808,10 @@ fn wait_for_start(
std::env::set_current_dir(cmd.cwd)?;
for (k, v) in cmd.env {
std::env::set_var(k, v);
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
std::env::set_var(k, v)
};
}
let args = [argv0]

106
cli/module_loader.rs
View file

@ -10,26 +10,14 @@ use std::path::PathBuf;
use std::pin::Pin;
use std::rc::Rc;
use std::str;
use std::sync::Arc;
use std::sync::atomic::AtomicU16;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::SystemTime;
use deno_ast::MediaType;
use deno_ast::ModuleKind;
use deno_cache_dir::file_fetcher::FetchLocalOptions;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context as _;
use deno_core::error::AnyError;
use deno_core::error::ModuleLoaderError;
use deno_core::futures::future::FutureExt;
use deno_core::futures::io::BufReader;
use deno_core::futures::stream::FuturesOrdered;
use deno_core::futures::StreamExt;
use deno_core::parking_lot::Mutex;
use deno_core::resolve_url;
use deno_core::resolve_url_or_path;
use deno_core::serde_json;
use deno_core::ModuleCodeString;
use deno_core::ModuleLoader;
use deno_core::ModuleSource;
@ -38,6 +26,18 @@ use deno_core::ModuleSpecifier;
use deno_core::ModuleType;
use deno_core::RequestedModuleType;
use deno_core::SourceCodeCacheInfo;
use deno_core::anyhow::Context as _;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::error::ModuleLoaderError;
use deno_core::futures::StreamExt;
use deno_core::futures::future::FutureExt;
use deno_core::futures::io::BufReader;
use deno_core::futures::stream::FuturesOrdered;
use deno_core::parking_lot::Mutex;
use deno_core::resolve_url;
use deno_core::resolve_url_or_path;
use deno_core::serde_json;
use deno_error::JsErrorBox;
use deno_graph::GraphKind;
use deno_graph::JsModule;
@ -46,10 +46,10 @@ use deno_graph::ModuleGraph;
use deno_graph::ModuleGraphError;
use deno_graph::WalkOptions;
use deno_graph::WasmModule;
use deno_lib::loader::module_type_from_media_type;
use deno_lib::loader::ModuleCodeStringSource;
use deno_lib::loader::NpmModuleLoadError;
use deno_lib::loader::StrippingTypesNodeModulesError;
use deno_lib::loader::module_type_from_media_type;
use deno_lib::npm::NpmRegistryReadPermissionChecker;
use deno_lib::util::hash::FastInsecureHasher;
use deno_lib::worker::CreateModuleLoaderResult;
@ -62,38 +62,38 @@ use deno_resolver::graph::ResolveWithGraphOptions;
use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_resolver::npm::ResolveNpmReqRefError;
use deno_runtime::code_cache;
use deno_runtime::deno_node::NodeRequireLoader;
use deno_runtime::deno_node::create_host_defined_options;
use deno_runtime::deno_node::ops::require::UnableToGetCwdError;
use deno_runtime::deno_node::NodeRequireLoader;
use deno_runtime::deno_permissions::CheckSpecifierKind;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_semver::npm::NpmPackageReqReference;
use eszip::EszipV2;
use node_resolver::errors::ClosestPkgJsonError;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use node_resolver::InNpmPackageChecker;
use node_resolver::NodeResolutionKind;
use node_resolver::ResolutionMode;
use node_resolver::errors::ClosestPkgJsonError;
use sys_traits::FsMetadata;
use sys_traits::FsMetadataValue;
use sys_traits::FsRead;
use tokio_util::compat::TokioAsyncReadCompatExt;
use crate::args::jsr_url;
use crate::args::CliLockfile;
use crate::args::CliOptions;
use crate::args::DenoSubcommand;
use crate::args::TsTypeLib;
use crate::args::jsr_url;
use crate::cache::CodeCache;
use crate::file_fetcher::CliFileFetcher;
use crate::graph_container::MainModuleGraphContainer;
use crate::graph_container::ModuleGraphContainer;
use crate::graph_container::ModuleGraphUpdatePermit;
use crate::graph_util::enhance_graph_error;
use crate::graph_util::BuildGraphRequest;
use crate::graph_util::BuildGraphWithNpmOptions;
use crate::graph_util::EnhanceGraphErrorMode;
use crate::graph_util::ModuleGraphBuilder;
use crate::graph_util::enhance_graph_error;
use crate::node::CliCjsCodeAnalyzer;
use crate::node::CliNodeCodeTranslator;
use crate::npm::CliNpmResolver;
@ -635,7 +635,9 @@ pub enum CliModuleLoaderError {
#[error(transparent)]
LoadPreparedModule(#[from] Box<LoadPreparedModuleError>),
#[class(generic)]
#[error("Attempted to load JSON module without specifying \"type\": \"json\" attribute in the import statement.")]
#[error(
"Attempted to load JSON module without specifying \"type\": \"json\" attribute in the import statement."
)]
MissingJsonAttribute,
#[class(inherit)]
#[error(transparent)]
@ -775,38 +777,38 @@ impl<TGraphContainer: ModuleGraphContainer>
{
Some(code) => Ok(code),
None => {
let specifier = if let Ok(reference) =
NpmPackageReqReference::from_specifier(specifier)
let specifier = match NpmPackageReqReference::from_specifier(specifier)
{
let referrer = match maybe_referrer {
// if we're here, it means it was importing from a dynamic import
// and so there will be a referrer
Some(r) => Cow::Borrowed(r),
// but the repl may also end up here and it won't have
// a referrer so create a referrer for it here
None => Cow::Owned(
Ok(reference) => {
let referrer = match maybe_referrer {
// if we're here, it means it was importing from a dynamic import
// and so there will be a referrer
Some(r) => Cow::Borrowed(r),
// but the repl may also end up here and it won't have
// a referrer so create a referrer for it here
None => Cow::Owned(
self
.resolve_referrer("")
.map_err(LoadCodeSourceError::from_err)?,
),
};
Cow::Owned(
self
.resolve_referrer("")
.shared
.resolver
.resolve_non_workspace_npm_req_ref_to_file(
&reference,
&referrer,
ResolutionMode::Import,
NodeResolutionKind::Execution,
)
.map_err(LoadCodeSourceError::from_err)?
.unwrap()
.into_url()
.map_err(LoadCodeSourceError::from_err)?,
),
};
Cow::Owned(
self
.shared
.resolver
.resolve_non_workspace_npm_req_ref_to_file(
&reference,
&referrer,
ResolutionMode::Import,
NodeResolutionKind::Execution,
)
.map_err(LoadCodeSourceError::from_err)?
.unwrap()
.into_url()
.map_err(LoadCodeSourceError::from_err)?,
)
} else {
Cow::Borrowed(specifier)
)
}
_ => Cow::Borrowed(specifier),
};
if self.shared.in_npm_pkg_checker.in_npm_package(&specifier) {
return self
@ -1024,7 +1026,10 @@ impl<TGraphContainer: ModuleGraphContainer>
&& !specifier.as_str().starts_with(jsr_url().as_str())
&& matches!(specifier.scheme(), "http" | "https")
{
return Err(JsErrorBox::generic(format!("Importing {} blocked. JSR packages cannot import non-JSR remote modules for security reasons.", specifier)));
return Err(JsErrorBox::generic(format!(
"Importing {} blocked. JSR packages cannot import non-JSR remote modules for security reasons.",
specifier
)));
}
Ok(())
}
@ -1664,7 +1669,8 @@ impl<TGraphContainer: ModuleGraphContainer> ModuleLoader
if line_number >= lines.len() {
Some(format!(
"{} Couldn't format source line: Line {} is out of bounds (source may have changed at runtime)",
crate::colors::yellow("Warning"), line_number + 1,
crate::colors::yellow("Warning"),
line_number + 1,
))
} else {
Some(lines[line_number].to_string())

2
cli/node.rs
View file

@ -2,9 +2,9 @@
use deno_resolver::cjs::analyzer::DenoCjsCodeAnalyzer;
use deno_resolver::npm::DenoInNpmPackageChecker;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use node_resolver::analyze::CjsModuleExportAnalyzer;
use node_resolver::analyze::NodeCodeTranslator;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use crate::npm::CliNpmResolver;
use crate::sys::CliSys;

16
cli/npm.rs
View file

@ -12,27 +12,27 @@ use deno_core::serde_json;
use deno_core::url::Url;
use deno_error::JsErrorBox;
use deno_lib::version::DENO_VERSION_INFO;
use deno_npm::NpmResolutionPackage;
use deno_npm::npm_rc::ResolvedNpmRc;
use deno_npm::registry::NpmPackageInfo;
use deno_npm::resolution::NpmResolutionSnapshot;
use deno_npm::NpmResolutionPackage;
use deno_npm_cache::NpmCacheHttpClientBytesResponse;
use deno_npm_cache::NpmCacheHttpClientResponse;
use deno_npm_installer::lifecycle_scripts::is_broken_default_install_script;
use deno_npm_installer::lifecycle_scripts::LifecycleScriptsExecutor;
use deno_npm_installer::lifecycle_scripts::LifecycleScriptsExecutorOptions;
use deno_npm_installer::lifecycle_scripts::PackageWithScript;
use deno_npm_installer::lifecycle_scripts::LIFECYCLE_SCRIPTS_RUNNING_ENV_VAR;
use deno_npm_installer::BinEntries;
use deno_npm_installer::CachedNpmPackageExtraInfoProvider;
use deno_npm_installer::ExpectedExtraInfo;
use deno_npm_installer::lifecycle_scripts::LIFECYCLE_SCRIPTS_RUNNING_ENV_VAR;
use deno_npm_installer::lifecycle_scripts::LifecycleScriptsExecutor;
use deno_npm_installer::lifecycle_scripts::LifecycleScriptsExecutorOptions;
use deno_npm_installer::lifecycle_scripts::PackageWithScript;
use deno_npm_installer::lifecycle_scripts::is_broken_default_install_script;
use deno_resolver::npm::ByonmNpmResolverCreateOptions;
use deno_resolver::npm::ManagedNpmResolverRc;
use deno_runtime::deno_io::FromRawIoHandle;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_semver::Version;
use deno_semver::VersionReq;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_task_shell::KillSignal;
use crate::file_fetcher::CliFileFetcher;

25
cli/ops/bench.rs
View file

@ -3,10 +3,10 @@
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use deno_core::op2;
use deno_core::v8;
use deno_core::ModuleSpecifier;
use deno_core::OpState;
use deno_core::op2;
use deno_core::v8;
use deno_error::JsErrorBox;
use deno_runtime::deno_permissions::ChildPermissionsArg;
use deno_runtime::deno_permissions::PermissionsContainer;
@ -77,16 +77,19 @@ pub fn op_restore_test_permissions(
state: &mut OpState,
#[serde] token: Uuid,
) -> Result<(), JsErrorBox> {
if let Some(permissions_holder) = state.try_take::<PermissionsHolder>() {
if token != permissions_holder.0 {
panic!("restore test permissions token does not match the stored token");
}
match state.try_take::<PermissionsHolder>() {
Some(permissions_holder) => {
if token != permissions_holder.0 {
panic!(
"restore test permissions token does not match the stored token"
);
}
let permissions = permissions_holder.1;
state.put::<PermissionsContainer>(permissions);
Ok(())
} else {
Err(JsErrorBox::generic("no permissions to restore"))
let permissions = permissions_holder.1;
state.put::<PermissionsContainer>(permissions);
Ok(())
}
_ => Err(JsErrorBox::generic("no permissions to restore")),
}
}

4
cli/ops/jupyter.rs
View file

@ -8,11 +8,11 @@ use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;
use deno_core::OpState;
use deno_core::error::AnyError;
use deno_core::op2;
use deno_core::parking_lot::Mutex;
use deno_core::serde_json;
use deno_core::OpState;
use deno_error::JsErrorBox;
use jupyter_runtime::InputRequest;
use jupyter_runtime::JupyterMessage;
@ -329,7 +329,7 @@ pub fn op_jupyter_create_png_from_texture(
return Err(JsErrorBox::type_error(format!(
"Unsupported texture format '{}'",
texture.format.as_str()
)))
)));
}
};

6
cli/ops/lint.rs
View file

@ -6,8 +6,8 @@ use deno_ast::ParseDiagnostic;
use deno_ast::SourceRange;
use deno_ast::SourceTextInfo;
use deno_ast::SourceTextProvider;
use deno_core::op2;
use deno_core::OpState;
use deno_core::op2;
use deno_lint::diagnostic::LintDiagnostic;
use deno_lint::diagnostic::LintDiagnosticDetails;
use deno_lint::diagnostic::LintDiagnosticRange;
@ -236,7 +236,9 @@ struct LintReportFix {
#[derive(Debug, thiserror::Error, deno_error::JsError)]
pub enum LintReportError {
#[class(type)]
#[error("Invalid range [{start}, {end}], the source has a range of [0, {source_end}]")]
#[error(
"Invalid range [{start}, {end}], the source has a range of [0, {source_end}]"
)]
IncorrectRange {
start: usize,
end: usize,

25
cli/ops/testing.rs
View file

@ -3,10 +3,10 @@
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use deno_core::op2;
use deno_core::v8;
use deno_core::ModuleSpecifier;
use deno_core::OpState;
use deno_core::op2;
use deno_core::v8;
use deno_error::JsErrorBox;
use deno_runtime::deno_permissions::ChildPermissionsArg;
use deno_runtime::deno_permissions::PermissionsContainer;
@ -72,16 +72,19 @@ pub fn op_restore_test_permissions(
state: &mut OpState,
#[serde] token: Uuid,
) -> Result<(), JsErrorBox> {
if let Some(permissions_holder) = state.try_take::<PermissionsHolder>() {
if token != permissions_holder.0 {
panic!("restore test permissions token does not match the stored token");
}
match state.try_take::<PermissionsHolder>() {
Some(permissions_holder) => {
if token != permissions_holder.0 {
panic!(
"restore test permissions token does not match the stored token"
);
}
let permissions = permissions_holder.1;
state.put::<PermissionsContainer>(permissions);
Ok(())
} else {
Err(JsErrorBox::generic("no permissions to restore"))
let permissions = permissions_holder.1;
state.put::<PermissionsContainer>(permissions);
Ok(())
}
_ => Err(JsErrorBox::generic("no permissions to restore")),
}
}

18
cli/rt/binary.rs
View file

@ -8,35 +8,35 @@ use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::url::Url;
use deno_core::FastString;
use deno_core::ModuleCodeBytes;
use deno_core::ModuleSourceCode;
use deno_core::ModuleType;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::url::Url;
use deno_error::JsError;
use deno_error::JsErrorBox;
use deno_lib::standalone::binary::DenoRtDeserializable;
use deno_lib::standalone::binary::MAGIC_BYTES;
use deno_lib::standalone::binary::Metadata;
use deno_lib::standalone::binary::RemoteModuleEntry;
use deno_lib::standalone::binary::SpecifierDataStore;
use deno_lib::standalone::binary::SpecifierId;
use deno_lib::standalone::binary::MAGIC_BYTES;
use deno_lib::standalone::virtual_fs::VirtualDirectory;
use deno_lib::standalone::virtual_fs::VirtualDirectoryEntries;
use deno_media_type::MediaType;
use deno_npm::NpmPackageId;
use deno_npm::resolution::SerializedNpmResolutionSnapshot;
use deno_npm::resolution::SerializedNpmResolutionSnapshotPackage;
use deno_npm::resolution::ValidSerializedNpmResolutionSnapshot;
use deno_npm::NpmPackageId;
use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_fs::RealFs;
use deno_runtime::deno_io::fs::FsError;
use deno_semver::package::PackageReq;
use deno_semver::StackString;
use deno_semver::package::PackageReq;
use indexmap::IndexMap;
use thiserror::Error;
@ -372,7 +372,7 @@ impl StandaloneModules {
match RealFs.read_file_sync(&path, None) {
Ok(bytes) => bytes,
Err(FsError::Io(err)) if err.kind() == ErrorKind::NotFound => {
return Ok(None)
return Ok(None);
}
Err(err) => return Err(JsErrorBox::from_err(err)),
}

40
cli/rt/code_cache.rs
View file

@ -461,12 +461,16 @@ mod test {
// first run
{
let code_cache = DenoCompileCodeCache::new(file_path.clone(), 1234);
assert!(code_cache
.get_sync(&url1, CodeCacheType::EsModule, 0)
.is_none());
assert!(code_cache
.get_sync(&url2, CodeCacheType::EsModule, 1)
.is_none());
assert!(
code_cache
.get_sync(&url1, CodeCacheType::EsModule, 0)
.is_none()
);
assert!(
code_cache
.get_sync(&url2, CodeCacheType::EsModule, 1)
.is_none()
);
assert!(code_cache.enabled());
code_cache.set_sync(url1.clone(), CodeCacheType::EsModule, 0, &[1, 2, 3]);
assert!(code_cache.enabled());
@ -494,12 +498,16 @@ mod test {
// new cache key first run
{
let code_cache = DenoCompileCodeCache::new(file_path.clone(), 54321);
assert!(code_cache
.get_sync(&url1, CodeCacheType::EsModule, 0)
.is_none());
assert!(code_cache
.get_sync(&url2, CodeCacheType::EsModule, 1)
.is_none());
assert!(
code_cache
.get_sync(&url1, CodeCacheType::EsModule, 0)
.is_none()
);
assert!(
code_cache
.get_sync(&url2, CodeCacheType::EsModule, 1)
.is_none()
);
code_cache.set_sync(url1.clone(), CodeCacheType::EsModule, 0, &[2, 2, 3]);
code_cache.set_sync(url2.clone(), CodeCacheType::EsModule, 1, &[3, 2, 3]);
}
@ -510,9 +518,11 @@ mod test {
.get_sync(&url1, CodeCacheType::EsModule, 0)
.unwrap();
assert_eq!(result1, vec![2, 2, 3]);
assert!(code_cache
.get_sync(&url2, CodeCacheType::EsModule, 5) // different hash will cause none
.is_none());
assert!(
code_cache
.get_sync(&url2, CodeCacheType::EsModule, 5) // different hash will cause none
.is_none()
);
}
}
}

16
cli/rt/file_system.rs
View file

@ -39,11 +39,11 @@ use deno_runtime::deno_napi::DenoRtNativeAddonLoader;
use deno_runtime::deno_napi::DenoRtNativeAddonLoaderRc;
#[cfg(windows)]
use deno_subprocess_windows::Stdio as StdStdio;
use sys_traits::FsCopy;
use sys_traits::boxed::BoxedFsDirEntry;
use sys_traits::boxed::BoxedFsMetadataValue;
use sys_traits::boxed::FsMetadataBoxed;
use sys_traits::boxed::FsReadDirBoxed;
use sys_traits::FsCopy;
use url::Url;
#[derive(Debug, Clone)]
@ -1090,7 +1090,10 @@ impl FileBackedVfsFile {
if offset >= 0 {
*current_pos += offset as u64;
} else if -offset as u64 > *current_pos {
return Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "An attempt was made to move the file pointer before the beginning of the file."));
return Err(std::io::Error::new(
std::io::ErrorKind::PermissionDenied,
"An attempt was made to move the file pointer before the beginning of the file.",
));
} else {
*current_pos -= -offset as u64;
}
@ -1407,7 +1410,7 @@ impl FileBackedVfs {
pub fn read_dir_with_metadata(
&self,
path: &Path,
) -> std::io::Result<impl Iterator<Item = FileBackedVfsDirEntry>> {
) -> std::io::Result<impl Iterator<Item = FileBackedVfsDirEntry> + use<>> {
let dir = self.dir_entry(path)?;
let path = path.to_path_buf();
Ok(
@ -1538,8 +1541,8 @@ mod test {
use std::io::Write;
use deno_lib::standalone::virtual_fs::VfsBuilder;
use test_util::assert_contains;
use test_util::TempDir;
use test_util::assert_contains;
use super::*;
@ -1773,10 +1776,7 @@ mod test {
file.read_to_buf(&mut buf).unwrap();
assert_eq!(buf, b"23");
assert_eq!(
file
.seek(SeekFrom::Current(-5))
.unwrap_err()
.to_string(),
file.seek(SeekFrom::Current(-5)).unwrap_err().to_string(),
"An attempt was made to move the file pointer before the beginning of the file."
);
// go beyond the file length, then back

5
cli/rt/main.rs
View file

@ -60,7 +60,10 @@ fn unwrap_or_exit<T>(result: Result<T, AnyError>) -> T {
fn load_env_vars(env_vars: &IndexMap<String, String>) {
env_vars.iter().for_each(|env_var| {
if env::var(env_var.0).is_err() {
std::env::set_var(env_var.0, env_var.1);
#[allow(clippy::undocumented_unsafe_blocks)]
unsafe {
std::env::set_var(env_var.0, env_var.1)
};
}
})
}

2
cli/rt/node.rs
View file

@ -11,11 +11,11 @@ use deno_media_type::MediaType;
use deno_resolver::npm::DenoInNpmPackageChecker;
use deno_resolver::npm::NpmReqResolver;
use deno_runtime::deno_fs::FileSystem;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use node_resolver::analyze::CjsAnalysis;
use node_resolver::analyze::CjsAnalysisExports;
use node_resolver::analyze::EsmAnalysisMode;
use node_resolver::analyze::NodeCodeTranslator;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use crate::binary::StandaloneModules;
use crate::file_system::DenoRtSys;

57
cli/rt/run.rs
View file

@ -8,12 +8,6 @@ use std::sync::OnceLock;
use deno_cache_dir::npm::NpmCacheDir;
use deno_config::workspace::ResolverWorkspaceJsrPackage;
use deno_core::error::AnyError;
use deno_core::error::ModuleLoaderError;
use deno_core::futures::future::LocalBoxFuture;
use deno_core::futures::FutureExt;
use deno_core::url::Url;
use deno_core::v8_set_flags;
use deno_core::FastString;
use deno_core::ModuleLoader;
use deno_core::ModuleSourceCode;
@ -21,15 +15,21 @@ use deno_core::ModuleType;
use deno_core::RequestedModuleType;
use deno_core::ResolutionKind;
use deno_core::SourceCodeCacheInfo;
use deno_core::error::AnyError;
use deno_core::error::ModuleLoaderError;
use deno_core::futures::FutureExt;
use deno_core::futures::future::LocalBoxFuture;
use deno_core::url::Url;
use deno_core::v8_set_flags;
use deno_error::JsErrorBox;
use deno_lib::args::get_root_cert_store;
use deno_lib::args::npm_pkg_req_ref_to_binary_command;
use deno_lib::args::CaData;
use deno_lib::args::RootCertStoreLoadError;
use deno_lib::args::get_root_cert_store;
use deno_lib::args::npm_pkg_req_ref_to_binary_command;
use deno_lib::loader::NpmModuleLoader;
use deno_lib::npm::create_npm_process_state_provider;
use deno_lib::npm::NpmRegistryReadPermissionChecker;
use deno_lib::npm::NpmRegistryReadPermissionCheckerMode;
use deno_lib::npm::create_npm_process_state_provider;
use deno_lib::standalone::binary::NodeModules;
use deno_lib::util::hash::FastInsecureHasher;
use deno_lib::util::text_encoding::from_utf8_lossy_cow;
@ -44,11 +44,9 @@ use deno_media_type::MediaType;
use deno_npm::npm_rc::ResolvedNpmRc;
use deno_npm::resolution::NpmResolutionSnapshot;
use deno_package_json::PackageJsonDepValue;
use deno_resolver::DenoResolveErrorKind;
use deno_resolver::cjs::CjsTracker;
use deno_resolver::cjs::IsCjsResolutionMode;
use deno_resolver::npm::managed::ManagedInNpmPkgCheckerCreateOptions;
use deno_resolver::npm::managed::ManagedNpmResolverCreateOptions;
use deno_resolver::npm::managed::NpmResolutionCell;
use deno_resolver::npm::ByonmNpmResolverCreateOptions;
use deno_resolver::npm::CreateInNpmPkgCheckerOptions;
use deno_resolver::npm::DenoInNpmPackageChecker;
@ -56,34 +54,36 @@ use deno_resolver::npm::NpmReqResolver;
use deno_resolver::npm::NpmReqResolverOptions;
use deno_resolver::npm::NpmResolver;
use deno_resolver::npm::NpmResolverCreateOptions;
use deno_resolver::npm::managed::ManagedInNpmPkgCheckerCreateOptions;
use deno_resolver::npm::managed::ManagedNpmResolverCreateOptions;
use deno_resolver::npm::managed::NpmResolutionCell;
use deno_resolver::workspace::MappedResolution;
use deno_resolver::workspace::SloppyImportsOptions;
use deno_resolver::workspace::WorkspaceResolver;
use deno_resolver::DenoResolveErrorKind;
use deno_runtime::code_cache::CodeCache;
use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_node::create_host_defined_options;
use deno_runtime::deno_node::NodeRequireLoader;
use deno_runtime::deno_permissions::Permissions;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_tls::RootCertStoreProvider;
use deno_runtime::deno_web::BlobStore;
use deno_runtime::permissions::RuntimePermissionDescriptorParser;
use deno_runtime::FeatureChecker;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::WorkerLogLevel;
use deno_runtime::code_cache::CodeCache;
use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_node::NodeRequireLoader;
use deno_runtime::deno_node::create_host_defined_options;
use deno_runtime::deno_permissions::Permissions;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::deno_tls::RootCertStoreProvider;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_web::BlobStore;
use deno_runtime::permissions::RuntimePermissionDescriptorParser;
use deno_semver::npm::NpmPackageReqReference;
use node_resolver::analyze::CjsModuleExportAnalyzer;
use node_resolver::analyze::NodeCodeTranslator;
use node_resolver::cache::NodeResolutionSys;
use node_resolver::errors::ClosestPkgJsonError;
use node_resolver::DenoIsBuiltInNodeModuleChecker;
use node_resolver::NodeResolutionKind;
use node_resolver::NodeResolver;
use node_resolver::PackageJsonResolver;
use node_resolver::PackageJsonThreadLocalCache;
use node_resolver::ResolutionMode;
use node_resolver::analyze::CjsModuleExportAnalyzer;
use node_resolver::analyze::NodeCodeTranslator;
use node_resolver::cache::NodeResolutionSys;
use node_resolver::errors::ClosestPkgJsonError;
use crate::binary::DenoCompileModuleSource;
use crate::binary::StandaloneData;
@ -578,7 +578,8 @@ impl ModuleLoader for EmbeddedModuleLoader {
if line_number >= lines.len() {
Some(format!(
"{} Couldn't format source line: Line {} is out of bounds (source may have changed at runtime)",
crate::colors::yellow("Warning"), line_number + 1,
crate::colors::yellow("Warning"),
line_number + 1,
))
} else {
Some(lines[line_number].to_string())

21
cli/standalone/binary.rs
View file

@ -17,8 +17,8 @@ use deno_ast::MediaType;
use deno_ast::ModuleKind;
use deno_ast::ModuleSpecifier;
use deno_cache_dir::CACHE_PERM;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::url::Url;
@ -27,6 +27,7 @@ use deno_lib::args::CaData;
use deno_lib::args::UnstableConfig;
use deno_lib::shared::ReleaseChannel;
use deno_lib::standalone::binary::CjsExportAnalysisEntry;
use deno_lib::standalone::binary::MAGIC_BYTES;
use deno_lib::standalone::binary::Metadata;
use deno_lib::standalone::binary::NodeModules;
use deno_lib::standalone::binary::RemoteModuleEntry;
@ -35,20 +36,19 @@ use deno_lib::standalone::binary::SerializedWorkspaceResolver;
use deno_lib::standalone::binary::SerializedWorkspaceResolverImportMap;
use deno_lib::standalone::binary::SpecifierDataStore;
use deno_lib::standalone::binary::SpecifierId;
use deno_lib::standalone::binary::MAGIC_BYTES;
use deno_lib::standalone::virtual_fs::BuiltVfs;
use deno_lib::standalone::virtual_fs::DENO_COMPILE_GLOBAL_NODE_MODULES_DIR_NAME;
use deno_lib::standalone::virtual_fs::VfsBuilder;
use deno_lib::standalone::virtual_fs::VfsEntry;
use deno_lib::standalone::virtual_fs::VirtualDirectory;
use deno_lib::standalone::virtual_fs::VirtualDirectoryEntries;
use deno_lib::standalone::virtual_fs::WindowsSystemRootablePath;
use deno_lib::standalone::virtual_fs::DENO_COMPILE_GLOBAL_NODE_MODULES_DIR_NAME;
use deno_lib::util::hash::FastInsecureHasher;
use deno_lib::util::text_encoding::is_valid_utf8;
use deno_lib::util::v8::construct_v8_flags;
use deno_lib::version::DENO_VERSION_INFO;
use deno_npm::resolution::SerializedNpmResolutionSnapshot;
use deno_npm::NpmSystemInfo;
use deno_npm::resolution::SerializedNpmResolutionSnapshot;
use deno_path_util::fs::atomic_write_file_with_retries;
use deno_path_util::url_from_directory_path;
use deno_path_util::url_to_file_path;
@ -60,9 +60,9 @@ use indexmap::IndexMap;
use node_resolver::analyze::ResolvedCjsAnalysis;
use super::virtual_fs::output_vfs;
use crate::args::get_default_v8_flags;
use crate::args::CliOptions;
use crate::args::CompileFlags;
use crate::args::get_default_v8_flags;
use crate::cache::DenoDir;
use crate::file_fetcher::CliFileFetcher;
use crate::http_util::HttpClientProvider;
@ -697,7 +697,11 @@ impl<'a> DenoCompileBinaryWriter<'a> {
Some(env_filenames) => {
let mut aggregated_env_vars = IndexMap::new();
for env_filename in env_filenames.iter().rev() {
log::info!("{} Environment variables from the file \"{}\" were embedded in the generated executable file", crate::colors::yellow("Warning"), env_filename);
log::info!(
"{} Environment variables from the file \"{}\" were embedded in the generated executable file",
crate::colors::yellow("Warning"),
env_filename
);
let env_vars = get_file_env_vars(env_filename.to_string())?;
aggregated_env_vars.extend(env_vars);
@ -844,7 +848,10 @@ impl<'a> DenoCompileBinaryWriter<'a> {
fn fill_npm_vfs(&self, builder: &mut VfsBuilder) -> Result<(), AnyError> {
fn maybe_warn_different_system(system_info: &NpmSystemInfo) {
if system_info != &NpmSystemInfo::default() {
log::warn!("{} The node_modules directory may be incompatible with the target system.", crate::colors::yellow("Warning"));
log::warn!(
"{} The node_modules directory may be incompatible with the target system.",
crate::colors::yellow("Warning")
);
}
}

2
cli/standalone/virtual_fs.rs
View file

@ -5,6 +5,7 @@ use std::collections::HashSet;
use std::path::PathBuf;
use deno_lib::standalone::virtual_fs::BuiltVfs;
use deno_lib::standalone::virtual_fs::DENO_COMPILE_GLOBAL_NODE_MODULES_DIR_NAME;
use deno_lib::standalone::virtual_fs::OffsetWithLength;
use deno_lib::standalone::virtual_fs::VfsEntry;
use deno_lib::standalone::virtual_fs::VirtualDirectory;
@ -12,7 +13,6 @@ use deno_lib::standalone::virtual_fs::VirtualDirectoryEntries;
use deno_lib::standalone::virtual_fs::VirtualFile;
use deno_lib::standalone::virtual_fs::VirtualSymlinkParts;
use deno_lib::standalone::virtual_fs::WindowsSystemRootablePath;
use deno_lib::standalone::virtual_fs::DENO_COMPILE_GLOBAL_NODE_MODULES_DIR_NAME;
use deno_resolver::display::DisplayTreeNode;
use crate::util::display::human_size;

44
cli/task_runner.rs
View file

@ -323,7 +323,10 @@ impl ShellCommand for NodeGypCommand {
.resolve_command_path(OsStr::new("node-gyp"))
.is_err()
{
log::warn!("{} node-gyp was used in a script, but was not listed as a dependency. Either add it as a dependency or install it globally (e.g. `npm install -g node-gyp`)", crate::colors::yellow("Warning"));
log::warn!(
"{} node-gyp was used in a script, but was not listed as a dependency. Either add it as a dependency or install it globally (e.g. `npm install -g node-gyp`)",
crate::colors::yellow("Warning")
);
}
ExecutableCommand::new(
"node-gyp".to_string(),
@ -341,25 +344,28 @@ impl ShellCommand for NpxCommand {
mut context: ShellCommandContext,
) -> LocalBoxFuture<'static, ExecuteResult> {
if let Some(first_arg) = context.args.first().cloned() {
if let Some(command) = context.state.resolve_custom_command(&first_arg) {
let context = ShellCommandContext {
args: context.args.into_iter().skip(1).collect::<Vec<_>>(),
..context
};
command.execute(context)
} else {
// can't find the command, so fallback to running the real npx command
let npx_path =
match context.state.resolve_command_path(OsStr::new("npx")) {
Ok(npx) => npx,
Err(err) => {
let _ = context.stderr.write_line(&format!("{}", err));
return Box::pin(std::future::ready(
ExecuteResult::from_exit_code(err.exit_code()),
));
}
match context.state.resolve_custom_command(&first_arg) {
Some(command) => {
let context = ShellCommandContext {
args: context.args.into_iter().skip(1).collect::<Vec<_>>(),
..context
};
ExecutableCommand::new("npx".to_string(), npx_path).execute(context)
command.execute(context)
}
_ => {
// can't find the command, so fallback to running the real npx command
let npx_path =
match context.state.resolve_command_path(OsStr::new("npx")) {
Ok(npx) => npx,
Err(err) => {
let _ = context.stderr.write_line(&format!("{}", err));
return Box::pin(std::future::ready(
ExecuteResult::from_exit_code(err.exit_code()),
));
}
};
ExecutableCommand::new("npx".to_string(), npx_path).execute(context)
}
}
} else {
let _ = context.stderr.write_line("npx: missing command");

12
cli/tools/bench/mod.rs
View file

@ -6,33 +6,33 @@ use std::sync::Arc;
use std::time::Duration;
use deno_config::glob::WalkEntry;
use deno_core::ModuleSpecifier;
use deno_core::PollEventLoopOptions;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::error::CoreError;
use deno_core::error::JsError;
use deno_core::futures::StreamExt;
use deno_core::futures::future;
use deno_core::futures::stream;
use deno_core::futures::StreamExt;
use deno_core::serde_v8;
use deno_core::unsync::spawn;
use deno_core::unsync::spawn_blocking;
use deno_core::v8;
use deno_core::ModuleSpecifier;
use deno_core::PollEventLoopOptions;
use deno_error::JsErrorBox;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::deno_permissions::Permissions;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::permissions::RuntimePermissionDescriptorParser;
use deno_runtime::tokio_util::create_and_run_current_thread;
use deno_runtime::WorkerExecutionMode;
use indexmap::IndexMap;
use indexmap::IndexSet;
use log::Level;
use serde::Deserialize;
use serde::Serialize;
use tokio::sync::mpsc::unbounded_channel;
use tokio::sync::mpsc::UnboundedSender;
use tokio::sync::mpsc::unbounded_channel;
use crate::args::BenchFlags;
use crate::args::Flags;
@ -43,8 +43,8 @@ use crate::graph_container::CheckSpecifiersOptions;
use crate::graph_util::has_graph_root_local_dependent_changed;
use crate::ops;
use crate::sys::CliSys;
use crate::tools::test::format_test_error;
use crate::tools::test::TestFilter;
use crate::tools::test::format_test_error;
use crate::util::file_watcher;
use crate::util::fs::collect_specifiers;
use crate::util::path::is_script_ext;

16
cli/tools/bench/reporters.rs
View file

@ -233,7 +233,13 @@ impl BenchReporter for ConsoleReporter {
);
if !stats.high_precision && stats.used_explicit_timers {
println!("{}", colors::yellow(format!("Warning: start() and end() calls in \"{}\" are ignored because it averages less\nthan 10µs per iteration. Remove them for better results.", &desc.name)));
println!(
"{}",
colors::yellow(format!(
"Warning: start() and end() calls in \"{}\" are ignored because it averages less\nthan 10µs per iteration. Remove them for better results.",
&desc.name
))
);
}
self.group_measurements.push((desc, stats.clone()));
@ -306,8 +312,12 @@ impl BenchReporter for ConsoleReporter {
colors::red_bold("error"),
format_test_error(&error, &TestFailureFormatOptions::default())
);
println!("This error was not caught from a benchmark and caused the bench runner to fail on the referenced module.");
println!("It most likely originated from a dangling promise, event/timeout handler or top-level code.");
println!(
"This error was not caught from a benchmark and caused the bench runner to fail on the referenced module."
);
println!(
"It most likely originated from a dangling promise, event/timeout handler or top-level code."
);
println!();
}
}

37
cli/tools/bundle/mod.rs
View file

@ -17,12 +17,12 @@ use deno_ast::EmitOptions;
use deno_ast::MediaType;
use deno_ast::ModuleSpecifier;
use deno_config::workspace::TsTypeLib;
use deno_core::RequestedModuleType;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt as _;
use deno_core::resolve_url_or_path;
use deno_core::serde_json;
use deno_core::url::Url;
use deno_core::RequestedModuleType;
use deno_error::JsError;
use deno_graph::ModuleErrorKind;
use deno_graph::Position;
@ -31,15 +31,15 @@ use deno_resolver::graph::ResolveWithGraphOptions;
use deno_resolver::npm::managed::ResolvePkgFolderFromDenoModuleError;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_semver::npm::NpmPackageReqReference;
use esbuild_client::protocol;
use esbuild_client::protocol::BuildResponse;
use esbuild_client::EsbuildFlags;
use esbuild_client::EsbuildFlagsBuilder;
use esbuild_client::EsbuildService;
use esbuild_client::protocol;
use esbuild_client::protocol::BuildResponse;
use indexmap::IndexMap;
use node_resolver::errors::PackageSubpathResolveError;
use node_resolver::NodeResolutionKind;
use node_resolver::ResolutionMode;
use node_resolver::errors::PackageSubpathResolveError;
use sys_traits::EnvCurrentDir;
use crate::args::BundleFlags;
@ -640,10 +640,10 @@ impl BundleLoadError {
pub fn is_unsupported_media_type(&self) -> bool {
match self {
BundleLoadError::CliModuleLoader(
CliModuleLoaderError::LoadCodeSource(LoadCodeSourceError(ref e)),
CliModuleLoaderError::LoadCodeSource(LoadCodeSourceError(e)),
) => match &**e {
LoadCodeSourceErrorKind::LoadPreparedModule(
LoadPreparedModuleError::Graph(ref e),
LoadPreparedModuleError::Graph(e),
) => matches!(
e.error.as_kind(),
ModuleErrorKind::UnsupportedMediaType { .. },
@ -1041,19 +1041,20 @@ fn resolve_roots(
let mut roots = Vec::with_capacity(entrypoints.len());
for url in entrypoints {
let root = if let Ok(v) = NpmPackageReqReference::from_specifier(&url) {
let referrer =
ModuleSpecifier::from_directory_path(sys.env_current_dir().unwrap())
let root = match NpmPackageReqReference::from_specifier(&url) {
Ok(v) => {
let referrer =
ModuleSpecifier::from_directory_path(sys.env_current_dir().unwrap())
.unwrap();
let package_folder = npm_resolver
.resolve_pkg_folder_from_deno_module_req(v.req(), &referrer)
.unwrap();
let package_folder = npm_resolver
.resolve_pkg_folder_from_deno_module_req(v.req(), &referrer)
.unwrap();
let main_module = node_resolver
.resolve_binary_export(&package_folder, v.sub_path())
.unwrap();
Url::from_file_path(&main_module).unwrap()
} else {
url
let main_module = node_resolver
.resolve_binary_export(&package_folder, v.sub_path())
.unwrap();
Url::from_file_path(&main_module).unwrap()
}
_ => url,
};
roots.push(root)
}

29
cli/tools/clean.rs
View file

@ -9,12 +9,12 @@ use std::path::PathBuf;
use std::sync::Arc;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::url::Url;
use deno_graph::packages::PackageSpecifiers;
use deno_graph::ModuleGraph;
use deno_graph::packages::PackageSpecifiers;
use deno_npm_installer::graph::NpmCachingStrategy;
use sys_traits::FsCanonicalize;
use sys_traits::FsCreateDirAll;
@ -527,7 +527,7 @@ fn clean_node_modules(
"failed to clean node_modules directory at {}",
dir.display()
)
})
});
}
};
@ -646,22 +646,23 @@ fn remove_file(
}
state.files_removed += 1;
state.update_progress();
if let Err(e) = std::fs::remove_file(path)
match std::fs::remove_file(path)
.with_context(|| format!("Failed to remove file: {}", path.display()))
{
if cfg!(windows) {
if let Ok(meta) = path.symlink_metadata() {
if meta.is_symlink() {
std::fs::remove_dir(path).with_context(|| {
format!("Failed to remove symlink: {}", path.display())
})?;
return Ok(());
Err(e) => {
if cfg!(windows) {
if let Ok(meta) = path.symlink_metadata() {
if meta.is_symlink() {
std::fs::remove_dir(path).with_context(|| {
format!("Failed to remove symlink: {}", path.display())
})?;
return Ok(());
}
}
}
Err(e)
}
Err(e)
} else {
Ok(())
_ => Ok(()),
}
}

20
cli/tools/compile.rs
View file

@ -9,9 +9,9 @@ use std::sync::Arc;
use deno_ast::MediaType;
use deno_ast::ModuleSpecifier;
use deno_core::anyhow::Context;
use deno_core::anyhow::anyhow;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
use deno_core::resolve_url_or_path;
use deno_graph::GraphKind;
@ -25,8 +25,8 @@ use super::installer::BinNameResolver;
use crate::args::CompileFlags;
use crate::args::Flags;
use crate::factory::CliFactory;
use crate::standalone::binary::is_standalone_binary;
use crate::standalone::binary::WriteBinOptions;
use crate::standalone::binary::is_standalone_binary;
pub async fn compile(
flags: Arc<Flags>,
@ -83,7 +83,7 @@ pub async fn compile(
temp_filename.push(format!(
".tmp-{}",
faster_hex::hex_encode(
&rand::thread_rng().gen::<[u8; 8]>(),
&rand::thread_rng().r#gen::<[u8; 8]>(),
&mut [0u8; 16]
)
.unwrap()
@ -307,13 +307,13 @@ fn validate_output_path(output_path: &Path) -> Result<(), AnyError> {
let output_base = &output_path.parent().unwrap();
if output_base.exists() && output_base.is_file() {
bail!(
concat!(
"Could not compile to file '{}' because its parent directory ",
"is an existing file. You can use the `--output <file-path>` flag to ",
"provide an alternative name.",
),
output_base.display(),
);
concat!(
"Could not compile to file '{}' because its parent directory ",
"is an existing file. You can use the `--output <file-path>` flag to ",
"provide an alternative name.",
),
output_base.display(),
);
}
std::fs::create_dir_all(output_base)?;
}

2
cli/tools/coverage/ignore_directives.rs
View file

@ -2,9 +2,9 @@
use std::collections::HashSet;
use deno_ast::swc::common::comments::CommentKind;
use deno_ast::MediaType;
use deno_ast::TextLines;
use deno_ast::swc::common::comments::CommentKind;
use deno_core::url::Url;
static COVERAGE_IGNORE_START_DIRECTIVE: &str = "deno-coverage-ignore-start";

4
cli/tools/coverage/merge.rs
View file

@ -209,7 +209,7 @@ impl<'a> Iterator for StartEventQueue<'a> {
fn next(&mut self) -> Option<<Self as Iterator>::Item> {
let pending_offset: Option<usize> = match &self.pending {
Some(ref start_event) if !start_event.trees.is_empty() => {
Some(start_event) if !start_event.trees.is_empty() => {
Some(start_event.offset)
}
_ => None,
@ -299,7 +299,7 @@ fn merge_range_tree_children<'a>(
}
None => {
let mut open_range_end: usize = event.offset + 1;
for (_, ref tree) in &event.trees {
for (_, tree) in &event.trees {
open_range_end = if tree.end > open_range_end {
tree.end
} else {

4
cli/tools/coverage/mod.rs
View file

@ -15,14 +15,14 @@ use deno_config::glob::FileCollector;
use deno_config::glob::FilePatterns;
use deno_config::glob::PathOrPattern;
use deno_config::glob::PathOrPatternSet;
use deno_core::anyhow::anyhow;
use deno_core::LocalInspectorSession;
use deno_core::anyhow::Context;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_core::error::CoreError;
use deno_core::serde_json;
use deno_core::sourcemap::SourceMap;
use deno_core::url::Url;
use deno_core::LocalInspectorSession;
use deno_error::JsErrorBox;
use deno_resolver::npm::DenoInNpmPackageChecker;
use node_resolver::InNpmPackageChecker;

2
cli/tools/coverage/reporter.rs
View file

@ -13,8 +13,8 @@ use deno_core::error::AnyError;
use deno_core::url::Url;
use deno_lib::version::DENO_VERSION_INFO;
use super::util;
use super::CoverageReport;
use super::util;
use crate::args::CoverageType;
use crate::colors;

2
cli/tools/deploy.rs
View file

@ -6,10 +6,10 @@ use deno_core::error::AnyError;
use deno_lib::worker::LibWorkerFactoryRoots;
use deno_runtime::WorkerExecutionMode;
use crate::args::jsr_api_url;
use crate::args::DenoSubcommand;
use crate::args::Flags;
use crate::args::RunFlags;
use crate::args::jsr_api_url;
use crate::factory::CliFactory;
use crate::registry;
use crate::tools;

12
cli/tools/doc.rs
View file

@ -7,24 +7,24 @@ use std::sync::Arc;
use deno_ast::diagnostics::Diagnostic;
use deno_config::glob::FilePatterns;
use deno_config::glob::PathOrPatternSet;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_doc as doc;
use deno_doc::html::UrlResolveKind;
use deno_doc::html::UsageComposer;
use deno_doc::html::UsageComposerEntry;
use deno_graph::analysis::ModuleAnalyzer;
use deno_graph::ast::EsParser;
use deno_graph::source::NullFileSystem;
use deno_graph::CheckJsOption;
use deno_graph::GraphKind;
use deno_graph::ModuleSpecifier;
use deno_graph::analysis::ModuleAnalyzer;
use deno_graph::ast::EsParser;
use deno_graph::source::NullFileSystem;
use deno_lib::version::DENO_VERSION_INFO;
use deno_npm_installer::graph::NpmCachingStrategy;
use doc::html::ShortPath;
use doc::DocDiagnostic;
use doc::html::ShortPath;
use indexmap::IndexMap;
use crate::args::DocFlags;
@ -34,9 +34,9 @@ use crate::args::Flags;
use crate::colors;
use crate::display;
use crate::factory::CliFactory;
use crate::graph_util::GraphWalkErrorsOptions;
use crate::graph_util::graph_exit_integrity_errors;
use crate::graph_util::graph_walk_errors;
use crate::graph_util::GraphWalkErrorsOptions;
use crate::sys::CliSys;
use crate::tsc::get_types_declaration_file_text;
use crate::util::fs::collect_specifiers;

24
cli/tools/fmt.rs
View file

@ -9,23 +9,23 @@
use std::borrow::Cow;
use std::fs;
use std::io::stdin;
use std::io::stdout;
use std::io::Read;
use std::io::Write;
use std::io::stdin;
use std::io::stdout;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use async_trait::async_trait;
use deno_ast::ParsedSource;
use deno_config::glob::FileCollector;
use deno_config::glob::FilePatterns;
use deno_core::anyhow::Context;
use deno_core::anyhow::anyhow;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
use deno_core::futures;
use deno_core::parking_lot::Mutex;
@ -540,7 +540,8 @@ fn create_external_formatter_for_typescript(
&str,
String,
&dprint_plugin_typescript::configuration::Configuration,
) -> deno_core::anyhow::Result<Option<String>> {
) -> deno_core::anyhow::Result<Option<String>>
+ use<> {
let unstable_sql = unstable_options.sql;
move |lang, text, config| match lang {
"css" => format_embedded_css(&text, config),
@ -1211,11 +1212,7 @@ fn format_stdin(
}
fn files_str(len: usize) -> &'static str {
if len == 1 {
"file"
} else {
"files"
}
if len == 1 { "file" } else { "files" }
}
fn get_typescript_config_builder(
@ -1686,10 +1683,9 @@ where
.and_then(|handle_result| handle_result.err())
});
if let Some(e) = errors.next() {
Err(e)
} else {
Ok(())
match errors.next() {
Some(e) => Err(e),
_ => Ok(()),
}
}

17
cli/tools/info.rs
View file

@ -21,13 +21,13 @@ use deno_graph::ModuleGraph;
use deno_graph::Resolution;
use deno_lib::util::checksum;
use deno_lib::version::DENO_VERSION_INFO;
use deno_npm::npm_rc::ResolvedNpmRc;
use deno_npm::resolution::NpmResolutionSnapshot;
use deno_npm::NpmPackageId;
use deno_npm::NpmResolutionPackage;
use deno_npm::npm_rc::ResolvedNpmRc;
use deno_npm::resolution::NpmResolutionSnapshot;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_resolver::display::DisplayTreeNode;
use deno_resolver::DenoResolveErrorKind;
use deno_resolver::display::DisplayTreeNode;
use deno_semver::npm::NpmPackageNvReference;
use deno_semver::npm::NpmPackageReqReference;
use deno_semver::package::PackageNv;
@ -60,12 +60,12 @@ pub async fn info(
let cwd_url =
url::Url::from_directory_path(cli_options.initial_cwd()).unwrap();
let maybe_import_specifier = if let Ok(resolved) = resolver.resolve(
let maybe_import_specifier = match resolver.resolve(
&specifier,
&cwd_url,
deno_resolver::workspace::ResolutionKind::Execution,
) {
match resolved {
Ok(resolved) => match resolved {
deno_resolver::workspace::MappedResolution::Normal {
specifier,
..
@ -135,9 +135,8 @@ pub async fn info(
))?)
}
},
}
} else {
None
},
_ => None,
};
let specifier = match maybe_import_specifier {
@ -222,7 +221,7 @@ fn print_cache_info(
if let Some(location) = &location {
origin_dir =
origin_dir.join(checksum::gen(&[location.to_string().as_bytes()]));
origin_dir.join(checksum::r#gen(&[location.to_string().as_bytes()]));
}
let local_storage_dir = origin_dir.join("local_storage");

13
cli/tools/init/mod.rs
View file

@ -299,13 +299,22 @@ async fn init_npm(name: &str, args: Vec<String>) -> Result<i32, AnyError> {
let script_name = npm_name_to_create_package(name);
fn print_manual_usage(script_name: &str, args: &[String]) -> i32 {
log::info!("{}", cformat!("You can initialize project manually by running <u>deno run {} {}</> and applying desired permissions.", script_name, args.join(" ")));
log::info!(
"{}",
cformat!(
"You can initialize project manually by running <u>deno run {} {}</> and applying desired permissions.",
script_name,
args.join(" ")
)
);
1
}
if std::io::stdin().is_terminal() {
log::info!(
cstr!("⚠️ Do you fully trust <y>{}</> package? Deno will invoke code from it with all permissions. Do you want to continue? <p(245)>[y/n]</>"),
cstr!(
"⚠️ Do you fully trust <y>{}</> package? Deno will invoke code from it with all permissions. Do you want to continue? <p(245)>[y/n]</>"
),
script_name
);
loop {

49
cli/tools/installer/mod.rs
View file

@ -12,9 +12,9 @@ use std::path::PathBuf;
use std::sync::Arc;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_core::anyhow::Context;
use deno_core::anyhow::anyhow;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
use deno_core::resolve_url_or_path;
use deno_core::url::Url;
@ -26,7 +26,6 @@ use regex::Regex;
use regex::RegexBuilder;
pub use self::bin_name_resolver::BinNameResolver;
use crate::args::resolve_no_prompt;
use crate::args::AddFlags;
use crate::args::ConfigFlag;
use crate::args::Flags;
@ -36,9 +35,10 @@ use crate::args::InstallFlagsLocal;
use crate::args::TypeCheckMode;
use crate::args::UninstallFlags;
use crate::args::UninstallKind;
use crate::args::resolve_no_prompt;
use crate::factory::CliFactory;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::file_fetcher::CreateCliFileFetcherOptions;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::graph_container::ModuleGraphContainer;
use crate::jsr::JsrFetchResolver;
use crate::npm::NpmFetchResolver;
@ -288,7 +288,12 @@ fn check_if_installs_a_single_package_globally(
return Ok(());
};
if matches!(url.scheme(), "http" | "https") {
bail!("Failed to install \"{}\" specifier. If you are trying to install {} globally, run again with `-g` flag:\n deno install -g {}", url.scheme(), url.as_str(), url.as_str());
bail!(
"Failed to install \"{}\" specifier. If you are trying to install {} globally, run again with `-g` flag:\n deno install -g {}",
url.scheme(),
url.as_str(),
url.as_str()
);
}
Ok(())
}
@ -371,7 +376,10 @@ async fn install_global(
if matches!(flags.config_flag, ConfigFlag::Discover)
&& cli_options.workspace().deno_jsons().next().is_some()
{
log::warn!("{} discovered config file will be ignored in the installed command. Use the --config flag if you wish to include it.", crate::colors::yellow("Warning"));
log::warn!(
"{} discovered config file will be ignored in the installed command. Use the --config flag if you wish to include it.",
crate::colors::yellow("Warning")
);
}
let bin_name_resolver = factory.bin_name_resolver()?;
@ -464,11 +472,13 @@ async fn resolve_shim_data(
let name = match name {
Some(name) => name,
None => return Err(anyhow!(
"An executable name was not provided. One could not be inferred from the URL. Aborting.\n {} {}",
deno_runtime::colors::cyan("hint:"),
"provide one with the `--name` flag"
)),
None => {
return Err(anyhow!(
"An executable name was not provided. One could not be inferred from the URL. Aborting.\n {} {}",
deno_runtime::colors::cyan("hint:"),
"provide one with the `--name` flag"
));
}
};
validate_name(name.as_str())?;
@ -655,8 +665,8 @@ mod tests {
use std::process::Command;
use deno_lib::args::UnstableConfig;
use test_util::testdata_path;
use test_util::TempDir;
use test_util::testdata_path;
use super::*;
use crate::args::ConfigFlag;
@ -720,8 +730,11 @@ mod tests {
r#""run" "--no-config" "http://localhost:4545/echo_server.ts""#
));
} else {
assert!(content
.contains(r#"run --no-config 'http://localhost:4545/echo_server.ts'"#));
assert!(
content.contains(
r#"run --no-config 'http://localhost:4545/echo_server.ts'"#
)
);
}
}
@ -1120,10 +1133,12 @@ mod tests {
)
.await;
assert!(no_force_result.is_err());
assert!(no_force_result
.unwrap_err()
.to_string()
.contains("Existing installation found"));
assert!(
no_force_result
.unwrap_err()
.to_string()
.contains("Existing installation found")
);
// Assert not modified
let file_content = fs::read_to_string(&file_path).unwrap();
assert!(file_content.contains("echo_server.ts"));

2
cli/tools/jupyter/install.rs
View file

@ -5,8 +5,8 @@ use std::io::Write;
use std::path::Path;
use std::path::PathBuf;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::serde_json;
use deno_core::serde_json::json;

10
cli/tools/jupyter/mod.rs
View file

@ -2,9 +2,9 @@
use std::sync::Arc;
use deno_core::anyhow::Context;
use deno_core::anyhow::anyhow;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt;
use deno_core::located_script_name;
@ -12,10 +12,10 @@ use deno_core::resolve_url_or_path;
use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::url::Url;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::deno_io::Stdio;
use deno_runtime::deno_io::StdioPipe;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::WorkerExecutionMode;
use deno_terminal::colors;
use jupyter_protocol::messaging::StreamContent;
use jupyter_runtime::ConnectionInfo;
@ -24,17 +24,17 @@ use tokio::sync::mpsc::UnboundedSender;
use tokio::sync::oneshot;
use tokio_util::sync::CancellationToken;
use crate::CliFactory;
use crate::args::Flags;
use crate::args::JupyterFlags;
use crate::cdp;
use crate::lsp::ReplCompletionItem;
use crate::ops;
use crate::tools::repl;
use crate::tools::test::create_single_test_event_channel;
use crate::tools::test::reporters::PrettyTestReporter;
use crate::tools::test::TestEventWorkerSender;
use crate::tools::test::TestFailureFormatOptions;
use crate::CliFactory;
use crate::tools::test::create_single_test_event_channel;
use crate::tools::test::reporters::PrettyTestReporter;
mod install;
pub mod server;

4
cli/tools/jupyter/server.rs
View file

@ -11,13 +11,13 @@ use std::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::futures;
use deno_core::parking_lot::Mutex;
use deno_core::serde_json;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
use deno_lib::version::DENO_VERSION_INFO;
use jupyter_protocol::messaging;
use jupyter_runtime::ConnectionInfo;

2
cli/tools/lint/ast_buffer/buffer.rs
View file

@ -2,8 +2,8 @@
use std::fmt::Display;
use deno_ast::swc::common::Span;
use deno_ast::swc::common::DUMMY_SP;
use deno_ast::swc::common::Span;
use indexmap::IndexMap;
use crate::util::text_encoding::Utf16Map;

2
cli/tools/lint/ast_buffer/swc.rs
View file

@ -1,5 +1,6 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use deno_ast::ParsedSource;
use deno_ast::swc::ast::AssignTarget;
use deno_ast::swc::ast::AssignTargetPat;
use deno_ast::swc::ast::BindingIdent;
@ -87,7 +88,6 @@ use deno_ast::view::TsTypeOperatorOp;
use deno_ast::view::UnaryOp;
use deno_ast::view::UpdateOp;
use deno_ast::view::VarDeclKind;
use deno_ast::ParsedSource;
use super::buffer::AstBufSerializer;
use super::buffer::CommentKind;

2
cli/tools/lint/linter.rs
View file

@ -26,11 +26,11 @@ use deno_lint::linter::LinterOptions;
use deno_path_util::fs::atomic_write_file_with_retries;
use deno_runtime::tokio_util;
use super::ConfiguredRules;
use super::plugins;
use super::plugins::PluginHostProxy;
use super::rules::FileOrPackageLintRule;
use super::rules::PackageLintRule;
use super::ConfiguredRules;
use crate::sys::CliSys;
use crate::util::fs::specifier_from_file_path;
use crate::util::text_encoding::Utf16Map;

10
cli/tools/lint/mod.rs
View file

@ -5,8 +5,8 @@
use std::collections::HashSet;
use std::fs;
use std::io::stdin;
use std::io::Read;
use std::io::stdin;
use std::path::PathBuf;
use std::rc::Rc;
use std::sync::Arc;
@ -20,8 +20,8 @@ use deno_config::workspace::WorkspaceDirectory;
use deno_core::anyhow::anyhow;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::futures::future::LocalBoxFuture;
use deno_core::futures::FutureExt;
use deno_core::futures::future::LocalBoxFuture;
use deno_core::parking_lot::Mutex;
use deno_core::serde_json;
use deno_core::unsync::future::LocalFutureExt;
@ -31,8 +31,8 @@ use deno_lib::util::hash::FastInsecureHasher;
use deno_lint::diagnostic::LintDiagnostic;
use deno_resolver::deno_json::CompilerOptionsResolver;
use log::debug;
use reporters::create_reporter;
use reporters::LintReporter;
use reporters::create_reporter;
use crate::args::CliOptions;
use crate::args::Flags;
@ -64,11 +64,11 @@ mod rules;
pub use ast_buffer::serialize_ast_to_buffer;
pub use linter::CliLinter;
pub use linter::CliLinterOptions;
pub use plugins::create_runner_and_load_plugins;
pub use plugins::PluginLogger;
pub use rules::collect_no_slow_type_diagnostics;
pub use plugins::create_runner_and_load_plugins;
pub use rules::ConfiguredRules;
pub use rules::LintRuleProvider;
pub use rules::collect_no_slow_type_diagnostics;
const JSON_SCHEMA_VERSION: u8 = 1;

4
cli/tools/lint/plugins.rs
View file

@ -9,6 +9,7 @@ use ::tokio_util::sync::CancellationToken;
use deno_ast::ModuleSpecifier;
use deno_ast::ParsedSource;
use deno_ast::SourceTextInfo;
use deno_core::PollEventLoopOptions;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::error::CoreError;
@ -17,14 +18,13 @@ use deno_core::futures::FutureExt;
use deno_core::parking_lot::Mutex;
use deno_core::resolve_url_or_path;
use deno_core::v8;
use deno_core::PollEventLoopOptions;
use deno_lint::diagnostic::LintDiagnostic;
use deno_path_util::url_from_file_path;
use deno_runtime::WorkerExecutionMode;
use deno_runtime::deno_permissions::Permissions;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_runtime::tokio_util;
use deno_runtime::worker::MainWorker;
use deno_runtime::WorkerExecutionMode;
use tokio::sync::mpsc;
use tokio::sync::oneshot;

2
cli/tools/lint/rules/mod.rs
View file

@ -130,7 +130,7 @@ impl ConfiguredRules {
self.rules.iter().all(|r| r.supports_incremental_cache())
}
pub fn incremental_cache_state(&self) -> impl std::hash::Hash {
pub fn incremental_cache_state(&self) -> impl std::hash::Hash + use<> {
// use a hash of the rule names in order to bust the cache
let mut codes = self.rules.iter().map(|r| r.code()).collect::<Vec<_>>();
// ensure this is stable by sorting it

2
cli/tools/lint/rules/no_sloppy_imports.rs
View file

@ -7,9 +7,9 @@ use std::sync::Arc;
use deno_ast::SourceRange;
use deno_error::JsErrorBox;
use deno_graph::Range;
use deno_graph::source::ResolutionKind;
use deno_graph::source::ResolveError;
use deno_graph::Range;
use deno_lint::diagnostic::LintDiagnosticDetails;
use deno_lint::diagnostic::LintDiagnosticRange;
use deno_lint::diagnostic::LintDocsUrl;

4
cli/tools/lint/rules/no_slow_types.rs
View file

@ -2,10 +2,10 @@
use std::borrow::Cow;
use deno_ast::diagnostics::Diagnostic;
use deno_ast::ModuleSpecifier;
use deno_graph::fast_check::FastCheckDiagnostic;
use deno_ast::diagnostics::Diagnostic;
use deno_graph::ModuleGraph;
use deno_graph::fast_check::FastCheckDiagnostic;
use deno_lint::diagnostic::LintDiagnostic;
use deno_lint::diagnostic::LintDiagnosticDetails;
use deno_lint::diagnostic::LintDiagnosticRange;

6
cli/tools/pm/cache_deps.rs
View file

@ -6,13 +6,13 @@ use std::collections::HashSet;
use std::sync::Arc;
use deno_core::error::AnyError;
use deno_core::futures::stream::FuturesUnordered;
use deno_core::futures::StreamExt;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_core::futures::stream::FuturesUnordered;
use deno_npm_installer::PackageCaching;
use deno_npm_installer::graph::NpmCachingStrategy;
use deno_semver::Version;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;
use deno_semver::Version;
use crate::factory::CliFactory;
use crate::graph_container::ModuleGraphContainer;

17
cli/tools/pm/deps.rs
View file

@ -10,26 +10,26 @@ use deno_config::deno_json::ConfigFile;
use deno_config::deno_json::ConfigFileRc;
use deno_config::workspace::Workspace;
use deno_config::workspace::WorkspaceDirectory;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt;
use deno_core::futures::StreamExt;
use deno_core::futures::future::try_join;
use deno_core::futures::stream::FuturesOrdered;
use deno_core::futures::stream::FuturesUnordered;
use deno_core::futures::FutureExt;
use deno_core::futures::StreamExt;
use deno_core::serde_json;
use deno_package_json::PackageJsonDepsMap;
use deno_package_json::PackageJsonRc;
use deno_runtime::deno_permissions::PermissionsContainer;
use deno_semver::StackString;
use deno_semver::Version;
use deno_semver::VersionReq;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_semver::package::PackageReqReference;
use deno_semver::StackString;
use deno_semver::Version;
use deno_semver::VersionReq;
use import_map::ImportMap;
use import_map::ImportMapWithDiagnostics;
use import_map::SpecifierMapEntry;
@ -902,7 +902,10 @@ impl DepManager {
format!("npm:{first}@{version_req}")
}
} else if string_value.contains(":") {
bail!("Unexpected package json dependency string: \"{string_value}\" in {}", arc.path.display());
bail!(
"Unexpected package json dependency string: \"{string_value}\" in {}",
arc.path.display()
);
} else {
version_req.to_string()
};

53
cli/tools/pm/mod.rs
View file

@ -4,21 +4,21 @@ use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_core::anyhow::bail;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_core::anyhow::Context;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt;
use deno_core::futures::StreamExt;
use deno_path_util::url_to_file_path;
use deno_semver::StackString;
use deno_semver::Version;
use deno_semver::VersionReq;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_semver::StackString;
use deno_semver::Version;
use deno_semver::VersionReq;
use deps::KeyPath;
use jsonc_parser::cst::CstObject;
use jsonc_parser::cst::CstObjectProp;
@ -30,8 +30,8 @@ use crate::args::CliOptions;
use crate::args::Flags;
use crate::args::RemoveFlags;
use crate::factory::CliFactory;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::file_fetcher::CreateCliFileFetcherOptions;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::jsr::JsrFetchResolver;
use crate::npm::NpmFetchResolver;
@ -138,11 +138,14 @@ impl ConfigUpdater {
let imports = self.root_object.object_value_or_set("imports");
let value =
format!("{}@{}", selected.package_name, selected.version_req);
if let Some(prop) = imports.get(&selected.import_name) {
prop.set_value(json!(value));
} else {
let index = insert_index(&imports, &selected.import_name);
imports.insert(index, &selected.import_name, json!(value));
match imports.get(&selected.import_name) {
Some(prop) => {
prop.set_value(json!(value));
}
_ => {
let index = insert_index(&imports, &selected.import_name);
imports.insert(index, &selected.import_name, json!(value));
}
}
}
ConfigKind::PackageJson => {
@ -192,11 +195,14 @@ impl ConfigUpdater {
}
}
if let Some(prop) = dependencies.get(&alias) {
prop.set_value(json!(value));
} else {
let index = insert_index(&dependencies, &alias);
dependencies.insert(index, &alias, json!(value));
match dependencies.get(&alias) {
Some(prop) => {
prop.set_value(json!(value));
}
_ => {
let index = insert_index(&dependencies, &alias);
dependencies.insert(index, &alias, json!(value));
}
}
}
}
@ -207,15 +213,16 @@ impl ConfigUpdater {
fn remove(&mut self, package: &str) -> bool {
let removed = match self.kind {
ConfigKind::DenoJson => {
if let Some(prop) = self
match self
.root_object
.object_value("imports")
.and_then(|i| i.get(package))
{
remove_prop_and_maybe_parent_prop(prop);
true
} else {
false
Some(prop) => {
remove_prop_and_maybe_parent_prop(prop);
true
}
_ => false,
}
}
ConfigKind::PackageJson => {
@ -512,7 +519,9 @@ pub async fn add(
bail!(
"{} has only pre-release versions available. Try specifying a version: `{}`",
crate::colors::red(&package_name),
crate::colors::yellow(format!("deno {cmd_name} {package_name}@^{version}"))
crate::colors::yellow(format!(
"deno {cmd_name} {package_name}@^{version}"
))
)
}
None => bail!("{} was not found.", crate::colors::red(package_name)),

18
cli/tools/pm/outdated/interactive.rs
View file

@ -7,13 +7,13 @@ use std::io;
use console_static_text::ConsoleSize;
use console_static_text::TextItem;
use crossterm::ExecutableCommand;
use crossterm::cursor;
use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyEventKind;
use crossterm::event::KeyModifiers;
use crossterm::terminal;
use crossterm::ExecutableCommand;
use deno_core::anyhow;
use deno_semver::Version;
use deno_semver::VersionReq;
@ -57,15 +57,15 @@ impl From<PackageInfo> for FormattedPackageInfo {
let new_version_string =
package.new_version.version_text().trim_start_matches('^');
let new_version_highlighted =
if let (Some(current_version), Ok(new_version)) = (
&package.current_version,
Version::parse_standard(new_version_string),
) {
let new_version_highlighted = match (
&package.current_version,
Version::parse_standard(new_version_string),
) {
(Some(current_version), Ok(new_version)) => {
highlight_new_version(current_version, &new_version)
} else {
new_version_string.to_string()
};
}
_ => new_version_string.to_string(),
};
FormattedPackageInfo {
dep_ids: vec![package.id],
current_version_string: package

10
cli/tools/pm/outdated/mod.rs
View file

@ -5,14 +5,14 @@ mod interactive;
use std::collections::HashSet;
use std::sync::Arc;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_cache_dir::GlobalOrLocalHttpCache;
use deno_cache_dir::file_fetcher::CacheSetting;
use deno_core::anyhow::bail;
use deno_core::error::AnyError;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_semver::StackString;
use deno_semver::VersionReq;
use deno_semver::package::PackageNv;
use deno_semver::package::PackageReq;
use deno_terminal::colors;
use super::deps::Dep;
@ -24,8 +24,8 @@ use super::deps::PackageLatestVersion;
use crate::args::Flags;
use crate::args::OutdatedFlags;
use crate::factory::CliFactory;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::file_fetcher::CreateCliFileFetcherOptions;
use crate::file_fetcher::create_cli_file_fetcher;
use crate::jsr::JsrFetchResolver;
use crate::npm::NpmFetchResolver;
@ -533,8 +533,8 @@ async fn dep_manager_args(
}
mod filter {
use deno_core::anyhow::anyhow;
use deno_core::anyhow::Context;
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
use deno_semver::VersionReq;

12
cli/tools/publish/auth.rs
View file

@ -30,12 +30,12 @@ fn get_gh_oidc_env_vars() -> Option<Result<(String, String), AnyError>> {
let url = std::env::var("ACTIONS_ID_TOKEN_REQUEST_URL");
let token = std::env::var("ACTIONS_ID_TOKEN_REQUEST_TOKEN");
match (url, token) {
(Ok(url), Ok(token)) => Some(Ok((url, token))),
(Err(_), Err(_)) => Some(Err(anyhow::anyhow!(
"No means to authenticate. Pass a token to `--token`, or enable tokenless publishing from GitHub Actions using OIDC. Learn more at https://deno.co/ghoidc"
))),
_ => None,
}
(Ok(url), Ok(token)) => Some(Ok((url, token))),
(Err(_), Err(_)) => Some(Err(anyhow::anyhow!(
"No means to authenticate. Pass a token to `--token`, or enable tokenless publishing from GitHub Actions using OIDC. Learn more at https://deno.co/ghoidc"
))),
_ => None,
}
} else {
None
}

Some files were not shown because too many files have changed in this diff Show more