diff --git a/.rustfmt.toml b/.rustfmt.toml index 9bb8d9d458..899a162a68 100644 --- a/.rustfmt.toml +++ b/.rustfmt.toml @@ -1,3 +1,3 @@ max_width = 80 tab_spaces = 2 -edition = "2021" +edition = "2024" diff --git a/Cargo.toml b/Cargo.toml index ec25c5e573..63826e2b91 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/bench_util/README.md b/bench_util/README.md index 30616a08fd..ba442a20a5 100644 --- a/bench_util/README.md +++ b/bench_util/README.md @@ -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] diff --git a/bench_util/benches/utf8.rs b/bench_util/benches/utf8.rs index 3a879169c2..1e05212875 100644 --- a/bench_util/benches/utf8.rs +++ b/bench_util/benches/utf8.rs @@ -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 { diff --git a/bench_util/js_runtime.rs b/bench_util/js_runtime.rs index 402c9a4b00..d49d644158 100644 --- a/bench_util/js_runtime.rs +++ b/bench_util/js_runtime.rs @@ -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; diff --git a/cli/args/flags.rs b/cli/args/flags.rs index 0454d463de..dfebedb85a 100644 --- a/cli/args/flags.rs +++ b/cli/args/flags.rs @@ -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 { 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) -> clap::error::Result { } if let Some(help_expansion) = matches.get_one::("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) -> clap::error::Result { 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) -> clap::error::Result { 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::("script_arg").unwrap()); } - let include = if let Some(files) = matches.remove_many::("files") { - files.collect() - } else { - Vec::new() + let include = match matches.remove_many::("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 = vec![]; @@ -5729,25 +5739,30 @@ fn run_parse( flags.code_cache_enabled = !matches.get_flag("no-code-cache"); let coverage_dir = matches.remove_one::("coverage"); - if let Some(mut script_arg) = matches.remove_many::("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::("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::("") - .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::("") + .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::("files") { - files.collect() - } else { - Vec::new() + let include = match matches.remove_many::("files") { + Some(files) => files.collect(), + _ => Vec::new(), }; let junit_path = matches.remove_one::("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[=...]")); } @@ -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] diff --git a/cli/args/mod.rs b/cli/args/mod.rs index 00880048e1..cc1ce5014c 100644 --- a/cli/args/mod.rs +++ b/cli/args/mod.rs @@ -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::().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 + ), } } } diff --git a/cli/bench/lsp.rs b/cli/bench/lsp.rs index c95eff0ed6..01209015a6 100644 --- a/cli/bench/lsp.rs +++ b/cli/bench/lsp.rs @@ -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"); diff --git a/cli/bench/lsp_bench_standalone.rs b/cli/bench/lsp_bench_standalone.rs index 45d8788256..cee73f5e72 100644 --- a/cli/bench/lsp_bench_standalone.rs +++ b/cli/bench/lsp_bench_standalone.rs @@ -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; diff --git a/cli/cache/cache_db.rs b/cli/cache/cache_db.rs index 4b81b0fe05..04d6334609 100644 --- a/cli/cache/cache_db.rs +++ b/cli/cache/cache_db.rs @@ -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 { diff --git a/cli/cache/code_cache.rs b/cli/cache/code_cache.rs index d938732635..6877931f48 100644 --- a/cli/cache/code_cache.rs +++ b/cli/cache/code_cache.rs @@ -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( diff --git a/cli/cache/incremental.rs b/cli/cache/incremental.rs index f430c1266f..6fe8b32f7c 100644 --- a/cli/cache/incremental.rs +++ b/cli/cache/incremental.rs @@ -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; diff --git a/cli/cache/module_info.rs b/cli/cache/module_info.rs index 4a57fd956d..1494792bf0 100644 --- a/cli/cache/module_info.rs +++ b/cli/cache/module_info.rs @@ -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::*; diff --git a/cli/cache/node.rs b/cli/cache/node.rs index 78b45d2fb2..bed48c13d1 100644 --- a/cli/cache/node.rs +++ b/cli/cache/node.rs @@ -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() + ); } } diff --git a/cli/factory.rs b/cli/factory.rs index 6dad37b6b8..e7fb7dd953 100644 --- a/cli/factory.rs +++ b/cli/factory.rs @@ -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; diff --git a/cli/file_fetcher.rs b/cli/file_fetcher.rs index 2bcc228c12..0cde5938e8 100644 --- a/cli/file_fetcher.rs +++ b/cli/file_fetcher.rs @@ -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!(), } diff --git a/cli/graph_util.rs b/cli/graph_util.rs index 4c6fc8ab64..e2b9e3d75f 100644 --- a/cli/graph_util.rs +++ b/cli/graph_util.rs @@ -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 { 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::*; diff --git a/cli/http_util.rs b/cli/http_util.rs index 0a7d9e47c7..693624bf02 100644 --- a/cli/http_util.rs +++ b/cli/http_util.rs @@ -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() }, ) diff --git a/cli/lib/args.rs b/cli/lib/args.rs index 751867866e..6ff75ee97c 100644 --- a/cli/lib/args.rs +++ b/cli/lib/args.rs @@ -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; } diff --git a/cli/lib/loader.rs b/cli/lib/loader.rs index c62949a774..ce04d06185 100644 --- a/cli/lib/loader.rs +++ b/cli/lib/loader.rs @@ -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, diff --git a/cli/lib/shared.rs b/cli/lib/shared.rs index 15ec3c2440..d455446b5f 100644 --- a/cli/lib/shared.rs +++ b/cli/lib/shared.rs @@ -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())); } }) } diff --git a/cli/lib/standalone/binary.rs b/cli/lib/standalone/binary.rs index 6a92fcd67f..574c0391fc 100644 --- a/cli/lib/standalone/binary.rs +++ b/cli/lib/standalone/binary.rs @@ -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)) diff --git a/cli/lib/standalone/virtual_fs.rs b/cli/lib/standalone/virtual_fs.rs index 07f0918d93..3b482b04b0 100644 --- a/cli/lib/standalone/virtual_fs.rs +++ b/cli/lib/standalone/virtual_fs.rs @@ -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(); diff --git a/cli/lib/util/checksum.rs b/cli/lib/util/checksum.rs index da4066ed2f..b463c74390 100644 --- a/cli/lib/util/checksum.rs +++ b/cli/lib/util/checksum.rs @@ -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" diff --git a/cli/lib/worker.rs b/cli/lib/worker.rs index 8f7d514c45..a233a1338f 100644 --- a/cli/lib/worker.rs +++ b/cli/lib/worker.rs @@ -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 LibWorkerFactorySharedState { .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 LibMainWorkerFactory { .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 { diff --git a/cli/lsp/analysis.rs b/cli/lsp/analysis.rs index 0dbdca5c3c..35ce4766cf 100644 --- a/cli/lsp/analysis.rs +++ b/cli/lsp/analysis.rs @@ -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::>(); - if reqs.is_empty() { - None - } else { - Some(reqs) - } + if reqs.is_empty() { None } else { Some(reqs) } } fn try_reverse_map_package_json_exports( diff --git a/cli/lsp/cache.rs b/cli/lsp/cache.rs index 4d8a30eb14..b2115c17d6 100644 --- a/cli/lsp/cache.rs +++ b/cli/lsp/cache.rs @@ -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; diff --git a/cli/lsp/capabilities.rs b/cli/lsp/capabilities.rs index 1efdce037c..8f7d081e55 100644 --- a/cli/lsp/capabilities.rs +++ b/cli/lsp/capabilities.rs @@ -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", diff --git a/cli/lsp/client.rs b/cli/lsp/client.rs index 85ea1bb4e5..111e3a195b 100644 --- a/cli/lsp/client.rs +++ b/cli/lsp/client.rs @@ -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; diff --git a/cli/lsp/code_lens.rs b/cli/lsp/code_lens.rs index 4154cd191e..552ad4a9e0 100644 --- a/cli/lsp/code_lens.rs +++ b/cli/lsp/code_lens.rs @@ -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; diff --git a/cli/lsp/completions.rs b/cli/lsp/completions.rs index 31cbb8e21a..dad08cd47b 100644 --- a/cli/lsp/completions.rs +++ b/cli/lsp/completions.rs @@ -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 = 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 = 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!(), } diff --git a/cli/lsp/config.rs b/cli/lsp/config.rs index a5e81e7233..ca7b3a54bb 100644 --- a/cli/lsp/config.rs +++ b/cli/lsp/config.rs @@ -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; } diff --git a/cli/lsp/diagnostics.rs b/cli/lsp/diagnostics.rs index cfd66274e2..00c71a7553 100644 --- a/cli/lsp/diagnostics.rs +++ b/cli/lsp/diagnostics.rs @@ -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(®ex_string).inspect_err(|e| { + match regex::Regex::new(®ex_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::>() - } else { - Vec::new() + .collect::>(), + _ => 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 diff --git a/cli/lsp/documents.rs b/cli/lsp/documents.rs index 25998d6590..e46613d58c 100644 --- a/cli/lsp/documents.rs +++ b/cli/lsp/documents.rs @@ -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 { 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> { 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> { 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 diff --git a/cli/lsp/jsr.rs b/cli/lsp/jsr.rs index 8b17898fe4..b68801fc4f 100644 --- a/cli/lsp/jsr.rs +++ b/cli/lsp/jsr.rs @@ -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 { diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs index 549a7130a4..df04548663 100644 --- a/cli/lsp/language_server.rs +++ b/cli/lsp/language_server.rs @@ -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( - ¶ms.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( + ¶ms.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) diff --git a/cli/lsp/logging.rs b/cli/lsp/logging.rs index 6df8b26a93..849aca95ac 100644 --- a/cli/lsp/logging.rs +++ b/cli/lsp/logging.rs @@ -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)); + } }); } diff --git a/cli/lsp/npm.rs b/cli/lsp/npm.rs index e58df36e24..15f02fad2d 100644 --- a/cli/lsp/npm.rs +++ b/cli/lsp/npm.rs @@ -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; diff --git a/cli/lsp/parent_process_checker.rs b/cli/lsp/parent_process_checker.rs index b8ab60922b..03febeb65b 100644 --- a/cli/lsp/parent_process_checker.rs +++ b/cli/lsp/parent_process_checker.rs @@ -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); + } } }); } diff --git a/cli/lsp/path_to_regex.rs b/cli/lsp/path_to_regex.rs index 65322da6d0..513d2d3fe7 100644 --- a/cli/lsp/path_to_regex.rs +++ b/cli/lsp/path_to_regex.rs @@ -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:?}" + ); } } } diff --git a/cli/lsp/registries.rs b/cli/lsp/registries.rs index 4aefed4d7b..11c3ac47f8 100644 --- a/cli/lsp/registries.rs +++ b/cli/lsp/registries.rs @@ -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, diff --git a/cli/lsp/repl.rs b/cli/lsp/repl.rs index 7aec4c0676..f77513928a 100644 --- a/cli/lsp/repl.rs +++ b/cli/lsp/repl.rs @@ -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; diff --git a/cli/lsp/resolver.rs b/cli/lsp/resolver.rs index 6f083dc672..08a5ed5dc2 100644 --- a/cli/lsp/resolver.rs +++ b/cli/lsp/resolver.rs @@ -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; diff --git a/cli/lsp/search.rs b/cli/lsp/search.rs index f3811b47ea..2d1857327b 100644 --- a/cli/lsp/search.rs +++ b/cli/lsp/search.rs @@ -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>, AnyError>; async fn versions(&self, name: &str) -> Result>, AnyError>; async fn exports(&self, nv: &PackageNv) - -> Result>, AnyError>; + -> Result>, AnyError>; } #[cfg(test)] diff --git a/cli/lsp/testing/collectors.rs b/cli/lsp/testing/collectors.rs index f6277fa6f7..7cf653aac5 100644 --- a/cli/lsp/testing/collectors.rs +++ b/cli/lsp/testing/collectors.rs @@ -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; diff --git a/cli/lsp/testing/definitions.rs b/cli/lsp/testing/definitions.rs index c1aae484ce..a7b97d96ea 100644 --- a/cli/lsp/testing/definitions.rs +++ b/cli/lsp/testing/definitions.rs @@ -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("".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); } diff --git a/cli/lsp/testing/execution.rs b/cli/lsp/testing/execution.rs index 32789329e3..0374ba4240 100644 --- a/cli/lsp/testing/execution.rs +++ b/cli/lsp/testing/execution.rs @@ -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 { diff --git a/cli/lsp/testing/server.rs b/cli/lsp/testing/server.rs index 159788b0f2..101dff8669 100644 --- a/cli/lsp/testing/server.rs +++ b/cli/lsp/testing/server.rs @@ -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; diff --git a/cli/lsp/text.rs b/cli/lsp/text.rs index 10017dc4aa..daeebc1cf2 100644 --- a/cli/lsp/text.rs +++ b/cli/lsp/text.rs @@ -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; diff --git a/cli/lsp/trace.rs b/cli/lsp/trace.rs index aa35d6840a..102cdb4115 100644 --- a/cli/lsp/trace.rs +++ b/cli/lsp/trace.rs @@ -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; diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs index b9594cb664..329e8e83d9 100644 --- a/cli/lsp/tsc.rs +++ b/cli/lsp/tsc.rs @@ -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; diff --git a/cli/main.rs b/cli/main.rs index a00d2a0348..22dfaed5a7 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -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::(&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::>(); - let suggestions = args::did_you_mean(&run_flags.script, command_names); + let command_names = cmd + .get_subcommands() + .map(|command| command.get_name()) + .collect::>(); + 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::::new(clap::error::ErrorKind::InvalidSubcommand).with_cmd(&cmd); + let mut error = + clap::error::Error::::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)>, 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] diff --git a/cli/module_loader.rs b/cli/module_loader.rs index 3f173532be..1a8a5e3978 100644 --- a/cli/module_loader.rs +++ b/cli/module_loader.rs @@ -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), #[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 { 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 && !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 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()) diff --git a/cli/node.rs b/cli/node.rs index 8338fde131..67997a43b6 100644 --- a/cli/node.rs +++ b/cli/node.rs @@ -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; diff --git a/cli/npm.rs b/cli/npm.rs index a4bc0e651f..5526492da2 100644 --- a/cli/npm.rs +++ b/cli/npm.rs @@ -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; diff --git a/cli/ops/bench.rs b/cli/ops/bench.rs index a06182fbd0..3c463ffe39 100644 --- a/cli/ops/bench.rs +++ b/cli/ops/bench.rs @@ -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::() { - if token != permissions_holder.0 { - panic!("restore test permissions token does not match the stored token"); - } + match state.try_take::() { + 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::(permissions); - Ok(()) - } else { - Err(JsErrorBox::generic("no permissions to restore")) + let permissions = permissions_holder.1; + state.put::(permissions); + Ok(()) + } + _ => Err(JsErrorBox::generic("no permissions to restore")), } } diff --git a/cli/ops/jupyter.rs b/cli/ops/jupyter.rs index 999ab11e0d..35ab515a83 100644 --- a/cli/ops/jupyter.rs +++ b/cli/ops/jupyter.rs @@ -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() - ))) + ))); } }; diff --git a/cli/ops/lint.rs b/cli/ops/lint.rs index 89b81256b4..2b27cb571e 100644 --- a/cli/ops/lint.rs +++ b/cli/ops/lint.rs @@ -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, diff --git a/cli/ops/testing.rs b/cli/ops/testing.rs index c00ab949be..fff53332fb 100644 --- a/cli/ops/testing.rs +++ b/cli/ops/testing.rs @@ -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::() { - if token != permissions_holder.0 { - panic!("restore test permissions token does not match the stored token"); - } + match state.try_take::() { + 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::(permissions); - Ok(()) - } else { - Err(JsErrorBox::generic("no permissions to restore")) + let permissions = permissions_holder.1; + state.put::(permissions); + Ok(()) + } + _ => Err(JsErrorBox::generic("no permissions to restore")), } } diff --git a/cli/rt/binary.rs b/cli/rt/binary.rs index 95a3b95d35..400e58233d 100644 --- a/cli/rt/binary.rs +++ b/cli/rt/binary.rs @@ -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)), } diff --git a/cli/rt/code_cache.rs b/cli/rt/code_cache.rs index c97638abd1..759cd691c9 100644 --- a/cli/rt/code_cache.rs +++ b/cli/rt/code_cache.rs @@ -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() + ); } } } diff --git a/cli/rt/file_system.rs b/cli/rt/file_system.rs index be36a4e2dc..fa263ea473 100644 --- a/cli/rt/file_system.rs +++ b/cli/rt/file_system.rs @@ -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> { + ) -> std::io::Result + 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 diff --git a/cli/rt/main.rs b/cli/rt/main.rs index c4c825d838..3b05c1ac42 100644 --- a/cli/rt/main.rs +++ b/cli/rt/main.rs @@ -60,7 +60,10 @@ fn unwrap_or_exit(result: Result) -> T { fn load_env_vars(env_vars: &IndexMap) { 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) + }; } }) } diff --git a/cli/rt/node.rs b/cli/rt/node.rs index dca6cbfab4..774828b3cb 100644 --- a/cli/rt/node.rs +++ b/cli/rt/node.rs @@ -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; diff --git a/cli/rt/run.rs b/cli/rt/run.rs index 362e98ae05..0f70bc935e 100644 --- a/cli/rt/run.rs +++ b/cli/rt/run.rs @@ -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()) diff --git a/cli/standalone/binary.rs b/cli/standalone/binary.rs index e749d70d5c..f3e3c572b3 100644 --- a/cli/standalone/binary.rs +++ b/cli/standalone/binary.rs @@ -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") + ); } } diff --git a/cli/standalone/virtual_fs.rs b/cli/standalone/virtual_fs.rs index 863d1ff610..476ed80e4b 100644 --- a/cli/standalone/virtual_fs.rs +++ b/cli/standalone/virtual_fs.rs @@ -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; diff --git a/cli/task_runner.rs b/cli/task_runner.rs index 9ea690cd99..2125f31d04 100644 --- a/cli/task_runner.rs +++ b/cli/task_runner.rs @@ -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::>(), - ..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::>(), + ..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"); diff --git a/cli/tools/bench/mod.rs b/cli/tools/bench/mod.rs index f6c127c9bc..d60a056291 100644 --- a/cli/tools/bench/mod.rs +++ b/cli/tools/bench/mod.rs @@ -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; diff --git a/cli/tools/bench/reporters.rs b/cli/tools/bench/reporters.rs index c3df53b76a..7150fbb496 100644 --- a/cli/tools/bench/reporters.rs +++ b/cli/tools/bench/reporters.rs @@ -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!(); } } diff --git a/cli/tools/bundle/mod.rs b/cli/tools/bundle/mod.rs index aff4d7b109..9ecb066289 100644 --- a/cli/tools/bundle/mod.rs +++ b/cli/tools/bundle/mod.rs @@ -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) } diff --git a/cli/tools/clean.rs b/cli/tools/clean.rs index 2ea447015e..07701536cf 100644 --- a/cli/tools/clean.rs +++ b/cli/tools/clean.rs @@ -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(()), } } diff --git a/cli/tools/compile.rs b/cli/tools/compile.rs index a1e815a010..119824cf04 100644 --- a/cli/tools/compile.rs +++ b/cli/tools/compile.rs @@ -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, @@ -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 ` 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 ` flag to ", + "provide an alternative name.", + ), + output_base.display(), + ); } std::fs::create_dir_all(output_base)?; } diff --git a/cli/tools/coverage/ignore_directives.rs b/cli/tools/coverage/ignore_directives.rs index ec1e5b771c..89e34117a9 100644 --- a/cli/tools/coverage/ignore_directives.rs +++ b/cli/tools/coverage/ignore_directives.rs @@ -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"; diff --git a/cli/tools/coverage/merge.rs b/cli/tools/coverage/merge.rs index 85447cec1d..d2501a9b35 100644 --- a/cli/tools/coverage/merge.rs +++ b/cli/tools/coverage/merge.rs @@ -209,7 +209,7 @@ impl<'a> Iterator for StartEventQueue<'a> { fn next(&mut self) -> Option<::Item> { let pending_offset: Option = 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 { diff --git a/cli/tools/coverage/mod.rs b/cli/tools/coverage/mod.rs index 4654f4193e..007a0caff3 100644 --- a/cli/tools/coverage/mod.rs +++ b/cli/tools/coverage/mod.rs @@ -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; diff --git a/cli/tools/coverage/reporter.rs b/cli/tools/coverage/reporter.rs index 0828e3d4f3..dd2f0c762e 100644 --- a/cli/tools/coverage/reporter.rs +++ b/cli/tools/coverage/reporter.rs @@ -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; diff --git a/cli/tools/deploy.rs b/cli/tools/deploy.rs index dd4e8f948e..cf75a3ef72 100644 --- a/cli/tools/deploy.rs +++ b/cli/tools/deploy.rs @@ -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; diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs index a233574f18..e363ee7999 100644 --- a/cli/tools/doc.rs +++ b/cli/tools/doc.rs @@ -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; diff --git a/cli/tools/fmt.rs b/cli/tools/fmt.rs index 221f5361ad..86c6d09d8e 100644 --- a/cli/tools/fmt.rs +++ b/cli/tools/fmt.rs @@ -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> { +) -> deno_core::anyhow::Result> ++ 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(()), } } diff --git a/cli/tools/info.rs b/cli/tools/info.rs index 94bdff88fa..2cbf9fa152 100644 --- a/cli/tools/info.rs +++ b/cli/tools/info.rs @@ -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"); diff --git a/cli/tools/init/mod.rs b/cli/tools/init/mod.rs index 9e80987510..b5daff687f 100644 --- a/cli/tools/init/mod.rs +++ b/cli/tools/init/mod.rs @@ -299,13 +299,22 @@ async fn init_npm(name: &str, args: Vec) -> Result { 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 deno run {} {} and applying desired permissions.", script_name, args.join(" "))); + log::info!( + "{}", + cformat!( + "You can initialize project manually by running deno run {} {} and applying desired permissions.", + script_name, + args.join(" ") + ) + ); 1 } if std::io::stdin().is_terminal() { log::info!( - cstr!("⚠️ Do you fully trust {} package? Deno will invoke code from it with all permissions. Do you want to continue? [y/n]"), + cstr!( + "⚠️ Do you fully trust {} package? Deno will invoke code from it with all permissions. Do you want to continue? [y/n]" + ), script_name ); loop { diff --git a/cli/tools/installer/mod.rs b/cli/tools/installer/mod.rs index 1a3d31923e..0792d758aa 100644 --- a/cli/tools/installer/mod.rs +++ b/cli/tools/installer/mod.rs @@ -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")); diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 777ad42d9e..4a598781de 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -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; diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 4f2f9ac860..916949bd4c 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -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; diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 64766d1029..5b72a2df8f 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -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; diff --git a/cli/tools/lint/ast_buffer/buffer.rs b/cli/tools/lint/ast_buffer/buffer.rs index 982fb870b8..889fe29d79 100644 --- a/cli/tools/lint/ast_buffer/buffer.rs +++ b/cli/tools/lint/ast_buffer/buffer.rs @@ -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; diff --git a/cli/tools/lint/ast_buffer/swc.rs b/cli/tools/lint/ast_buffer/swc.rs index c1aea8e320..e57a998acc 100644 --- a/cli/tools/lint/ast_buffer/swc.rs +++ b/cli/tools/lint/ast_buffer/swc.rs @@ -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; diff --git a/cli/tools/lint/linter.rs b/cli/tools/lint/linter.rs index 1b7b999594..7fb1e19622 100644 --- a/cli/tools/lint/linter.rs +++ b/cli/tools/lint/linter.rs @@ -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; diff --git a/cli/tools/lint/mod.rs b/cli/tools/lint/mod.rs index 12a7fea7a6..7e47fce06e 100644 --- a/cli/tools/lint/mod.rs +++ b/cli/tools/lint/mod.rs @@ -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; diff --git a/cli/tools/lint/plugins.rs b/cli/tools/lint/plugins.rs index f8d63815e4..2d5f40fd83 100644 --- a/cli/tools/lint/plugins.rs +++ b/cli/tools/lint/plugins.rs @@ -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; diff --git a/cli/tools/lint/rules/mod.rs b/cli/tools/lint/rules/mod.rs index 7df17b381c..4b94904f65 100644 --- a/cli/tools/lint/rules/mod.rs +++ b/cli/tools/lint/rules/mod.rs @@ -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::>(); // ensure this is stable by sorting it diff --git a/cli/tools/lint/rules/no_sloppy_imports.rs b/cli/tools/lint/rules/no_sloppy_imports.rs index 01c2be8f6a..ec25b605d5 100644 --- a/cli/tools/lint/rules/no_sloppy_imports.rs +++ b/cli/tools/lint/rules/no_sloppy_imports.rs @@ -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; diff --git a/cli/tools/lint/rules/no_slow_types.rs b/cli/tools/lint/rules/no_slow_types.rs index 49fbc6f8c7..39493493a6 100644 --- a/cli/tools/lint/rules/no_slow_types.rs +++ b/cli/tools/lint/rules/no_slow_types.rs @@ -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; diff --git a/cli/tools/pm/cache_deps.rs b/cli/tools/pm/cache_deps.rs index 433b63442f..7c64bdd183 100644 --- a/cli/tools/pm/cache_deps.rs +++ b/cli/tools/pm/cache_deps.rs @@ -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; diff --git a/cli/tools/pm/deps.rs b/cli/tools/pm/deps.rs index ae79efd60e..b7aa2ae422 100644 --- a/cli/tools/pm/deps.rs +++ b/cli/tools/pm/deps.rs @@ -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() }; diff --git a/cli/tools/pm/mod.rs b/cli/tools/pm/mod.rs index 1b62fa2fa4..891830d37b 100644 --- a/cli/tools/pm/mod.rs +++ b/cli/tools/pm/mod.rs @@ -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)), diff --git a/cli/tools/pm/outdated/interactive.rs b/cli/tools/pm/outdated/interactive.rs index 6c8a5d228f..c8994e31c4 100644 --- a/cli/tools/pm/outdated/interactive.rs +++ b/cli/tools/pm/outdated/interactive.rs @@ -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 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 diff --git a/cli/tools/pm/outdated/mod.rs b/cli/tools/pm/outdated/mod.rs index 6e9226e857..3501aaede9 100644 --- a/cli/tools/pm/outdated/mod.rs +++ b/cli/tools/pm/outdated/mod.rs @@ -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; diff --git a/cli/tools/publish/auth.rs b/cli/tools/publish/auth.rs index 3665990905..008255ac68 100644 --- a/cli/tools/publish/auth.rs +++ b/cli/tools/publish/auth.rs @@ -30,12 +30,12 @@ fn get_gh_oidc_env_vars() -> Option> { 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 } diff --git a/cli/tools/publish/diagnostics.rs b/cli/tools/publish/diagnostics.rs index a986275079..2b7e03d596 100644 --- a/cli/tools/publish/diagnostics.rs +++ b/cli/tools/publish/diagnostics.rs @@ -4,6 +4,11 @@ use std::borrow::Cow; use std::path::PathBuf; use std::sync::Arc; +use deno_ast::ParseDiagnostic; +use deno_ast::SourcePos; +use deno_ast::SourceRange; +use deno_ast::SourceRanged; +use deno_ast::SourceTextInfo; use deno_ast::diagnostics::Diagnostic; use deno_ast::diagnostics::DiagnosticLevel; use deno_ast::diagnostics::DiagnosticLocation; @@ -13,11 +18,6 @@ use deno_ast::diagnostics::DiagnosticSnippetHighlightStyle; use deno_ast::diagnostics::DiagnosticSourcePos; use deno_ast::diagnostics::DiagnosticSourceRange; use deno_ast::swc::common::util::take::Take; -use deno_ast::ParseDiagnostic; -use deno_ast::SourcePos; -use deno_ast::SourceRange; -use deno_ast::SourceRanged; -use deno_ast::SourceTextInfo; use deno_core::anyhow::anyhow; use deno_core::error::AnyError; use deno_core::parking_lot::Mutex; @@ -210,19 +210,30 @@ impl Diagnostic for PublishDiagnostic { FastCheck(diagnostic) => diagnostic.message(), SpecifierUnfurl(diagnostic) => diagnostic.message(), InvalidPath { message, .. } => Cow::Borrowed(message.as_str()), - DuplicatePath { .. } => { - Cow::Borrowed("package path is a case insensitive duplicate of another path in the package") - } + DuplicatePath { .. } => Cow::Borrowed( + "package path is a case insensitive duplicate of another path in the package", + ), UnsupportedFileType { kind, .. } => { Cow::Owned(format!("unsupported file type '{kind}'")) } - InvalidExternalImport { kind, .. } => Cow::Owned(format!("invalid import to a {kind} specifier")), - ExcludedModule { .. } => Cow::Borrowed("module in package's module graph was excluded from publishing"), - MissingConstraint { specifier, .. } => Cow::Owned(format!("specifier '{}' is missing a version constraint", specifier)), - BannedTripleSlashDirectives { .. } => Cow::Borrowed("triple slash directives that modify globals are not allowed"), + InvalidExternalImport { kind, .. } => { + Cow::Owned(format!("invalid import to a {kind} specifier")) + } + ExcludedModule { .. } => Cow::Borrowed( + "module in package's module graph was excluded from publishing", + ), + MissingConstraint { specifier, .. } => Cow::Owned(format!( + "specifier '{}' is missing a version constraint", + specifier + )), + BannedTripleSlashDirectives { .. } => Cow::Borrowed( + "triple slash directives that modify globals are not allowed", + ), SyntaxError(diagnostic) => diagnostic.message(), MissingLicense { .. } => Cow::Borrowed("missing license field or file"), - UnstableRawImport { .. } => Cow::Borrowed("raw imports have not been stabilized"), + UnstableRawImport { .. } => { + Cow::Borrowed("raw imports have not been stabilized") + } } } @@ -361,34 +372,38 @@ impl Diagnostic for PublishDiagnostic { match &self { FastCheck(diagnostic) => diagnostic.hint(), SpecifierUnfurl(d) => d.hint(), - InvalidPath { .. } => Some( - Cow::Borrowed("rename or remove the file, or add it to 'publish.exclude' in the config file"), - ), - DuplicatePath { .. } => Some( - Cow::Borrowed("rename or remove the file"), - ), - UnsupportedFileType { .. } => Some( - Cow::Borrowed("remove the file, or add it to 'publish.exclude' in the config file"), - ), - InvalidExternalImport { .. } => Some(Cow::Borrowed("replace this import with one from jsr or npm, or vendor the dependency into your package")), - ExcludedModule { .. } => Some( - Cow::Borrowed("remove the module from 'exclude' and/or 'publish.exclude' in the config file or use 'publish.exclude' with a negative glob to unexclude from gitignore"), - ), - MissingConstraint { specifier_text, .. } => { - Some(Cow::Borrowed(if specifier_text.starts_with("jsr:") || specifier_text.starts_with("npm:") { + InvalidPath { .. } => Some(Cow::Borrowed( + "rename or remove the file, or add it to 'publish.exclude' in the config file", + )), + DuplicatePath { .. } => Some(Cow::Borrowed("rename or remove the file")), + UnsupportedFileType { .. } => Some(Cow::Borrowed( + "remove the file, or add it to 'publish.exclude' in the config file", + )), + InvalidExternalImport { .. } => Some(Cow::Borrowed( + "replace this import with one from jsr or npm, or vendor the dependency into your package", + )), + ExcludedModule { .. } => Some(Cow::Borrowed( + "remove the module from 'exclude' and/or 'publish.exclude' in the config file or use 'publish.exclude' with a negative glob to unexclude from gitignore", + )), + MissingConstraint { specifier_text, .. } => Some(Cow::Borrowed( + if specifier_text.starts_with("jsr:") + || specifier_text.starts_with("npm:") + { "specify a version constraint for the specifier" } else { "specify a version constraint for the specifier in the import map" - })) - }, - BannedTripleSlashDirectives { .. } => Some( - Cow::Borrowed("remove the triple slash directive"), - ), + }, + )), + BannedTripleSlashDirectives { .. } => { + Some(Cow::Borrowed("remove the triple slash directive")) + } SyntaxError(diagnostic) => diagnostic.hint(), - MissingLicense { .. } => Some( - Cow::Borrowed("add a \"license\" field. Alternatively, add a LICENSE file to the package and ensure it is not ignored from being published"), - ), - UnstableRawImport { .. } => Some(Cow::Borrowed("for the time being, embed the data directly into a JavaScript file (ex. as encoded base64 text)")) + MissingLicense { .. } => Some(Cow::Borrowed( + "add a \"license\" field. Alternatively, add a LICENSE file to the package and ensure it is not ignored from being published", + )), + UnstableRawImport { .. } => Some(Cow::Borrowed( + "for the time being, embed the data directly into a JavaScript file (ex. as encoded base64 text)", + )), } } @@ -435,33 +450,44 @@ impl Diagnostic for PublishDiagnostic { match &self { FastCheck(d) => d.info(), SpecifierUnfurl(d) => d.info(), - InvalidPath { .. } => Cow::Borrowed(&[ - Cow::Borrowed("to portably support all platforms, including windows, the allowed characters in package paths are limited"), - ]), - DuplicatePath { .. } => Cow::Borrowed(&[ - Cow::Borrowed("to support case insensitive file systems, no two package paths may differ only by case"), - ]), + InvalidPath { .. } => Cow::Borrowed(&[Cow::Borrowed( + "to portably support all platforms, including windows, the allowed characters in package paths are limited", + )]), + DuplicatePath { .. } => Cow::Borrowed(&[Cow::Borrowed( + "to support case insensitive file systems, no two package paths may differ only by case", + )]), UnsupportedFileType { .. } => Cow::Borrowed(&[ Cow::Borrowed("only files and directories are supported"), - Cow::Borrowed("the file was ignored and will not be published") + Cow::Borrowed("the file was ignored and will not be published"), ]), InvalidExternalImport { imported, .. } => Cow::Owned(vec![ Cow::Owned(format!("the import was resolved to '{}'", imported)), Cow::Borrowed("this specifier is not allowed to be imported on jsr"), - Cow::Borrowed("jsr only supports importing `jsr:`, `npm:`, `data:`, `bun:`, and `node:` specifiers"), + Cow::Borrowed( + "jsr only supports importing `jsr:`, `npm:`, `data:`, `bun:`, and `node:` specifiers", + ), ]), - ExcludedModule { .. } => Cow::Owned(vec![ - Cow::Borrowed("excluded modules referenced via a package export will error at runtime due to not existing in the package"), - ]), - MissingConstraint { resolved_version, .. } => Cow::Owned(vec![ + ExcludedModule { .. } => Cow::Owned(vec![Cow::Borrowed( + "excluded modules referenced via a package export will error at runtime due to not existing in the package", + )]), + MissingConstraint { + resolved_version, .. + } => Cow::Owned(vec![ Cow::Owned(format!( "the specifier resolved to version {} today, but will resolve to a different", - resolved_version.as_ref().map(|v| v.to_string()).unwrap_or_else(|| "".to_string())), + resolved_version + .as_ref() + .map(|v| v.to_string()) + .unwrap_or_else(|| "".to_string()) + )), + Cow::Borrowed( + "major version if one is published in the future and potentially break", ), - Cow::Borrowed("major version if one is published in the future and potentially break"), ]), BannedTripleSlashDirectives { .. } => Cow::Borrowed(&[ - Cow::Borrowed("instead instruct the user of your package to specify these directives"), + Cow::Borrowed( + "instead instruct the user of your package to specify these directives", + ), Cow::Borrowed("or set their 'lib' compiler option appropriately"), ]), SyntaxError(diagnostic) => diagnostic.info(), diff --git a/cli/tools/publish/graph.rs b/cli/tools/publish/graph.rs index c23ccad023..5aa554c3e0 100644 --- a/cli/tools/publish/graph.rs +++ b/cli/tools/publish/graph.rs @@ -3,10 +3,10 @@ use std::collections::HashSet; use std::sync::Arc; -use deno_ast::swc::common::comments::CommentKind; use deno_ast::ParsedSource; use deno_ast::SourceRangedForSpanned; use deno_ast::SourceTextInfo; +use deno_ast::swc::common::comments::CommentKind; use deno_core::error::AnyError; use deno_core::url::Url; use deno_graph::ModuleEntryRef; diff --git a/cli/tools/publish/mod.rs b/cli/tools/publish/mod.rs index a38ffb7a4e..ed7ada65a3 100644 --- a/cli/tools/publish/mod.rs +++ b/cli/tools/publish/mod.rs @@ -9,22 +9,22 @@ use std::process::Stdio; use std::rc::Rc; use std::sync::Arc; -use base64::prelude::BASE64_STANDARD; use base64::Engine; +use base64::prelude::BASE64_STANDARD; use deno_ast::ModuleSpecifier; use deno_config::deno_json::ConfigFile; use deno_config::workspace::JsrPackageConfig; use deno_config::workspace::Workspace; -use deno_core::anyhow::bail; use deno_core::anyhow::Context; +use deno_core::anyhow::bail; use deno_core::error::AnyError; -use deno_core::futures::future::LocalBoxFuture; -use deno_core::futures::stream::FuturesUnordered; use deno_core::futures::FutureExt; use deno_core::futures::StreamExt; +use deno_core::futures::future::LocalBoxFuture; +use deno_core::futures::stream::FuturesUnordered; 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_runtime::deno_fetch; use deno_terminal::colors; @@ -40,11 +40,11 @@ use self::graph::GraphDiagnosticsCollector; use self::module_content::ModuleContentProvider; use self::paths::CollectedPublishPath; use self::tar::PublishableTarball; -use crate::args::jsr_api_url; -use crate::args::jsr_url; use crate::args::CliOptions; use crate::args::Flags; use crate::args::PublishFlags; +use crate::args::jsr_api_url; +use crate::args::jsr_url; use crate::factory::CliFactory; use crate::graph_util::ModuleGraphCreator; use crate::http_util::HttpClient; @@ -65,8 +65,8 @@ mod publish_order; mod tar; mod unfurl; -use auth::get_auth_method; use auth::AuthMethod; +use auth::get_auth_method; use publish_order::PublishOrderGraph; use unfurl::SpecifierUnfurler; @@ -102,7 +102,9 @@ pub async fn publish( if let Some(version) = &publish_flags.set_version { if publish_configs.len() > 1 { - bail!("Cannot use --set-version when publishing a workspace. Change your cwd to an individual package instead."); + bail!( + "Cannot use --set-version when publishing a workspace. Change your cwd to an individual package instead." + ); } if let Some(publish_config) = publish_configs.get_mut(0) { let mut config_file = publish_config.config_file.as_ref().clone(); @@ -155,7 +157,9 @@ pub async fn publish( check_if_git_repo_dirty(cli_options.initial_cwd()).await { log::error!("\nUncommitted changes:\n\n{}\n", dirty_text); - bail!("Aborting due to uncommitted changes. Check in source code or run with --allow-dirty"); + bail!( + "Aborting due to uncommitted changes. Check in source code or run with --allow-dirty" + ); } } @@ -318,7 +322,9 @@ impl PublishPreparer { .await .is_some() { - bail!("When using DENO_INTERNAL_FAST_CHECK_OVERWRITE, the git repo must be in a clean state."); + bail!( + "When using DENO_INTERNAL_FAST_CHECK_OVERWRITE, the git repo must be in a clean state." + ); } for module in graph.modules() { @@ -951,7 +957,7 @@ async fn publish_package( "Failed to publish @{}/{} at {}", package.scope, package.package, package.version ) - }) + }); } }; @@ -1020,12 +1026,13 @@ async fn publish_package( provenance::generate_provenance(http_client, vec![subject]).await?; let tlog_entry = &bundle.verification_material.tlog_entries[0]; - log::info!("{}", + log::info!( + "{}", colors::green(format!( "Provenance transparency log available at https://search.sigstore.dev/?logIndex={}", tlog_entry.log_index )) - ); + ); // Submit bundle to JSR let provenance_url = format!( diff --git a/cli/tools/publish/module_content.rs b/cli/tools/publish/module_content.rs index ae800bb74b..685111aebe 100644 --- a/cli/tools/publish/module_content.rs +++ b/cli/tools/publish/module_content.rs @@ -291,15 +291,15 @@ mod test { use deno_resolver::npm::DenoInNpmPackageChecker; use deno_resolver::npm::NpmResolverCreateOptions; use deno_resolver::workspace::WorkspaceResolver; - use node_resolver::cache::NodeResolutionSys; use node_resolver::DenoIsBuiltInNodeModuleChecker; use node_resolver::NodeResolver; use node_resolver::NodeResolverOptions; use node_resolver::PackageJsonResolver; + use node_resolver::cache::NodeResolutionSys; use pretty_assertions::assert_eq; - use sys_traits::impls::InMemorySys; use sys_traits::FsCreateDirAll; use sys_traits::FsWrite; + use sys_traits::impls::InMemorySys; use super::*; use crate::npm::CliNpmResolver; @@ -326,22 +326,30 @@ mod test { }"#, None, ), - ("/package-b/deno.json", r#"{ + ( + "/package-b/deno.json", + r#"{ "compilerOptions": { "jsx": "react-jsx" }, "imports": { "react": "npm:react" "@types/react": "npm:@types/react" } - }"#, None), + }"#, + None, + ), ( "/package-a/main.tsx", "export const component =
;", - Some("/** @jsxRuntime automatic *//** @jsxImportSource npm:react *//** @jsxImportSourceTypes npm:@types/react *//** @jsxFactory React.createElement *//** @jsxFragmentFactory React.Fragment */export const component =
;"), + Some( + "/** @jsxRuntime automatic *//** @jsxImportSource npm:react *//** @jsxImportSourceTypes npm:@types/react *//** @jsxFactory React.createElement *//** @jsxFragmentFactory React.Fragment */export const component =
;", + ), ), ( "/package-b/main.tsx", "export const componentB =
;", - Some("/** @jsxRuntime automatic *//** @jsxImportSource npm:react *//** @jsxImportSourceTypes npm:react *//** @jsxFactory React.createElement *//** @jsxFragmentFactory React.Fragment */export const componentB =
;"), + Some( + "/** @jsxRuntime automatic *//** @jsxImportSource npm:react *//** @jsxImportSourceTypes npm:react *//** @jsxFactory React.createElement *//** @jsxFragmentFactory React.Fragment */export const componentB =
;", + ), ), ( "/package-a/other.tsx", @@ -352,13 +360,13 @@ mod test { /** @jsxRuntime automatic */ export const component =
;", Some( - "/** @jsxImportSource npm:preact */ + "/** @jsxImportSource npm:preact */ /** @jsxFragmentFactory h1 */ /** @jsxImportSourceTypes npm:@types/example */ /** @jsxFactory h2 */ /** @jsxRuntime automatic */ export const component =
;", - ) + ), ), ]); } diff --git a/cli/tools/publish/paths.rs b/cli/tools/publish/paths.rs index 121214cad7..d5e7a96911 100644 --- a/cli/tools/publish/paths.rs +++ b/cli/tools/publish/paths.rs @@ -167,7 +167,9 @@ fn valid_char(c: char) -> Option { #[derive(Debug, Clone, Error)] pub enum PackagePathValidationError { - #[error("package path must be at most 160 characters long, but is {0} characters long")] + #[error( + "package path must be at most 160 characters long, but is {0} characters long" + )] TooLong(usize), #[error("package path must be prefixed with a slash")] diff --git a/cli/tools/publish/provenance.rs b/cli/tools/publish/provenance.rs index 23f87f01c5..31f134a513 100644 --- a/cli/tools/publish/provenance.rs +++ b/cli/tools/publish/provenance.rs @@ -6,9 +6,9 @@ use std::env; use aws_lc_rs::rand::SystemRandom; use aws_lc_rs::signature::EcdsaKeyPair; use aws_lc_rs::signature::KeyPair; +use base64::Engine as _; use base64::engine::general_purpose::STANDARD_NO_PAD; use base64::prelude::BASE64_STANDARD; -use base64::Engine as _; use deno_core::anyhow; use deno_core::anyhow::bail; use deno_core::error::AnyError; @@ -21,9 +21,9 @@ use p256::pkcs8::AssociatedOid; use serde::Deserialize; use serde::Serialize; use sha2::Digest; +use spki::der::EncodePem; use spki::der::asn1; use spki::der::pem::LineEnding; -use spki::der::EncodePem; use super::auth::gha_oidc_token; use super::auth::is_gha; @@ -717,21 +717,24 @@ mod tests { fn slsa_github_actions() { // Set environment variable if env::var("GITHUB_ACTIONS").is_err() { - env::set_var("CI", "true"); - env::set_var("GITHUB_ACTIONS", "true"); - env::set_var("ACTIONS_ID_TOKEN_REQUEST_URL", "https://example.com"); - env::set_var("ACTIONS_ID_TOKEN_REQUEST_TOKEN", "dummy"); - env::set_var("GITHUB_REPOSITORY", "littledivy/deno_sdl2"); - env::set_var("GITHUB_SERVER_URL", "https://github.com"); - env::set_var("GITHUB_REF", "refs/tags/sdl2@0.0.1"); - env::set_var("GITHUB_SHA", "lol"); - env::set_var("GITHUB_RUN_ID", "1"); - env::set_var("GITHUB_RUN_ATTEMPT", "1"); - env::set_var("RUNNER_ENVIRONMENT", "github-hosted"); - env::set_var( - "GITHUB_WORKFLOW_REF", - "littledivy/deno_sdl2@refs/tags/sdl2@0.0.1", - ); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + env::set_var("CI", "true"); + env::set_var("GITHUB_ACTIONS", "true"); + env::set_var("ACTIONS_ID_TOKEN_REQUEST_URL", "https://example.com"); + env::set_var("ACTIONS_ID_TOKEN_REQUEST_TOKEN", "dummy"); + env::set_var("GITHUB_REPOSITORY", "littledivy/deno_sdl2"); + env::set_var("GITHUB_SERVER_URL", "https://github.com"); + env::set_var("GITHUB_REF", "refs/tags/sdl2@0.0.1"); + env::set_var("GITHUB_SHA", "lol"); + env::set_var("GITHUB_RUN_ID", "1"); + env::set_var("GITHUB_RUN_ATTEMPT", "1"); + env::set_var("RUNNER_ENVIRONMENT", "github-hosted"); + env::set_var( + "GITHUB_WORKFLOW_REF", + "littledivy/deno_sdl2@refs/tags/sdl2@0.0.1", + ) + } } let subject = Subject { diff --git a/cli/tools/publish/unfurl.rs b/cli/tools/publish/unfurl.rs index 8789a11b63..cfa42caf59 100644 --- a/cli/tools/publish/unfurl.rs +++ b/cli/tools/publish/unfurl.rs @@ -3,6 +3,11 @@ use std::borrow::Cow; use std::sync::Arc; +use deno_ast::ParsedSource; +use deno_ast::SourceRange; +use deno_ast::SourceTextInfo; +use deno_ast::SourceTextProvider; +use deno_ast::TextChange; use deno_ast::diagnostics::Diagnostic; use deno_ast::diagnostics::DiagnosticLevel; use deno_ast::diagnostics::DiagnosticLocation; @@ -11,13 +16,8 @@ use deno_ast::diagnostics::DiagnosticSnippetHighlight; use deno_ast::diagnostics::DiagnosticSnippetHighlightStyle; use deno_ast::diagnostics::DiagnosticSourcePos; use deno_ast::diagnostics::DiagnosticSourceRange; -use deno_ast::ParsedSource; -use deno_ast::SourceRange; -use deno_ast::SourceTextInfo; -use deno_ast::SourceTextProvider; -use deno_ast::TextChange; -use deno_core::anyhow; use deno_core::ModuleSpecifier; +use deno_core::anyhow; use deno_graph::analysis::DependencyDescriptor; use deno_graph::analysis::DynamicTemplatePart; use deno_graph::analysis::StaticDependencyKind; @@ -256,20 +256,28 @@ impl Diagnostic for SpecifierUnfurlerDiagnostic { fn info(&self) -> Cow<'_, [Cow<'_, str>]> { match self { - SpecifierUnfurlerDiagnostic::UnanalyzableDynamicImport { .. } => Cow::Borrowed(&[ - Cow::Borrowed("after publishing this package, imports from the local import map / package.json do not work"), - Cow::Borrowed("dynamic imports that can not be analyzed at publish time will not be rewritten automatically"), - Cow::Borrowed("make sure the dynamic import is resolvable at runtime without an import map / package.json") - ]), + SpecifierUnfurlerDiagnostic::UnanalyzableDynamicImport { .. } => { + Cow::Borrowed(&[ + Cow::Borrowed( + "after publishing this package, imports from the local import map / package.json do not work", + ), + Cow::Borrowed( + "dynamic imports that can not be analyzed at publish time will not be rewritten automatically", + ), + Cow::Borrowed( + "make sure the dynamic import is resolvable at runtime without an import map / package.json", + ), + ]) + } SpecifierUnfurlerDiagnostic::ResolvingNpmWorkspacePackage { .. } => { Cow::Borrowed(&[]) - }, - SpecifierUnfurlerDiagnostic::UnsupportedPkgJsonFileSpecifier { .. } => { - Cow::Borrowed(&[]) - }, - SpecifierUnfurlerDiagnostic::UnsupportedPkgJsonJsrSpecifier { .. } => { - Cow::Borrowed(&[]) - }, + } + SpecifierUnfurlerDiagnostic::UnsupportedPkgJsonFileSpecifier { + .. + } => Cow::Borrowed(&[]), + SpecifierUnfurlerDiagnostic::UnsupportedPkgJsonJsrSpecifier { + .. + } => Cow::Borrowed(&[]), } } @@ -381,128 +389,129 @@ impl SpecifierUnfurler { specifier: &str, resolution_kind: deno_resolver::workspace::ResolutionKind, ) -> Result, UnfurlSpecifierError> { - let resolved = if let Ok(resolved) = - self - .workspace_resolver - .resolve(specifier, referrer, resolution_kind) - { - match resolved { - MappedResolution::Normal { specifier, .. } => Some(specifier), - MappedResolution::WorkspaceJsrPackage { pkg_req_ref, .. } => { - Some(ModuleSpecifier::parse(&pkg_req_ref.to_string()).unwrap()) - } - MappedResolution::WorkspaceNpmPackage { - target_pkg_json: pkg_json, - pkg_name, - sub_path, - } => { - // todo(#24612): consider warning or error when this is also a jsr package? - ModuleSpecifier::parse(&format!( - "npm:{}{}{}", + let resolved = match self.workspace_resolver.resolve( + specifier, + referrer, + resolution_kind, + ) { + Ok(resolved) => { + match resolved { + MappedResolution::Normal { specifier, .. } => Some(specifier), + MappedResolution::WorkspaceJsrPackage { pkg_req_ref, .. } => { + Some(ModuleSpecifier::parse(&pkg_req_ref.to_string()).unwrap()) + } + MappedResolution::WorkspaceNpmPackage { + target_pkg_json: pkg_json, pkg_name, - pkg_json - .version - .as_ref() - .map(|v| format!("@^{}", v)) - .unwrap_or_default(), - sub_path - .as_ref() - .map(|s| format!("/{}", s)) - .unwrap_or_default() - )) - .ok() - } - MappedResolution::PackageJson { - alias, - sub_path, - dep_result, - .. - } => match dep_result { - Ok(dep) => match dep { - PackageJsonDepValue::File(_) => { - return Err( - UnfurlSpecifierError::UnsupportedPkgJsonFileSpecifier { - package_name: alias.to_string(), - }, + sub_path, + } => { + // todo(#24612): consider warning or error when this is also a jsr package? + ModuleSpecifier::parse(&format!( + "npm:{}{}{}", + pkg_name, + pkg_json + .version + .as_ref() + .map(|v| format!("@^{}", v)) + .unwrap_or_default(), + sub_path + .as_ref() + .map(|s| format!("/{}", s)) + .unwrap_or_default() + )) + .ok() + } + MappedResolution::PackageJson { + alias, + sub_path, + dep_result, + .. + } => match dep_result { + Ok(dep) => match dep { + PackageJsonDepValue::File(_) => { + return Err( + UnfurlSpecifierError::UnsupportedPkgJsonFileSpecifier { + package_name: alias.to_string(), + }, + ); + } + PackageJsonDepValue::JsrReq(_) => { + return Err( + UnfurlSpecifierError::UnsupportedPkgJsonJsrSpecifier { + package_name: alias.to_string(), + }, + ); + } + PackageJsonDepValue::Req(pkg_req) => { + // todo(#24612): consider warning or error when this is an npm workspace + // member that's also a jsr package? + ModuleSpecifier::parse(&format!( + "npm:{}{}", + pkg_req, + sub_path + .as_ref() + .map(|s| format!("/{}", s)) + .unwrap_or_default() + )) + .ok() + } + PackageJsonDepValue::Workspace(workspace_version_req) => { + let version_req = match workspace_version_req { + PackageJsonDepWorkspaceReq::VersionReq(version_req) => { + Cow::Borrowed(version_req) + } + PackageJsonDepWorkspaceReq::Caret => { + let version = self + .find_workspace_npm_dep_version(alias) + .map_err(|err| UnfurlSpecifierError::Workspace { + package_name: alias.to_string(), + reason: err.to_string(), + })?; + // version was validated, so ok to unwrap + Cow::Owned( + VersionReq::parse_from_npm(&format!("^{}", version)) + .unwrap(), + ) + } + PackageJsonDepWorkspaceReq::Tilde => { + let version = self + .find_workspace_npm_dep_version(alias) + .map_err(|err| UnfurlSpecifierError::Workspace { + package_name: alias.to_string(), + reason: err.to_string(), + })?; + // version was validated, so ok to unwrap + Cow::Owned( + VersionReq::parse_from_npm(&format!("~{}", version)) + .unwrap(), + ) + } + }; + // todo(#24612): warn when this is also a jsr package telling + // people to map the specifiers in the import map + ModuleSpecifier::parse(&format!( + "npm:{}@{}{}", + alias, + version_req, + sub_path + .as_ref() + .map(|s| format!("/{}", s)) + .unwrap_or_default() + )) + .ok() + } + }, + Err(err) => { + log::warn!( + "Ignoring failed to resolve package.json dependency. {:#}", + err ); - } - PackageJsonDepValue::JsrReq(_) => { - return Err( - UnfurlSpecifierError::UnsupportedPkgJsonJsrSpecifier { - package_name: alias.to_string(), - }, - ); - } - PackageJsonDepValue::Req(pkg_req) => { - // todo(#24612): consider warning or error when this is an npm workspace - // member that's also a jsr package? - ModuleSpecifier::parse(&format!( - "npm:{}{}", - pkg_req, - sub_path - .as_ref() - .map(|s| format!("/{}", s)) - .unwrap_or_default() - )) - .ok() - } - PackageJsonDepValue::Workspace(workspace_version_req) => { - let version_req = match workspace_version_req { - PackageJsonDepWorkspaceReq::VersionReq(version_req) => { - Cow::Borrowed(version_req) - } - PackageJsonDepWorkspaceReq::Caret => { - let version = self - .find_workspace_npm_dep_version(alias) - .map_err(|err| UnfurlSpecifierError::Workspace { - package_name: alias.to_string(), - reason: err.to_string(), - })?; - // version was validated, so ok to unwrap - Cow::Owned( - VersionReq::parse_from_npm(&format!("^{}", version)) - .unwrap(), - ) - } - PackageJsonDepWorkspaceReq::Tilde => { - let version = self - .find_workspace_npm_dep_version(alias) - .map_err(|err| UnfurlSpecifierError::Workspace { - package_name: alias.to_string(), - reason: err.to_string(), - })?; - // version was validated, so ok to unwrap - Cow::Owned( - VersionReq::parse_from_npm(&format!("~{}", version)) - .unwrap(), - ) - } - }; - // todo(#24612): warn when this is also a jsr package telling - // people to map the specifiers in the import map - ModuleSpecifier::parse(&format!( - "npm:{}@{}{}", - alias, - version_req, - sub_path - .as_ref() - .map(|s| format!("/{}", s)) - .unwrap_or_default() - )) - .ok() + None } }, - Err(err) => { - log::warn!( - "Ignoring failed to resolve package.json dependency. {:#}", - err - ); - None - } - }, + } } - } else { - None + _ => None, }; let resolved = match resolved { Some(resolved) => resolved, diff --git a/cli/tools/repl/channel.rs b/cli/tools/repl/channel.rs index 5510112589..6dda44a929 100644 --- a/cli/tools/repl/channel.rs +++ b/cli/tools/repl/channel.rs @@ -8,20 +8,20 @@ use deno_core::error::CoreError; use deno_core::serde_json; use deno_core::serde_json::Value; use deno_error::JsErrorBox; -use tokio::sync::mpsc::channel; -use tokio::sync::mpsc::unbounded_channel; use tokio::sync::mpsc::Receiver; use tokio::sync::mpsc::Sender; use tokio::sync::mpsc::UnboundedReceiver; use tokio::sync::mpsc::UnboundedSender; +use tokio::sync::mpsc::channel; +use tokio::sync::mpsc::unbounded_channel; use crate::lsp::ReplCompletionItem; /// Rustyline uses synchronous methods in its interfaces, but we need to call /// async methods. To get around this, we communicate with async code by using /// a channel and blocking on the result. -pub fn rustyline_channel( -) -> (RustylineSyncMessageSender, RustylineSyncMessageHandler) { +pub fn rustyline_channel() +-> (RustylineSyncMessageSender, RustylineSyncMessageHandler) { let (message_tx, message_rx) = channel(1); let (response_tx, response_rx) = unbounded_channel(); @@ -65,23 +65,20 @@ impl RustylineSyncMessageSender { method: &str, params: Option, ) -> Result { - if let Err(err) = - self - .message_tx - .blocking_send(RustylineSyncMessage::PostMessage { - method: method.to_string(), - params: params - .map(|params| serde_json::to_value(params)) - .transpose() - .map_err(JsErrorBox::from_err)?, - }) - { - Err(JsErrorBox::from_err(err).into()) - } else { - match self.response_rx.borrow_mut().blocking_recv().unwrap() { + match self + .message_tx + .blocking_send(RustylineSyncMessage::PostMessage { + method: method.to_string(), + params: params + .map(|params| serde_json::to_value(params)) + .transpose() + .map_err(JsErrorBox::from_err)?, + }) { + Err(err) => Err(JsErrorBox::from_err(err).into()), + _ => match self.response_rx.borrow_mut().blocking_recv().unwrap() { RustylineSyncResponse::PostMessage(result) => result, RustylineSyncResponse::LspCompletions(_) => unreachable!(), - } + }, } } diff --git a/cli/tools/repl/editor.rs b/cli/tools/repl/editor.rs index 99b9a91454..7e7a0025cc 100644 --- a/cli/tools/repl/editor.rs +++ b/cli/tools/repl/editor.rs @@ -2,9 +2,9 @@ use std::borrow::Cow; use std::path::PathBuf; +use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering::Relaxed; -use std::sync::Arc; use deno_ast::swc::parser::error::SyntaxError; use deno_ast::swc::parser::token::BinOpToken; @@ -15,12 +15,6 @@ use deno_core::anyhow::Context as _; use deno_core::error::AnyError; use deno_core::parking_lot::Mutex; use deno_core::serde_json; -use rustyline::completion::Completer; -use rustyline::error::ReadlineError; -use rustyline::highlight::Highlighter; -use rustyline::validate::ValidationContext; -use rustyline::validate::ValidationResult; -use rustyline::validate::Validator; use rustyline::Cmd; use rustyline::CompletionType; use rustyline::ConditionalEventHandler; @@ -34,6 +28,12 @@ use rustyline::KeyCode; use rustyline::KeyEvent; use rustyline::Modifiers; use rustyline::RepeatCount; +use rustyline::completion::Completer; +use rustyline::error::ReadlineError; +use rustyline::highlight::Highlighter; +use rustyline::validate::ValidationContext; +use rustyline::validate::ValidationResult; +use rustyline::validate::Validator; use rustyline_derive::Helper; use rustyline_derive::Hinter; diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs index 22f4ff4797..a4d16e4c61 100644 --- a/cli/tools/repl/mod.rs +++ b/cli/tools/repl/mod.rs @@ -26,10 +26,10 @@ mod channel; mod editor; mod session; -use channel::rustyline_channel; use channel::RustylineSyncMessage; use channel::RustylineSyncMessageHandler; use channel::RustylineSyncResponse; +use channel::rustyline_channel; use editor::EditorHelper; use editor::ReplEditor; pub use session::EvaluationOutput; diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs index 5b0e268ddb..a93024c506 100644 --- a/cli/tools/repl/session.rs +++ b/cli/tools/repl/session.rs @@ -2,12 +2,6 @@ use std::sync::Arc; -use deno_ast::diagnostics::Diagnostic; -use deno_ast::swc::ast as swc_ast; -use deno_ast::swc::common::comments::CommentKind; -use deno_ast::swc::ecma_visit::noop_visit_type; -use deno_ast::swc::ecma_visit::Visit; -use deno_ast::swc::ecma_visit::VisitWith; use deno_ast::ImportsNotUsedAsValues; use deno_ast::ModuleKind; use deno_ast::ModuleSpecifier; @@ -16,22 +10,28 @@ use deno_ast::ParsedSource; use deno_ast::SourcePos; use deno_ast::SourceRangedForSpanned; use deno_ast::SourceTextInfo; +use deno_ast::diagnostics::Diagnostic; +use deno_ast::swc::ast as swc_ast; +use deno_ast::swc::common::comments::CommentKind; +use deno_ast::swc::ecma_visit::Visit; +use deno_ast::swc::ecma_visit::VisitWith; +use deno_ast::swc::ecma_visit::noop_visit_type; +use deno_core::LocalInspectorSession; +use deno_core::PollEventLoopOptions; use deno_core::anyhow::anyhow; use deno_core::error::AnyError; use deno_core::error::CoreError; -use deno_core::futures::channel::mpsc::UnboundedReceiver; use deno_core::futures::FutureExt; use deno_core::futures::StreamExt; +use deno_core::futures::channel::mpsc::UnboundedReceiver; use deno_core::serde_json; use deno_core::serde_json::Value; use deno_core::unsync::spawn; use deno_core::url::Url; -use deno_core::LocalInspectorSession; -use deno_core::PollEventLoopOptions; use deno_error::JsErrorBox; -use deno_graph::analysis::SpecifierWithRange; use deno_graph::Position; use deno_graph::PositionRange; +use deno_graph::analysis::SpecifierWithRange; use deno_lib::util::result::any_and_jserrorbox_downcast_ref; use deno_resolver::deno_json::CompilerOptionsResolver; use deno_runtime::worker::MainWorker; @@ -50,15 +50,15 @@ use crate::colors; use crate::lsp::ReplLanguageServer; use crate::npm::CliNpmInstaller; use crate::resolver::CliResolver; +use crate::tools::test::TestEvent; +use crate::tools::test::TestEventReceiver; +use crate::tools::test::TestFailureFormatOptions; use crate::tools::test::report_tests; use crate::tools::test::reporters::PrettyTestReporter; use crate::tools::test::reporters::TestReporter; use crate::tools::test::run_tests_for_worker; use crate::tools::test::send_test_event; use crate::tools::test::worker_has_tests; -use crate::tools::test::TestEvent; -use crate::tools::test::TestEventReceiver; -use crate::tools::test::TestFailureFormatOptions; fn comment_source_to_position_range( comment_start: SourcePos, @@ -226,13 +226,15 @@ impl ReplSession { let execution_context_created = serde_json::from_value::< cdp::ExecutionContextCreated, >(notification.params)?; - assert!(execution_context_created - .context - .aux_data - .get("isDefault") - .unwrap() - .as_bool() - .unwrap()); + assert!( + execution_context_created + .context + .aux_data + .get("isDefault") + .unwrap() + .as_bool() + .unwrap() + ); context_id = execution_context_created.context.id; break; } @@ -645,13 +647,14 @@ impl ReplSession { match parse_source_as(expression.to_string(), deno_ast::MediaType::Tsx) { Ok(parsed) => parsed, Err(err) => { - if let Ok(parsed) = parse_source_as( + match parse_source_as( expression.to_string(), deno_ast::MediaType::TypeScript, ) { - parsed - } else { - return Err(err); + Ok(parsed) => parsed, + _ => { + return Err(err); + } } } }; diff --git a/cli/tools/run/hmr.rs b/cli/tools/run/hmr.rs index f0d3ae225f..52f7153069 100644 --- a/cli/tools/run/hmr.rs +++ b/cli/tools/run/hmr.rs @@ -4,12 +4,12 @@ use std::collections::HashMap; use std::path::PathBuf; use std::sync::Arc; +use deno_core::LocalInspectorSession; use deno_core::error::CoreError; use deno_core::futures::StreamExt; use deno_core::serde_json::json; use deno_core::serde_json::{self}; use deno_core::url::Url; -use deno_core::LocalInspectorSession; use deno_error::JsErrorBox; use deno_terminal::colors; use tokio::select; diff --git a/cli/tools/run/mod.rs b/cli/tools/run/mod.rs index 74f2d9eb97..75864a5366 100644 --- a/cli/tools/run/mod.rs +++ b/cli/tools/run/mod.rs @@ -11,8 +11,8 @@ use deno_core::futures::FutureExt; use deno_core::resolve_url_or_path; use deno_lib::standalone::binary::SerializedWorkspaceResolverImportMap; use deno_lib::worker::LibWorkerFactoryRoots; -use deno_npm_installer::graph::NpmCachingStrategy; use deno_npm_installer::PackageCaching; +use deno_npm_installer::graph::NpmCachingStrategy; use deno_runtime::WorkerExecutionMode; use eszip::EszipV2; use jsonc_parser::ParseOptions; @@ -43,10 +43,13 @@ To grant permissions, set them before the script argument. For example: fn set_npm_user_agent() { static ONCE: std::sync::Once = std::sync::Once::new(); ONCE.call_once(|| { - std::env::set_var( - crate::npm::NPM_CONFIG_USER_AGENT_ENV_VAR, - crate::npm::get_npm_config_user_agent(), - ); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + std::env::set_var( + crate::npm::NPM_CONFIG_USER_AGENT_ENV_VAR, + crate::npm::get_npm_config_user_agent(), + ) + }; }); } diff --git a/cli/tools/serve.rs b/cli/tools/serve.rs index fa7654e8e4..5d92deafb3 100644 --- a/cli/tools/serve.rs +++ b/cli/tools/serve.rs @@ -4,20 +4,20 @@ use std::num::NonZeroUsize; use std::str::FromStr; use std::sync::Arc; +use deno_core::ModuleSpecifier; use deno_core::error::AnyError; use deno_core::futures::FutureExt; use deno_core::futures::TryFutureExt; -use deno_core::ModuleSpecifier; use deno_lib::worker::LibWorkerFactoryRoots; use deno_runtime::UnconfiguredRuntime; use super::run::check_permission_before_script; use super::run::maybe_npm_install; -use crate::args::parallelism_count; use crate::args::Flags; use crate::args::ServeFlags; use crate::args::WatchFlagsWithPaths; use crate::args::WorkspaceMainModuleResolver; +use crate::args::parallelism_count; use crate::factory::CliFactory; use crate::util::file_watcher::WatcherRestartMode; use crate::worker::CliMainWorkerFactory; diff --git a/cli/tools/task.rs b/cli/tools/task.rs index 04d3fd3eb7..e36367c11d 100644 --- a/cli/tools/task.rs +++ b/cli/tools/task.rs @@ -15,14 +15,14 @@ use deno_config::workspace::TaskOrScript; use deno_config::workspace::WorkspaceDirectory; use deno_config::workspace::WorkspaceMemberTasksConfig; use deno_config::workspace::WorkspaceTasksConfig; +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::future::LocalBoxFuture; -use deno_core::futures::stream::futures_unordered; use deno_core::futures::FutureExt; use deno_core::futures::StreamExt; +use deno_core::futures::future::LocalBoxFuture; +use deno_core::futures::stream::futures_unordered; use deno_core::url::Url; use deno_npm_installer::PackageCaching; use deno_path_util::normalize_path; @@ -59,15 +59,21 @@ pub async fn execute_script( let cli_options = factory.cli_options()?; let start_dir = &cli_options.start_dir; if !start_dir.has_deno_or_pkg_json() && !task_flags.eval { - bail!("deno task couldn't find deno.json(c). See https://docs.deno.com/go/config") + bail!( + "deno task couldn't find deno.json(c). See https://docs.deno.com/go/config" + ) } let force_use_pkg_json = std::env::var_os(crate::task_runner::USE_PKG_JSON_HIDDEN_ENV_VAR_NAME) .map(|v| { // always remove so sub processes don't inherit this env var - std::env::remove_var( - crate::task_runner::USE_PKG_JSON_HIDDEN_ENV_VAR_NAME, - ); + + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + std::env::remove_var( + crate::task_runner::USE_PKG_JSON_HIDDEN_ENV_VAR_NAME, + ) + }; v == "1" }) .unwrap_or(false); @@ -384,10 +390,13 @@ impl<'a> TaskRunner<'a> { while context.has_remaining_tasks() { while queue.len() < self.concurrency { - if let Some(task) = context.get_next_task(self, kill_signal, args) { - queue.push(task); - } else { - break; + match context.get_next_task(self, kill_signal, args) { + Some(task) => { + queue.push(task); + } + _ => { + break; + } } } @@ -748,7 +757,10 @@ fn print_available_tasks_workspace( if !matched { log::warn!( "{}", - colors::red(format!("No package name matched the filter '{}' in available 'deno.json' or 'package.json' files.", filter)) + colors::red(format!( + "No package name matched the filter '{}' in available 'deno.json' or 'package.json' files.", + filter + )) ); } diff --git a/cli/tools/test/channel.rs b/cli/tools/test/channel.rs index c696671bd4..ce79c8a288 100644 --- a/cli/tools/test/channel.rs +++ b/cli/tools/test/channel.rs @@ -1,30 +1,30 @@ // Copyright 2018-2025 the Deno authors. MIT license. use std::fmt::Display; -use std::future::poll_fn; use std::future::Future; +use std::future::poll_fn; use std::io::Write; use std::pin::Pin; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; -use std::task::ready; use std::task::Poll; +use std::task::ready; use std::time::Duration; use deno_core::parking_lot; use deno_core::parking_lot::lock_api::RawMutex; use deno_core::parking_lot::lock_api::RawMutexTimed; -use deno_runtime::deno_io::pipe; use deno_runtime::deno_io::AsyncPipeRead; use deno_runtime::deno_io::PipeRead; use deno_runtime::deno_io::PipeWrite; +use deno_runtime::deno_io::pipe; use tokio::io::AsyncRead; use tokio::io::AsyncReadExt; use tokio::io::ReadBuf; -use tokio::sync::mpsc::error::SendError; use tokio::sync::mpsc::UnboundedReceiver; use tokio::sync::mpsc::UnboundedSender; use tokio::sync::mpsc::WeakUnboundedSender; +use tokio::sync::mpsc::error::SendError; use super::TestEvent; @@ -85,8 +85,8 @@ pub fn create_test_event_channel() -> (TestEventSenderFactory, TestEventReceiver /// Create a [`TestEventWorkerSender`] and [`TestEventReceiver`] pair.The [`TestEventReceiver`] /// will be kept alive until the [`TestEventSender`] is dropped. -pub fn create_single_test_event_channel( -) -> (TestEventWorkerSender, TestEventReceiver) { +pub fn create_single_test_event_channel() +-> (TestEventWorkerSender, TestEventReceiver) { let (factory, receiver) = create_test_event_channel(); (factory.worker(), receiver) } diff --git a/cli/tools/test/fmt.rs b/cli/tools/test/fmt.rs index e5b40b874b..0bffbc31a4 100644 --- a/cli/tools/test/fmt.rs +++ b/cli/tools/test/fmt.rs @@ -124,10 +124,14 @@ fn format_sanitizer_accum( let hint = resource_close_hint(&item_name); let value = if appeared { - format!("{name} was {action1} during the test, but not {action2} during the test. {hint}") + format!( + "{name} was {action1} during the test, but not {action2} during the test. {hint}" + ) } else { - format!("{name} was {action1} before the test started, but was {action2} during the test. \ - Do not close resources in a test that were not created during that test.") + format!( + "{name} was {action1} before the test started, but was {action2} during the test. \ + Do not close resources in a test that were not created during that test." + ) }; output.push(value); } else if item_type == RuntimeActivityType::AsyncOp { @@ -144,7 +148,9 @@ fn format_sanitizer_accum( let mut value = if let Some([operation, hint]) = OP_DETAILS.get(&item_name) { - format!("{count_str} async operation{plural} to {operation} {tense} {phrase}. This is often caused by not {hint}.") + format!( + "{count_str} async operation{plural} to {operation} {tense} {phrase}. This is often caused by not {hint}." + ) } else { format!( "{count_str} async call{plural} to {item_name} {tense} {phrase}." @@ -168,7 +174,9 @@ fn format_sanitizer_accum( } else { "started before the test, but completed during the test. Intervals and timers should not complete in a test if they were not started in that test" }; - let mut value = format!("{count_str} timer{plural} {tense} {phrase}. This is often caused by not calling `clearTimeout`."); + let mut value = format!( + "{count_str} timer{plural} {tense} {phrase}. This is often caused by not calling `clearTimeout`." + ); value += &if let Some(trace) = trace { format!(" The operation {tense} started here:\n{trace}") } else { @@ -187,7 +195,9 @@ fn format_sanitizer_accum( } else { "started before the test, but completed during the test. Intervals and timers should not complete in a test if they were not started in that test" }; - let mut value = format!("{count_str} interval{plural} {tense} {phrase}. This is often caused by not calling `clearInterval`."); + let mut value = format!( + "{count_str} interval{plural} {tense} {phrase}. This is often caused by not calling `clearInterval`." + ); value += &if let Some(trace) = trace { format!(" The operation {tense} started here:\n{trace}") } else { @@ -266,35 +276,67 @@ fn pretty_resource_name( fn resource_close_hint(name: &str) -> &'static str { match name { "fsFile" => "Close the file handle by calling `file.close()`.", - "fetchRequest" => "Await the promise returned from `fetch()` or abort the fetch with an abort signal.", - "fetchRequestBody" => "Terminate the request body `ReadableStream` by closing or erroring it.", - "fetchResponse" => "Consume or close the response body `ReadableStream`, e.g `await resp.text()` or `await resp.body.cancel()`.", + "fetchRequest" => { + "Await the promise returned from `fetch()` or abort the fetch with an abort signal." + } + "fetchRequestBody" => { + "Terminate the request body `ReadableStream` by closing or erroring it." + } + "fetchResponse" => { + "Consume or close the response body `ReadableStream`, e.g `await resp.text()` or `await resp.body.cancel()`." + } "httpClient" => "Close the HTTP client by calling `httpClient.close()`.", - "dynamicLibrary" => "Unload the dynamic library by calling `dynamicLibrary.close()`.", - "httpConn" => "Close the inbound HTTP connection by calling `httpConn.close()`.", - "httpStream" => "Close the inbound HTTP request by responding with `e.respondWith()` or closing the HTTP connection.", + "dynamicLibrary" => { + "Unload the dynamic library by calling `dynamicLibrary.close()`." + } + "httpConn" => { + "Close the inbound HTTP connection by calling `httpConn.close()`." + } + "httpStream" => { + "Close the inbound HTTP request by responding with `e.respondWith()` or closing the HTTP connection." + } "tcpStream" => "Close the TCP connection by calling `tcpConn.close()`.", - "unixStream" => "Close the Unix socket connection by calling `unixConn.close()`.", + "unixStream" => { + "Close the Unix socket connection by calling `unixConn.close()`." + } "tlsStream" => "Close the TLS connection by calling `tlsConn.close()`.", "tlsListener" => "Close the TLS listener by calling `tlsListener.close()`.", - "unixListener" => "Close the Unix socket listener by calling `unixListener.close()`.", - "unixDatagram" => "Close the Unix datagram socket by calling `unixDatagram.close()`.", + "unixListener" => { + "Close the Unix socket listener by calling `unixListener.close()`." + } + "unixDatagram" => { + "Close the Unix datagram socket by calling `unixDatagram.close()`." + } "tcpListener" => "Close the TCP listener by calling `tcpListener.close()`.", "udpSocket" => "Close the UDP socket by calling `udpSocket.close()`.", "timer" => "Clear the timer by calling `clearInterval` or `clearTimeout`.", - "textDecoder" => "Close the text decoder by calling `textDecoder.decode('')` or `await textDecoderStream.readable.cancel()`.", + "textDecoder" => { + "Close the text decoder by calling `textDecoder.decode('')` or `await textDecoderStream.readable.cancel()`." + } "messagePort" => "Close the message port by calling `messagePort.close()`.", "webSocketStream" => "Close the WebSocket by calling `webSocket.close()`.", "fsEvents" => "Close the file system watcher by calling `watcher.close()`.", - "childStdin" => "Close the child process stdin by calling `proc.stdin.close()`.", - "childStdout" => "Close the child process stdout by calling `proc.stdout.close()` or `await child.stdout.cancel()`.", - "childStderr" => "Close the child process stderr by calling `proc.stderr.close()` or `await child.stderr.cancel()`.", - "child" => "Close the child process by calling `proc.kill()` or `proc.close()`.", - "signal" => "Clear the signal listener by calling `Deno.removeSignalListener`.", + "childStdin" => { + "Close the child process stdin by calling `proc.stdin.close()`." + } + "childStdout" => { + "Close the child process stdout by calling `proc.stdout.close()` or `await child.stdout.cancel()`." + } + "childStderr" => { + "Close the child process stderr by calling `proc.stderr.close()` or `await child.stderr.cancel()`." + } + "child" => { + "Close the child process by calling `proc.kill()` or `proc.close()`." + } + "signal" => { + "Clear the signal listener by calling `Deno.removeSignalListener`." + } "stdin" => "Close the stdin pipe by calling `Deno.stdin.close()`.", "stdout" => "Close the stdout pipe by calling `Deno.stdout.close()`.", "stderr" => "Close the stderr pipe by calling `Deno.stderr.close()`.", - "compression" => "Close the compression stream by calling `await stream.writable.close()`.", + "compression" => { + "Close the compression stream by calling `await stream.writable.close()`." + } _ => "Close the resource before the end of the test.", } } @@ -402,7 +444,11 @@ mod tests { // https://github.com/denoland/deno/issues/13729 // https://github.com/denoland/deno/issues/13938 - leak_format_test!(op_unknown, true, [RuntimeActivity::AsyncOp(0, None, "op_unknown")], + leak_format_test!( + op_unknown, + true, + [RuntimeActivity::AsyncOp(0, None, "op_unknown")], " - An async call to op_unknown was started in this test, but never completed.\n\ - To get more details where leaks occurred, run again with the --trace-leaks flag.\n"); + To get more details where leaks occurred, run again with the --trace-leaks flag.\n" + ); } diff --git a/cli/tools/test/mod.rs b/cli/tools/test/mod.rs index 892eb078e7..94a40a3fc5 100644 --- a/cli/tools/test/mod.rs +++ b/cli/tools/test/mod.rs @@ -13,10 +13,10 @@ use std::io::Write; use std::num::NonZeroUsize; use std::path::Path; use std::path::PathBuf; +use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; -use std::sync::Arc; use std::task::Poll; use std::time::Duration; use std::time::Instant; @@ -25,15 +25,18 @@ use deno_ast::MediaType; use deno_cache_dir::file_fetcher::File; use deno_config::glob::FilePatterns; use deno_config::glob::WalkEntry; +use deno_core::ModuleSpecifier; +use deno_core::OpState; +use deno_core::PollEventLoopOptions; use deno_core::anyhow; use deno_core::anyhow::anyhow; use deno_core::error::AnyError; use deno_core::error::CoreError; use deno_core::error::JsError; -use deno_core::futures::future; -use deno_core::futures::stream; use deno_core::futures::FutureExt; use deno_core::futures::StreamExt; +use deno_core::futures::future; +use deno_core::futures::stream; use deno_core::located_script_name; use deno_core::serde_v8; use deno_core::stats::RuntimeActivity; @@ -46,11 +49,9 @@ use deno_core::unsync::spawn; use deno_core::unsync::spawn_blocking; use deno_core::url::Url; use deno_core::v8; -use deno_core::ModuleSpecifier; -use deno_core::OpState; -use deno_core::PollEventLoopOptions; use deno_error::JsErrorBox; use deno_npm_installer::graph::NpmCachingStrategy; +use deno_runtime::WorkerExecutionMode; use deno_runtime::deno_io::Stdio; use deno_runtime::deno_io::StdioPipe; use deno_runtime::deno_permissions::Permissions; @@ -59,13 +60,12 @@ use deno_runtime::fmt_errors::format_js_error; use deno_runtime::permissions::RuntimePermissionDescriptorParser; use deno_runtime::tokio_util::create_and_run_current_thread; use deno_runtime::worker::MainWorker; -use deno_runtime::WorkerExecutionMode; use indexmap::IndexMap; use indexmap::IndexSet; use log::Level; +use rand::SeedableRng; use rand::rngs::SmallRng; use rand::seq::SliceRandom; -use rand::SeedableRng; use regex::Regex; use serde::Deserialize; use tokio::signal; @@ -97,11 +97,11 @@ mod channel; pub mod fmt; pub mod reporters; -pub use channel::create_single_test_event_channel; -pub use channel::create_test_event_channel; pub use channel::TestEventReceiver; pub use channel::TestEventSender; pub use channel::TestEventWorkerSender; +pub use channel::create_single_test_event_channel; +pub use channel::create_test_event_channel; use fmt::format_sanitizer_diff; pub use fmt::format_test_error; use reporters::CompoundTestReporter; @@ -343,12 +343,12 @@ impl TestFailure { TestFailure::FailedSteps(n) => { Cow::Owned(format!("{} test steps failed.", n)) } - TestFailure::IncompleteSteps => { - Cow::Borrowed("Completed while steps were still running. Ensure all steps are awaited with `await t.step(...)`.") - } - TestFailure::Incomplete => { - Cow::Borrowed("Didn't complete before parent. Await step with `await t.step(...)`.") - } + TestFailure::IncompleteSteps => Cow::Borrowed( + "Completed while steps were still running. Ensure all steps are awaited with `await t.step(...)`.", + ), + TestFailure::Incomplete => Cow::Borrowed( + "Didn't complete before parent. Await step with `await t.step(...)`.", + ), TestFailure::Leaked(details, trailer_notes) => { let mut f = String::new(); write!(f, "Leaks detected:").ok(); diff --git a/cli/tools/upgrade.rs b/cli/tools/upgrade.rs index dc7758d828..3f4bcc8c70 100644 --- a/cli/tools/upgrade.rs +++ b/cli/tools/upgrade.rs @@ -14,8 +14,8 @@ use std::sync::Arc; use std::time::Duration; use async_trait::async_trait; -use deno_core::anyhow::bail; use deno_core::anyhow::Context; +use deno_core::anyhow::bail; use deno_core::error::AnyError; use deno_core::unsync::spawn; use deno_core::url::Url; @@ -26,8 +26,8 @@ use deno_semver::Version; use once_cell::sync::Lazy; use crate::args::Flags; -use crate::args::UpgradeFlags; use crate::args::UPGRADE_USAGE; +use crate::args::UpgradeFlags; use crate::colors; use crate::factory::CliFactory; use crate::http_util::HttpClient; @@ -158,10 +158,8 @@ struct UpdateChecker< maybe_file: Option, } -impl< - TEnvironment: UpdateCheckerEnvironment, - TVersionProvider: VersionProvider, - > UpdateChecker +impl + UpdateChecker { pub fn new(env: TEnvironment, version_provider: TVersionProvider) -> Self { let maybe_file = CheckVersionFile::parse(env.read_check_file()); @@ -996,11 +994,14 @@ fn set_exe_permissions( if std::os::unix::fs::MetadataExt::uid(&metadata) == 0 && !nix::unistd::Uid::effective().is_root() { - bail!(concat!( - "You don't have write permission to {} because it's owned by root.\n", - "Consider updating deno through your package manager if its installed from it.\n", - "Otherwise run `deno upgrade` as root.", - ), output_exe_path.display()); + bail!( + concat!( + "You don't have write permission to {} because it's owned by root.\n", + "Consider updating deno through your package manager if its installed from it.\n", + "Otherwise run `deno upgrade` as root.", + ), + output_exe_path.display() + ); } Ok(permissions) } diff --git a/cli/tsc/diagnostics.rs b/cli/tsc/diagnostics.rs index 8cd3f3f020..e3bdcf6ecf 100644 --- a/cli/tsc/diagnostics.rs +++ b/cli/tsc/diagnostics.rs @@ -618,7 +618,10 @@ mod tests { ]); let diagnostics: Diagnostics = serde_json::from_value(value).unwrap(); let actual = diagnostics.to_string(); - assert_eq!(strip_ansi_codes(&actual), "TS2584 [ERROR]: Cannot find name \'console\'. Do you need to change your target library? Try changing the `lib` compiler option to include \'dom\'.\nconsole.log(\"a\");\n~~~~~~~\n at test.ts:1:1"); + assert_eq!( + strip_ansi_codes(&actual), + "TS2584 [ERROR]: Cannot find name \'console\'. Do you need to change your target library? Try changing the `lib` compiler option to include \'dom\'.\nconsole.log(\"a\");\n~~~~~~~\n at test.ts:1:1" + ); } #[test] @@ -659,6 +662,9 @@ mod tests { ]); let diagnostics: Diagnostics = serde_json::from_value(value).unwrap(); let actual = diagnostics.to_string(); - assert_eq!(strip_ansi_codes(&actual), "TS2552 [ERROR]: Cannot find name \'foo_Bar\'. Did you mean \'foo_bar\'?\nfoo_Bar();\n~~~~~~~\n at test.ts:8:1\n\n \'foo_bar\' is declared here.\n function foo_bar() {\n ~~~~~~~\n at test.ts:4:10"); + assert_eq!( + strip_ansi_codes(&actual), + "TS2552 [ERROR]: Cannot find name \'foo_Bar\'. Did you mean \'foo_bar\'?\nfoo_Bar();\n~~~~~~~\n at test.ts:8:1\n\n \'foo_bar\' is declared here.\n function foo_bar() {\n ~~~~~~~\n at test.ts:4:10" + ); } } diff --git a/cli/tsc/mod.rs b/cli/tsc/mod.rs index d1d22f11b6..a672e67878 100644 --- a/cli/tsc/mod.rs +++ b/cli/tsc/mod.rs @@ -10,6 +10,11 @@ use std::sync::Arc; use std::sync::OnceLock; use deno_ast::MediaType; +use deno_core::FastString; +use deno_core::JsRuntime; +use deno_core::ModuleSpecifier; +use deno_core::OpState; +use deno_core::RuntimeOptions; use deno_core::anyhow::Context; use deno_core::located_script_name; use deno_core::op2; @@ -20,11 +25,6 @@ use deno_core::serde::Serialize; use deno_core::serde::Serializer; use deno_core::serde_json::json; use deno_core::url::Url; -use deno_core::FastString; -use deno_core::JsRuntime; -use deno_core::ModuleSpecifier; -use deno_core::OpState; -use deno_core::RuntimeOptions; use deno_graph::GraphKind; use deno_graph::Module; use deno_graph::ModuleGraph; @@ -32,16 +32,16 @@ use deno_graph::ResolutionResolved; use deno_lib::util::checksum; use deno_lib::util::hash::FastInsecureHasher; use deno_lib::worker::create_isolate_create_params; -use deno_resolver::npm::managed::ResolvePkgFolderFromDenoModuleError; use deno_resolver::npm::ResolvePkgFolderFromDenoReqError; +use deno_resolver::npm::managed::ResolvePkgFolderFromDenoModuleError; use deno_semver::npm::NpmPackageReqReference; use indexmap::IndexMap; +use node_resolver::NodeResolutionKind; +use node_resolver::ResolutionMode; use node_resolver::errors::NodeJsErrorCode; use node_resolver::errors::NodeJsErrorCoded; use node_resolver::errors::PackageSubpathResolveError; use node_resolver::resolve_specifier_into_node_modules; -use node_resolver::NodeResolutionKind; -use node_resolver::ResolutionMode; use once_cell::sync::Lazy; use thiserror::Error; @@ -96,9 +96,7 @@ pub fn get_types_declaration_file_text() -> String { } macro_rules! maybe_compressed_source { - ($file: expr) => {{ - maybe_compressed_source!(compressed = $file, uncompressed = $file) - }}; + ($file: expr) => {{ maybe_compressed_source!(compressed = $file, uncompressed = $file) }}; (compressed = $comp: expr, uncompressed = $uncomp: expr) => {{ #[cfg(feature = "hmr")] { @@ -392,7 +390,7 @@ fn get_hash(source: &str, hash_data: u64) -> String { /// Hash the URL so it can be sent to `tsc` in a supportable way fn hash_url(specifier: &ModuleSpecifier, media_type: MediaType) -> String { - let hash = checksum::gen(&[specifier.path().as_bytes()]); + let hash = checksum::r#gen(&[specifier.path().as_bytes()]); format!( "{}:///{}{}", specifier.scheme(), @@ -661,9 +659,7 @@ pub enum LoadError { #[error("{0}")] ResolveUrlOrPathError(#[from] deno_path_util::ResolveUrlOrPathError), #[class(inherit)] - #[error( - "Error converting a string module specifier for \"op_resolve\": {0}" - )] + #[error("Error converting a string module specifier for \"op_resolve\": {0}")] ModuleResolution(#[from] deno_core::ModuleResolutionError), #[class(inherit)] #[error("{0}")] @@ -709,7 +705,7 @@ fn op_load_inner( return Err(LoadError::LoadFromNodeModule { path: file_path.display().to_string(), error: err, - }) + }); } }; let code: Arc = code.into(); @@ -764,7 +760,7 @@ fn op_load_inner( version: Some("1".to_string()), script_kind: as_ts_script_kind(*media_type), is_cjs: false, - })) + })); } _ => None, }, @@ -845,9 +841,7 @@ fn op_load_inner( #[derive(Debug, Error, deno_error::JsError)] pub enum ResolveError { #[class(inherit)] - #[error( - "Error converting a string module specifier for \"op_resolve\": {0}" - )] + #[error("Error converting a string module specifier for \"op_resolve\": {0}")] ModuleResolution(#[from] deno_core::ModuleResolutionError), #[class(inherit)] #[error(transparent)] @@ -1204,35 +1198,39 @@ fn resolve_non_graph_specifier_types( .and_then(|res| res.into_url()) .ok(), ))) - } else if let Ok(npm_req_ref) = - NpmPackageReqReference::from_str(raw_specifier) - { - debug_assert_eq!(resolution_mode, ResolutionMode::Import); - // todo(dsherret): add support for injecting this in the graph so - // we don't need this special code here. - // This could occur when resolving npm:@types/node when it is - // injected and not part of the graph - let package_folder = npm - .npm_resolver - .resolve_pkg_folder_from_deno_module_req(npm_req_ref.req(), referrer)?; - let res_result = node_resolver.resolve_package_subpath_from_deno_module( - &package_folder, - npm_req_ref.sub_path(), - Some(referrer), - resolution_mode, - NodeResolutionKind::Types, - ); - let maybe_url = match res_result { - Ok(url_or_path) => Some(url_or_path.into_url()?), - Err(err) => match err.code() { - NodeJsErrorCode::ERR_TYPES_NOT_FOUND - | NodeJsErrorCode::ERR_MODULE_NOT_FOUND => None, - _ => return Err(err.into()), - }, - }; - Ok(Some(into_specifier_and_media_type(maybe_url))) } else { - Ok(None) + match NpmPackageReqReference::from_str(raw_specifier) { + Ok(npm_req_ref) => { + debug_assert_eq!(resolution_mode, ResolutionMode::Import); + // todo(dsherret): add support for injecting this in the graph so + // we don't need this special code here. + // This could occur when resolving npm:@types/node when it is + // injected and not part of the graph + let package_folder = + npm.npm_resolver.resolve_pkg_folder_from_deno_module_req( + npm_req_ref.req(), + referrer, + )?; + let res_result = node_resolver + .resolve_package_subpath_from_deno_module( + &package_folder, + npm_req_ref.sub_path(), + Some(referrer), + resolution_mode, + NodeResolutionKind::Types, + ); + let maybe_url = match res_result { + Ok(url_or_path) => Some(url_or_path.into_url()?), + Err(err) => match err.code() { + NodeJsErrorCode::ERR_TYPES_NOT_FOUND + | NodeJsErrorCode::ERR_MODULE_NOT_FOUND => None, + _ => return Err(err.into()), + }, + }; + Ok(Some(into_specifier_and_media_type(maybe_url))) + } + _ => Ok(None), + } } } @@ -1512,10 +1510,10 @@ pub fn exec( #[cfg(test)] mod tests { + use deno_core::OpState; use deno_core::futures::future; use deno_core::parking_lot::Mutex; use deno_core::serde_json; - use deno_core::OpState; use deno_error::JsErrorBox; use deno_graph::GraphKind; use deno_graph::ModuleGraph; @@ -1656,7 +1654,10 @@ mod tests { "data:application/javascript,console.log(\"Hello%20Deno\");", ) .unwrap(); - assert_eq!(hash_url(&specifier, MediaType::JavaScript), "data:///d300ea0796bd72b08df10348e0b70514c021f2e45bfe59cec24e12e97cd79c58.js"); + assert_eq!( + hash_url(&specifier, MediaType::JavaScript), + "data:///d300ea0796bd72b08df10348e0b70514c021f2e45bfe59cec24e12e97cd79c58.js" + ); } #[tokio::test] diff --git a/cli/type_checker.rs b/cli/type_checker.rs index dbfaacb443..f0a79b60e6 100644 --- a/cli/type_checker.rs +++ b/cli/type_checker.rs @@ -32,11 +32,11 @@ use crate::args::TypeCheckMode; use crate::cache::CacheDBHash; use crate::cache::Caches; use crate::cache::TypeCheckCache; +use crate::graph_util::BuildFastCheckGraphOptions; +use crate::graph_util::ModuleGraphBuilder; use crate::graph_util::maybe_additional_sloppy_imports_message; use crate::graph_util::module_error_for_tsc_diagnostic; use crate::graph_util::resolution_error_for_tsc_diagnostic; -use crate::graph_util::BuildFastCheckGraphOptions; -use crate::graph_util::ModuleGraphBuilder; use crate::node::CliNodeResolver; use crate::npm::CliNpmResolver; use crate::sys::CliSys; @@ -673,8 +673,8 @@ impl<'a> GraphWalker<'a> { pub fn add_config_import(&mut self, specifier: &'a Url, referrer: &Url) { let specifier = self.graph.resolve(specifier); if self.seen.insert(specifier) { - if let Ok(nv_ref) = NpmPackageNvReference::from_specifier(specifier) { - match self.resolve_npm_nv_ref(&nv_ref, referrer) { + match NpmPackageNvReference::from_specifier(specifier) { + Ok(nv_ref) => match self.resolve_npm_nv_ref(&nv_ref, referrer) { Some(resolved) => { let mt = MediaType::from_specifier(&resolved); self.roots.push((resolved, mt)); @@ -688,10 +688,11 @@ impl<'a> GraphWalker<'a> { maybe_additional_sloppy_imports_message(self.sys, specifier), )); } + }, + _ => { + self.pending.push_back((specifier, false)); + self.resolve_pending(); } - } else { - self.pending.push_back((specifier, false)); - self.resolve_pending(); } } } diff --git a/cli/util/archive.rs b/cli/util/archive.rs index e3efd69adb..202428f5d1 100644 --- a/cli/util/archive.rs +++ b/cli/util/archive.rs @@ -5,8 +5,8 @@ use std::path::Path; use std::path::PathBuf; use std::process::Command; -use deno_core::anyhow::bail; use deno_core::anyhow::Context; +use deno_core::anyhow::bail; use deno_core::error::AnyError; fn unzip_with_shell( diff --git a/cli/util/extract.rs b/cli/util/extract.rs index cd769754c2..5f86ffa725 100644 --- a/cli/util/extract.rs +++ b/cli/util/extract.rs @@ -4,20 +4,20 @@ use std::collections::BTreeSet; use std::fmt::Write as _; use std::sync::Arc; +use deno_ast::MediaType; +use deno_ast::SourceRangedForSpanned as _; use deno_ast::swc::ast; use deno_ast::swc::atoms::Atom; -use deno_ast::swc::common::comments::CommentKind; use deno_ast::swc::common::DUMMY_SP; -use deno_ast::swc::ecma_visit::visit_mut_pass; +use deno_ast::swc::common::comments::CommentKind; use deno_ast::swc::ecma_visit::Visit; use deno_ast::swc::ecma_visit::VisitMut; use deno_ast::swc::ecma_visit::VisitWith as _; +use deno_ast::swc::ecma_visit::visit_mut_pass; use deno_ast::swc::utils as swc_utils; -use deno_ast::MediaType; -use deno_ast::SourceRangedForSpanned as _; use deno_cache_dir::file_fetcher::File; -use deno_core::error::AnyError; use deno_core::ModuleSpecifier; +use deno_core::error::AnyError; use regex::Regex; use crate::file_fetcher::TextDecodedFile; diff --git a/cli/util/file_watcher.rs b/cli/util/file_watcher.rs index 429e8310e1..44468799bd 100644 --- a/cli/util/file_watcher.rs +++ b/cli/util/file_watcher.rs @@ -17,17 +17,17 @@ use deno_core::parking_lot::Mutex; use deno_lib::util::result::any_and_jserrorbox_downcast_ref; use deno_runtime::fmt_errors::format_js_error; use log::info; -use notify::event::Event as NotifyEvent; -use notify::event::EventKind; use notify::Error as NotifyError; use notify::RecommendedWatcher; use notify::RecursiveMode; use notify::Watcher; +use notify::event::Event as NotifyEvent; +use notify::event::EventKind; use tokio::select; use tokio::sync::broadcast::error::RecvError; use tokio::sync::mpsc; -use tokio::sync::mpsc::error::SendError; use tokio::sync::mpsc::UnboundedReceiver; +use tokio::sync::mpsc::error::SendError; use tokio::time::sleep; use crate::args::Flags; diff --git a/cli/util/fs.rs b/cli/util/fs.rs index 5efd46a42a..5b6b595110 100644 --- a/cli/util/fs.rs +++ b/cli/util/fs.rs @@ -10,9 +10,9 @@ use deno_config::glob::FilePatterns; use deno_config::glob::PathOrPattern; use deno_config::glob::PathOrPatternSet; use deno_config::glob::WalkEntry; +use deno_core::ModuleSpecifier; use deno_core::anyhow::anyhow; use deno_core::error::AnyError; -use deno_core::ModuleSpecifier; use crate::sys::CliSys; @@ -288,14 +288,14 @@ mod tests { let result = collect_specifiers( FilePatterns { base: root_dir_path.to_path_buf(), - include: Some(PathOrPatternSet::new(vec![PathOrPattern::new( - &format!( + include: Some(PathOrPatternSet::new(vec![ + PathOrPattern::new(&format!( "{}{}", scheme, root_dir_path.join("child").to_string().replace('\\', "/") - ), - ) - .unwrap()])), + )) + .unwrap(), + ])), exclude: Default::default(), }, None, diff --git a/cli/util/progress_bar/mod.rs b/cli/util/progress_bar/mod.rs index 7c5497774f..15b74063a4 100644 --- a/cli/util/progress_bar/mod.rs +++ b/cli/util/progress_bar/mod.rs @@ -1,8 +1,8 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use std::sync::Arc; use std::sync::atomic::AtomicU64; use std::sync::atomic::Ordering; -use std::sync::Arc; use std::time::Instant; use deno_core::parking_lot::Mutex; diff --git a/cli/util/text_encoding.rs b/cli/util/text_encoding.rs index 3a8044e13b..ab42ffb060 100644 --- a/cli/util/text_encoding.rs +++ b/cli/util/text_encoding.rs @@ -3,10 +3,10 @@ use std::collections::HashMap; use std::ops::Range; -use base64::prelude::BASE64_STANDARD; use base64::Engine; -use deno_core::error::AnyError; +use base64::prelude::BASE64_STANDARD; use deno_core::ModuleSourceCode; +use deno_core::error::AnyError; use deno_error::JsErrorBox; use text_lines::LineAndColumnIndex; use text_size::TextSize; diff --git a/cli/util/v8/convert.rs b/cli/util/v8/convert.rs index 4d0cb732a8..8f006b6247 100644 --- a/cli/util/v8/convert.rs +++ b/cli/util/v8/convert.rs @@ -1,8 +1,8 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::v8; use deno_core::FromV8; use deno_core::ToV8; +use deno_core::v8; #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] /// A wrapper type for `Option` that (de)serializes `None` as `null` diff --git a/cli/worker.rs b/cli/worker.rs index 65d0f12643..fbbac6738b 100644 --- a/cli/worker.rs +++ b/cli/worker.rs @@ -5,21 +5,21 @@ use std::rc::Rc; use std::sync::Arc; use deno_ast::ModuleSpecifier; -use deno_core::error::CoreError; -use deno_core::futures::FutureExt; -use deno_core::v8; use deno_core::Extension; use deno_core::OpState; use deno_core::PollEventLoopOptions; +use deno_core::error::CoreError; +use deno_core::futures::FutureExt; +use deno_core::v8; use deno_error::JsErrorBox; use deno_lib::worker::LibMainWorker; use deno_lib::worker::LibMainWorkerFactory; use deno_lib::worker::ResolveNpmBinaryEntrypointError; -use deno_npm_installer::graph::NpmCachingStrategy; use deno_npm_installer::PackageCaching; +use deno_npm_installer::graph::NpmCachingStrategy; +use deno_runtime::WorkerExecutionMode; use deno_runtime::deno_permissions::PermissionsContainer; use deno_runtime::worker::MainWorker; -use deno_runtime::WorkerExecutionMode; use deno_semver::npm::NpmPackageReqReference; use sys_traits::EnvCurrentDir; use tokio::select; @@ -417,53 +417,53 @@ impl CliMainWorkerFactory { stdio: deno_runtime::deno_io::Stdio, unconfigured_runtime: Option, ) -> Result { - let main_module = if let Ok(package_ref) = - NpmPackageReqReference::from_specifier(&main_module) + let main_module = match NpmPackageReqReference::from_specifier(&main_module) { - if let Some(npm_installer) = &self.npm_installer { - let reqs = &[package_ref.req().clone()]; - npm_installer - .add_package_reqs( - reqs, - if matches!( - self.default_npm_caching_strategy, - NpmCachingStrategy::Lazy - ) { - PackageCaching::Only(reqs.into()) - } else { - PackageCaching::All - }, - ) - .await - .map_err(CreateCustomWorkerError::NpmPackageReq)?; + Ok(package_ref) => { + if let Some(npm_installer) = &self.npm_installer { + let reqs = &[package_ref.req().clone()]; + npm_installer + .add_package_reqs( + reqs, + if matches!( + self.default_npm_caching_strategy, + NpmCachingStrategy::Lazy + ) { + PackageCaching::Only(reqs.into()) + } else { + PackageCaching::All + }, + ) + .await + .map_err(CreateCustomWorkerError::NpmPackageReq)?; + } + + // use a fake referrer that can be used to discover the package.json if necessary + let referrer = + ModuleSpecifier::from_directory_path(self.sys.env_current_dir()?) + .unwrap() + .join("package.json")?; + let package_folder = + self.npm_resolver.resolve_pkg_folder_from_deno_module_req( + package_ref.req(), + &referrer, + )?; + let main_module = + self.lib_main_worker_factory.resolve_npm_binary_entrypoint( + &package_folder, + package_ref.sub_path(), + )?; + + if let Some(lockfile) = &self.maybe_lockfile { + // For npm binary commands, ensure that the lockfile gets updated + // so that we can re-use the npm resolution the next time it runs + // for better performance + lockfile.write_if_changed()?; + } + + main_module } - - // use a fake referrer that can be used to discover the package.json if necessary - let referrer = - ModuleSpecifier::from_directory_path(self.sys.env_current_dir()?) - .unwrap() - .join("package.json")?; - let package_folder = - self.npm_resolver.resolve_pkg_folder_from_deno_module_req( - package_ref.req(), - &referrer, - )?; - let main_module = - self.lib_main_worker_factory.resolve_npm_binary_entrypoint( - &package_folder, - package_ref.sub_path(), - )?; - - if let Some(lockfile) = &self.maybe_lockfile { - // For npm binary commands, ensure that the lockfile gets updated - // so that we can re-use the npm resolution the next time it runs - // for better performance - lockfile.write_if_changed()?; - } - - main_module - } else { - main_module + _ => main_module, }; let mut worker = self.lib_main_worker_factory.create_custom_worker( @@ -509,8 +509,8 @@ impl CliMainWorkerFactory { mod tests { use std::rc::Rc; - use deno_core::resolve_path; use deno_core::FsModuleLoader; + use deno_core::resolve_path; use deno_resolver::npm::DenoInNpmPackageChecker; use deno_runtime::deno_fs::RealFs; use deno_runtime::deno_permissions::Permissions; diff --git a/ext/broadcast_channel/lib.rs b/ext/broadcast_channel/lib.rs index 8660c2b2a3..73195d731d 100644 --- a/ext/broadcast_channel/lib.rs +++ b/ext/broadcast_channel/lib.rs @@ -7,11 +7,11 @@ use std::rc::Rc; use std::sync::Arc; use async_trait::async_trait; -use deno_core::op2; use deno_core::JsBuffer; use deno_core::OpState; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::op2; use deno_error::JsErrorBox; use deno_features::FeatureChecker; pub use in_memory_broadcast_channel::InMemoryBroadcastChannel; diff --git a/ext/cache/lib.rs b/ext/cache/lib.rs index b6b66cff0f..87d0a362d7 100644 --- a/ext/cache/lib.rs +++ b/ext/cache/lib.rs @@ -9,15 +9,15 @@ use std::sync::Arc; use async_trait::async_trait; use bytes::Bytes; -use deno_core::op2; -use deno_core::serde::Deserialize; -use deno_core::serde::Serialize; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::ByteString; use deno_core::OpState; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::op2; +use deno_core::serde::Deserialize; +use deno_core::serde::Serialize; use deno_error::JsErrorBox; use futures::Stream; use tokio::io::AsyncRead; diff --git a/ext/cache/lsc_shard.rs b/ext/cache/lsc_shard.rs index 3138cf132f..231a53d3a9 100644 --- a/ext/cache/lsc_shard.rs +++ b/ext/cache/lsc_shard.rs @@ -6,16 +6,16 @@ use bytes::Bytes; use http::Method; use http::Request; use http::Response; -use http_body_util::combinators::UnsyncBoxBody; use http_body_util::BodyExt; use http_body_util::Either; use http_body_util::Empty; -use hyper::body::Incoming; -use hyper::header::AUTHORIZATION; +use http_body_util::combinators::UnsyncBoxBody; use hyper::HeaderMap; use hyper::StatusCode; -use hyper_util::client::legacy::connect::HttpConnector; +use hyper::body::Incoming; +use hyper::header::AUTHORIZATION; use hyper_util::client::legacy::Client; +use hyper_util::client::legacy::connect::HttpConnector; use hyper_util::rt::tokio::TokioExecutor; use crate::CacheError; diff --git a/ext/cache/lscache.rs b/ext/cache/lscache.rs index 280c66d582..59d009336f 100644 --- a/ext/cache/lscache.rs +++ b/ext/cache/lscache.rs @@ -6,28 +6,28 @@ use std::rc::Rc; use async_stream::try_stream; use base64::Engine; use bytes::Bytes; -use deno_core::unsync::spawn; use deno_core::BufMutView; use deno_core::ByteString; use deno_core::Resource; +use deno_core::unsync::spawn; use futures::StreamExt; use futures::TryStreamExt; -use http::header::VARY; use http::HeaderMap; use http::HeaderName; use http::HeaderValue; +use http::header::VARY; use http_body_util::combinators::UnsyncBoxBody; use slab::Slab; -use crate::get_header; -use crate::get_headers_from_vary_header; -use crate::lsc_shard::CacheShard; use crate::CacheDeleteRequest; use crate::CacheError; use crate::CacheMatchRequest; use crate::CacheMatchResponseMeta; use crate::CachePutRequest; use crate::CacheResponseResource; +use crate::get_header; +use crate::get_headers_from_vary_header; +use crate::lsc_shard::CacheShard; const REQHDR_PREFIX: &str = "x-lsc-meta-reqhdr-"; diff --git a/ext/cache/sqlite.rs b/ext/cache/sqlite.rs index 9c25793ea9..34023a63a0 100644 --- a/ext/cache/sqlite.rs +++ b/ext/cache/sqlite.rs @@ -8,27 +8,27 @@ use std::sync::Arc; use std::time::SystemTime; use std::time::UNIX_EPOCH; -use deno_core::parking_lot::Mutex; -use deno_core::unsync::spawn_blocking; use deno_core::BufMutView; use deno_core::ByteString; use deno_core::Resource; -use rusqlite::params; +use deno_core::parking_lot::Mutex; +use deno_core::unsync::spawn_blocking; use rusqlite::Connection; use rusqlite::OptionalExtension; +use rusqlite::params; use tokio::io::AsyncWrite; use tokio::io::AsyncWriteExt; -use crate::deserialize_headers; -use crate::get_header; -use crate::serialize_headers; -use crate::vary_header_matches; use crate::CacheDeleteRequest; use crate::CacheError; use crate::CacheMatchRequest; use crate::CacheMatchResponseMeta; use crate::CachePutRequest; use crate::CacheResponseResource; +use crate::deserialize_headers; +use crate::get_header; +use crate::serialize_headers; +use crate::vary_header_matches; #[derive(Clone)] pub struct SqliteBackedCache { @@ -243,9 +243,11 @@ impl SqliteBackedCache { Some(body_key) ); } else { - assert!(insert_cache_asset(db, request_response, None) - .await? - .is_none()); + assert!( + insert_cache_asset(db, request_response, None) + .await? + .is_none() + ); } Ok(()) } diff --git a/ext/canvas/lib.rs b/ext/canvas/lib.rs index 05c9ae6caa..397dbb4768 100644 --- a/ext/canvas/lib.rs +++ b/ext/canvas/lib.rs @@ -20,7 +20,9 @@ pub enum CanvasError { #[error("Cannot decode image '{0}'")] InvalidImage(image::ImageError), #[class("DOMExceptionInvalidStateError")] - #[error("The chunk data is not big enough with the specified width: {0} and height: {1}")] + #[error( + "The chunk data is not big enough with the specified width: {0} and height: {1}" + )] NotBigEnoughChunk(u32, u32), #[class("DOMExceptionInvalidStateError")] #[error("The width: {0} or height: {1} could not be zero")] diff --git a/ext/canvas/op_create_image_bitmap.rs b/ext/canvas/op_create_image_bitmap.rs index cc184dd1f7..0f9cc00634 100644 --- a/ext/canvas/op_create_image_bitmap.rs +++ b/ext/canvas/op_create_image_bitmap.rs @@ -3,27 +3,27 @@ use std::io::BufReader; use std::io::Cursor; -use deno_core::op2; use deno_core::JsBuffer; use deno_core::ToJsBuffer; +use deno_core::op2; +// use image::codecs::webp::WebPDecoder; +use image::DynamicImage; +use image::ImageDecoder; +use image::RgbaImage; use image::codecs::bmp::BmpDecoder; // use image::codecs::gif::GifDecoder; use image::codecs::ico::IcoDecoder; use image::codecs::jpeg::JpegDecoder; use image::codecs::png::PngDecoder; -// use image::codecs::webp::WebPDecoder; -use image::imageops::overlay; use image::imageops::FilterType; +use image::imageops::overlay; use image::metadata::Orientation; -use image::DynamicImage; -use image::ImageDecoder; -use image::RgbaImage; +use crate::CanvasError; use crate::image_ops::create_image_from_raw_bytes; use crate::image_ops::premultiply_alpha as process_premultiply_alpha; use crate::image_ops::to_srgb_from_icc_profile; use crate::image_ops::unpremultiply_alpha; -use crate::CanvasError; #[derive(Debug, PartialEq)] enum ImageBitmapSource { diff --git a/ext/cron/lib.rs b/ext/cron/lib.rs index 4442faf1c1..a6fe5e3cfc 100644 --- a/ext/cron/lib.rs +++ b/ext/cron/lib.rs @@ -8,10 +8,10 @@ use std::cell::RefCell; use std::rc::Rc; use std::sync::Arc; -use deno_core::op2; use deno_core::OpState; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::op2; use deno_error::JsErrorBox; use deno_error::JsErrorClass; use deno_features::FeatureChecker; @@ -59,7 +59,9 @@ pub enum CronError { #[error("Cron name cannot exceed 64 characters: current length {0}")] NameExceeded(usize), #[class(type)] - #[error("Invalid cron name: only alphanumeric characters, whitespace, hyphens, and underscores are allowed")] + #[error( + "Invalid cron name: only alphanumeric characters, whitespace, hyphens, and underscores are allowed" + )] NameInvalid, #[class(type)] #[error("Cron with this name already exists")] diff --git a/ext/cron/local.rs b/ext/cron/local.rs index ab18283605..c0a1ffc4d6 100644 --- a/ext/cron/local.rs +++ b/ext/cron/local.rs @@ -12,12 +12,12 @@ use std::sync::Arc; use async_trait::async_trait; use deno_core::futures; use deno_core::futures::FutureExt; -use deno_core::unsync::spawn; use deno_core::unsync::JoinHandle; -use tokio::sync::mpsc; -use tokio::sync::mpsc::WeakSender; +use deno_core::unsync::spawn; use tokio::sync::OwnedSemaphorePermit; use tokio::sync::Semaphore; +use tokio::sync::mpsc; +use tokio::sync::mpsc::WeakSender; use crate::CronError; use crate::CronHandle; diff --git a/ext/crypto/decrypt.rs b/ext/crypto/decrypt.rs index 766f62d16f..cc7e64dde7 100644 --- a/ext/crypto/decrypt.rs +++ b/ext/crypto/decrypt.rs @@ -1,25 +1,25 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use aes::cipher::block_padding::Pkcs7; use aes::cipher::BlockDecryptMut; use aes::cipher::KeyIvInit; -use aes_gcm::aead::generic_array::typenum::U12; -use aes_gcm::aead::generic_array::typenum::U16; -use aes_gcm::aead::generic_array::ArrayLength; -use aes_gcm::aes::Aes128; -use aes_gcm::aes::Aes192; -use aes_gcm::aes::Aes256; +use aes::cipher::block_padding::Pkcs7; use aes_gcm::AeadInPlace; use aes_gcm::KeyInit; use aes_gcm::Nonce; -use ctr::cipher::StreamCipher; -use ctr::Ctr128BE; +use aes_gcm::aead::generic_array::ArrayLength; +use aes_gcm::aead::generic_array::typenum::U12; +use aes_gcm::aead::generic_array::typenum::U16; +use aes_gcm::aes::Aes128; +use aes_gcm::aes::Aes192; +use aes_gcm::aes::Aes256; use ctr::Ctr32BE; use ctr::Ctr64BE; -use deno_core::op2; -use deno_core::unsync::spawn_blocking; +use ctr::Ctr128BE; +use ctr::cipher::StreamCipher; use deno_core::JsBuffer; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::unsync::spawn_blocking; use rsa::pkcs1::DecodeRsaPrivateKey; use serde::Deserialize; use sha1::Sha1; diff --git a/ext/crypto/ed25519.rs b/ext/crypto/ed25519.rs index 2b0acdf853..dae4b01a19 100644 --- a/ext/crypto/ed25519.rs +++ b/ext/crypto/ed25519.rs @@ -2,16 +2,16 @@ use aws_lc_rs::signature::Ed25519KeyPair; use aws_lc_rs::signature::KeyPair; -use base64::prelude::BASE64_URL_SAFE_NO_PAD; use base64::Engine; -use deno_core::op2; +use base64::prelude::BASE64_URL_SAFE_NO_PAD; use deno_core::ToJsBuffer; +use deno_core::op2; use elliptic_curve::pkcs8::PrivateKeyInfo; -use rand::rngs::OsRng; use rand::RngCore; -use spki::der::asn1::BitString; +use rand::rngs::OsRng; use spki::der::Decode; use spki::der::Encode; +use spki::der::asn1::BitString; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum Ed25519Error { diff --git a/ext/crypto/encrypt.rs b/ext/crypto/encrypt.rs index d94eb97cfd..c8f15c223d 100644 --- a/ext/crypto/encrypt.rs +++ b/ext/crypto/encrypt.rs @@ -1,25 +1,25 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use aes::cipher::block_padding::Pkcs7; use aes::cipher::BlockEncryptMut; use aes::cipher::KeyIvInit; use aes::cipher::StreamCipher; -use aes_gcm::aead::generic_array::typenum::U12; -use aes_gcm::aead::generic_array::typenum::U16; -use aes_gcm::aead::generic_array::ArrayLength; -use aes_gcm::aes::Aes128; -use aes_gcm::aes::Aes192; -use aes_gcm::aes::Aes256; +use aes::cipher::block_padding::Pkcs7; use aes_gcm::AeadInPlace; use aes_gcm::KeyInit; use aes_gcm::Nonce; -use ctr::Ctr128BE; +use aes_gcm::aead::generic_array::ArrayLength; +use aes_gcm::aead::generic_array::typenum::U12; +use aes_gcm::aead::generic_array::typenum::U16; +use aes_gcm::aes::Aes128; +use aes_gcm::aes::Aes192; +use aes_gcm::aes::Aes256; use ctr::Ctr32BE; use ctr::Ctr64BE; -use deno_core::op2; -use deno_core::unsync::spawn_blocking; +use ctr::Ctr128BE; use deno_core::JsBuffer; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::unsync::spawn_blocking; use rand::rngs::OsRng; use rsa::pkcs1::DecodeRsaPublicKey; use serde::Deserialize; diff --git a/ext/crypto/export_key.rs b/ext/crypto/export_key.rs index c7d59e3cc5..e6bbdca0d6 100644 --- a/ext/crypto/export_key.rs +++ b/ext/crypto/export_key.rs @@ -1,22 +1,22 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use base64::prelude::BASE64_URL_SAFE_NO_PAD; use base64::Engine; +use base64::prelude::BASE64_URL_SAFE_NO_PAD; use const_oid::AssociatedOid; use const_oid::ObjectIdentifier; -use deno_core::op2; use deno_core::ToJsBuffer; +use deno_core::op2; use elliptic_curve::sec1::ToEncodedPoint; use p256::pkcs8::DecodePrivateKey; use rsa::pkcs1::der::Decode; -use rsa::pkcs8::der::asn1::UintRef; use rsa::pkcs8::der::Encode; +use rsa::pkcs8::der::asn1::UintRef; use serde::Deserialize; use serde::Serialize; -use spki::der::asn1; -use spki::der::asn1::BitString; use spki::AlgorithmIdentifier; use spki::AlgorithmIdentifierOwned; +use spki::der::asn1; +use spki::der::asn1::BitString; use crate::shared::*; diff --git a/ext/crypto/generate_key.rs b/ext/crypto/generate_key.rs index e5d6b89282..26c3f0622a 100644 --- a/ext/crypto/generate_key.rs +++ b/ext/crypto/generate_key.rs @@ -2,15 +2,15 @@ use aws_lc_rs::rand::SecureRandom; use aws_lc_rs::signature::EcdsaKeyPair; +use deno_core::ToJsBuffer; use deno_core::op2; use deno_core::unsync::spawn_blocking; -use deno_core::ToJsBuffer; use elliptic_curve::rand_core::OsRng; use num_traits::FromPrimitive; use once_cell::sync::Lazy; -use rsa::pkcs1::EncodeRsaPrivateKey; use rsa::BigUint; use rsa::RsaPrivateKey; +use rsa::pkcs1::EncodeRsaPrivateKey; use serde::Deserialize; use crate::shared::*; diff --git a/ext/crypto/import_key.rs b/ext/crypto/import_key.rs index e9059bbdc6..bf8265102d 100644 --- a/ext/crypto/import_key.rs +++ b/ext/crypto/import_key.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. use base64::Engine; -use deno_core::op2; use deno_core::JsBuffer; use deno_core::ToJsBuffer; +use deno_core::op2; use elliptic_curve::pkcs8::PrivateKeyInfo; use p256::pkcs8::EncodePrivateKey; use rsa::pkcs1::UintRef; diff --git a/ext/crypto/lib.rs b/ext/crypto/lib.rs index 1b5fcddd56..3512ee224c 100644 --- a/ext/crypto/lib.rs +++ b/ext/crypto/lib.rs @@ -10,13 +10,13 @@ use aws_lc_rs::hkdf; use aws_lc_rs::hmac::Algorithm as HmacAlgorithm; use aws_lc_rs::hmac::Key as HmacKey; use aws_lc_rs::pbkdf2; -use base64::prelude::BASE64_URL_SAFE_NO_PAD; use base64::Engine; -use deno_core::op2; -use deno_core::unsync::spawn_blocking; +use base64::prelude::BASE64_URL_SAFE_NO_PAD; use deno_core::JsBuffer; use deno_core::OpState; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::unsync::spawn_blocking; use deno_error::JsErrorBox; use p256::ecdsa::Signature as P256Signature; use p256::ecdsa::SigningKey as P256SigningKey; @@ -27,20 +27,20 @@ use p384::ecdsa::Signature as P384Signature; use p384::ecdsa::SigningKey as P384SigningKey; use p384::ecdsa::VerifyingKey as P384VerifyingKey; pub use rand; +use rand::Rng; +use rand::SeedableRng; use rand::rngs::OsRng; use rand::rngs::StdRng; use rand::thread_rng; -use rand::Rng; -use rand::SeedableRng; +use rsa::Pss; +use rsa::RsaPrivateKey; +use rsa::RsaPublicKey; use rsa::pkcs1::DecodeRsaPrivateKey; use rsa::pkcs1::DecodeRsaPublicKey; use rsa::signature::SignatureEncoding; use rsa::signature::Signer; use rsa::signature::Verifier; use rsa::traits::SignatureScheme; -use rsa::Pss; -use rsa::RsaPrivateKey; -use rsa::RsaPublicKey; use serde::Deserialize; use sha1::Sha1; use sha2::Digest; @@ -61,25 +61,25 @@ mod shared; mod x25519; mod x448; -pub use crate::decrypt::op_crypto_decrypt; pub use crate::decrypt::DecryptError; +pub use crate::decrypt::op_crypto_decrypt; pub use crate::ed25519::Ed25519Error; -pub use crate::encrypt::op_crypto_encrypt; pub use crate::encrypt::EncryptError; -pub use crate::export_key::op_crypto_export_key; +pub use crate::encrypt::op_crypto_encrypt; pub use crate::export_key::ExportKeyError; -pub use crate::generate_key::op_crypto_generate_key; +pub use crate::export_key::op_crypto_export_key; pub use crate::generate_key::GenerateKeyError; -pub use crate::import_key::op_crypto_import_key; +pub use crate::generate_key::op_crypto_generate_key; pub use crate::import_key::ImportKeyError; +pub use crate::import_key::op_crypto_import_key; use crate::key::Algorithm; use crate::key::CryptoHash; use crate::key::CryptoNamedCurve; use crate::key::HkdfOutput; pub use crate::shared::SharedError; use crate::shared::V8RawKeyData; -pub use crate::x25519::X25519Error; pub use crate::x448::X448Error; +pub use crate::x25519::X25519Error; deno_core::extension!(deno_crypto, deps = [ deno_webidl, deno_web ], @@ -209,7 +209,9 @@ pub enum CryptoError { #[error("decryption error - integrity check failed")] DecryptionError, #[class("DOMExceptionQuotaExceededError")] - #[error("The ArrayBufferView's byte length ({0}) exceeds the number of bytes of entropy available via this API (65536)")] + #[error( + "The ArrayBufferView's byte length ({0}) exceeds the number of bytes of entropy available via this API (65536)" + )] ArrayBufferViewLengthExceeded(usize), #[class(inherit)] #[error(transparent)] @@ -513,16 +515,17 @@ pub async fn op_crypto_verify_key( } _ => return Err(CryptoError::InvalidKeyFormat), }; - if let Ok(signature) = P256Signature::from_slice(&args.signature) { - let prehash = match hash { - CryptoHash::Sha1 => sha1::Sha1::digest(data).to_vec(), - CryptoHash::Sha256 => sha2::Sha256::digest(data).to_vec(), - CryptoHash::Sha384 => sha2::Sha384::digest(data).to_vec(), - CryptoHash::Sha512 => sha2::Sha512::digest(data).to_vec(), - }; - verifying_key.verify_prehash(&prehash, &signature).is_ok() - } else { - false + match P256Signature::from_slice(&args.signature) { + Ok(signature) => { + let prehash = match hash { + CryptoHash::Sha1 => sha1::Sha1::digest(data).to_vec(), + CryptoHash::Sha256 => sha2::Sha256::digest(data).to_vec(), + CryptoHash::Sha384 => sha2::Sha384::digest(data).to_vec(), + CryptoHash::Sha512 => sha2::Sha512::digest(data).to_vec(), + }; + verifying_key.verify_prehash(&prehash, &signature).is_ok() + } + _ => false, } } CryptoNamedCurve::P384 => { @@ -540,16 +543,17 @@ pub async fn op_crypto_verify_key( } _ => return Err(CryptoError::InvalidKeyFormat), }; - if let Ok(signature) = P384Signature::from_slice(&args.signature) { - let prehash = match hash { - CryptoHash::Sha1 => sha1::Sha1::digest(data).to_vec(), - CryptoHash::Sha256 => sha2::Sha256::digest(data).to_vec(), - CryptoHash::Sha384 => sha2::Sha384::digest(data).to_vec(), - CryptoHash::Sha512 => sha2::Sha512::digest(data).to_vec(), - }; - verifying_key.verify_prehash(&prehash, &signature).is_ok() - } else { - false + match P384Signature::from_slice(&args.signature) { + Ok(signature) => { + let prehash = match hash { + CryptoHash::Sha1 => sha1::Sha1::digest(data).to_vec(), + CryptoHash::Sha256 => sha2::Sha256::digest(data).to_vec(), + CryptoHash::Sha384 => sha2::Sha384::digest(data).to_vec(), + CryptoHash::Sha512 => sha2::Sha512::digest(data).to_vec(), + }; + verifying_key.verify_prehash(&prehash, &signature).is_ok() + } + _ => false, } } } diff --git a/ext/crypto/shared.rs b/ext/crypto/shared.rs index 1c28e0b87d..dfea6013ba 100644 --- a/ext/crypto/shared.rs +++ b/ext/crypto/shared.rs @@ -6,9 +6,9 @@ use deno_core::JsBuffer; use deno_core::ToJsBuffer; use elliptic_curve::sec1::ToEncodedPoint; use p256::pkcs8::DecodePrivateKey; +use rsa::RsaPrivateKey; use rsa::pkcs1::DecodeRsaPrivateKey; use rsa::pkcs1::EncodeRsaPublicKey; -use rsa::RsaPrivateKey; use serde::Deserialize; use serde::Serialize; diff --git a/ext/crypto/x25519.rs b/ext/crypto/x25519.rs index aee8ae0e29..309b3de5ee 100644 --- a/ext/crypto/x25519.rs +++ b/ext/crypto/x25519.rs @@ -2,15 +2,15 @@ use base64::prelude::BASE64_URL_SAFE_NO_PAD; use curve25519_dalek::montgomery::MontgomeryPoint; -use deno_core::op2; use deno_core::ToJsBuffer; +use deno_core::op2; use elliptic_curve::pkcs8::PrivateKeyInfo; use elliptic_curve::subtle::ConstantTimeEq; -use rand::rngs::OsRng; use rand::RngCore; -use spki::der::asn1::BitString; +use rand::rngs::OsRng; use spki::der::Decode; use spki::der::Encode; +use spki::der::asn1::BitString; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum X25519Error { diff --git a/ext/crypto/x448.rs b/ext/crypto/x448.rs index 2086a8f048..8c0cf751f9 100644 --- a/ext/crypto/x448.rs +++ b/ext/crypto/x448.rs @@ -1,16 +1,16 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; use deno_core::ToJsBuffer; -use ed448_goldilocks::curve::MontgomeryPoint; +use deno_core::op2; use ed448_goldilocks::Scalar; +use ed448_goldilocks::curve::MontgomeryPoint; use elliptic_curve::pkcs8::PrivateKeyInfo; use elliptic_curve::subtle::ConstantTimeEq; -use rand::rngs::OsRng; use rand::RngCore; -use spki::der::asn1::BitString; +use rand::rngs::OsRng; use spki::der::Decode; use spki::der::Encode; +use spki::der::asn1::BitString; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum X448Error { diff --git a/ext/fetch/fs_fetch_handler.rs b/ext/fetch/fs_fetch_handler.rs index 5b1886258c..492e227561 100644 --- a/ext/fetch/fs_fetch_handler.rs +++ b/ext/fetch/fs_fetch_handler.rs @@ -2,15 +2,15 @@ use std::rc::Rc; +use deno_core::CancelFuture; +use deno_core::OpState; use deno_core::futures::FutureExt; use deno_core::futures::TryFutureExt; use deno_core::futures::TryStreamExt; use deno_core::url::Url; -use deno_core::CancelFuture; -use deno_core::OpState; use deno_error::JsErrorBox; -use deno_fs::open_options_with_access_check; use deno_fs::OpenOptions; +use deno_fs::open_options_with_access_check; use deno_permissions::PermissionsContainer; use http::StatusCode; use http_body_util::BodyExt; diff --git a/ext/fetch/lib.rs b/ext/fetch/lib.rs index 350e6b8306..51f3c74cae 100644 --- a/ext/fetch/lib.rs +++ b/ext/fetch/lib.rs @@ -26,15 +26,6 @@ use bytes::Bytes; // Re-export data_url pub use data_url; use data_url::DataUrl; -use deno_core::futures::stream::Peekable; -use deno_core::futures::FutureExt; -use deno_core::futures::Stream; -use deno_core::futures::StreamExt; -use deno_core::futures::TryFutureExt; -use deno_core::op2; -use deno_core::url; -use deno_core::url::Url; -use deno_core::v8; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::BufView; @@ -48,47 +39,56 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::futures::FutureExt; +use deno_core::futures::Stream; +use deno_core::futures::StreamExt; +use deno_core::futures::TryFutureExt; +use deno_core::futures::stream::Peekable; +use deno_core::op2; +use deno_core::url; +use deno_core::url::Url; +use deno_core::v8; use deno_error::JsErrorBox; -use deno_fs::open_options_with_access_check; use deno_fs::CheckedPath; pub use deno_fs::FsError; use deno_fs::OpenOptions; +use deno_fs::open_options_with_access_check; use deno_path_util::PathToUrlError; use deno_permissions::PermissionCheckError; use deno_permissions::PermissionsContainer; -use deno_tls::rustls::RootCertStore; use deno_tls::Proxy; use deno_tls::RootCertStoreProvider; use deno_tls::TlsKey; use deno_tls::TlsKeys; use deno_tls::TlsKeysHolder; +use deno_tls::rustls::RootCertStore; pub use fs_fetch_handler::FsFetchHandler; -use http::header::HeaderName; -use http::header::HeaderValue; +use http::Extensions; +use http::Method; +use http::Uri; use http::header::ACCEPT; use http::header::ACCEPT_ENCODING; use http::header::AUTHORIZATION; use http::header::CONTENT_LENGTH; use http::header::HOST; +use http::header::HeaderName; +use http::header::HeaderValue; use http::header::PROXY_AUTHORIZATION; use http::header::RANGE; use http::header::USER_AGENT; -use http::Extensions; -use http::Method; -use http::Uri; -use http_body_util::combinators::BoxBody; use http_body_util::BodyExt; +use http_body_util::combinators::BoxBody; use hyper::body::Frame; +use hyper_util::client::legacy::Builder as HyperClientBuilder; use hyper_util::client::legacy::connect::HttpConnector; use hyper_util::client::legacy::connect::HttpInfo; -use hyper_util::client::legacy::Builder as HyperClientBuilder; use hyper_util::rt::TokioExecutor; use hyper_util::rt::TokioTimer; pub use proxy::basic_auth; use serde::Deserialize; use serde::Serialize; -use tower::retry; use tower::ServiceExt; +use tower::retry; use tower_http::decompression::Decompression; #[derive(Clone)] @@ -356,8 +356,8 @@ impl Stream for ResourceToBodyAdapter { cx: &mut Context<'_>, ) -> Poll> { let this = self.get_mut(); - if let Some(mut fut) = this.1.take() { - match fut.poll_unpin(cx) { + match this.1.take() { + Some(mut fut) => match fut.poll_unpin(cx) { Poll::Pending => { this.1 = Some(fut); Poll::Pending @@ -370,9 +370,8 @@ impl Stream for ResourceToBodyAdapter { } Err(err) => Poll::Ready(Some(Err(err))), }, - } - } else { - Poll::Ready(None) + }, + _ => Poll::Ready(None), } } } @@ -1129,7 +1128,9 @@ pub enum HttpClientCreateError { InvalidAddress(String), #[error("invalid proxy url")] InvalidProxyUrl, - #[error("Cannot create Http Client: either `http1` or `http2` needs to be set to true")] + #[error( + "Cannot create Http Client: either `http1` or `http2` needs to be set to true" + )] HttpVersionSelectionInvalid, #[class(inherit)] #[error(transparent)] @@ -1250,7 +1251,7 @@ pub fn create_http_client( } (true, true) => {} (false, false) => { - return Err(HttpClientCreateError::HttpVersionSelectionInvalid) + return Err(HttpClientCreateError::HttpVersionSelectionInvalid); } } @@ -1408,29 +1409,29 @@ impl hyper::body::Body for ReqBody { cx: &mut Context<'_>, ) -> Poll, Self::Error>>> { match &mut *self { - ReqBody::Full(ref mut b) => { + ReqBody::Full(b) => { Pin::new(b).poll_frame(cx).map_err(|never| match never {}) } - ReqBody::Empty(ref mut b) => { + ReqBody::Empty(b) => { Pin::new(b).poll_frame(cx).map_err(|never| match never {}) } - ReqBody::Streaming(ref mut b) => Pin::new(b).poll_frame(cx), + ReqBody::Streaming(b) => Pin::new(b).poll_frame(cx), } } fn is_end_stream(&self) -> bool { match self { - ReqBody::Full(ref b) => b.is_end_stream(), - ReqBody::Empty(ref b) => b.is_end_stream(), - ReqBody::Streaming(ref b) => b.is_end_stream(), + ReqBody::Full(b) => b.is_end_stream(), + ReqBody::Empty(b) => b.is_end_stream(), + ReqBody::Streaming(b) => b.is_end_stream(), } } fn size_hint(&self) -> hyper::body::SizeHint { match self { - ReqBody::Full(ref b) => b.size_hint(), - ReqBody::Empty(ref b) => b.size_hint(), - ReqBody::Streaming(ref b) => b.size_hint(), + ReqBody::Full(b) => b.size_hint(), + ReqBody::Empty(b) => b.size_hint(), + ReqBody::Streaming(b) => b.size_hint(), } } } diff --git a/ext/fetch/proxy.rs b/ext/fetch/proxy.rs index 498ffacb70..f7929001f7 100644 --- a/ext/fetch/proxy.rs +++ b/ext/fetch/proxy.rs @@ -15,9 +15,9 @@ use std::task::Poll; use deno_core::futures::TryFutureExt; use deno_tls::rustls::ClientConfig as TlsConfig; +use http::Uri; use http::header::HeaderValue; use http::uri::Scheme; -use http::Uri; use hyper_rustls::HttpsConnector; use hyper_rustls::MaybeHttpsStream; use hyper_util::client::legacy::connect::Connected; @@ -28,8 +28,8 @@ use percent_encoding::percent_decode_str; use tokio::net::TcpStream; #[cfg(not(windows))] use tokio::net::UnixStream; -use tokio_rustls::client::TlsStream; use tokio_rustls::TlsConnector; +use tokio_rustls::client::TlsStream; use tokio_socks::tcp::Socks5Stream; #[cfg(any(target_os = "linux", target_os = "macos"))] use tokio_vsock::VsockStream; @@ -94,25 +94,40 @@ enum Filter { pub(crate) fn from_env() -> Proxies { let mut intercepts = Vec::new(); - if let Some(proxy) = parse_env_var("ALL_PROXY", Filter::All) { - intercepts.push(proxy); - } else if let Some(proxy) = parse_env_var("all_proxy", Filter::All) { - intercepts.push(proxy); + match parse_env_var("ALL_PROXY", Filter::All) { + Some(proxy) => { + intercepts.push(proxy); + } + _ => { + if let Some(proxy) = parse_env_var("all_proxy", Filter::All) { + intercepts.push(proxy); + } + } } - if let Some(proxy) = parse_env_var("HTTPS_PROXY", Filter::Https) { - intercepts.push(proxy); - } else if let Some(proxy) = parse_env_var("https_proxy", Filter::Https) { - intercepts.push(proxy); + match parse_env_var("HTTPS_PROXY", Filter::Https) { + Some(proxy) => { + intercepts.push(proxy); + } + _ => { + if let Some(proxy) = parse_env_var("https_proxy", Filter::Https) { + intercepts.push(proxy); + } + } } // In a CGI context, headers become environment variables. So, "Proxy:" becomes HTTP_PROXY. // To prevent an attacker from injecting a proxy, check if we are in CGI. if env::var_os("REQUEST_METHOD").is_none() { - if let Some(proxy) = parse_env_var("HTTP_PROXY", Filter::Http) { - intercepts.push(proxy); - } else if let Some(proxy) = parse_env_var("http_proxy", Filter::Http) { - intercepts.push(proxy); + match parse_env_var("HTTP_PROXY", Filter::Http) { + Some(proxy) => { + intercepts.push(proxy); + } + _ => { + if let Some(proxy) = parse_env_var("http_proxy", Filter::Http) { + intercepts.push(proxy); + } + } } } @@ -796,9 +811,9 @@ where { fn connected(&self) -> Connected { match self { - Proxied::PassThrough(ref p) => p.connected(), - Proxied::HttpForward(ref p) => p.connected().proxy(true), - Proxied::HttpTunneled(ref p) => { + Proxied::PassThrough(p) => p.connected(), + Proxied::HttpForward(p) => p.connected().proxy(true), + Proxied::HttpTunneled(p) => { let tunneled_tls = p.inner().get_ref(); if tunneled_tls.1.alpn_protocol() == Some(b"h2") { tunneled_tls.0.connected().negotiated_h2() @@ -806,8 +821,8 @@ where tunneled_tls.0.connected() } } - Proxied::Socks(ref p) => p.connected(), - Proxied::SocksTls(ref p) => { + Proxied::Socks(p) => p.connected(), + Proxied::SocksTls(p) => { let tunneled_tls = p.inner().get_ref(); if tunneled_tls.1.alpn_protocol() == Some(b"h2") { tunneled_tls.0.connected().negotiated_h2() diff --git a/ext/fetch/tests.rs b/ext/fetch/tests.rs index e921eea8de..871c66e9fe 100644 --- a/ext/fetch/tests.rs +++ b/ext/fetch/tests.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. use std::net::SocketAddr; +use std::sync::Arc; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering::SeqCst; -use std::sync::Arc; use bytes::Bytes; use fast_socks5::server::Config as Socks5Config; @@ -12,8 +12,8 @@ use http_body_util::BodyExt; use tokio::io::AsyncReadExt; use tokio::io::AsyncWriteExt; -use super::create_http_client; use super::CreateHttpClientOptions; +use super::create_http_client; use crate::dns; static EXAMPLE_CRT: &[u8] = include_bytes!("../tls/testdata/example1_cert.der"); diff --git a/ext/ffi/call.rs b/ext/ffi/call.rs index d1fbcdd379..d006486a42 100644 --- a/ext/ffi/call.rs +++ b/ext/ffi/call.rs @@ -5,25 +5,25 @@ use std::ffi::c_void; use std::future::Future; use std::rc::Rc; +use deno_core::OpState; +use deno_core::ResourceId; use deno_core::op2; use deno_core::serde_json::Value; use deno_core::serde_v8::BigInt as V8BigInt; use deno_core::serde_v8::ExternalPointer; use deno_core::unsync::spawn_blocking; use deno_core::v8; -use deno_core::OpState; -use deno_core::ResourceId; use libffi::middle::Arg; use num_bigint::BigInt; use serde::Serialize; +use crate::FfiPermissions; +use crate::ForeignFunction; use crate::callback::PtrSymbol; use crate::dlfcn::DynamicLibraryResource; use crate::ir::*; use crate::symbol::NativeType; use crate::symbol::Symbol; -use crate::FfiPermissions; -use crate::ForeignFunction; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum CallError { @@ -54,12 +54,15 @@ unsafe fn ffi_call_rtype_struct( call_args: Vec, out_buffer: *mut u8, ) { - libffi::raw::ffi_call( - cif.as_raw_ptr(), - Some(*fn_ptr.as_safe_fun()), - out_buffer as *mut c_void, - call_args.as_ptr() as *mut *mut c_void, - ); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + libffi::raw::ffi_call( + cif.as_raw_ptr(), + Some(*fn_ptr.as_safe_fun()), + out_buffer as *mut c_void, + call_args.as_ptr() as *mut *mut c_void, + ); + } } // A one-off synchronous FFI call. @@ -304,7 +307,10 @@ pub fn op_ffi_call_ptr_nonblocking( #[serde] def: ForeignFunction, parameters: v8::Local, out_buffer: Option>, -) -> Result>, CallError> +) -> Result< + impl Future> + use, + CallError, +> where FP: FfiPermissions + 'static, { @@ -349,7 +355,8 @@ pub fn op_ffi_call_nonblocking( #[string] symbol: String, parameters: v8::Local, out_buffer: Option>, -) -> Result>, CallError> { +) -> Result> + use<>, CallError> +{ let symbol = { let state = state.borrow(); let resource = state.resource_table.get::(rid)?; diff --git a/ext/ffi/callback.rs b/ext/ffi/callback.rs index a6c104ef42..a76c0cc352 100644 --- a/ext/ffi/callback.rs +++ b/ext/ffi/callback.rs @@ -13,21 +13,21 @@ use std::sync::atomic; use std::sync::atomic::AtomicU32; use std::task::Poll; -use deno_core::op2; -use deno_core::v8; -use deno_core::v8::TryCatch; use deno_core::CancelFuture; use deno_core::CancelHandle; use deno_core::OpState; use deno_core::Resource; use deno_core::ResourceId; use deno_core::V8CrossThreadTaskSpawner; +use deno_core::op2; +use deno_core::v8; +use deno_core::v8::TryCatch; use libffi::middle::Cif; use serde::Deserialize; -use crate::symbol::NativeType; use crate::FfiPermissions; use crate::ForeignFunction; +use crate::symbol::NativeType; static THREAD_ID_COUNTER: AtomicU32 = AtomicU32::new(1); @@ -151,47 +151,50 @@ unsafe extern "C" fn deno_ffi_callback( args: *const *const c_void, info: &CallbackInfo, ) { - LOCAL_THREAD_ID.with(|s| { - if *s.borrow() == info.thread_id { - // Call from main thread. If this callback is being triggered due to a - // function call coming from Deno itself, then this callback will build - // ontop of that stack. - // If this callback is being triggered outside of Deno (for example from a - // signal handler) then this will either create an empty new stack if - // Deno currently has nothing running and is waiting for promises to resolve, - // or will (very incorrectly) build ontop of whatever stack exists. - // The callback will even be called through from a `while (true)` liveloop, but - // it somehow cannot change the values that the loop sees, even if they both - // refer the same `let bool_value`. - let context: NonNull = info.context; - let context = std::mem::transmute::< - NonNull, - v8::Local, - >(context); - let mut cb_scope = v8::CallbackScope::new(context); - let scope = &mut v8::HandleScope::new(&mut cb_scope); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + LOCAL_THREAD_ID.with(|s| { + if *s.borrow() == info.thread_id { + // Call from main thread. If this callback is being triggered due to a + // function call coming from Deno itself, then this callback will build + // ontop of that stack. + // If this callback is being triggered outside of Deno (for example from a + // signal handler) then this will either create an empty new stack if + // Deno currently has nothing running and is waiting for promises to resolve, + // or will (very incorrectly) build ontop of whatever stack exists. + // The callback will even be called through from a `while (true)` liveloop, but + // it somehow cannot change the values that the loop sees, even if they both + // refer the same `let bool_value`. + let context: NonNull = info.context; + let context = std::mem::transmute::< + NonNull, + v8::Local, + >(context); + let mut cb_scope = v8::CallbackScope::new(context); + let scope = &mut v8::HandleScope::new(&mut cb_scope); - do_ffi_callback(scope, cif, info, result, args); - } else { - let async_work_sender = &info.async_work_sender; + do_ffi_callback(scope, cif, info, result, args); + } else { + let async_work_sender = &info.async_work_sender; - let mut args = TaskArgs { - cif: NonNull::from(cif), - result: NonNull::from(result), - args, - info: NonNull::from(info), - }; + let mut args = TaskArgs { + cif: NonNull::from(cif), + result: NonNull::from(result), + args, + info: NonNull::from(info), + }; - async_work_sender.spawn_blocking(move |scope| { - // We don't have a lot of choice here, so just print an unhandled exception message - let tc_scope = &mut TryCatch::new(scope); - args.run(tc_scope); - if tc_scope.exception().is_some() { - log::error!("Illegal unhandled exception in nonblocking callback"); - } - }); - } - }); + async_work_sender.spawn_blocking(move |scope| { + // We don't have a lot of choice here, so just print an unhandled exception message + let tc_scope = &mut TryCatch::new(scope); + args.run(tc_scope); + if tc_scope.exception().is_some() { + log::error!("Illegal unhandled exception in nonblocking callback"); + } + }); + } + }); + } } unsafe fn do_ffi_callback( @@ -201,335 +204,348 @@ unsafe fn do_ffi_callback( result: &mut c_void, args: *const *const c_void, ) { - let callback: NonNull = info.callback; - let func = std::mem::transmute::< - NonNull, - v8::Local, - >(callback); - let result = result as *mut c_void; - let vals: &[*const c_void] = - std::slice::from_raw_parts(args, info.parameters.len()); - let arg_types = std::slice::from_raw_parts(cif.arg_types, cif.nargs as usize); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + let callback: NonNull = info.callback; + let func = std::mem::transmute::< + NonNull, + v8::Local, + >(callback); + let result = result as *mut c_void; + let vals: &[*const c_void] = + std::slice::from_raw_parts(args, info.parameters.len()); + let arg_types = + std::slice::from_raw_parts(cif.arg_types, cif.nargs as usize); - let mut params: Vec> = vec![]; - for ((index, native_type), val) in - info.parameters.iter().enumerate().zip(vals) - { - let value: v8::Local = match native_type { + let mut params: Vec> = vec![]; + for ((index, native_type), val) in + info.parameters.iter().enumerate().zip(vals) + { + let value: v8::Local = match native_type { + NativeType::Bool => { + let value = *((*val) as *const bool); + v8::Boolean::new(scope, value).into() + } + NativeType::F32 => { + let value = *((*val) as *const f32); + v8::Number::new(scope, value as f64).into() + } + NativeType::F64 => { + let value = *((*val) as *const f64); + v8::Number::new(scope, value).into() + } + NativeType::I8 => { + let value = *((*val) as *const i8); + v8::Integer::new(scope, value as i32).into() + } + NativeType::U8 => { + let value = *((*val) as *const u8); + v8::Integer::new_from_unsigned(scope, value as u32).into() + } + NativeType::I16 => { + let value = *((*val) as *const i16); + v8::Integer::new(scope, value as i32).into() + } + NativeType::U16 => { + let value = *((*val) as *const u16); + v8::Integer::new_from_unsigned(scope, value as u32).into() + } + NativeType::I32 => { + let value = *((*val) as *const i32); + v8::Integer::new(scope, value).into() + } + NativeType::U32 => { + let value = *((*val) as *const u32); + v8::Integer::new_from_unsigned(scope, value).into() + } + NativeType::I64 | NativeType::ISize => { + let result = *((*val) as *const i64); + v8::BigInt::new_from_i64(scope, result).into() + } + NativeType::U64 | NativeType::USize => { + let result = *((*val) as *const u64); + v8::BigInt::new_from_u64(scope, result).into() + } + NativeType::Pointer | NativeType::Buffer | NativeType::Function => { + let result = *((*val) as *const *mut c_void); + if result.is_null() { + v8::null(scope).into() + } else { + v8::External::new(scope, result).into() + } + } + NativeType::Struct(_) => { + let size = arg_types[index].as_ref().unwrap().size; + let ptr = (*val) as *const u8; + let slice = std::slice::from_raw_parts(ptr, size); + let boxed = Box::from(slice); + let store = + v8::ArrayBuffer::new_backing_store_from_boxed_slice(boxed); + let ab = + v8::ArrayBuffer::with_backing_store(scope, &store.make_shared()); + let local_value: v8::Local = + v8::Uint8Array::new(scope, ab, 0, ab.byte_length()) + .unwrap() + .into(); + local_value + } + NativeType::Void => unreachable!(), + }; + params.push(value); + } + + let recv = v8::undefined(scope); + let call_result = func.call(scope, recv.into(), ¶ms); + + if call_result.is_none() { + // JS function threw an exception. Set the return value to zero and return. + // The exception continue propagating up the call chain when the event loop + // resumes. + match info.result { + NativeType::Bool => { + *(result as *mut bool) = false; + } + NativeType::U32 | NativeType::I32 => { + // zero is equal for signed and unsigned alike + *(result as *mut u32) = 0; + } + NativeType::F32 => { + *(result as *mut f32) = 0.0; + } + NativeType::F64 => { + *(result as *mut f64) = 0.0; + } + NativeType::U8 | NativeType::I8 => { + // zero is equal for signed and unsigned alike + *(result as *mut u8) = 0; + } + NativeType::U16 | NativeType::I16 => { + // zero is equal for signed and unsigned alike + *(result as *mut u16) = 0; + } + NativeType::Pointer + | NativeType::Buffer + | NativeType::Function + | NativeType::U64 + | NativeType::I64 => { + *(result as *mut usize) = 0; + } + NativeType::Void => { + // nop + } + _ => { + unreachable!(); + } + }; + + return; + } + let value = call_result.unwrap(); + + match info.result { NativeType::Bool => { - let value = *((*val) as *const bool); - v8::Boolean::new(scope, value).into() + let value = if let Ok(value) = v8::Local::::try_from(value) + { + value.is_true() + } else { + value.boolean_value(scope) + }; + *(result as *mut bool) = value; } NativeType::F32 => { - let value = *((*val) as *const f32); - v8::Number::new(scope, value as f64).into() + let value = if let Ok(value) = v8::Local::::try_from(value) + { + value.value() as f32 + } else { + // Fallthrough, probably UB. + value + .number_value(scope) + .expect("Unable to deserialize result parameter.") as f32 + }; + *(result as *mut f32) = value; } NativeType::F64 => { - let value = *((*val) as *const f64); - v8::Number::new(scope, value).into() + let value = if let Ok(value) = v8::Local::::try_from(value) + { + value.value() + } else { + // Fallthrough, probably UB. + value + .number_value(scope) + .expect("Unable to deserialize result parameter.") + }; + *(result as *mut f64) = value; + } + NativeType::Buffer => { + let pointer: *mut u8 = if let Ok(value) = + v8::Local::::try_from(value) + { + let byte_offset = value.byte_offset(); + let pointer = value + .buffer(scope) + .expect("Unable to deserialize result parameter.") + .data(); + if let Some(non_null) = pointer { + // SAFETY: Pointer is non-null, and V8 guarantees that the byte_offset + // is within the buffer backing store. + non_null.as_ptr().add(byte_offset) as *mut u8 + } else { + ptr::null_mut() + } + } else if let Ok(value) = v8::Local::::try_from(value) + { + let pointer = value.data(); + if let Some(non_null) = pointer { + non_null.as_ptr() as *mut u8 + } else { + ptr::null_mut() + } + } else { + ptr::null_mut() + }; + *(result as *mut *mut u8) = pointer; + } + NativeType::Pointer | NativeType::Function => { + let pointer: *mut c_void = + if let Ok(external) = v8::Local::::try_from(value) { + external.value() + } else { + // TODO(@aapoalas): Start throwing errors into JS about invalid callback return values. + ptr::null_mut() + }; + *(result as *mut *mut c_void) = pointer; } NativeType::I8 => { - let value = *((*val) as *const i8); - v8::Integer::new(scope, value as i32).into() + let value = if let Ok(value) = v8::Local::::try_from(value) { + value.value() as i8 + } else { + // Fallthrough, essentially UB. + value + .int32_value(scope) + .expect("Unable to deserialize result parameter.") as i8 + }; + *(result as *mut i8) = value; } NativeType::U8 => { - let value = *((*val) as *const u8); - v8::Integer::new_from_unsigned(scope, value as u32).into() + let value = if let Ok(value) = v8::Local::::try_from(value) + { + value.value() as u8 + } else { + // Fallthrough, essentially UB. + value + .uint32_value(scope) + .expect("Unable to deserialize result parameter.") as u8 + }; + *(result as *mut u8) = value; } NativeType::I16 => { - let value = *((*val) as *const i16); - v8::Integer::new(scope, value as i32).into() + let value = if let Ok(value) = v8::Local::::try_from(value) { + value.value() as i16 + } else { + // Fallthrough, essentially UB. + value + .int32_value(scope) + .expect("Unable to deserialize result parameter.") as i16 + }; + *(result as *mut i16) = value; } NativeType::U16 => { - let value = *((*val) as *const u16); - v8::Integer::new_from_unsigned(scope, value as u32).into() + let value = if let Ok(value) = v8::Local::::try_from(value) + { + value.value() as u16 + } else { + // Fallthrough, essentially UB. + value + .uint32_value(scope) + .expect("Unable to deserialize result parameter.") as u16 + }; + *(result as *mut u16) = value; } NativeType::I32 => { - let value = *((*val) as *const i32); - v8::Integer::new(scope, value).into() + let value = if let Ok(value) = v8::Local::::try_from(value) { + value.value() + } else { + // Fallthrough, essentially UB. + value + .int32_value(scope) + .expect("Unable to deserialize result parameter.") + }; + *(result as *mut i32) = value; } NativeType::U32 => { - let value = *((*val) as *const u32); - v8::Integer::new_from_unsigned(scope, value).into() + let value = if let Ok(value) = v8::Local::::try_from(value) + { + value.value() + } else { + // Fallthrough, essentially UB. + value + .uint32_value(scope) + .expect("Unable to deserialize result parameter.") + }; + *(result as *mut u32) = value; } NativeType::I64 | NativeType::ISize => { - let result = *((*val) as *const i64); - v8::BigInt::new_from_i64(scope, result).into() + if let Ok(value) = v8::Local::::try_from(value) { + *(result as *mut i64) = value.i64_value().0; + } else if let Ok(value) = v8::Local::::try_from(value) { + *(result as *mut i64) = value.value() as i64; + } else if let Ok(value) = v8::Local::::try_from(value) { + *(result as *mut i64) = value.value() as i64; + } else { + *(result as *mut i64) = value + .integer_value(scope) + .expect("Unable to deserialize result parameter."); + } } NativeType::U64 | NativeType::USize => { - let result = *((*val) as *const u64); - v8::BigInt::new_from_u64(scope, result).into() - } - NativeType::Pointer | NativeType::Buffer | NativeType::Function => { - let result = *((*val) as *const *mut c_void); - if result.is_null() { - v8::null(scope).into() + if let Ok(value) = v8::Local::::try_from(value) { + *(result as *mut u64) = value.u64_value().0; + } else if let Ok(value) = v8::Local::::try_from(value) { + *(result as *mut u64) = value.value() as u64; + } else if let Ok(value) = v8::Local::::try_from(value) { + *(result as *mut u64) = value.value() as u64; } else { - v8::External::new(scope, result).into() + *(result as *mut u64) = value + .integer_value(scope) + .expect("Unable to deserialize result parameter.") + as u64; } } NativeType::Struct(_) => { - let size = arg_types[index].as_ref().unwrap().size; - let ptr = (*val) as *const u8; - let slice = std::slice::from_raw_parts(ptr, size); - let boxed = Box::from(slice); - let store = v8::ArrayBuffer::new_backing_store_from_boxed_slice(boxed); - let ab = - v8::ArrayBuffer::with_backing_store(scope, &store.make_shared()); - let local_value: v8::Local = - v8::Uint8Array::new(scope, ab, 0, ab.byte_length()) - .unwrap() - .into(); - local_value - } - NativeType::Void => unreachable!(), - }; - params.push(value); - } - - let recv = v8::undefined(scope); - let call_result = func.call(scope, recv.into(), ¶ms); - - if call_result.is_none() { - // JS function threw an exception. Set the return value to zero and return. - // The exception continue propagating up the call chain when the event loop - // resumes. - match info.result { - NativeType::Bool => { - *(result as *mut bool) = false; - } - NativeType::U32 | NativeType::I32 => { - // zero is equal for signed and unsigned alike - *(result as *mut u32) = 0; - } - NativeType::F32 => { - *(result as *mut f32) = 0.0; - } - NativeType::F64 => { - *(result as *mut f64) = 0.0; - } - NativeType::U8 | NativeType::I8 => { - // zero is equal for signed and unsigned alike - *(result as *mut u8) = 0; - } - NativeType::U16 | NativeType::I16 => { - // zero is equal for signed and unsigned alike - *(result as *mut u16) = 0; - } - NativeType::Pointer - | NativeType::Buffer - | NativeType::Function - | NativeType::U64 - | NativeType::I64 => { - *(result as *mut usize) = 0; + let size; + let pointer = if let Ok(value) = + v8::Local::::try_from(value) + { + let byte_offset = value.byte_offset(); + let ab = value + .buffer(scope) + .expect("Unable to deserialize result parameter."); + size = value.byte_length(); + ab.data() + .expect("Unable to deserialize result parameter.") + .as_ptr() + .add(byte_offset) + } else if let Ok(value) = v8::Local::::try_from(value) + { + size = value.byte_length(); + value + .data() + .expect("Unable to deserialize result parameter.") + .as_ptr() + } else { + panic!("Unable to deserialize result parameter."); + }; + std::ptr::copy_nonoverlapping( + pointer as *mut u8, + result as *mut u8, + std::cmp::min(size, (*cif.rtype).size), + ); } NativeType::Void => { // nop } - _ => { - unreachable!(); - } }; - - return; } - let value = call_result.unwrap(); - - match info.result { - NativeType::Bool => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.is_true() - } else { - value.boolean_value(scope) - }; - *(result as *mut bool) = value; - } - NativeType::F32 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() as f32 - } else { - // Fallthrough, probably UB. - value - .number_value(scope) - .expect("Unable to deserialize result parameter.") as f32 - }; - *(result as *mut f32) = value; - } - NativeType::F64 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() - } else { - // Fallthrough, probably UB. - value - .number_value(scope) - .expect("Unable to deserialize result parameter.") - }; - *(result as *mut f64) = value; - } - NativeType::Buffer => { - let pointer: *mut u8 = if let Ok(value) = - v8::Local::::try_from(value) - { - let byte_offset = value.byte_offset(); - let pointer = value - .buffer(scope) - .expect("Unable to deserialize result parameter.") - .data(); - if let Some(non_null) = pointer { - // SAFETY: Pointer is non-null, and V8 guarantees that the byte_offset - // is within the buffer backing store. - unsafe { non_null.as_ptr().add(byte_offset) as *mut u8 } - } else { - ptr::null_mut() - } - } else if let Ok(value) = v8::Local::::try_from(value) { - let pointer = value.data(); - if let Some(non_null) = pointer { - non_null.as_ptr() as *mut u8 - } else { - ptr::null_mut() - } - } else { - ptr::null_mut() - }; - *(result as *mut *mut u8) = pointer; - } - NativeType::Pointer | NativeType::Function => { - let pointer: *mut c_void = - if let Ok(external) = v8::Local::::try_from(value) { - external.value() - } else { - // TODO(@aapoalas): Start throwing errors into JS about invalid callback return values. - ptr::null_mut() - }; - *(result as *mut *mut c_void) = pointer; - } - NativeType::I8 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() as i8 - } else { - // Fallthrough, essentially UB. - value - .int32_value(scope) - .expect("Unable to deserialize result parameter.") as i8 - }; - *(result as *mut i8) = value; - } - NativeType::U8 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() as u8 - } else { - // Fallthrough, essentially UB. - value - .uint32_value(scope) - .expect("Unable to deserialize result parameter.") as u8 - }; - *(result as *mut u8) = value; - } - NativeType::I16 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() as i16 - } else { - // Fallthrough, essentially UB. - value - .int32_value(scope) - .expect("Unable to deserialize result parameter.") as i16 - }; - *(result as *mut i16) = value; - } - NativeType::U16 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() as u16 - } else { - // Fallthrough, essentially UB. - value - .uint32_value(scope) - .expect("Unable to deserialize result parameter.") as u16 - }; - *(result as *mut u16) = value; - } - NativeType::I32 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() - } else { - // Fallthrough, essentially UB. - value - .int32_value(scope) - .expect("Unable to deserialize result parameter.") - }; - *(result as *mut i32) = value; - } - NativeType::U32 => { - let value = if let Ok(value) = v8::Local::::try_from(value) { - value.value() - } else { - // Fallthrough, essentially UB. - value - .uint32_value(scope) - .expect("Unable to deserialize result parameter.") - }; - *(result as *mut u32) = value; - } - NativeType::I64 | NativeType::ISize => { - if let Ok(value) = v8::Local::::try_from(value) { - *(result as *mut i64) = value.i64_value().0; - } else if let Ok(value) = v8::Local::::try_from(value) { - *(result as *mut i64) = value.value() as i64; - } else if let Ok(value) = v8::Local::::try_from(value) { - *(result as *mut i64) = value.value() as i64; - } else { - *(result as *mut i64) = value - .integer_value(scope) - .expect("Unable to deserialize result parameter."); - } - } - NativeType::U64 | NativeType::USize => { - if let Ok(value) = v8::Local::::try_from(value) { - *(result as *mut u64) = value.u64_value().0; - } else if let Ok(value) = v8::Local::::try_from(value) { - *(result as *mut u64) = value.value() as u64; - } else if let Ok(value) = v8::Local::::try_from(value) { - *(result as *mut u64) = value.value() as u64; - } else { - *(result as *mut u64) = value - .integer_value(scope) - .expect("Unable to deserialize result parameter.") - as u64; - } - } - NativeType::Struct(_) => { - let size; - let pointer = if let Ok(value) = - v8::Local::::try_from(value) - { - let byte_offset = value.byte_offset(); - let ab = value - .buffer(scope) - .expect("Unable to deserialize result parameter."); - size = value.byte_length(); - ab.data() - .expect("Unable to deserialize result parameter.") - .as_ptr() - .add(byte_offset) - } else if let Ok(value) = v8::Local::::try_from(value) { - size = value.byte_length(); - value - .data() - .expect("Unable to deserialize result parameter.") - .as_ptr() - } else { - panic!("Unable to deserialize result parameter."); - }; - std::ptr::copy_nonoverlapping( - pointer as *mut u8, - result as *mut u8, - std::cmp::min(size, (*cif.rtype).size), - ); - } - NativeType::Void => { - // nop - } - }; } #[op2(async)] diff --git a/ext/ffi/dlfcn.rs b/ext/ffi/dlfcn.rs index 5a02961631..9f26432b97 100644 --- a/ext/ffi/dlfcn.rs +++ b/ext/ffi/dlfcn.rs @@ -6,11 +6,11 @@ use std::collections::HashMap; use std::ffi::c_void; use std::rc::Rc; -use deno_core::op2; -use deno_core::v8; use deno_core::GarbageCollected; use deno_core::OpState; use deno_core::Resource; +use deno_core::op2; +use deno_core::v8; use deno_error::JsErrorBox; use deno_error::JsErrorClass; use denort_helper::DenoRtNativeAddonLoaderRc; @@ -18,12 +18,12 @@ use dlopen2::raw::Library; use serde::Deserialize; use serde_value::ValueDeserializer; +use crate::FfiPermissions; use crate::ir::out_buffer_as_ptr; use crate::symbol::NativeType; use crate::symbol::Symbol; use crate::turbocall; use crate::turbocall::Turbocall; -use crate::FfiPermissions; deno_error::js_error_wrapper!(dlopen2::Error, JsDlopen2Error, |err| { match err { @@ -129,13 +129,14 @@ impl<'de> Deserialize<'de> for ForeignSymbol { let value = serde_value::Value::deserialize(deserializer)?; // Probe a ForeignStatic and if that doesn't match, assume ForeignFunction to improve error messages - if let Ok(res) = ForeignStatic::deserialize( - ValueDeserializer::::new(value.clone()), - ) { - Ok(ForeignSymbol::ForeignStatic(res)) - } else { - ForeignFunction::deserialize(ValueDeserializer::::new(value)) - .map(ForeignSymbol::ForeignFunction) + match ForeignStatic::deserialize(ValueDeserializer::::new( + value.clone(), + )) { + Ok(res) => Ok(ForeignSymbol::ForeignStatic(res)), + _ => { + ForeignFunction::deserialize(ValueDeserializer::::new(value)) + .map(ForeignSymbol::ForeignFunction) + } } } } @@ -361,9 +362,9 @@ pub(crate) fn format_error( use winapi::shared::minwindef::DWORD; use winapi::shared::winerror::ERROR_INSUFFICIENT_BUFFER; use winapi::um::errhandlingapi::GetLastError; - use winapi::um::winbase::FormatMessageW; use winapi::um::winbase::FORMAT_MESSAGE_ARGUMENT_ARRAY; use winapi::um::winbase::FORMAT_MESSAGE_FROM_SYSTEM; + use winapi::um::winbase::FormatMessageW; use winapi::um::winnt::LANG_SYSTEM_DEFAULT; use winapi::um::winnt::MAKELANGID; use winapi::um::winnt::SUBLANG_SYS_DEFAULT; diff --git a/ext/ffi/ir.rs b/ext/ffi/ir.rs index 21af3ddb2e..cea1d5bcca 100644 --- a/ext/ffi/ir.rs +++ b/ext/ffi/ir.rs @@ -98,25 +98,28 @@ pub union NativeValue { impl NativeValue { pub unsafe fn as_arg(&self, native_type: &NativeType) -> Arg { - match native_type { - NativeType::Void => unreachable!(), - NativeType::Bool => Arg::new(&self.bool_value), - NativeType::U8 => Arg::new(&self.u8_value), - NativeType::I8 => Arg::new(&self.i8_value), - NativeType::U16 => Arg::new(&self.u16_value), - NativeType::I16 => Arg::new(&self.i16_value), - NativeType::U32 => Arg::new(&self.u32_value), - NativeType::I32 => Arg::new(&self.i32_value), - NativeType::U64 => Arg::new(&self.u64_value), - NativeType::I64 => Arg::new(&self.i64_value), - NativeType::USize => Arg::new(&self.usize_value), - NativeType::ISize => Arg::new(&self.isize_value), - NativeType::F32 => Arg::new(&self.f32_value), - NativeType::F64 => Arg::new(&self.f64_value), - NativeType::Pointer | NativeType::Buffer | NativeType::Function => { - Arg::new(&self.pointer) + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + match native_type { + NativeType::Void => unreachable!(), + NativeType::Bool => Arg::new(&self.bool_value), + NativeType::U8 => Arg::new(&self.u8_value), + NativeType::I8 => Arg::new(&self.i8_value), + NativeType::U16 => Arg::new(&self.u16_value), + NativeType::I16 => Arg::new(&self.i16_value), + NativeType::U32 => Arg::new(&self.u32_value), + NativeType::I32 => Arg::new(&self.i32_value), + NativeType::U64 => Arg::new(&self.u64_value), + NativeType::I64 => Arg::new(&self.i64_value), + NativeType::USize => Arg::new(&self.usize_value), + NativeType::ISize => Arg::new(&self.isize_value), + NativeType::F32 => Arg::new(&self.f32_value), + NativeType::F64 => Arg::new(&self.f64_value), + NativeType::Pointer | NativeType::Buffer | NativeType::Function => { + Arg::new(&self.pointer) + } + NativeType::Struct(_) => Arg::new(&*self.pointer), } - NativeType::Struct(_) => Arg::new(&*self.pointer), } } @@ -127,40 +130,49 @@ impl NativeValue { scope: &mut v8::HandleScope<'scope>, native_type: NativeType, ) -> v8::Local<'scope, v8::Value> { - match native_type { - NativeType::Void => v8::undefined(scope).into(), - NativeType::Bool => v8::Boolean::new(scope, self.bool_value).into(), - NativeType::U8 => { - v8::Integer::new_from_unsigned(scope, self.u8_value as u32).into() + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + match native_type { + NativeType::Void => v8::undefined(scope).into(), + NativeType::Bool => v8::Boolean::new(scope, self.bool_value).into(), + NativeType::U8 => { + v8::Integer::new_from_unsigned(scope, self.u8_value as u32).into() + } + NativeType::I8 => v8::Integer::new(scope, self.i8_value as i32).into(), + NativeType::U16 => { + v8::Integer::new_from_unsigned(scope, self.u16_value as u32).into() + } + NativeType::I16 => { + v8::Integer::new(scope, self.i16_value as i32).into() + } + NativeType::U32 => { + v8::Integer::new_from_unsigned(scope, self.u32_value).into() + } + NativeType::I32 => v8::Integer::new(scope, self.i32_value).into(), + NativeType::U64 => { + v8::BigInt::new_from_u64(scope, self.u64_value).into() + } + NativeType::I64 => { + v8::BigInt::new_from_i64(scope, self.i64_value).into() + } + NativeType::USize => { + v8::BigInt::new_from_u64(scope, self.usize_value as u64).into() + } + NativeType::ISize => { + v8::BigInt::new_from_i64(scope, self.isize_value as i64).into() + } + NativeType::F32 => v8::Number::new(scope, self.f32_value as f64).into(), + NativeType::F64 => v8::Number::new(scope, self.f64_value).into(), + NativeType::Pointer | NativeType::Buffer | NativeType::Function => { + let local_value: v8::Local = if self.pointer.is_null() { + v8::null(scope).into() + } else { + v8::External::new(scope, self.pointer).into() + }; + local_value + } + NativeType::Struct(_) => v8::null(scope).into(), } - NativeType::I8 => v8::Integer::new(scope, self.i8_value as i32).into(), - NativeType::U16 => { - v8::Integer::new_from_unsigned(scope, self.u16_value as u32).into() - } - NativeType::I16 => v8::Integer::new(scope, self.i16_value as i32).into(), - NativeType::U32 => { - v8::Integer::new_from_unsigned(scope, self.u32_value).into() - } - NativeType::I32 => v8::Integer::new(scope, self.i32_value).into(), - NativeType::U64 => v8::BigInt::new_from_u64(scope, self.u64_value).into(), - NativeType::I64 => v8::BigInt::new_from_i64(scope, self.i64_value).into(), - NativeType::USize => { - v8::BigInt::new_from_u64(scope, self.usize_value as u64).into() - } - NativeType::ISize => { - v8::BigInt::new_from_i64(scope, self.isize_value as i64).into() - } - NativeType::F32 => v8::Number::new(scope, self.f32_value as f64).into(), - NativeType::F64 => v8::Number::new(scope, self.f64_value).into(), - NativeType::Pointer | NativeType::Buffer | NativeType::Function => { - let local_value: v8::Local = if self.pointer.is_null() { - v8::null(scope).into() - } else { - v8::External::new(scope, self.pointer).into() - }; - local_value - } - NativeType::Struct(_) => v8::null(scope).into(), } } } diff --git a/ext/ffi/lib.rs b/ext/ffi/lib.rs index cfaf57118b..1130486617 100644 --- a/ext/ffi/lib.rs +++ b/ext/ffi/lib.rs @@ -14,25 +14,25 @@ mod r#static; mod symbol; mod turbocall; +pub use call::CallError; use call::op_ffi_call_nonblocking; use call::op_ffi_call_ptr; use call::op_ffi_call_ptr_nonblocking; -pub use call::CallError; +pub use callback::CallbackError; use callback::op_ffi_unsafe_callback_close; use callback::op_ffi_unsafe_callback_create; use callback::op_ffi_unsafe_callback_ref; -pub use callback::CallbackError; use deno_permissions::PermissionCheckError; pub use denort_helper::DenoRtNativeAddonLoader; pub use denort_helper::DenoRtNativeAddonLoaderRc; -use dlfcn::op_ffi_load; pub use dlfcn::DlfcnError; use dlfcn::ForeignFunction; +use dlfcn::op_ffi_load; pub use ir::IRError; -use r#static::op_ffi_get_static; -pub use r#static::StaticError; pub use repr::ReprError; use repr::*; +pub use r#static::StaticError; +use r#static::op_ffi_get_static; use symbol::NativeType; use symbol::Symbol; diff --git a/ext/ffi/repr.rs b/ext/ffi/repr.rs index 90cec9f477..e1f4fd6acd 100644 --- a/ext/ffi/repr.rs +++ b/ext/ffi/repr.rs @@ -1,13 +1,13 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use std::ffi::CStr; use std::ffi::c_char; use std::ffi::c_void; -use std::ffi::CStr; use std::ptr; +use deno_core::OpState; use deno_core::op2; use deno_core::v8; -use deno_core::OpState; use crate::FfiPermissions; diff --git a/ext/ffi/static.rs b/ext/ffi/static.rs index 6d999430e3..6edbaa5beb 100644 --- a/ext/ffi/static.rs +++ b/ext/ffi/static.rs @@ -2,10 +2,10 @@ use std::ptr; -use deno_core::op2; -use deno_core::v8; use deno_core::OpState; use deno_core::ResourceId; +use deno_core::op2; +use deno_core::v8; use crate::dlfcn::DynamicLibraryResource; use crate::symbol::NativeType; diff --git a/ext/ffi/symbol.rs b/ext/ffi/symbol.rs index 2fe17ccac5..348db6c30c 100644 --- a/ext/ffi/symbol.rs +++ b/ext/ffi/symbol.rs @@ -57,7 +57,7 @@ impl TryFrom for libffi::middle::Type { false => { return Err(JsErrorBox::type_error( "Struct must have at least one field", - )) + )); } }) } diff --git a/ext/ffi/turbocall.rs b/ext/ffi/turbocall.rs index 1bce0f9d8c..49e7e933e4 100644 --- a/ext/ffi/turbocall.rs +++ b/ext/ffi/turbocall.rs @@ -396,10 +396,13 @@ extern "C" fn turbocall_ab_contents( unsafe extern "C" fn turbocall_raise( options: *const deno_core::v8::fast_api::FastApiCallbackOptions, ) { - let mut scope = deno_core::v8::CallbackScope::new(&*options); - let exception = deno_core::error::to_v8_error( - &mut scope, - &crate::IRError::InvalidBufferType, - ); - scope.throw_exception(exception); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + let mut scope = deno_core::v8::CallbackScope::new(&*options); + let exception = deno_core::error::to_v8_error( + &mut scope, + &crate::IRError::InvalidBufferType, + ); + scope.throw_exception(exception); + } } diff --git a/ext/fs/lib.rs b/ext/fs/lib.rs index f1926dd6bc..94c926abee 100644 --- a/ext/fs/lib.rs +++ b/ext/fs/lib.rs @@ -24,8 +24,8 @@ pub use crate::ops::FsOpsError; pub use crate::ops::FsOpsErrorKind; pub use crate::ops::OperationError; use crate::ops::*; -pub use crate::std_fs::open_options_with_access_check; pub use crate::std_fs::RealFs; +pub use crate::std_fs::open_options_with_access_check; pub use crate::sync::MaybeSend; pub use crate::sync::MaybeSync; diff --git a/ext/fs/ops.rs b/ext/fs/ops.rs index 1b1d9f1f43..bec8cdadb6 100644 --- a/ext/fs/ops.rs +++ b/ext/fs/ops.rs @@ -12,8 +12,6 @@ use std::path::StripPrefixError; use std::rc::Rc; use boxed_error::Boxed; -use deno_core::error::ResourceError; -use deno_core::op2; use deno_core::CancelFuture; use deno_core::CancelHandle; use deno_core::FastString; @@ -21,22 +19,24 @@ use deno_core::JsBuffer; use deno_core::OpState; use deno_core::ResourceId; use deno_core::ToJsBuffer; +use deno_core::error::ResourceError; +use deno_core::op2; use deno_error::JsErrorBox; use deno_io::fs::FileResource; use deno_io::fs::FsError; use deno_io::fs::FsStat; use deno_permissions::PermissionCheckError; +use rand::Rng; use rand::rngs::ThreadRng; use rand::thread_rng; -use rand::Rng; use serde::Serialize; +use crate::FsPermissions; +use crate::OpenOptions; use crate::interface::AccessCheckFn; use crate::interface::FileSystemRc; use crate::interface::FsDirEntry; use crate::interface::FsFileType; -use crate::FsPermissions; -use crate::OpenOptions; #[derive(Debug, Boxed, deno_error::JsError)] pub struct FsOpsError(pub Box); @@ -109,7 +109,9 @@ impl From for FsOpsError { fn print_not_capable_info(standalone: bool, err: &'static str) -> String { if standalone { - format!("specify the required permissions during compilation using `deno compile --allow-{err}`") + format!( + "specify the required permissions during compilation using `deno compile --allow-{err}`" + ) } else { format!("run again with the --allow-{err} flag") } @@ -1292,7 +1294,7 @@ fn tmp_name( // before hitting a 50% chance. We also base32-encode this value so the entire // thing is 1) case insensitive and 2) slightly shorter than the equivalent hex // value. - let unique = rng.gen::(); + let unique = rng.r#gen::(); base32::encode(base32::Alphabet::Crockford, &unique.to_le_bytes()); let path = dir.join(format!("{prefix}{unique:08x}{suffix}")); diff --git a/ext/fs/std_fs.rs b/ext/fs/std_fs.rs index 673f620665..8b1166e342 100644 --- a/ext/fs/std_fs.rs +++ b/ext/fs/std_fs.rs @@ -13,20 +13,20 @@ use std::path::PathBuf; use std::rc::Rc; use deno_core::unsync::spawn_blocking; +use deno_io::StdFileResourceInner; use deno_io::fs::File; use deno_io::fs::FsError; use deno_io::fs::FsResult; use deno_io::fs::FsStat; -use deno_io::StdFileResourceInner; use deno_path_util::normalize_path; +use crate::FileSystem; +use crate::GetPath; +use crate::OpenOptions; use crate::interface::AccessCheckCb; use crate::interface::CheckedPath; use crate::interface::FsDirEntry; use crate::interface::FsFileType; -use crate::FileSystem; -use crate::GetPath; -use crate::OpenOptions; #[derive(Debug, Default, Clone)] pub struct RealFs; @@ -55,9 +55,9 @@ impl FileSystem for RealFs { #[cfg(unix)] fn umask(&self, mask: Option) -> FsResult { + use nix::sys::stat::Mode; use nix::sys::stat::mode_t; use nix::sys::stat::umask; - use nix::sys::stat::Mode; let r = if let Some(mask) = mask { // If mask provided, return previous. umask(Mode::from_bits_truncate(mask as mode_t)) @@ -450,9 +450,9 @@ fn chmod(path: &Path, _mode: u32) -> FsResult<()> { #[cfg(unix)] fn chown(path: &Path, uid: Option, gid: Option) -> FsResult<()> { - use nix::unistd::chown; use nix::unistd::Gid; use nix::unistd::Uid; + use nix::unistd::chown; let owner = uid.map(Uid::from_raw); let group = gid.map(Gid::from_raw); let res = chown(path, owner, group); @@ -838,20 +838,23 @@ fn stat_extra(file: &std::fs::File, fsstat: &mut FsStat) -> FsResult<()> { handle: winapi::shared::ntdef::HANDLE, ) -> std::io::Result { use winapi::shared::minwindef::FALSE; - use winapi::um::fileapi::GetFileInformationByHandle; use winapi::um::fileapi::BY_HANDLE_FILE_INFORMATION; + use winapi::um::fileapi::GetFileInformationByHandle; - let info = { - let mut info = - std::mem::MaybeUninit::::zeroed(); - if GetFileInformationByHandle(handle, info.as_mut_ptr()) == FALSE { - return Err(std::io::Error::last_os_error()); - } + // SAFETY: winapi calls + unsafe { + let info = { + let mut info = + std::mem::MaybeUninit::::zeroed(); + if GetFileInformationByHandle(handle, info.as_mut_ptr()) == FALSE { + return Err(std::io::Error::last_os_error()); + } - info.assume_init() - }; + info.assume_init() + }; - Ok(info.dwVolumeSerialNumber as u64) + Ok(info.dwVolumeSerialNumber as u64) + } } const WINDOWS_TICK: i64 = 10_000; // 100-nanosecond intervals in a millisecond @@ -869,34 +872,37 @@ fn stat_extra(file: &std::fs::File, fsstat: &mut FsStat) -> FsResult<()> { handle: winapi::shared::ntdef::HANDLE, ) -> Result { use windows_sys::Wdk::Storage::FileSystem::NtQueryInformationFile; - use windows_sys::Win32::Foundation::RtlNtStatusToDosError; use windows_sys::Win32::Foundation::ERROR_MORE_DATA; + use windows_sys::Win32::Foundation::RtlNtStatusToDosError; use windows_sys::Win32::System::IO::IO_STATUS_BLOCK; - let mut info = std::mem::MaybeUninit::::zeroed(); - let mut io_status_block = - std::mem::MaybeUninit::::zeroed(); - let status = NtQueryInformationFile( - handle as _, - io_status_block.as_mut_ptr(), - info.as_mut_ptr() as *mut _, - std::mem::size_of::() as _, - 18, /* FileAllInformation */ - ); + // SAFETY: winapi calls + unsafe { + let mut info = std::mem::MaybeUninit::::zeroed(); + let mut io_status_block = + std::mem::MaybeUninit::::zeroed(); + let status = NtQueryInformationFile( + handle as _, + io_status_block.as_mut_ptr(), + info.as_mut_ptr() as *mut _, + std::mem::size_of::() as _, + 18, /* FileAllInformation */ + ); - if status < 0 { - let converted_status = RtlNtStatusToDosError(status); + if status < 0 { + let converted_status = RtlNtStatusToDosError(status); - // If error more data is returned, then it means that the buffer is too small to get full filename information - // to have that we should retry. However, since we only use BasicInformation and StandardInformation, it is fine to ignore it - // since struct is populated with other data anyway. - // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/nf-ntifs-ntqueryinformationfile#remarksdd - if converted_status != ERROR_MORE_DATA { - return Err(converted_status as NTSTATUS); + // If error more data is returned, then it means that the buffer is too small to get full filename information + // to have that we should retry. However, since we only use BasicInformation and StandardInformation, it is fine to ignore it + // since struct is populated with other data anyway. + // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/nf-ntifs-ntqueryinformationfile#remarksdd + if converted_status != ERROR_MORE_DATA { + return Err(converted_status as NTSTATUS); + } } - } - Ok(info.assume_init()) + Ok(info.assume_init()) + } } // SAFETY: winapi calls @@ -949,8 +955,8 @@ fn stat_extra(file: &std::fs::File, fsstat: &mut FsStat) -> FsResult<()> { fn exists(path: &Path) -> bool { #[cfg(unix)] { - use nix::unistd::access; use nix::unistd::AccessFlags; + use nix::unistd::access; access(path, AccessFlags::F_OK).is_ok() } @@ -1041,7 +1047,7 @@ fn symlink( return Err(FsError::Io(io::Error::new( io::ErrorKind::InvalidInput, "On Windows an `options` argument is required if the target does not exist", - ))) + ))); } Err(err) => return Err(err.into()), } diff --git a/ext/http/benches/compressible.rs b/ext/http/benches/compressible.rs index 96b21512ba..b2515b1870 100644 --- a/ext/http/benches/compressible.rs +++ b/ext/http/benches/compressible.rs @@ -1,7 +1,7 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use bencher::Bencher; use bencher::benchmark_group; use bencher::benchmark_main; -use bencher::Bencher; use deno_http::compressible::is_content_compressible; fn compressible_simple_hit(b: &mut Bencher) { diff --git a/ext/http/fly_accept_encoding.rs b/ext/http/fly_accept_encoding.rs index 1be864fd3b..247bd57ce1 100644 --- a/ext/http/fly_accept_encoding.rs +++ b/ext/http/fly_accept_encoding.rs @@ -124,9 +124,9 @@ fn encodings_iter_inner<'s>( #[cfg(test)] mod tests { - use http_v02::header::ACCEPT_ENCODING; use http_v02::HeaderMap; use http_v02::HeaderValue; + use http_v02::header::ACCEPT_ENCODING; use super::*; diff --git a/ext/http/http_next.rs b/ext/http/http_next.rs index c2e53d6a63..063290744f 100644 --- a/ext/http/http_next.rs +++ b/ext/http/http_next.rs @@ -2,21 +2,14 @@ use std::borrow::Cow; use std::cell::RefCell; use std::ffi::c_void; -use std::future::poll_fn; use std::future::Future; +use std::future::poll_fn; use std::io; use std::pin::Pin; use std::ptr::null; use std::rc::Rc; use cache_control::CacheControl; -use deno_core::external; -use deno_core::futures::TryFutureExt; -use deno_core::op2; -use deno_core::serde_v8::from_v8; -use deno_core::unsync::spawn; -use deno_core::unsync::JoinHandle; -use deno_core::v8; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::BufView; @@ -30,12 +23,19 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::external; +use deno_core::futures::TryFutureExt; +use deno_core::op2; +use deno_core::serde_v8::from_v8; +use deno_core::unsync::JoinHandle; +use deno_core::unsync::spawn; +use deno_core::v8; use deno_net::ops_tls::TlsStream; use deno_net::raw::NetworkStream; use deno_websocket::ws_create_server_stream; use fly_accept_encoding::Encoding; +use hyper::StatusCode; use hyper::body::Incoming; -use hyper::header::HeaderMap; use hyper::header::ACCEPT_ENCODING; use hyper::header::CACHE_CONTROL; use hyper::header::CONTENT_ENCODING; @@ -43,13 +43,13 @@ use hyper::header::CONTENT_LENGTH; use hyper::header::CONTENT_RANGE; use hyper::header::CONTENT_TYPE; use hyper::header::COOKIE; +use hyper::header::HeaderMap; use hyper::http::HeaderName; use hyper::http::HeaderValue; use hyper::server::conn::http1; use hyper::server::conn::http2; -use hyper::service::service_fn; use hyper::service::HttpService; -use hyper::StatusCode; +use hyper::service::service_fn; use hyper_util::rt::TokioIo; use once_cell::sync::Lazy; use smallvec::SmallVec; @@ -57,6 +57,8 @@ use tokio::io::AsyncReadExt; use tokio::io::AsyncWriteExt; use super::fly_accept_encoding; +use crate::LocalExecutor; +use crate::Options; use crate::compressible::is_content_compressible; use crate::extract_network_stream; use crate::network_buffered_stream::NetworkStreamPrefixCheck; @@ -66,17 +68,15 @@ use crate::request_properties::HttpListenProperties; use crate::request_properties::HttpPropertyExtractor; use crate::response_body::Compression; use crate::response_body::ResponseBytesInner; -use crate::service::handle_request; -use crate::service::http_general_trace; -use crate::service::http_trace; use crate::service::HttpRecord; use crate::service::HttpRecordResponse; use crate::service::HttpRequestBodyAutocloser; use crate::service::HttpServerState; use crate::service::SignallingRc; +use crate::service::handle_request; +use crate::service::http_general_trace; +use crate::service::http_trace; use crate::websocket_upgrade::WebSocketUpgrade; -use crate::LocalExecutor; -use crate::Options; type Request = hyper::Request; @@ -115,9 +115,8 @@ trait HttpServeStream: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static { } -impl< - S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static, - > HttpServeStream for S +impl + HttpServeStream for S { } @@ -397,12 +396,13 @@ where .unwrap() .into(); - let (peer_ip, peer_port) = if let Some(client_addr) = &*http.client_addr() { - let addr: std::net::SocketAddr = - client_addr.to_str().unwrap().parse().unwrap(); - (Rc::from(format!("{}", addr.ip())), Some(addr.port() as u32)) - } else { - (request_info.peer_address.clone(), request_info.peer_port) + let (peer_ip, peer_port) = match &*http.client_addr() { + Some(client_addr) => { + let addr: std::net::SocketAddr = + client_addr.to_str().unwrap().parse().unwrap(); + (Rc::from(format!("{}", addr.ip())), Some(addr.port() as u32)) + } + _ => (request_info.peer_address.clone(), request_info.peer_port), }; let peer_ip: v8::Local = v8::String::new_from_utf8( @@ -515,13 +515,16 @@ pub fn op_http_read_request_body( let http = // SAFETY: op is called with external. unsafe { clone_external!(external, "op_http_read_request_body") }; - let rid = if let Some(incoming) = http.take_request_body() { - let body_resource = Rc::new(HttpRequestBody::new(incoming)); - state.borrow_mut().resource_table.add_rc(body_resource) - } else { - // This should not be possible, but rather than panicking we'll return an invalid - // resource value to JavaScript. - ResourceId::MAX + let rid = match http.take_request_body() { + Some(incoming) => { + let body_resource = Rc::new(HttpRequestBody::new(incoming)); + state.borrow_mut().resource_table.add_rc(body_resource) + } + _ => { + // This should not be possible, but rather than panicking we'll return an invalid + // resource value to JavaScript. + ResourceId::MAX + } }; http.put_resource(HttpRequestBodyAutocloser::new(rid, state.clone())); rid diff --git a/ext/http/lib.rs b/ext/http/lib.rs index 59544d6503..13b00dedda 100644 --- a/ext/http/lib.rs +++ b/ext/http/lib.rs @@ -4,43 +4,30 @@ use std::borrow::Cow; use std::cell::RefCell; use std::cmp::min; use std::error::Error; -use std::future::pending; use std::future::Future; use std::future::Pending; +use std::future::pending; use std::io; use std::io::Write; use std::mem::replace; use std::mem::take; use std::net::SocketAddr; -use std::pin::pin; use std::pin::Pin; +use std::pin::pin; use std::rc::Rc; +use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; -use std::sync::Arc; -use std::task::ready; use std::task::Context; use std::task::Poll; +use std::task::ready; +use async_compression::Level; use async_compression::tokio::write::BrotliEncoder; use async_compression::tokio::write::GzipEncoder; -use async_compression::Level; -use base64::prelude::BASE64_STANDARD; use base64::Engine; +use base64::prelude::BASE64_STANDARD; use cache_control::CacheControl; -use deno_core::futures::channel::mpsc; -use deno_core::futures::channel::oneshot; -use deno_core::futures::future::select; -use deno_core::futures::future::Either; -use deno_core::futures::future::RemoteHandle; -use deno_core::futures::future::Shared; -use deno_core::futures::never::Never; -use deno_core::futures::stream::Peekable; -use deno_core::futures::FutureExt; -use deno_core::futures::StreamExt; -use deno_core::futures::TryFutureExt; -use deno_core::op2; -use deno_core::unsync::spawn; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::BufView; @@ -54,18 +41,35 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; use deno_core::StringOrBuffer; +use deno_core::futures::FutureExt; +use deno_core::futures::StreamExt; +use deno_core::futures::TryFutureExt; +use deno_core::futures::channel::mpsc; +use deno_core::futures::channel::oneshot; +use deno_core::futures::future::Either; +use deno_core::futures::future::RemoteHandle; +use deno_core::futures::future::Shared; +use deno_core::futures::future::select; +use deno_core::futures::never::Never; +use deno_core::futures::stream::Peekable; +use deno_core::op2; +use deno_core::unsync::spawn; use deno_error::JsErrorBox; use deno_net::raw::NetworkStream; use deno_telemetry::Histogram; use deno_telemetry::MeterProvider; -use deno_telemetry::UpDownCounter; use deno_telemetry::OTEL_GLOBALS; +use deno_telemetry::UpDownCounter; use deno_websocket::ws_create_server_stream; -use flate2::write::GzEncoder; use flate2::Compression; +use flate2::write::GzEncoder; use hyper::server::conn::http1; use hyper::server::conn::http2; use hyper_util::rt::TokioIo; +use hyper_v014::Body; +use hyper_v014::HeaderMap; +use hyper_v014::Request; +use hyper_v014::Response; use hyper_v014::body::Bytes; use hyper_v014::body::HttpBody; use hyper_v014::body::SizeHint; @@ -73,10 +77,6 @@ use hyper_v014::header::HeaderName; use hyper_v014::header::HeaderValue; use hyper_v014::server::conn::Http; use hyper_v014::service::Service; -use hyper_v014::Body; -use hyper_v014::HeaderMap; -use hyper_v014::Request; -use hyper_v014::Response; use once_cell::sync::OnceCell; use serde::Serialize; use tokio::io::AsyncRead; @@ -898,7 +898,7 @@ impl Resource for HttpStreamReadResource { Err(err) => { break Err(JsErrorBox::from_err(HttpError::HyperV014( Arc::new(err), - ))) + ))); } }, None => break Ok(BufView::empty()), @@ -1375,10 +1375,10 @@ async fn op_http_write_resource( loop { match *wr { HttpResponseWriter::Headers(_) => { - return Err(HttpError::NoResponseHeaders) + return Err(HttpError::NoResponseHeaders); } HttpResponseWriter::Closed => { - return Err(HttpError::ResponseAlreadyCompleted) + return Err(HttpError::ResponseAlreadyCompleted); } _ => {} }; @@ -1542,7 +1542,7 @@ async fn op_http_upgrade_websocket( HttpRequestReader::Headers(request) => request, _ => { return Err(HttpError::UpgradeBodyUsed) - .inspect_err(|e| handle_error_otel(&stream.otel_info, e)) + .inspect_err(|e| handle_error_otel(&stream.otel_info, e)); } }; diff --git a/ext/http/network_buffered_stream.rs b/ext/http/network_buffered_stream.rs index fc3a2ec8c6..f19cda3686 100644 --- a/ext/http/network_buffered_stream.rs +++ b/ext/http/network_buffered_stream.rs @@ -4,8 +4,8 @@ use std::future::poll_fn; use std::io; use std::mem::MaybeUninit; use std::pin::Pin; -use std::task::ready; use std::task::Poll; +use std::task::ready; use bytes::Bytes; use tokio::io::AsyncRead; diff --git a/ext/http/reader_stream.rs b/ext/http/reader_stream.rs index b6985927f4..62ba403e7e 100644 --- a/ext/http/reader_stream.rs +++ b/ext/http/reader_stream.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. use std::pin::Pin; +use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; -use std::sync::Arc; use std::task::Context; use std::task::Poll; diff --git a/ext/http/request_body.rs b/ext/http/request_body.rs index 50ca1635c3..079e0576dc 100644 --- a/ext/http/request_body.rs +++ b/ext/http/request_body.rs @@ -2,19 +2,19 @@ use std::borrow::Cow; use std::pin::Pin; use std::rc::Rc; -use std::task::ready; use std::task::Poll; +use std::task::ready; use bytes::Bytes; -use deno_core::futures::stream::Peekable; -use deno_core::futures::Stream; -use deno_core::futures::StreamExt; -use deno_core::futures::TryFutureExt; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::BufView; use deno_core::RcRef; use deno_core::Resource; +use deno_core::futures::Stream; +use deno_core::futures::StreamExt; +use deno_core::futures::TryFutureExt; +use deno_core::futures::stream::Peekable; use deno_error::JsErrorBox; use hyper::body::Body; use hyper::body::Incoming; diff --git a/ext/http/request_properties.rs b/ext/http/request_properties.rs index 36ca5dbe9d..6803432f19 100644 --- a/ext/http/request_properties.rs +++ b/ext/http/request_properties.rs @@ -8,15 +8,15 @@ use std::rc::Rc; use deno_core::OpState; use deno_core::ResourceId; use deno_error::JsErrorBox; -use deno_net::raw::take_network_stream_listener_resource; -use deno_net::raw::take_network_stream_resource; use deno_net::raw::NetworkStream; use deno_net::raw::NetworkStreamAddress; use deno_net::raw::NetworkStreamListener; use deno_net::raw::NetworkStreamType; -use hyper::header::HOST; +use deno_net::raw::take_network_stream_listener_resource; +use deno_net::raw::take_network_stream_resource; use hyper::HeaderMap; use hyper::Uri; +use hyper::header::HOST; // TODO(mmastrac): I don't like that we have to clone this, but it's one-time setup #[derive(Clone)] diff --git a/ext/http/response_body.rs b/ext/http/response_body.rs index 1571ce557c..f0ae731fae 100644 --- a/ext/http/response_body.rs +++ b/ext/http/response_body.rs @@ -10,10 +10,10 @@ use brotli::enc::encode::BrotliEncoderStateStruct; use brotli::writer::StandardAlloc; use bytes::Bytes; use bytes::BytesMut; -use deno_core::futures::FutureExt; use deno_core::AsyncResult; use deno_core::BufView; use deno_core::Resource; +use deno_core::futures::FutureExt; use deno_error::JsErrorBox; use flate2::write::GzEncoder; use hyper::body::Frame; @@ -350,7 +350,7 @@ impl PollFrame for GZipResponseStream { let orig_state = *state; let frame = match *state { GZipState::EndOfStream => { - return std::task::Poll::Ready(ResponseStreamResult::EndOfStream) + return std::task::Poll::Ready(ResponseStreamResult::EndOfStream); } GZipState::Header => { *state = GZipState::Streaming; @@ -367,13 +367,12 @@ impl PollFrame for GZipResponseStream { BufView::from(v), )); } - GZipState::Streaming => { - if let Some(partial) = this.partial.take() { - ResponseStreamResult::NonEmptyBuf(partial) - } else { + GZipState::Streaming => match this.partial.take() { + Some(partial) => ResponseStreamResult::NonEmptyBuf(partial), + _ => { ready!(Pin::new(&mut this.underlying).poll_frame(cx)) } - } + }, GZipState::Flushing => ResponseStreamResult::EndOfStream, }; @@ -391,7 +390,7 @@ impl PollFrame for GZipResponseStream { let res = match frame { // Short-circuit these and just return x @ (ResponseStreamResult::NoData | ResponseStreamResult::Error(..)) => { - return std::task::Poll::Ready(x) + return std::task::Poll::Ready(x); } ResponseStreamResult::EndOfStream => { *state = GZipState::Flushing; @@ -492,11 +491,7 @@ fn max_compressed_size(input_size: usize) -> usize { let overhead = 2 + (4 * num_large_blocks) + 3 + 1; let result = input_size + overhead; - if result < input_size { - 0 - } else { - result - } + if result < input_size { 0 } else { result } } impl PollFrame for BrotliResponseStream { diff --git a/ext/http/service.rs b/ext/http/service.rs index 4fa2ff9ffa..2e9281e3e9 100644 --- a/ext/http/service.rs +++ b/ext/http/service.rs @@ -10,10 +10,10 @@ use std::mem::ManuallyDrop; use std::pin::Pin; use std::rc::Rc; use std::sync::OnceLock; -use std::task::ready; use std::task::Context; use std::task::Poll; use std::task::Waker; +use std::task::ready; use deno_core::BufView; use deno_core::OpState; @@ -26,15 +26,15 @@ use hyper::body::Incoming; use hyper::body::SizeHint; use hyper::header::HeaderMap; use hyper::upgrade::OnUpgrade; -use scopeguard::guard; use scopeguard::ScopeGuard; +use scopeguard::guard; use tokio::sync::oneshot; +use crate::OtelInfo; +use crate::OtelInfoAttributes; use crate::request_properties::HttpConnectionProperties; use crate::response_body::ResponseBytesInner; use crate::response_body::ResponseStreamResult; -use crate::OtelInfo; -use crate::OtelInfoAttributes; pub type Request = hyper::Request; pub type Response = hyper::Response; @@ -104,7 +104,7 @@ impl SignallingRc { if Rc::strong_count(&self.0) == 1 { Poll::Ready(()) } else { - self.0 .1.set(Some(cx.waker().clone())); + self.0.1.set(Some(cx.waker().clone())); Poll::Pending } } @@ -122,7 +122,7 @@ impl Drop for SignallingRc { fn drop(&mut self) { // Trigger the waker iff the refcount is about to become 1. if Rc::strong_count(&self.0) == 2 { - if let Some(waker) = self.0 .1.take() { + if let Some(waker) = self.0.1.take() { waker.wake(); } } @@ -133,7 +133,7 @@ impl std::ops::Deref for SignallingRc { type Target = T; #[inline] fn deref(&self) -> &Self::Target { - &self.0 .0 + &self.0.0 } } @@ -321,7 +321,10 @@ fn trust_proxy_headers() -> bool { *TRUST_PROXY_HEADERS.get_or_init(|| { if let Some(v) = std::env::var_os(VAR_NAME) { - std::env::remove_var(VAR_NAME); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + std::env::remove_var(VAR_NAME) + }; v == "1" } else { false @@ -345,12 +348,13 @@ impl HttpRecord { }; let request_body = Some(request_body.into()); let (mut response_parts, _) = http::Response::new(()).into_parts(); - let record = - if let Some((record, headers)) = server_state.borrow_mut().pool.pop() { + let record = match server_state.borrow_mut().pool.pop() { + Some((record, headers)) => { response_parts.headers = headers; http_trace!(record, "HttpRecord::reuse"); record - } else { + } + _ => { #[cfg(feature = "__http_tracing")] { RECORD_COUNT.fetch_add(1, std::sync::atomic::Ordering::SeqCst); @@ -360,7 +364,8 @@ impl HttpRecord { let record = Rc::new(Self(RefCell::new(None))); http_trace!(record, "HttpRecord::new"); record - }; + } + }; *record.0.borrow_mut() = Some(HttpRecordInner { server_state, request_info, @@ -756,8 +761,8 @@ mod tests { use bytes::Buf; use deno_net::raw::NetworkStreamType; use hyper::body::Body; - use hyper::service::service_fn; use hyper::service::HttpService; + use hyper::service::service_fn; use hyper_util::rt::TokioIo; use super::*; diff --git a/ext/http/websocket_upgrade.rs b/ext/http/websocket_upgrade.rs index 306899ae7e..7460467824 100644 --- a/ext/http/websocket_upgrade.rs +++ b/ext/http/websocket_upgrade.rs @@ -5,9 +5,9 @@ use std::marker::PhantomData; use bytes::Bytes; use bytes::BytesMut; use httparse::Status; +use hyper::Response; use hyper::header::HeaderName; use hyper::header::HeaderValue; -use hyper::Response; use once_cell::sync::OnceCell; #[derive(Debug, thiserror::Error, deno_error::JsError)] diff --git a/ext/io/bi_pipe.rs b/ext/io/bi_pipe.rs index 33c3267075..acceb845c8 100644 --- a/ext/io/bi_pipe.rs +++ b/ext/io/bi_pipe.rs @@ -273,8 +273,8 @@ impl_async_write!(for BiPipe -> self.write_end); /// Creates both sides of a bidirectional pipe, returning the raw /// handles to the underlying OS resources. -pub fn bi_pipe_pair_raw( -) -> Result<(RawBiPipeHandle, RawBiPipeHandle), std::io::Error> { +pub fn bi_pipe_pair_raw() +-> Result<(RawBiPipeHandle, RawBiPipeHandle), std::io::Error> { #[cfg(unix)] { // SockFlag is broken on macOS diff --git a/ext/io/fs.rs b/ext/io/fs.rs index 9c00916c10..b6b41a7f6a 100644 --- a/ext/io/fs.rs +++ b/ext/io/fs.rs @@ -9,12 +9,12 @@ use std::rc::Rc; use std::time::SystemTime; use std::time::UNIX_EPOCH; -use deno_core::error::ResourceError; use deno_core::BufMutView; use deno_core::BufView; use deno_core::OpState; use deno_core::ResourceHandleFd; use deno_core::ResourceId; +use deno_core::error::ResourceError; use deno_error::JsErrorBox; #[cfg(windows)] use deno_subprocess_windows::Stdio as StdStdio; diff --git a/ext/io/lib.rs b/ext/io/lib.rs index aaf419aa04..15928ebe0e 100644 --- a/ext/io/lib.rs +++ b/ext/io/lib.rs @@ -21,10 +21,6 @@ use std::rc::Rc; #[cfg(windows)] use std::sync::Arc; -use deno_core::futures::TryFutureExt; -use deno_core::op2; -use deno_core::unsync::spawn_blocking; -use deno_core::unsync::TaskQueue; use deno_core::AsyncMutFuture; use deno_core::AsyncRefCell; use deno_core::AsyncResult; @@ -39,6 +35,10 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceHandle; use deno_core::ResourceHandleFd; +use deno_core::futures::TryFutureExt; +use deno_core::op2; +use deno_core::unsync::TaskQueue; +use deno_core::unsync::spawn_blocking; use deno_error::JsErrorBox; #[cfg(windows)] use deno_subprocess_windows::Stdio as StdStdio; @@ -69,18 +69,18 @@ mod winpipe; mod bi_pipe; -pub use bi_pipe::bi_pipe_pair_raw; pub use bi_pipe::BiPipe; pub use bi_pipe::BiPipeRead; pub use bi_pipe::BiPipeResource; pub use bi_pipe::BiPipeWrite; pub use bi_pipe::RawBiPipeHandle; -pub use pipe::pipe; +pub use bi_pipe::bi_pipe_pair_raw; pub use pipe::AsyncPipeRead; pub use pipe::AsyncPipeWrite; pub use pipe::PipeRead; pub use pipe::PipeWrite; pub use pipe::RawPipeHandle; +pub use pipe::pipe; /// Abstraction over `AsRawFd` (unix) and `AsRawHandle` (windows) pub trait AsRawIoHandle { @@ -566,7 +566,7 @@ impl StdFileResourceInner { fn with_blocking_task( &self, action: F, - ) -> impl Future + ) -> impl Future + use where F: FnOnce() -> R + Send + 'static, { diff --git a/ext/io/winpipe.rs b/ext/io/winpipe.rs index 600eda4091..b05b7bc83b 100644 --- a/ext/io/winpipe.rs +++ b/ext/io/winpipe.rs @@ -4,8 +4,8 @@ use std::os::windows::io::RawHandle; use std::sync::atomic::AtomicU32; use std::sync::atomic::Ordering; -use rand::thread_rng; use rand::RngCore; +use rand::thread_rng; use winapi::shared::minwindef::DWORD; use winapi::um::errhandlingapi::GetLastError; use winapi::um::fileapi::CreateFileA; diff --git a/ext/kv/dynamic.rs b/ext/kv/dynamic.rs index 923e3cd4d8..6b28417c34 100644 --- a/ext/kv/dynamic.rs +++ b/ext/kv/dynamic.rs @@ -10,15 +10,15 @@ use denokv_proto::CommitResult; use denokv_proto::ReadRangeOutput; use denokv_proto::WatchStream; -use crate::remote::RemoteDbHandlerPermissions; -use crate::sqlite::SqliteDbHandler; -use crate::sqlite::SqliteDbHandlerPermissions; use crate::AtomicWrite; use crate::Database; use crate::DatabaseHandler; use crate::QueueMessageHandle; use crate::ReadRange; use crate::SnapshotReadOptions; +use crate::remote::RemoteDbHandlerPermissions; +use crate::sqlite::SqliteDbHandler; +use crate::sqlite::SqliteDbHandlerPermissions; pub struct MultiBackendDbHandler { backends: Vec<(&'static [&'static str], Box)>, diff --git a/ext/kv/lib.rs b/ext/kv/lib.rs index 7bb60247b5..c42b69f7b8 100644 --- a/ext/kv/lib.rs +++ b/ext/kv/lib.rs @@ -13,15 +13,11 @@ use std::rc::Rc; use std::sync::Arc; use std::time::Duration; -use base64::prelude::BASE64_URL_SAFE; use base64::Engine; +use base64::prelude::BASE64_URL_SAFE; use boxed_error::Boxed; use chrono::DateTime; use chrono::Utc; -use deno_core::futures::StreamExt; -use deno_core::op2; -use deno_core::serde_v8::AnyValue; -use deno_core::serde_v8::BigInt; use deno_core::AsyncRefCell; use deno_core::ByteString; use deno_core::CancelFuture; @@ -32,11 +28,13 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; use deno_core::ToJsBuffer; +use deno_core::futures::StreamExt; +use deno_core::op2; +use deno_core::serde_v8::AnyValue; +use deno_core::serde_v8::BigInt; use deno_error::JsErrorBox; use deno_error::JsErrorClass; use deno_features::FeatureChecker; -use denokv_proto::decode_key; -use denokv_proto::encode_key; use denokv_proto::AtomicWrite; use denokv_proto::Check; use denokv_proto::Consistency; @@ -53,6 +51,8 @@ use denokv_proto::ReadRange; use denokv_proto::SnapshotReadOptions; use denokv_proto::WatchKeyOutput; use denokv_proto::WatchStream; +use denokv_proto::decode_key; +use denokv_proto::encode_key; use log::debug; use serde::Deserialize; use serde::Serialize; @@ -671,10 +671,10 @@ fn mutation_from_v8( MutationKind::SetSuffixVersionstampedKey(value.try_into()?) } (op, Some(_)) => { - return Err(KvMutationError::InvalidMutationWithValue(op.to_string())) + return Err(KvMutationError::InvalidMutationWithValue(op.to_string())); } (op, None) => { - return Err(KvMutationError::InvalidMutationWithoutValue(op.to_string())) + return Err(KvMutationError::InvalidMutationWithoutValue(op.to_string())); } }; Ok(Mutation { diff --git a/ext/kv/remote.rs b/ext/kv/remote.rs index 9b9832566d..9744ddadcc 100644 --- a/ext/kv/remote.rs +++ b/ext/kv/remote.rs @@ -8,16 +8,16 @@ use std::sync::Arc; use anyhow::Context; use async_trait::async_trait; use bytes::Bytes; -use deno_core::futures::Stream; use deno_core::OpState; +use deno_core::futures::Stream; use deno_error::JsErrorBox; -use deno_fetch::create_http_client; use deno_fetch::CreateHttpClientOptions; +use deno_fetch::create_http_client; use deno_permissions::PermissionCheckError; -use deno_tls::rustls::RootCertStore; use deno_tls::Proxy; use deno_tls::RootCertStoreProvider; use deno_tls::TlsKeys; +use deno_tls::rustls::RootCertStore; use denokv_remote::MetadataEndpoint; use denokv_remote::Remote; use denokv_remote::RemoteResponse; diff --git a/ext/kv/sqlite.rs b/ext/kv/sqlite.rs index 526e86caad..a069c0fb49 100644 --- a/ext/kv/sqlite.rs +++ b/ext/kv/sqlite.rs @@ -14,8 +14,8 @@ use std::sync::Mutex; use std::sync::OnceLock; use async_trait::async_trait; -use deno_core::unsync::spawn_blocking; use deno_core::OpState; +use deno_core::unsync::spawn_blocking; use deno_error::JsErrorBox; use deno_path_util::normalize_path; use deno_permissions::PermissionCheckError; diff --git a/ext/napi/js_native_api.rs b/ext/napi/js_native_api.rs index 4c2128886d..6df0a9c22e 100644 --- a/ext/napi/js_native_api.rs +++ b/ext/napi/js_native_api.rs @@ -19,9 +19,9 @@ use super::util::napi_set_last_error; use super::util::v8_name_from_property_descriptor; use crate::check_arg; use crate::check_env; +use crate::function::CallbackInfo; use crate::function::create_function; use crate::function::create_function_template; -use crate::function::CallbackInfo; use crate::*; #[derive(Debug, Clone, Copy, PartialEq)] @@ -2354,9 +2354,11 @@ fn napi_wrap( } let external = v8::External::new(&mut env.scope(), reference); - assert!(obj - .set_private(&mut env.scope(), napi_wrap, external.into()) - .unwrap()); + assert!( + obj + .set_private(&mut env.scope(), napi_wrap, external.into()) + .unwrap() + ); napi_ok } @@ -2396,9 +2398,11 @@ fn unwrap( } if !keep { - assert!(obj - .delete_private(&mut env.scope(), napi_wrap) - .unwrap_or(false)); + assert!( + obj + .delete_private(&mut env.scope(), napi_wrap) + .unwrap_or(false) + ); unsafe { Reference::remove(reference) }; } @@ -2869,12 +2873,10 @@ fn napi_get_and_clear_last_exception( let env = check_env!(env_ptr); check_arg!(env, result); - let ex: v8::Local = - if let Some(last_exception) = env.last_exception.take() { - v8::Local::new(&mut env.scope(), last_exception) - } else { - v8::undefined(&mut env.scope()).into() - }; + let ex: v8::Local = match env.last_exception.take() { + Some(last_exception) => v8::Local::new(&mut env.scope(), last_exception), + _ => v8::undefined(&mut env.scope()).into(), + }; unsafe { *result = ex.into(); diff --git a/ext/napi/lib.rs b/ext/napi/lib.rs index 152ba6bce2..163eb5b9ef 100644 --- a/ext/napi/lib.rs +++ b/ext/napi/lib.rs @@ -33,15 +33,15 @@ pub use std::ptr; use std::rc::Rc; use std::thread_local; +use deno_core::ExternalOpsTracker; +use deno_core::OpState; +use deno_core::V8CrossThreadTaskSpawner; use deno_core::op2; use deno_core::parking_lot::RwLock; use deno_core::url::Url; // Expose common stuff for ease of use. // `use deno_napi::*` pub use deno_core::v8; -use deno_core::ExternalOpsTracker; -use deno_core::OpState; -use deno_core::V8CrossThreadTaskSpawner; use deno_permissions::PermissionCheckError; pub use denort_helper::DenoRtNativeAddonLoader; pub use denort_helper::DenoRtNativeAddonLoaderRc; @@ -653,14 +653,19 @@ where assert_eq!(nm.nm_version, 1); // SAFETY: we are going blind, calling the register function on the other side. unsafe { (nm.nm_register_func)(env_ptr, exports.into()) } - } else if let Ok(init) = unsafe { - library.get::(b"napi_register_module_v1") - } { - // Initializer callback. - // SAFETY: we are going blind, calling the register function on the other side. - unsafe { init(env_ptr, exports.into()) } } else { - return Err(NApiError::ModuleNotFound(path)); + match unsafe { + library.get::(b"napi_register_module_v1") + } { + Ok(init) => { + // Initializer callback. + // SAFETY: we are going blind, calling the register function on the other side. + unsafe { init(env_ptr, exports.into()) } + } + _ => { + return Err(NApiError::ModuleNotFound(path)); + } + } }; let exports = maybe_exports.unwrap_or(exports.into()); diff --git a/ext/napi/node_api.rs b/ext/napi/node_api.rs index fc7377de08..b14d720070 100644 --- a/ext/napi/node_api.rs +++ b/ext/napi/node_api.rs @@ -2,22 +2,22 @@ #![deny(unsafe_op_in_unsafe_fn)] +use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicU8; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; -use std::sync::Arc; +use deno_core::V8CrossThreadTaskSpawner; use deno_core::parking_lot::Condvar; use deno_core::parking_lot::Mutex; -use deno_core::V8CrossThreadTaskSpawner; use napi_sym::napi_sym; +use super::util::SendPtr; use super::util::get_array_buffer_ptr; use super::util::make_external_backing_store; use super::util::napi_clear_last_error; use super::util::napi_set_last_error; -use super::util::SendPtr; use crate::check_arg; use crate::check_env; use crate::*; @@ -680,10 +680,12 @@ struct TsFn { impl Drop for TsFn { fn drop(&mut self) { - assert!(self - .is_closed - .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) - .is_ok()); + assert!( + self + .is_closed + .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) + .is_ok() + ); self.unref(); @@ -714,11 +716,7 @@ impl TsFn { Ordering::Relaxed, Ordering::Relaxed, |x| { - if x == 0 { - None - } else { - Some(x - 1) - } + if x == 0 { None } else { Some(x - 1) } }, ); diff --git a/ext/napi/sym/README.md b/ext/napi/sym/README.md index 66eb4bff26..7d660a6f88 100644 --- a/ext/napi/sym/README.md +++ b/ext/napi/sym/README.md @@ -9,10 +9,10 @@ A proc_macro for Deno's Node-API implementation. It does the following things: - Maps `deno_napi::Result` to raw `napi_result`. ```rust -use deno_napi::napi_value; use deno_napi::Env; use deno_napi::Error; use deno_napi::Result; +use deno_napi::napi_value; #[napi_sym::napi_sym] fn napi_get_boolean( diff --git a/ext/napi/util.rs b/ext/napi/util.rs index 3e836e334b..b6ca7d47c9 100644 --- a/ext/napi/util.rs +++ b/ext/napi/util.rs @@ -231,7 +231,7 @@ macro_rules! check_arg { macro_rules! napi_wrap { ( $( # [ $attr:meta ] )* $vis:vis fn $name:ident $( < $( $x:lifetime ),* > )? ( $env:ident : & $( $lt:lifetime )? mut Env $( , $ident:ident : $ty:ty )* $(,)? ) -> napi_status $body:block ) => { $( # [ $attr ] )* - #[no_mangle] + #[unsafe(no_mangle)] $vis unsafe extern "C" fn $name $( < $( $x ),* > )? ( env_ptr : *mut Env , $( $ident : $ty ),* ) -> napi_status { let env: & $( $lt )? mut Env = $crate::check_env!(env_ptr); @@ -271,7 +271,7 @@ macro_rules! napi_wrap { ( $( # [ $attr:meta ] )* $vis:vis fn $name:ident $( < $( $x:lifetime ),* > )? ( $( $ident:ident : $ty:ty ),* $(,)? ) -> napi_status $body:block ) => { $( # [ $attr ] )* - #[no_mangle] + #[unsafe(no_mangle)] $vis unsafe extern "C" fn $name $( < $( $x ),* > )? ( $( $ident : $ty ),* ) -> napi_status { #[inline(always)] fn inner $( < $( $x ),* > )? ( $( $ident : $ty ),* ) -> napi_status $body diff --git a/ext/napi/uv.rs b/ext/napi/uv.rs index ef4ac495c3..d0336700ed 100644 --- a/ext/napi/uv.rs +++ b/ext/napi/uv.rs @@ -44,7 +44,7 @@ struct uv_mutex_t { }], } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_mutex_init(lock: *mut uv_mutex_t) -> c_int { unsafe { addr_of_mut!((*lock).mutex).write(Mutex::new(())); @@ -52,7 +52,7 @@ unsafe extern "C" fn uv_mutex_init(lock: *mut uv_mutex_t) -> c_int { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_mutex_lock(lock: *mut uv_mutex_t) { unsafe { let guard = (*lock).mutex.lock(); @@ -62,14 +62,14 @@ unsafe extern "C" fn uv_mutex_lock(lock: *mut uv_mutex_t) { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_mutex_unlock(lock: *mut uv_mutex_t) { unsafe { (*lock).mutex.force_unlock(); } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_mutex_destroy(_lock: *mut uv_mutex_t) { // no cleanup required } @@ -145,7 +145,7 @@ struct uv_async_t { type uv_loop_t = Env; type uv_async_cb = extern "C" fn(handle: *mut uv_async_t); -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_async_init( r#loop: *mut uv_loop_t, // probably uninitialized @@ -179,14 +179,14 @@ unsafe extern "C" fn uv_async_init( } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_async_send(handle: *mut uv_async_t) -> c_int { unsafe { -napi_queue_async_work((*handle).r#loop, (*handle).work) } } type uv_close_cb = unsafe extern "C" fn(*mut uv_handle_t); -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn uv_close(handle: *mut uv_handle_t, close: uv_close_cb) { unsafe { if handle.is_null() { diff --git a/ext/net/io.rs b/ext/net/io.rs index 674d55fe7b..2bf158c4a3 100644 --- a/ext/net/io.rs +++ b/ext/net/io.rs @@ -3,7 +3,6 @@ use std::borrow::Cow; use std::rc::Rc; -use deno_core::futures::TryFutureExt; use deno_core::AsyncMutFuture; use deno_core::AsyncRefCell; use deno_core::AsyncResult; @@ -11,6 +10,7 @@ use deno_core::CancelHandle; use deno_core::CancelTryFuture; use deno_core::RcRef; use deno_core::Resource; +use deno_core::futures::TryFutureExt; use deno_error::JsErrorBox; use socket2::SockRef; use tokio::io::AsyncRead; diff --git a/ext/net/lib.rs b/ext/net/lib.rs index 06ac54d93b..cf8c5daf77 100644 --- a/ext/net/lib.rs +++ b/ext/net/lib.rs @@ -18,8 +18,8 @@ use std::sync::Arc; use deno_core::OpState; use deno_features::FeatureChecker; use deno_permissions::PermissionCheckError; -use deno_tls::rustls::RootCertStore; use deno_tls::RootCertStoreProvider; +use deno_tls::rustls::RootCertStore; pub use quic::QuicError; pub const UNSTABLE_FEATURE_NAME: &str = "net"; diff --git a/ext/net/ops.rs b/ext/net/ops.rs index 87925bdee7..1a26ec5962 100644 --- a/ext/net/ops.rs +++ b/ext/net/ops.rs @@ -8,7 +8,6 @@ use std::net::SocketAddr; use std::rc::Rc; use std::str::FromStr; -use deno_core::op2; use deno_core::AsyncRefCell; use deno_core::ByteString; use deno_core::CancelFuture; @@ -19,17 +18,18 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::op2; +use hickory_proto::ProtoError; +use hickory_proto::ProtoErrorKind; use hickory_proto::rr::rdata::caa::Value; use hickory_proto::rr::record_data::RData; use hickory_proto::rr::record_type::RecordType; -use hickory_proto::ProtoError; -use hickory_proto::ProtoErrorKind; +use hickory_resolver::ResolveError; +use hickory_resolver::ResolveErrorKind; use hickory_resolver::config::NameServerConfigGroup; use hickory_resolver::config::ResolverConfig; use hickory_resolver::config::ResolverOpts; use hickory_resolver::system_conf; -use hickory_resolver::ResolveError; -use hickory_resolver::ResolveErrorKind; use serde::Deserialize; use serde::Serialize; use socket2::Domain; @@ -39,12 +39,12 @@ use socket2::Type; use tokio::net::TcpStream; use tokio::net::UdpSocket; +use crate::NetPermissions; use crate::io::TcpStreamResource; use crate::raw::NetworkListenerResource; use crate::resolve_addr::resolve_addr; use crate::resolve_addr::resolve_addr_sync; use crate::tcp::TcpListener; -use crate::NetPermissions; pub type Fd = u32; @@ -1146,14 +1146,16 @@ mod tests { use std::sync::Arc; use std::sync::Mutex; - use deno_core::futures::FutureExt; use deno_core::JsRuntime; use deno_core::RuntimeOptions; + use deno_core::futures::FutureExt; use deno_permissions::PermissionCheckError; + use hickory_proto::rr::Name; + use hickory_proto::rr::rdata::SOA; use hickory_proto::rr::rdata::a::A; use hickory_proto::rr::rdata::aaaa::AAAA; - use hickory_proto::rr::rdata::caa::KeyValue; use hickory_proto::rr::rdata::caa::CAA; + use hickory_proto::rr::rdata::caa::KeyValue; use hickory_proto::rr::rdata::mx::MX; use hickory_proto::rr::rdata::name::ANAME; use hickory_proto::rr::rdata::name::CNAME; @@ -1162,9 +1164,7 @@ mod tests { use hickory_proto::rr::rdata::naptr::NAPTR; use hickory_proto::rr::rdata::srv::SRV; use hickory_proto::rr::rdata::txt::TXT; - use hickory_proto::rr::rdata::SOA; use hickory_proto::rr::record_data::RData; - use hickory_proto::rr::Name; use socket2::SockRef; use super::*; diff --git a/ext/net/ops_tls.rs b/ext/net/ops_tls.rs index fb361657ec..977a5d7008 100644 --- a/ext/net/ops_tls.rs +++ b/ext/net/ops_tls.rs @@ -12,9 +12,6 @@ use std::num::NonZeroUsize; use std::rc::Rc; use std::sync::Arc; -use deno_core::futures::TryFutureExt; -use deno_core::op2; -use deno_core::v8; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::CancelHandle; @@ -23,20 +20,23 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::futures::TryFutureExt; +use deno_core::op2; +use deno_core::v8; use deno_error::JsErrorBox; -use deno_tls::create_client_config; -use deno_tls::load_certs; -use deno_tls::load_private_keys; -use deno_tls::new_resolver; -use deno_tls::rustls::pki_types::ServerName; -use deno_tls::rustls::ClientConnection; -use deno_tls::rustls::ServerConfig; use deno_tls::ServerConfigProvider; use deno_tls::SocketUse; use deno_tls::TlsKey; use deno_tls::TlsKeyLookup; use deno_tls::TlsKeys; use deno_tls::TlsKeysHolder; +use deno_tls::create_client_config; +use deno_tls::load_certs; +use deno_tls::load_private_keys; +use deno_tls::new_resolver; +use deno_tls::rustls::ClientConnection; +use deno_tls::rustls::ServerConfig; +use deno_tls::rustls::pki_types::ServerName; pub use rustls_tokio_stream::TlsStream; use rustls_tokio_stream::TlsStreamRead; use rustls_tokio_stream::TlsStreamWrite; @@ -45,6 +45,9 @@ use tokio::io::AsyncReadExt; use tokio::io::AsyncWriteExt; use tokio::net::TcpStream; +use crate::DefaultTlsOptions; +use crate::NetPermissions; +use crate::UnsafelyIgnoreCertificateErrors; use crate::io::TcpStreamResource; use crate::ops::IpAddr; use crate::ops::NetError; @@ -53,9 +56,6 @@ use crate::raw::NetworkListenerResource; use crate::resolve_addr::resolve_addr; use crate::resolve_addr::resolve_addr_sync; use crate::tcp::TcpListener; -use crate::DefaultTlsOptions; -use crate::NetPermissions; -use crate::UnsafelyIgnoreCertificateErrors; pub(crate) const TLS_BUFFER_SIZE: Option = NonZeroUsize::new(65536); diff --git a/ext/net/ops_unix.rs b/ext/net/ops_unix.rs index 3cb336e3c6..6d300d9698 100644 --- a/ext/net/ops_unix.rs +++ b/ext/net/ops_unix.rs @@ -5,7 +5,6 @@ use std::cell::RefCell; use std::path::Path; use std::rc::Rc; -use deno_core::op2; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::CancelTryFuture; @@ -14,16 +13,17 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::op2; use serde::Deserialize; use serde::Serialize; use tokio::net::UnixDatagram; use tokio::net::UnixListener; pub use tokio::net::UnixStream; +use crate::NetPermissions; use crate::io::UnixStreamResource; use crate::ops::NetError; use crate::raw::NetworkListenerResource; -use crate::NetPermissions; /// A utility function to map OsStrings to Strings pub fn into_string(s: std::ffi::OsString) -> Result { diff --git a/ext/net/quic.rs b/ext/net/quic.rs index 27efec0770..4c2f194f4b 100644 --- a/ext/net/quic.rs +++ b/ext/net/quic.rs @@ -10,16 +10,14 @@ use std::net::SocketAddrV4; use std::net::SocketAddrV6; use std::pin::pin; use std::rc::Rc; +use std::sync::Arc; use std::sync::atomic::AtomicI32; use std::sync::atomic::Ordering; -use std::sync::Arc; use std::task::Context; use std::task::Poll; use std::task::Waker; use std::time::Duration; -use deno_core::error::ResourceError; -use deno_core::op2; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::BufMutView; @@ -31,14 +29,16 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; use deno_core::WriteOutcome; +use deno_core::error::ResourceError; +use deno_core::op2; use deno_error::JsError; use deno_error::JsErrorBox; use deno_permissions::PermissionCheckError; -use deno_tls::create_client_config; use deno_tls::SocketUse; use deno_tls::TlsError; use deno_tls::TlsKeys; use deno_tls::TlsKeysHolder; +use deno_tls::create_client_config; use quinn::crypto::rustls::QuicClientConfig; use quinn::crypto::rustls::QuicServerConfig; use quinn::rustls::client::ClientSessionMemoryCache; @@ -47,10 +47,10 @@ use quinn::rustls::client::Resumption; use serde::Deserialize; use serde::Serialize; -use crate::resolve_addr::resolve_addr_sync; use crate::DefaultTlsOptions; use crate::NetPermissions; use crate::UnsafelyIgnoreCertificateErrors; +use crate::resolve_addr::resolve_addr_sync; #[derive(Debug, thiserror::Error, JsError)] pub enum QuicError { @@ -103,7 +103,9 @@ pub enum QuicError { #[error("Invalid {0} resource")] BadResource(&'static str), #[class(range)] - #[error("Connection has reached the maximum number of concurrent outgoing {0} streams")] + #[error( + "Connection has reached the maximum number of concurrent outgoing {0} streams" + )] MaxStreams(&'static str), #[class(generic)] #[error("Peer does not support WebTransport")] @@ -1012,9 +1014,9 @@ pub(crate) mod webtransport { use deno_core::futures::try_join; use deno_tls::rustls; use rustls::client::danger::ServerCertVerifier; + use rustls::crypto::CryptoProvider; use rustls::crypto::verify_tls12_signature; use rustls::crypto::verify_tls13_signature; - use rustls::crypto::CryptoProvider; use sha2::Digest; use sha2::Sha256; diff --git a/ext/net/raw.rs b/ext/net/raw.rs index f06c46687b..50d72da90f 100644 --- a/ext/net/raw.rs +++ b/ext/net/raw.rs @@ -3,12 +3,12 @@ use std::borrow::Cow; use std::rc::Rc; -use deno_core::error::ResourceError; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::Resource; use deno_core::ResourceId; use deno_core::ResourceTable; +use deno_core::error::ResourceError; use deno_error::JsErrorBox; use crate::io::TcpStreamResource; diff --git a/ext/net/resolve_addr.rs b/ext/net/resolve_addr.rs index 9a757391ea..107dedb728 100644 --- a/ext/net/resolve_addr.rs +++ b/ext/net/resolve_addr.rs @@ -19,7 +19,7 @@ pub async fn resolve_addr( pub fn resolve_addr_sync( hostname: &str, port: u16, -) -> Result, std::io::Error> { +) -> Result + use<>, std::io::Error> { let addr_port_pair = make_addr_port_pair(hostname, port); let result = addr_port_pair.to_socket_addrs()?; Ok(result) diff --git a/ext/node/global.rs b/ext/node/global.rs index 09dd4a4ade..05cabfb658 100644 --- a/ext/node/global.rs +++ b/ext/node/global.rs @@ -248,11 +248,7 @@ fn current_mode(scope: &mut v8::HandleScope) -> Mode { return Mode::Deno; } let is_node = host_defined_options.get(scope, 0).is_true(); - if is_node { - Mode::Node - } else { - Mode::Deno - } + if is_node { Mode::Node } else { Mode::Deno } } pub fn getter<'s>( diff --git a/ext/node/lib.rs b/ext/node/lib.rs index 95aa3f9db8..065205faf8 100644 --- a/ext/node/lib.rs +++ b/ext/node/lib.rs @@ -8,20 +8,20 @@ use std::collections::HashSet; use std::path::Path; use std::path::PathBuf; +use deno_core::OpState; use deno_core::op2; use deno_core::url::Url; #[allow(unused_imports)] use deno_core::v8; use deno_core::v8::ExternalReference; -use deno_core::OpState; use deno_error::JsErrorBox; use deno_permissions::PermissionsContainer; -use node_resolver::errors::ClosestPkgJsonError; use node_resolver::DenoIsBuiltInNodeModuleChecker; use node_resolver::InNpmPackageChecker; use node_resolver::IsBuiltInNodeModuleChecker; use node_resolver::NpmPackageFolderResolver; use node_resolver::PackageJsonResolverRc; +use node_resolver::errors::ClosestPkgJsonError; use once_cell::sync::Lazy; extern crate libz_sys as zlib; @@ -31,19 +31,19 @@ pub mod ops; pub use deno_package_json::PackageJson; use deno_permissions::PermissionCheckError; -pub use node_resolver::PathClean; pub use node_resolver::DENO_SUPPORTED_BUILTIN_NODE_MODULES as SUPPORTED_BUILTIN_NODE_MODULES; +pub use node_resolver::PathClean; use ops::handle_wrap::AsyncId; pub use ops::ipc::ChildPipeFd; use ops::vm; -pub use ops::vm::create_v8_context; -pub use ops::vm::init_global_template; pub use ops::vm::ContextInitMode; pub use ops::vm::VM_CONTEXT_INDEX; +pub use ops::vm::create_v8_context; +pub use ops::vm::init_global_template; +pub use crate::global::GlobalsStorage; use crate::global::global_object_middleware; use crate::global::global_template_middleware; -pub use crate::global::GlobalsStorage; pub fn is_builtin_node_module(module_name: &str) -> bool { DenoIsBuiltInNodeModuleChecker.is_builtin_node_module(module_name) diff --git a/ext/node/ops/blocklist.rs b/ext/node/ops/blocklist.rs index 48e6500f4e..98a9f39a06 100644 --- a/ext/node/ops/blocklist.rs +++ b/ext/node/ops/blocklist.rs @@ -7,8 +7,8 @@ use std::net::Ipv4Addr; use std::net::Ipv6Addr; use std::net::SocketAddr; -use deno_core::op2; use deno_core::OpState; +use deno_core::op2; use ipnetwork::IpNetwork; use ipnetwork::Ipv4Network; use ipnetwork::Ipv6Network; diff --git a/ext/node/ops/crypto/cipher.rs b/ext/node/ops/crypto/cipher.rs index 89319b882a..95e4239e83 100644 --- a/ext/node/ops/crypto/cipher.rs +++ b/ext/node/ops/crypto/cipher.rs @@ -4,16 +4,16 @@ use std::borrow::Cow; use std::cell::RefCell; use std::rc::Rc; -use aes::cipher::block_padding::Pkcs7; use aes::cipher::BlockDecryptMut; use aes::cipher::BlockEncryptMut; use aes::cipher::KeyIvInit; use aes::cipher::KeySizeUser; use aes::cipher::StreamCipher; +use aes::cipher::block_padding::Pkcs7; use deno_core::Resource; use deno_error::JsErrorClass; -use digest::generic_array::GenericArray; use digest::KeyInit; +use digest::generic_array::GenericArray; type Tag = Option>; @@ -595,7 +595,7 @@ impl Decipher { Aes128Ctr(Box::new(ctr::Ctr128BE::new(key.into(), iv.into()))) } _ => { - return Err(DecipherError::UnknownCipher(algorithm_name.to_string())) + return Err(DecipherError::UnknownCipher(algorithm_name.to_string())); } }) } diff --git a/ext/node/ops/crypto/digest.rs b/ext/node/ops/crypto/digest.rs index 69a10cbf58..cec5bf5cd7 100644 --- a/ext/node/ops/crypto/digest.rs +++ b/ext/node/ops/crypto/digest.rs @@ -2,8 +2,8 @@ use std::cell::RefCell; use std::rc::Rc; -use deno_core::op2; use deno_core::GarbageCollected; +use deno_core::op2; use digest::Digest; use digest::DynDigest; use digest::ExtendableOutput; @@ -217,10 +217,10 @@ impl Hash { ) -> Result { match algorithm_name { "shake128" | "shake-128" => { - return Ok(Shake128(Default::default(), output_length)) + return Ok(Shake128(Default::default(), output_length)); } "shake256" | "shake-256" => { - return Ok(Shake256(Default::default(), output_length)) + return Ok(Shake256(Default::default(), output_length)); } "sha256" => { let digest = ring_sha2::RingSha256::new(); diff --git a/ext/node/ops/crypto/keys.rs b/ext/node/ops/crypto/keys.rs index a5940250d2..6aee5b8db0 100644 --- a/ext/node/ops/crypto/keys.rs +++ b/ext/node/ops/crypto/keys.rs @@ -4,11 +4,11 @@ use std::borrow::Cow; use std::cell::RefCell; use base64::Engine; +use deno_core::GarbageCollected; +use deno_core::ToJsBuffer; use deno_core::op2; use deno_core::serde_v8::BigInt as V8BigInt; use deno_core::unsync::spawn_blocking; -use deno_core::GarbageCollected; -use deno_core::ToJsBuffer; use deno_error::JsErrorBox; use ed25519_dalek::pkcs8::BitStringRef; use elliptic_curve::JwkEcKey; @@ -20,31 +20,31 @@ use pkcs8::EncodePrivateKey as _; use pkcs8::EncryptedPrivateKeyInfo; use pkcs8::PrivateKeyInfo; use pkcs8::SecretDocument; -use rand::thread_rng; use rand::RngCore as _; +use rand::thread_rng; +use rsa::RsaPrivateKey; +use rsa::RsaPublicKey; use rsa::pkcs1::DecodeRsaPrivateKey as _; use rsa::pkcs1::DecodeRsaPublicKey; use rsa::pkcs1::EncodeRsaPrivateKey as _; use rsa::pkcs1::EncodeRsaPublicKey; use rsa::traits::PrivateKeyParts; use rsa::traits::PublicKeyParts; -use rsa::RsaPrivateKey; -use rsa::RsaPublicKey; +use sec1::DecodeEcPrivateKey as _; +use sec1::LineEnding; use sec1::der::Tag; use sec1::der::Writer as _; use sec1::pem::PemLabel as _; -use sec1::DecodeEcPrivateKey as _; -use sec1::LineEnding; -use spki::der::asn1; -use spki::der::asn1::OctetStringRef; +use spki::DecodePublicKey as _; +use spki::EncodePublicKey as _; +use spki::SubjectPublicKeyInfoRef; use spki::der::AnyRef; use spki::der::Decode as _; use spki::der::Encode as _; use spki::der::PemWriter; use spki::der::Reader as _; -use spki::DecodePublicKey as _; -use spki::EncodePublicKey as _; -use spki::SubjectPublicKeyInfoRef; +use spki::der::asn1; +use spki::der::asn1::OctetStringRef; use x509_parser::error::X509Error; use x509_parser::x509; @@ -633,7 +633,7 @@ impl KeyObjectHandle { _ => { return Err(AsymmetricPrivateKeyError::UnsupportedPemLabel( label.to_string(), - )) + )); } } } @@ -666,13 +666,13 @@ impl KeyObjectHandle { _ => { return Err(AsymmetricPrivateKeyError::UnsupportedKeyType( typ.to_string(), - )) + )); } }, _ => { return Err(AsymmetricPrivateKeyError::UnsupportedKeyFormat( format.to_string(), - )) + )); } }; @@ -977,7 +977,7 @@ impl KeyObjectHandle { KeyObjectHandle::AsymmetricPrivate(private) => { return Ok(KeyObjectHandle::AsymmetricPublic( private.to_public_key(), - )) + )); } KeyObjectHandle::AsymmetricPublic(_) | KeyObjectHandle::Secret(_) => unreachable!(), @@ -996,7 +996,7 @@ impl KeyObjectHandle { _ => { return Err(AsymmetricPublicKeyError::UnsupportedPemLabel( label.to_string(), - )) + )); } } } @@ -1008,13 +1008,13 @@ impl KeyObjectHandle { _ => { return Err(AsymmetricPublicKeyError::UnsupportedKeyType( typ.to_string(), - )) + )); } }, _ => { return Err(AsymmetricPublicKeyError::UnsupportedKeyType( format.to_string(), - )) + )); } }; @@ -1156,7 +1156,7 @@ fn parse_rsa_pss_params( ID_SHA512_224_OID => RsaPssHashAlgorithm::Sha512_224, ID_SHA512_256_OID => RsaPssHashAlgorithm::Sha512_256, _ => { - return Err(RsaPssParamsParseError::UnsupportedPssMaskGenAlgorithm) + return Err(RsaPssParamsParseError::UnsupportedPssMaskGenAlgorithm); } } } @@ -1444,10 +1444,9 @@ fn rsa_private_to_jwk(key: &RsaPrivateKey) -> deno_core::serde_json::Value { }); if !oth.is_empty() { - obj["oth"] = deno_core::serde_json::json!(oth - .iter() - .map(|o| o.to_bytes_be()) - .collect::>()); + obj["oth"] = deno_core::serde_json::json!( + oth.iter().map(|o| o.to_bytes_be()).collect::>() + ); } obj @@ -2115,7 +2114,7 @@ fn dsa_generate( _ => { return Err(JsErrorBox::type_error( "Invalid modulusLength+divisorLength combination", - )) + )); } }; let components = Components::generate(&mut rng, key_size); @@ -2167,7 +2166,7 @@ fn ec_generate(named_curve: &str) -> Result { return Err(JsErrorBox::type_error(format!( "unsupported named curve: {}", named_curve - ))) + ))); } }; let public_key = private_key.to_public_key(); diff --git a/ext/node/ops/crypto/md5_sha1.rs b/ext/node/ops/crypto/md5_sha1.rs index c6c6eb1c83..cc1be9fa89 100644 --- a/ext/node/ops/crypto/md5_sha1.rs +++ b/ext/node/ops/crypto/md5_sha1.rs @@ -1,6 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. use core::fmt; +use digest::HashMarker; +use digest::Output; +use digest::Reset; use digest::core_api::AlgorithmName; use digest::core_api::BlockSizeUser; use digest::core_api::Buffer; @@ -9,9 +12,6 @@ use digest::core_api::CoreWrapper; use digest::core_api::FixedOutputCore; use digest::core_api::OutputSizeUser; use digest::core_api::UpdateCore; -use digest::HashMarker; -use digest::Output; -use digest::Reset; pub type Md5Sha1 = CoreWrapper; diff --git a/ext/node/ops/crypto/mod.rs b/ext/node/ops/crypto/mod.rs index d59d3b22b9..1c470dedf1 100644 --- a/ext/node/ops/crypto/mod.rs +++ b/ext/node/ops/crypto/mod.rs @@ -3,12 +3,12 @@ use std::future::Future; use std::rc::Rc; use aws_lc_rs::signature::Ed25519KeyPair; -use deno_core::op2; -use deno_core::unsync::spawn_blocking; use deno_core::JsBuffer; use deno_core::OpState; use deno_core::StringOrBuffer; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::unsync::spawn_blocking; use deno_error::JsErrorBox; use elliptic_curve::sec1::ToEncodedPoint; use hkdf::Hkdf; @@ -22,15 +22,15 @@ use num_bigint_dig::BigUint; use p224::NistP224; use p256::NistP256; use p384::NistP384; +use rand::Rng; use rand::distributions::Distribution; use rand::distributions::Uniform; -use rand::Rng; -use rsa::pkcs8::DecodePrivateKey; -use rsa::pkcs8::DecodePublicKey; use rsa::Oaep; use rsa::Pkcs1v15Encrypt; use rsa::RsaPrivateKey; use rsa::RsaPublicKey; +use rsa::pkcs8::DecodePrivateKey; +use rsa::pkcs8::DecodePublicKey; pub mod cipher; mod dh; @@ -75,7 +75,7 @@ pub async fn op_node_check_prime_async( pub fn op_node_check_prime_bytes_async( #[anybuffer] bytes: &[u8], #[number] checks: usize, -) -> impl Future> { +) -> impl Future> + use<> { let candidate = BigInt::from_bytes_be(num_bigint::Sign::Plus, bytes); // TODO(@littledivy): use rayon for CPU-bound tasks async move { diff --git a/ext/node/ops/crypto/sign.rs b/ext/node/ops/crypto/sign.rs index 74ed50eb2b..3fea41b807 100644 --- a/ext/node/ops/crypto/sign.rs +++ b/ext/node/ops/crypto/sign.rs @@ -3,8 +3,8 @@ use core::ops::Add; use ecdsa::der::MaxOverhead; use ecdsa::der::MaxSize; -use elliptic_curve::generic_array::ArrayLength; use elliptic_curve::FieldBytesSize; +use elliptic_curve::generic_array::ArrayLength; use rand::rngs::OsRng; use rsa::signature::hazmat::PrehashSigner as _; use rsa::signature::hazmat::PrehashVerifier as _; @@ -58,7 +58,9 @@ pub enum KeyObjectHandlePrehashedSignAndVerifyError { FailedToSignDigestWithRsaPss, #[error("failed to sign digest with DSA")] FailedToSignDigestWithDsa, - #[error("rsa-pss with different mf1 hash algorithm and hash algorithm is not supported")] + #[error( + "rsa-pss with different mf1 hash algorithm and hash algorithm is not supported" + )] RsaPssHashAlgorithmUnsupported, #[error( "private key does not allow {actual} to be used, expected {expected}" diff --git a/ext/node/ops/dns.rs b/ext/node/ops/dns.rs index 701cfdeeb3..2c645f4144 100644 --- a/ext/node/ops/dns.rs +++ b/ext/node/ops/dns.rs @@ -4,8 +4,8 @@ use std::cell::RefCell; use std::rc::Rc; use std::str::FromStr; -use deno_core::op2; use deno_core::OpState; +use deno_core::op2; use deno_error::JsError; use deno_net::ops::NetPermToken; use deno_permissions::PermissionCheckError; diff --git a/ext/node/ops/fs.rs b/ext/node/ops/fs.rs index 3b619f1f98..3e854285f0 100644 --- a/ext/node/ops/fs.rs +++ b/ext/node/ops/fs.rs @@ -3,8 +3,8 @@ use std::cell::RefCell; use std::rc::Rc; -use deno_core::op2; use deno_core::OpState; +use deno_core::op2; use deno_fs::FileSystemRc; use serde::Serialize; diff --git a/ext/node/ops/handle_wrap.rs b/ext/node/ops/handle_wrap.rs index 003e50dd37..ea18ae7aca 100644 --- a/ext/node/ops/handle_wrap.rs +++ b/ext/node/ops/handle_wrap.rs @@ -4,12 +4,12 @@ use std::cell::Cell; use std::cell::RefCell; use std::rc::Rc; -use deno_core::error::ResourceError; -use deno_core::op2; -use deno_core::v8; use deno_core::GarbageCollected; use deno_core::OpState; use deno_core::ResourceId; +use deno_core::error::ResourceError; +use deno_core::op2; +use deno_core::v8; pub struct AsyncId(i64); diff --git a/ext/node/ops/http.rs b/ext/node/ops/http.rs index 2b247675e4..b4059a13a0 100644 --- a/ext/node/ops/http.rs +++ b/ext/node/ops/http.rs @@ -11,16 +11,6 @@ use std::task::Context; use std::task::Poll; use bytes::Bytes; -use deno_core::error::ResourceError; -use deno_core::futures::channel::mpsc; -use deno_core::futures::stream::Peekable; -use deno_core::futures::FutureExt; -use deno_core::futures::Stream; -use deno_core::futures::StreamExt; -use deno_core::op2; -use deno_core::serde::Serialize; -use deno_core::unsync::spawn; -use deno_core::url::Url; use deno_core::AsyncRefCell; use deno_core::AsyncResult; use deno_core::BufView; @@ -33,6 +23,16 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::error::ResourceError; +use deno_core::futures::FutureExt; +use deno_core::futures::Stream; +use deno_core::futures::StreamExt; +use deno_core::futures::channel::mpsc; +use deno_core::futures::stream::Peekable; +use deno_core::op2; +use deno_core::serde::Serialize; +use deno_core::unsync::spawn; +use deno_core::url::Url; use deno_error::JsError; use deno_error::JsErrorBox; use deno_fetch::FetchCancelHandle; @@ -41,12 +41,12 @@ use deno_fetch::ResBody; use deno_net::io::TcpStreamResource; use deno_net::ops_tls::TlsStreamResource; use deno_permissions::PermissionCheckError; +use http::Method; +use http::header::AUTHORIZATION; +use http::header::CONTENT_LENGTH; use http::header::HeaderMap; use http::header::HeaderName; use http::header::HeaderValue; -use http::header::AUTHORIZATION; -use http::header::CONTENT_LENGTH; -use http::Method; use http_body_util::BodyExt; use hyper::body::Frame; use hyper::body::Incoming; @@ -187,54 +187,61 @@ where tokio::task::spawn(async move { conn.with_upgrades().await }), sender, ) - } else if let Ok(resource_rc) = state - .resource_table - .take::(conn_rid) - .map_err(ConnError::Resource) - { - let resource = - Rc::try_unwrap(resource_rc).map_err(|_| ConnError::TcpStreamBusy)?; - let (read_half, write_half) = resource.into_inner(); - let tcp_stream = read_half.reunite(write_half)?; - let io = TokioIo::new(tcp_stream); - drop(state); - let (sender, conn) = hyper::client::conn::http1::handshake(io).await?; - - // Spawn a task to poll the connection, driving the HTTP state - ( - tokio::task::spawn(async move { - conn.with_upgrades().await?; - Ok::<_, _>(()) - }), - sender, - ) } else { - #[cfg(unix)] + match state + .resource_table + .take::(conn_rid) + .map_err(ConnError::Resource) { - let resource_rc = state - .resource_table - .take::(conn_rid) - .map_err(ConnError::Resource)?; - let resource = - Rc::try_unwrap(resource_rc).map_err(|_| ConnError::TcpStreamBusy)?; - let (read_half, write_half) = resource.into_inner(); - let tcp_stream = read_half.reunite(write_half)?; - let io = TokioIo::new(tcp_stream); - drop(state); - let (sender, conn) = hyper::client::conn::http1::handshake(io).await?; + Ok(resource_rc) => { + let resource = Rc::try_unwrap(resource_rc) + .map_err(|_| ConnError::TcpStreamBusy)?; + let (read_half, write_half) = resource.into_inner(); + let tcp_stream = read_half.reunite(write_half)?; + let io = TokioIo::new(tcp_stream); + drop(state); + let (sender, conn) = + hyper::client::conn::http1::handshake(io).await?; - // Spawn a task to poll the connection, driving the HTTP state - ( - tokio::task::spawn(async move { - conn.with_upgrades().await?; - Ok::<_, _>(()) - }), - sender, - ) + // Spawn a task to poll the connection, driving the HTTP state + ( + tokio::task::spawn(async move { + conn.with_upgrades().await?; + Ok::<_, _>(()) + }), + sender, + ) + } + _ => { + #[cfg(unix)] + { + let resource_rc = state + .resource_table + .take::(conn_rid) + .map_err(ConnError::Resource)?; + let resource = Rc::try_unwrap(resource_rc) + .map_err(|_| ConnError::TcpStreamBusy)?; + let (read_half, write_half) = resource.into_inner(); + let tcp_stream = read_half.reunite(write_half)?; + let io = TokioIo::new(tcp_stream); + drop(state); + let (sender, conn) = + hyper::client::conn::http1::handshake(io).await?; + + // Spawn a task to poll the connection, driving the HTTP state + ( + tokio::task::spawn(async move { + conn.with_upgrades().await?; + Ok::<_, _>(()) + }), + sender, + ) + } + + #[cfg(not(unix))] + return Err(ConnError::Resource(ResourceError::BadResourceId)); + } } - - #[cfg(not(unix))] - return Err(ConnError::Resource(ResourceError::BadResourceId)); } }; @@ -698,8 +705,8 @@ impl Stream for NodeHttpResourceToBodyAdapter { cx: &mut Context<'_>, ) -> Poll> { let this = self.get_mut(); - if let Some(mut fut) = this.1.take() { - match fut.poll_unpin(cx) { + match this.1.take() { + Some(mut fut) => match fut.poll_unpin(cx) { Poll::Pending => { this.1 = Some(fut); Poll::Pending @@ -713,9 +720,8 @@ impl Stream for NodeHttpResourceToBodyAdapter { } Err(err) => Poll::Ready(Some(Err(err))), }, - } - } else { - Poll::Ready(None) + }, + _ => Poll::Ready(None), } } } diff --git a/ext/node/ops/http2.rs b/ext/node/ops/http2.rs index 19637e38fe..3faf6d9206 100644 --- a/ext/node/ops/http2.rs +++ b/ext/node/ops/http2.rs @@ -8,9 +8,6 @@ use std::rc::Rc; use std::task::Poll; use bytes::Bytes; -use deno_core::error::ResourceError; -use deno_core::op2; -use deno_core::serde::Serialize; use deno_core::AsyncRefCell; use deno_core::BufView; use deno_core::ByteString; @@ -21,18 +18,21 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; -use deno_net::raw::take_network_stream_resource; +use deno_core::error::ResourceError; +use deno_core::op2; +use deno_core::serde::Serialize; use deno_net::raw::NetworkStream; +use deno_net::raw::take_network_stream_resource; use h2; use h2::Reason; use h2::RecvStream; use http; -use http::header::HeaderName; -use http::header::HeaderValue; -use http::request::Parts; use http::HeaderMap; use http::Response; use http::StatusCode; +use http::header::HeaderName; +use http::header::HeaderValue; +use http::request::Parts; use url::Url; pub struct Http2Client { @@ -201,56 +201,61 @@ pub async fn op_http2_accept( .resource_table .get::(rid)?; let mut conn = RcRef::map(&resource, |r| &r.conn).borrow_mut().await; - if let Some(res) = conn.accept().await { - let (req, resp) = res?; - let (parts, body) = req.into_parts(); - let (trailers_tx, trailers_rx) = tokio::sync::oneshot::channel(); - let stm = state - .borrow_mut() - .resource_table - .add(Http2ClientResponseBody { - body: AsyncRefCell::new(body), - trailers_rx: AsyncRefCell::new(Some(trailers_rx)), - trailers_tx: AsyncRefCell::new(Some(trailers_tx)), - }); + match conn.accept().await { + Some(res) => { + let (req, resp) = res?; + let (parts, body) = req.into_parts(); + let (trailers_tx, trailers_rx) = tokio::sync::oneshot::channel(); + let stm = + state + .borrow_mut() + .resource_table + .add(Http2ClientResponseBody { + body: AsyncRefCell::new(body), + trailers_rx: AsyncRefCell::new(Some(trailers_rx)), + trailers_tx: AsyncRefCell::new(Some(trailers_tx)), + }); - let Parts { - uri, - method, - headers, - .. - } = parts; - let mut req_headers = Vec::with_capacity(headers.len() + 4); - req_headers.push(( - ByteString::from(":method"), - ByteString::from(method.as_str()), - )); - req_headers.push(( - ByteString::from(":scheme"), - ByteString::from(uri.scheme().map(|s| s.as_str()).unwrap_or("http")), - )); - req_headers.push(( - ByteString::from(":path"), - ByteString::from(uri.path_and_query().map(|p| p.as_str()).unwrap_or("")), - )); - req_headers.push(( - ByteString::from(":authority"), - ByteString::from(uri.authority().map(|a| a.as_str()).unwrap_or("")), - )); - for (key, val) in headers.iter() { - req_headers.push((key.as_str().into(), val.as_bytes().into())); + let Parts { + uri, + method, + headers, + .. + } = parts; + let mut req_headers = Vec::with_capacity(headers.len() + 4); + req_headers.push(( + ByteString::from(":method"), + ByteString::from(method.as_str()), + )); + req_headers.push(( + ByteString::from(":scheme"), + ByteString::from(uri.scheme().map(|s| s.as_str()).unwrap_or("http")), + )); + req_headers.push(( + ByteString::from(":path"), + ByteString::from( + uri.path_and_query().map(|p| p.as_str()).unwrap_or(""), + ), + )); + req_headers.push(( + ByteString::from(":authority"), + ByteString::from(uri.authority().map(|a| a.as_str()).unwrap_or("")), + )); + for (key, val) in headers.iter() { + req_headers.push((key.as_str().into(), val.as_bytes().into())); + } + + let resp = + state + .borrow_mut() + .resource_table + .add(Http2ServerSendResponse { + send_response: AsyncRefCell::new(resp), + }); + + Ok(Some((req_headers, stm, resp))) } - - let resp = state - .borrow_mut() - .resource_table - .add(Http2ServerSendResponse { - send_response: AsyncRefCell::new(resp), - }); - - Ok(Some((req_headers, stm, resp))) - } else { - Ok(None) + _ => Ok(None), } } @@ -485,10 +490,13 @@ fn poll_data_or_trailers( body: &mut RecvStream, ) -> Poll> { if let Poll::Ready(trailers) = body.poll_trailers(cx) { - if let Some(trailers) = trailers? { - return Poll::Ready(Ok(DataOrTrailers::Trailers(trailers))); - } else { - return Poll::Ready(Ok(DataOrTrailers::Eof)); + match trailers? { + Some(trailers) => { + return Poll::Ready(Ok(DataOrTrailers::Trailers(trailers))); + } + _ => { + return Poll::Ready(Ok(DataOrTrailers::Eof)); + } } } if let Poll::Ready(Some(data)) = body.poll_data(cx) { @@ -563,17 +571,18 @@ pub async fn op_http2_client_get_response_trailers( .await .take(); if let Some(trailers) = trailers { - if let Ok(Some(trailers)) = trailers.await { - let mut v = Vec::with_capacity(trailers.len()); - for (key, value) in trailers.iter() { - v.push(( - ByteString::from(key.as_str()), - ByteString::from(value.as_bytes()), - )); + match trailers.await { + Ok(Some(trailers)) => { + let mut v = Vec::with_capacity(trailers.len()); + for (key, value) in trailers.iter() { + v.push(( + ByteString::from(key.as_str()), + ByteString::from(value.as_bytes()), + )); + } + Ok(Some(v)) } - Ok(Some(v)) - } else { - Ok(None) + _ => Ok(None), } } else { Ok(None) diff --git a/ext/node/ops/inspector.rs b/ext/node/ops/inspector.rs index af9ceb891d..f06415cd32 100644 --- a/ext/node/ops/inspector.rs +++ b/ext/node/ops/inspector.rs @@ -3,14 +3,14 @@ use std::cell::RefCell; use std::rc::Rc; -use deno_core::futures::channel::mpsc; -use deno_core::op2; -use deno_core::v8; use deno_core::GarbageCollected; use deno_core::InspectorSessionKind; use deno_core::InspectorSessionOptions; use deno_core::JsRuntimeInspector; use deno_core::OpState; +use deno_core::futures::channel::mpsc; +use deno_core::op2; +use deno_core::v8; use deno_error::JsErrorBox; use crate::NodePermissions; diff --git a/ext/node/ops/ipc.rs b/ext/node/ops/ipc.rs index 6d0fd7d0ac..75a548c2e9 100644 --- a/ext/node/ops/ipc.rs +++ b/ext/node/ops/ipc.rs @@ -10,21 +10,21 @@ mod impl_ { use std::io; use std::rc::Rc; - use deno_core::op2; - use deno_core::serde; - use deno_core::serde::Serializer; - use deno_core::serde_json; - use deno_core::v8; use deno_core::CancelFuture; use deno_core::OpState; use deno_core::RcRef; use deno_core::ResourceId; use deno_core::ToV8; + use deno_core::op2; + use deno_core::serde; + use deno_core::serde::Serializer; + use deno_core::serde_json; + use deno_core::v8; use deno_error::JsErrorBox; + pub use deno_process::ipc::INITIAL_CAPACITY; use deno_process::ipc::IpcJsonStreamError; pub use deno_process::ipc::IpcJsonStreamResource; pub use deno_process::ipc::IpcRefTracker; - pub use deno_process::ipc::INITIAL_CAPACITY; use serde::Serialize; /// Wrapper around v8 value that implements Serialize. @@ -192,7 +192,7 @@ mod impl_ { // ideally we would just return `Result<(impl Future, bool), ..>`, but that's not // supported by `op2` currently. queue_ok: v8::Local<'a, v8::Array>, - ) -> Result>, IpcError> { + ) -> Result> + use<>, IpcError> { let mut serialized = Vec::with_capacity(64); let mut ser = serde_json::Serializer::new(&mut serialized); serialize_v8_value(scope, value, &mut ser).map_err(IpcError::SerdeJson)?; @@ -277,9 +277,9 @@ mod impl_ { #[cfg(test)] mod tests { - use deno_core::v8; use deno_core::JsRuntime; use deno_core::RuntimeOptions; + use deno_core::v8; fn wrap_expr(s: &str) -> String { format!("(function () {{ return {s}; }})()") diff --git a/ext/node/ops/os/cpus.rs b/ext/node/ops/os/cpus.rs index bbf783dd90..b8bf8bc042 100644 --- a/ext/node/ops/os/cpus.rs +++ b/ext/node/ops/os/cpus.rs @@ -73,7 +73,7 @@ pub fn cpu_info() -> Option> { cpu_speed = 2_400_000_000; } - extern "C" { + unsafe extern "C" { fn mach_host_self() -> std::ffi::c_uint; static mut mach_task_self_: std::ffi::c_uint; } diff --git a/ext/node/ops/os/mod.rs b/ext/node/ops/os/mod.rs index ad0be8200e..c162e57dea 100644 --- a/ext/node/ops/os/mod.rs +++ b/ext/node/ops/os/mod.rs @@ -2,8 +2,8 @@ use std::mem::MaybeUninit; -use deno_core::op2; use deno_core::OpState; +use deno_core::op2; use deno_permissions::PermissionCheckError; use sys_traits::EnvHomeDir; @@ -139,8 +139,8 @@ fn get_user_info(_uid: u32) -> Result { use std::os::windows::ffi::OsStringExt; use windows_sys::Win32::Foundation::CloseHandle; - use windows_sys::Win32::Foundation::GetLastError; use windows_sys::Win32::Foundation::ERROR_INSUFFICIENT_BUFFER; + use windows_sys::Win32::Foundation::GetLastError; use windows_sys::Win32::Foundation::HANDLE; use windows_sys::Win32::System::Threading::GetCurrentProcess; use windows_sys::Win32::System::Threading::OpenProcessToken; diff --git a/ext/node/ops/os/priority.rs b/ext/node/ops/os/priority.rs index 10640e4942..1cc37b8a05 100644 --- a/ext/node/ops/os/priority.rs +++ b/ext/node/ops/os/priority.rs @@ -15,11 +15,11 @@ pub enum PriorityError { #[cfg(unix)] mod impl_ { + use errno::Errno; use errno::errno; use errno::set_errno; - use errno::Errno; - use libc::id_t; use libc::PRIO_PROCESS; + use libc::id_t; const PRIORITY_HIGH: i32 = -14; diff --git a/ext/node/ops/perf_hooks.rs b/ext/node/ops/perf_hooks.rs index 3225b2fce4..e51017a771 100644 --- a/ext/node/ops/perf_hooks.rs +++ b/ext/node/ops/perf_hooks.rs @@ -3,8 +3,8 @@ use std::cell::Cell; use std::cell::RefCell; -use deno_core::op2; use deno_core::GarbageCollected; +use deno_core::op2; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum PerfHooksError { diff --git a/ext/node/ops/process.rs b/ext/node/ops/process.rs index 65ec98d440..6e944b2c4c 100644 --- a/ext/node/ops/process.rs +++ b/ext/node/ops/process.rs @@ -1,7 +1,7 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; use deno_core::OpState; +use deno_core::op2; use deno_permissions::PermissionsContainer; #[cfg(unix)] diff --git a/ext/node/ops/require.rs b/ext/node/ops/require.rs index 1d6ef3ec6b..109f966fa9 100644 --- a/ext/node/ops/require.rs +++ b/ext/node/ops/require.rs @@ -7,25 +7,25 @@ use std::path::PathBuf; use std::rc::Rc; use boxed_error::Boxed; -use deno_core::op2; -use deno_core::url::Url; -use deno_core::v8; use deno_core::FastString; use deno_core::JsRuntimeInspector; use deno_core::OpState; +use deno_core::op2; +use deno_core::url::Url; +use deno_core::v8; use deno_error::JsErrorBox; use deno_package_json::PackageJsonRc; use deno_path_util::normalize_path; use deno_path_util::url_from_file_path; use deno_path_util::url_to_file_path; -use node_resolver::cache::NodeResolutionThreadLocalCache; -use node_resolver::errors::ClosestPkgJsonError; use node_resolver::InNpmPackageChecker; use node_resolver::NodeResolutionKind; use node_resolver::NpmPackageFolderResolver; use node_resolver::ResolutionMode; use node_resolver::UrlOrPath; use node_resolver::UrlOrPathRef; +use node_resolver::cache::NodeResolutionThreadLocalCache; +use node_resolver::errors::ClosestPkgJsonError; use sys_traits::FsCanonicalize; use sys_traits::FsMetadata; use sys_traits::FsMetadataValue; diff --git a/ext/node/ops/sqlite/database.rs b/ext/node/ops/sqlite/database.rs index 4a69378898..571a63aeeb 100644 --- a/ext/node/ops/sqlite/database.rs +++ b/ext/node/ops/sqlite/database.rs @@ -2,33 +2,33 @@ use std::cell::Cell; use std::cell::RefCell; -use std::ffi::c_char; -use std::ffi::c_void; use std::ffi::CStr; use std::ffi::CString; +use std::ffi::c_char; +use std::ffi::c_void; use std::ptr::null; use std::rc::Rc; +use deno_core::FromV8; +use deno_core::GarbageCollected; +use deno_core::OpState; use deno_core::convert::OptionUndefined; use deno_core::cppgc; use deno_core::op2; use deno_core::v8; use deno_core::v8_static_strings; -use deno_core::FromV8; -use deno_core::GarbageCollected; -use deno_core::OpState; use deno_permissions::PermissionsContainer; use rusqlite::ffi as libsqlite3_sys; use rusqlite::ffi::SQLITE_DBCONFIG_DQS_DDL; use rusqlite::ffi::SQLITE_DBCONFIG_DQS_DML; use rusqlite::limits::Limit; -use super::session::SessionOptions; -use super::statement::check_error_code2; -use super::validators; use super::Session; use super::SqliteError; use super::StatementSync; +use super::session::SessionOptions; +use super::statement::check_error_code2; +use super::validators; const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; const SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE: i32 = 1021; @@ -580,35 +580,38 @@ impl DatabaseSync { e_conflict: i32, _: *mut libsqlite3_sys::sqlite3_changeset_iter, ) -> i32 { - let ctx = &mut *(p_ctx as *mut HandlerCtx); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + let ctx = &mut *(p_ctx as *mut HandlerCtx); - if let Some(conflict) = &mut ctx.confict { - let recv = v8::undefined(ctx.scope).into(); - let args = [v8::Integer::new(ctx.scope, e_conflict).into()]; + if let Some(conflict) = &mut ctx.confict { + let recv = v8::undefined(ctx.scope).into(); + let args = [v8::Integer::new(ctx.scope, e_conflict).into()]; - let tc_scope = &mut v8::TryCatch::new(ctx.scope); + let tc_scope = &mut v8::TryCatch::new(ctx.scope); - let ret = conflict - .call(tc_scope, recv, &args) - .unwrap_or_else(|| v8::undefined(tc_scope).into()); - if tc_scope.has_caught() { - tc_scope.rethrow(); - return libsqlite3_sys::SQLITE_CHANGESET_ABORT; + let ret = conflict + .call(tc_scope, recv, &args) + .unwrap_or_else(|| v8::undefined(tc_scope).into()); + if tc_scope.has_caught() { + tc_scope.rethrow(); + return libsqlite3_sys::SQLITE_CHANGESET_ABORT; + } + + const INVALID_VALUE: i32 = -1; + if !ret.is_int32() { + return INVALID_VALUE; + } + + let value = ret + .int32_value(tc_scope) + .unwrap_or(libsqlite3_sys::SQLITE_CHANGESET_ABORT); + + return value; } - const INVALID_VALUE: i32 = -1; - if !ret.is_int32() { - return INVALID_VALUE; - } - - let value = ret - .int32_value(tc_scope) - .unwrap_or(libsqlite3_sys::SQLITE_CHANGESET_ABORT); - - return value; + libsqlite3_sys::SQLITE_CHANGESET_ABORT } - - libsqlite3_sys::SQLITE_CHANGESET_ABORT } // Filter handler callback for `sqlite3changeset_apply()`. @@ -616,19 +619,22 @@ impl DatabaseSync { p_ctx: *mut c_void, z_tab: *const c_char, ) -> i32 { - let ctx = &mut *(p_ctx as *mut HandlerCtx); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + let ctx = &mut *(p_ctx as *mut HandlerCtx); - if let Some(filter) = &mut ctx.filter { - let tab = CStr::from_ptr(z_tab).to_str().unwrap(); + if let Some(filter) = &mut ctx.filter { + let tab = CStr::from_ptr(z_tab).to_str().unwrap(); - let recv = v8::undefined(ctx.scope).into(); - let args = [v8::String::new(ctx.scope, tab).unwrap().into()]; + let recv = v8::undefined(ctx.scope).into(); + let args = [v8::String::new(ctx.scope, tab).unwrap().into()]; - let ret = filter.call(ctx.scope, recv, &args).unwrap(); - return ret.boolean_value(ctx.scope) as i32; + let ret = filter.call(ctx.scope, recv, &args).unwrap(); + return ret.boolean_value(ctx.scope) as i32; + } + + 1 } - - 1 } let db = self.conn.borrow(); diff --git a/ext/node/ops/sqlite/mod.rs b/ext/node/ops/sqlite/mod.rs index 6ebe61ecac..38f533902f 100644 --- a/ext/node/ops/sqlite/mod.rs +++ b/ext/node/ops/sqlite/mod.rs @@ -50,7 +50,9 @@ pub enum SqliteError { #[property("code" = self.code())] InvalidBindValue(&'static str), #[class(generic)] - #[error("Cannot create bare named parameter '{0}' because of conflicting names '{1}' and '{2}'.")] + #[error( + "Cannot create bare named parameter '{0}' because of conflicting names '{1}' and '{2}'." + )] #[property("code" = self.code())] DuplicateNamedParameter(String, String, String), #[class(generic)] @@ -98,7 +100,9 @@ pub enum SqliteError { #[property("code" = self.code())] InvalidExpandedSql, #[class(range)] - #[error("The value of column {0} is too large to be represented as a JavaScript number: {1}")] + #[error( + "The value of column {0} is too large to be represented as a JavaScript number: {1}" + )] #[property("code" = self.code())] NumberTooLarge(i32, i64), #[class(type)] diff --git a/ext/node/ops/sqlite/session.rs b/ext/node/ops/sqlite/session.rs index 8f83b6b3f8..9d18ec8595 100644 --- a/ext/node/ops/sqlite/session.rs +++ b/ext/node/ops/sqlite/session.rs @@ -5,15 +5,15 @@ use std::cell::RefCell; use std::ffi::c_void; use std::rc::Weak; +use deno_core::FromV8; +use deno_core::GarbageCollected; use deno_core::op2; use deno_core::v8; use deno_core::v8_static_strings; -use deno_core::FromV8; -use deno_core::GarbageCollected; use rusqlite::ffi; -use super::validators; use super::SqliteError; +use super::validators; #[derive(Default)] pub struct SessionOptions { diff --git a/ext/node/ops/sqlite/statement.rs b/ext/node/ops/sqlite/statement.rs index 6398d634b2..c308c9e3c8 100644 --- a/ext/node/ops/sqlite/statement.rs +++ b/ext/node/ops/sqlite/statement.rs @@ -5,16 +5,16 @@ use std::cell::RefCell; use std::rc::Rc; use std::rc::Weak; +use deno_core::GarbageCollected; +use deno_core::ToV8; use deno_core::op2; use deno_core::v8; use deno_core::v8::GetPropertyNamesArgs; use deno_core::v8_static_strings; -use deno_core::GarbageCollected; -use deno_core::ToV8; use rusqlite::ffi; -use super::validators; use super::SqliteError; +use super::validators; // ECMA-262, 15th edition, 21.1.2.6. Number.MAX_SAFE_INTEGER (2^53-1) const MAX_SAFE_JS_INTEGER: i64 = 9007199254740991; diff --git a/ext/node/ops/util.rs b/ext/node/ops/util.rs index f30763b70a..03c02476e4 100644 --- a/ext/node/ops/util.rs +++ b/ext/node/ops/util.rs @@ -1,10 +1,10 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; -use deno_core::v8; use deno_core::OpState; use deno_core::ResourceHandle; use deno_core::ResourceHandleFd; +use deno_core::op2; +use deno_core::v8; use node_resolver::InNpmPackageChecker; use node_resolver::NpmPackageFolderResolver; diff --git a/ext/node/ops/v8.rs b/ext/node/ops/v8.rs index a8e7ac77ab..32fdc1a21e 100644 --- a/ext/node/ops/v8.rs +++ b/ext/node/ops/v8.rs @@ -2,11 +2,11 @@ use std::ptr::NonNull; -use deno_core::op2; -use deno_core::v8; use deno_core::FastString; use deno_core::GarbageCollected; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::v8; use deno_error::JsErrorBox; use v8::ValueDeserializerHelper; use v8::ValueSerializerHelper; diff --git a/ext/node/ops/vm.rs b/ext/node/ops/vm.rs index 48337881ba..00418f669c 100644 --- a/ext/node/ops/vm.rs +++ b/ext/node/ops/vm.rs @@ -5,11 +5,11 @@ use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; use std::time::Duration; +use deno_core::JsBuffer; use deno_core::op2; use deno_core::serde_v8; use deno_core::v8; use deno_core::v8::MapFnTo; -use deno_core::JsBuffer; use crate::create_host_defined_options; diff --git a/ext/node/ops/worker_threads.rs b/ext/node/ops/worker_threads.rs index ae3c28ef35..28f0574a22 100644 --- a/ext/node/ops/worker_threads.rs +++ b/ext/node/ops/worker_threads.rs @@ -4,9 +4,9 @@ use std::borrow::Cow; use std::path::Path; use std::path::PathBuf; +use deno_core::OpState; use deno_core::op2; use deno_core::url::Url; -use deno_core::OpState; use deno_error::JsErrorBox; use sys_traits::FsCanonicalize; use sys_traits::FsMetadata; diff --git a/ext/node/ops/zlib/brotli.rs b/ext/node/ops/zlib/brotli.rs index 5e4c1d16e6..50fc66a4cc 100644 --- a/ext/node/ops/zlib/brotli.rs +++ b/ext/node/ops/zlib/brotli.rs @@ -2,21 +2,21 @@ use std::cell::RefCell; use std::io::Read; +use brotli::BrotliDecompressStream; +use brotli::BrotliResult; +use brotli::BrotliState; +use brotli::Decompressor; use brotli::enc::backward_references::BrotliEncoderMode; use brotli::enc::encode::BrotliEncoderCompress; use brotli::enc::encode::BrotliEncoderOperation; use brotli::enc::encode::BrotliEncoderParameter; use brotli::enc::encode::BrotliEncoderStateStruct; use brotli::writer::StandardAlloc; -use brotli::BrotliDecompressStream; -use brotli::BrotliResult; -use brotli::BrotliState; -use brotli::Decompressor; -use deno_core::op2; use deno_core::JsBuffer; use deno_core::OpState; use deno_core::Resource; use deno_core::ToJsBuffer; +use deno_core::op2; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum BrotliError { @@ -102,11 +102,7 @@ fn max_compressed_size(input_size: usize) -> usize { let overhead = 2 + (4 * num_large_blocks) + 3 + 1; let result = input_size + overhead; - if result < input_size { - 0 - } else { - result - } + if result < input_size { 0 } else { result } } #[op2(async)] diff --git a/ext/os/lib.rs b/ext/os/lib.rs index 9a1dd6a8c7..7c2d1de94a 100644 --- a/ext/os/lib.rs +++ b/ext/os/lib.rs @@ -3,13 +3,13 @@ use std::collections::HashMap; use std::collections::HashSet; use std::env; +use std::sync::Arc; use std::sync::atomic::AtomicI32; use std::sync::atomic::Ordering; -use std::sync::Arc; +use deno_core::OpState; use deno_core::op2; use deno_core::v8; -use deno_core::OpState; use deno_path_util::normalize_path; use deno_permissions::PermissionCheckError; use deno_permissions::PermissionsContainer; @@ -127,7 +127,7 @@ fn op_exec_path() -> Result { } fn dt_change_notif(isolate: &mut v8::Isolate, key: &str) { - extern "C" { + unsafe extern "C" { #[cfg(unix)] fn tzset(); @@ -169,7 +169,10 @@ fn op_set_env( return Err(OsError::EnvInvalidValue(value.to_string())); } - env::set_var(key, value); + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + env::set_var(key, value) + }; dt_change_notif(scope, key); Ok(()) } @@ -241,7 +244,11 @@ fn op_delete_env( if key.is_empty() || key.contains(&['=', '\0'] as &[char]) { return Err(OsError::EnvInvalidKey(key.to_string())); } - env::remove_var(key); + + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + env::remove_var(key) + }; Ok(()) } @@ -594,7 +601,7 @@ fn rss() -> u64 { let mut count = libc::MACH_TASK_BASIC_INFO_COUNT; // SAFETY: libc calls let r = unsafe { - extern "C" { + unsafe extern "C" { static mut mach_task_self_: std::ffi::c_uint; } libc::task_info( diff --git a/ext/os/ops/signal.rs b/ext/os/ops/signal.rs index f728e8499f..488bee326c 100644 --- a/ext/os/ops/signal.rs +++ b/ext/os/ops/signal.rs @@ -5,12 +5,10 @@ use std::cell::RefCell; use std::collections::BTreeMap; use std::rc::Rc; #[cfg(unix)] -use std::sync::atomic::AtomicBool; -#[cfg(unix)] use std::sync::Arc; +#[cfg(unix)] +use std::sync::atomic::AtomicBool; -use deno_core::error::ResourceError; -use deno_core::op2; use deno_core::AsyncRefCell; use deno_core::CancelFuture; use deno_core::CancelHandle; @@ -18,12 +16,14 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; -#[cfg(unix)] -use tokio::signal::unix::signal; +use deno_core::error::ResourceError; +use deno_core::op2; #[cfg(unix)] use tokio::signal::unix::Signal; #[cfg(unix)] use tokio::signal::unix::SignalKind; +#[cfg(unix)] +use tokio::signal::unix::signal; #[cfg(windows)] use tokio::signal::windows::CtrlBreak; #[cfg(windows)] diff --git a/ext/os/signal.rs b/ext/os/signal.rs index 0e8fb71526..8483ae978b 100644 --- a/ext/os/signal.rs +++ b/ext/os/signal.rs @@ -2,7 +2,9 @@ #[cfg(target_os = "windows")] #[derive(Debug, thiserror::Error)] -#[error("Windows only supports ctrl-c (SIGINT), ctrl-break (SIGBREAK), and ctrl-close (SIGUP), but got {0}")] +#[error( + "Windows only supports ctrl-c (SIGINT), ctrl-break (SIGBREAK), and ctrl-close (SIGUP), but got {0}" +)] pub struct InvalidSignalStrError(pub String); #[cfg(any( @@ -20,7 +22,9 @@ pub struct InvalidSignalStrError(pub String); #[cfg(target_os = "windows")] #[derive(Debug, thiserror::Error)] -#[error("Windows only supports ctrl-c (SIGINT), ctrl-break (SIGBREAK), and ctrl-close (SIGUP), but got {0}")] +#[error( + "Windows only supports ctrl-c (SIGINT), ctrl-break (SIGBREAK), and ctrl-close (SIGUP), but got {0}" +)] pub struct InvalidSignalIntError(pub libc::c_int); #[cfg(any( diff --git a/ext/os/sys_info.rs b/ext/os/sys_info.rs index fa4bf8fc18..fa4796ea2d 100644 --- a/ext/os/sys_info.rs +++ b/ext/os/sys_info.rs @@ -279,7 +279,7 @@ pub fn mem_info() -> Option { mem_info.swap_total = xs.xsu_total; mem_info.swap_free = xs.xsu_avail; - extern "C" { + unsafe extern "C" { fn mach_host_self() -> std::ffi::c_uint; } diff --git a/ext/process/ipc.rs b/ext/process/ipc.rs index 3728943457..3d6e6a789a 100644 --- a/ext/process/ipc.rs +++ b/ext/process/ipc.rs @@ -10,16 +10,16 @@ use std::pin::Pin; use std::rc::Rc; use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicUsize; -use std::task::ready; use std::task::Context; use std::task::Poll; +use std::task::ready; -use deno_core::serde; -use deno_core::serde_json; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::ExternalOpsTracker; use deno_core::RcRef; +use deno_core::serde; +use deno_core::serde_json; use deno_io::BiPipe; use deno_io::BiPipeRead; use deno_io::BiPipeWrite; @@ -369,11 +369,11 @@ impl Future for ReadMsgInner<'_, R> { mod tests { use std::rc::Rc; - use deno_core::serde_json::json; - use deno_core::v8; use deno_core::JsRuntime; use deno_core::RcRef; use deno_core::RuntimeOptions; + use deno_core::serde_json::json; + use deno_core::v8; use super::IpcJsonStreamResource; diff --git a/ext/process/lib.rs b/ext/process/lib.rs index 65ecfc2cd2..4d7f154504 100644 --- a/ext/process/lib.rs +++ b/ext/process/lib.rs @@ -18,8 +18,6 @@ use std::process::ExitStatus; use std::process::Stdio as StdStdio; use std::rc::Rc; -use deno_core::op2; -use deno_core::serde_json; use deno_core::AsyncMutFuture; use deno_core::AsyncRefCell; use deno_core::JsBuffer; @@ -28,12 +26,14 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::serde_json; use deno_error::JsErrorBox; -use deno_io::fs::FileResource; use deno_io::ChildStderrResource; use deno_io::ChildStdinResource; use deno_io::ChildStdoutResource; use deno_io::IntoRawIoHandle; +use deno_io::fs::FileResource; use deno_os::SignalError; use deno_permissions::PermissionsContainer; use deno_permissions::RunQueryDescriptor; @@ -903,17 +903,19 @@ fn check_run_permission( if !env_var_names.is_empty() { // we don't allow users to launch subprocesses with any LD_ or DYLD_* // env vars set because this allows executing code (ex. LD_PRELOAD) - return Err(CheckRunPermissionError::Other( - JsErrorBox::new( - "NotCapable", - format!( - "Requires --allow-run permissions to spawn subprocess with {0} environment variable{1}. Alternatively, spawn with {2} environment variable{1} unset.", - env_var_names.join(", "), - if env_var_names.len() != 1 { "s" } else { "" }, - if env_var_names.len() != 1 { "these" } else { "the" } - ), + return Err(CheckRunPermissionError::Other(JsErrorBox::new( + "NotCapable", + format!( + "Requires --allow-run permissions to spawn subprocess with {0} environment variable{1}. Alternatively, spawn with {2} environment variable{1} unset.", + env_var_names.join(", "), + if env_var_names.len() != 1 { "s" } else { "" }, + if env_var_names.len() != 1 { + "these" + } else { + "the" + } ), - )); + ))); } permissions.check_run(cmd, api_name)?; } @@ -1262,8 +1264,8 @@ mod deprecated { pub fn kill(pid: i32, signal: &str) -> Result<(), ProcessError> { let signo = deno_os::signal::signal_str_to_int(signal) .map_err(SignalError::InvalidSignalStr)?; - use nix::sys::signal::kill as unix_kill; use nix::sys::signal::Signal; + use nix::sys::signal::kill as unix_kill; use nix::unistd::Pid; let sig = Signal::try_from(signo).map_err(|e| ProcessError::Nix(JsNixError(e)))?; diff --git a/ext/telemetry/lib.rs b/ext/telemetry/lib.rs index 5459a79c5b..01c0a2c94a 100644 --- a/ext/telemetry/lib.rs +++ b/ext/telemetry/lib.rs @@ -11,9 +11,9 @@ use std::ffi::c_void; use std::fmt::Debug; use std::pin::Pin; use std::rc::Rc; -use std::sync::atomic::AtomicU64; use std::sync::Arc; use std::sync::Mutex; +use std::sync::atomic::AtomicU64; use std::task::Context; use std::task::Poll; use std::thread; @@ -21,22 +21,27 @@ use std::time::Duration; use std::time::Instant; use std::time::SystemTime; +use deno_core::GarbageCollected; +use deno_core::OpState; +use deno_core::futures::FutureExt; +use deno_core::futures::Stream; +use deno_core::futures::StreamExt; use deno_core::futures::channel::mpsc; use deno_core::futures::channel::mpsc::UnboundedSender; use deno_core::futures::future::BoxFuture; use deno_core::futures::stream; -use deno_core::futures::FutureExt; -use deno_core::futures::Stream; -use deno_core::futures::StreamExt; use deno_core::op2; use deno_core::v8; use deno_core::v8::DataError; -use deno_core::GarbageCollected; -use deno_core::OpState; use deno_error::JsError; use deno_error::JsErrorBox; use once_cell::sync::Lazy; use once_cell::sync::OnceCell; +use opentelemetry::InstrumentationScope; +pub use opentelemetry::Key; +pub use opentelemetry::KeyValue; +pub use opentelemetry::StringValue; +pub use opentelemetry::Value; use opentelemetry::logs::AnyValue; use opentelemetry::logs::LogRecord as LogRecordTrait; use opentelemetry::logs::Severity; @@ -57,32 +62,27 @@ use opentelemetry::trace::Status as SpanStatus; use opentelemetry::trace::TraceFlags; use opentelemetry::trace::TraceId; use opentelemetry::trace::TraceState; -use opentelemetry::InstrumentationScope; -pub use opentelemetry::Key; -pub use opentelemetry::KeyValue; -pub use opentelemetry::StringValue; -pub use opentelemetry::Value; use opentelemetry_otlp::HttpExporterBuilder; use opentelemetry_otlp::Protocol; use opentelemetry_otlp::WithExportConfig; use opentelemetry_otlp::WithHttpConfig; +use opentelemetry_sdk::Resource; use opentelemetry_sdk::export::trace::SpanData; use opentelemetry_sdk::logs::BatchLogProcessor; use opentelemetry_sdk::logs::LogProcessor; use opentelemetry_sdk::logs::LogRecord; -use opentelemetry_sdk::metrics::exporter::PushMetricExporter; -use opentelemetry_sdk::metrics::reader::MetricReader; use opentelemetry_sdk::metrics::ManualReader; use opentelemetry_sdk::metrics::MetricResult; use opentelemetry_sdk::metrics::SdkMeterProvider; use opentelemetry_sdk::metrics::Temporality; +use opentelemetry_sdk::metrics::exporter::PushMetricExporter; +use opentelemetry_sdk::metrics::reader::MetricReader; use opentelemetry_sdk::trace::BatchSpanProcessor; use opentelemetry_sdk::trace::IdGenerator; use opentelemetry_sdk::trace::RandomIdGenerator; use opentelemetry_sdk::trace::SpanEvents; use opentelemetry_sdk::trace::SpanLinks; use opentelemetry_sdk::trace::SpanProcessor as _; -use opentelemetry_sdk::Resource; use opentelemetry_semantic_conventions::resource::PROCESS_RUNTIME_NAME; use opentelemetry_semantic_conventions::resource::PROCESS_RUNTIME_VERSION; use opentelemetry_semantic_conventions::resource::TELEMETRY_SDK_LANGUAGE; @@ -501,19 +501,19 @@ mod hyper_client { use std::task::Poll; use std::task::{self}; - use deno_tls::create_client_config; - use deno_tls::load_certs; - use deno_tls::load_private_keys; use deno_tls::SocketUse; use deno_tls::TlsKey; use deno_tls::TlsKeys; + use deno_tls::create_client_config; + use deno_tls::load_certs; + use deno_tls::load_private_keys; use http_body_util::BodyExt; use http_body_util::Full; use hyper::body::Body as HttpBody; use hyper::body::Frame; use hyper_rustls::HttpsConnector; - use hyper_util::client::legacy::connect::HttpConnector; use hyper_util::client::legacy::Client; + use hyper_util::client::legacy::connect::HttpConnector; use opentelemetry_http::Bytes; use opentelemetry_http::HttpError; use opentelemetry_http::Request; @@ -2354,11 +2354,12 @@ async fn op_otel_metric_wait_to_observe(state: Rc>) -> bool { .expect("mutex poisoned") .push(tx); } - if let Ok(done) = rx.await { - state.borrow_mut().put(ObservationDone(done)); - true - } else { - false + match rx.await { + Ok(done) => { + state.borrow_mut().put(ObservationDone(done)); + true + } + _ => false, } } diff --git a/ext/tls/lib.rs b/ext/tls/lib.rs index 3a21184a88..73da88a154 100644 --- a/ext/tls/lib.rs +++ b/ext/tls/lib.rs @@ -8,16 +8,16 @@ use std::sync::Arc; use deno_error::JsErrorBox; pub use deno_native_certs; pub use rustls; -use rustls::client::danger::HandshakeSignatureValid; -use rustls::client::danger::ServerCertVerified; -use rustls::client::danger::ServerCertVerifier; -use rustls::client::WebPkiServerVerifier; -use rustls::pki_types::CertificateDer; -use rustls::pki_types::PrivateKeyDer; -use rustls::pki_types::ServerName; use rustls::ClientConfig; use rustls::DigitallySignedStruct; use rustls::RootCertStore; +use rustls::client::WebPkiServerVerifier; +use rustls::client::danger::HandshakeSignatureValid; +use rustls::client::danger::ServerCertVerified; +use rustls::client::danger::ServerCertVerifier; +use rustls::pki_types::CertificateDer; +use rustls::pki_types::PrivateKeyDer; +use rustls::pki_types::ServerName; pub use rustls_pemfile; use rustls_pemfile::certs; use rustls_pemfile::ec_private_keys; diff --git a/ext/tls/tls_key.rs b/ext/tls/tls_key.rs index 15704ad2f2..ea860042e1 100644 --- a/ext/tls/tls_key.rs +++ b/ext/tls/tls_key.rs @@ -14,15 +14,15 @@ use std::cell::RefCell; use std::collections::HashMap; use std::fmt::Debug; +use std::future::Future; use std::future::poll_fn; use std::future::ready; -use std::future::Future; use std::io::ErrorKind; use std::rc::Rc; use std::sync::Arc; -use deno_core::futures::future::Either; use deno_core::futures::FutureExt; +use deno_core::futures::future::Either; use deno_core::unsync::spawn; use rustls::ServerConfig; use rustls_tokio_stream::ServerConfigProvider; @@ -198,7 +198,7 @@ impl TlsKeyResolver { pub fn resolve( &self, sni: String, - ) -> impl Future> { + ) -> impl Future> + use<> { let mut cache = self.inner.cache.borrow_mut(); let mut recv = match cache.get(&sni) { None => { @@ -255,13 +255,12 @@ impl TlsKeyLookup { /// Multiple `poll` calls are safe, but this method is not starvation-safe. Generally /// only one `poll`er should be active at any time. pub async fn poll(&self) -> Option { - if let Some((sni, sender)) = - poll_fn(|cx| self.resolution_rx.borrow_mut().poll_recv(cx)).await - { - self.pending.borrow_mut().insert(sni.clone(), sender); - Some(sni) - } else { - None + match poll_fn(|cx| self.resolution_rx.borrow_mut().poll_recv(cx)).await { + Some((sni, sender)) => { + self.pending.borrow_mut().insert(sni.clone(), sender); + Some(sni) + } + _ => None, } } diff --git a/ext/url/benches/url_ops.rs b/ext/url/benches/url_ops.rs index 7c260a562d..4bdc380830 100644 --- a/ext/url/benches/url_ops.rs +++ b/ext/url/benches/url_ops.rs @@ -2,8 +2,8 @@ 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; fn setup() -> Vec { diff --git a/ext/url/lib.rs b/ext/url/lib.rs index 79b977c0c5..993dc9402b 100644 --- a/ext/url/lib.rs +++ b/ext/url/lib.rs @@ -2,12 +2,12 @@ mod urlpattern; -use deno_core::op2; -use deno_core::url::form_urlencoded; -use deno_core::url::quirks; -use deno_core::url::Url; use deno_core::JsBuffer; use deno_core::OpState; +use deno_core::op2; +use deno_core::url::Url; +use deno_core::url::form_urlencoded; +use deno_core::url::quirks; use deno_error::JsErrorBox; use crate::urlpattern::op_urlpattern_parse; diff --git a/ext/web/benches/encoding.rs b/ext/web/benches/encoding.rs index c7f7c532a8..594db3739c 100644 --- a/ext/web/benches/encoding.rs +++ b/ext/web/benches/encoding.rs @@ -2,8 +2,8 @@ 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; #[derive(Clone)] diff --git a/ext/web/benches/timers_ops.rs b/ext/web/benches/timers_ops.rs index 383232cfdf..4ef2401116 100644 --- a/ext/web/benches/timers_ops.rs +++ b/ext/web/benches/timers_ops.rs @@ -2,8 +2,8 @@ use deno_bench_util::bench_js_async; 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; #[derive(Clone)] diff --git a/ext/web/blob.rs b/ext/web/blob.rs index d6a5a45931..9b0258cf31 100644 --- a/ext/web/blob.rs +++ b/ext/web/blob.rs @@ -7,12 +7,12 @@ use std::rc::Rc; use std::sync::Arc; use async_trait::async_trait; -use deno_core::op2; -use deno_core::parking_lot::Mutex; -use deno_core::url::Url; use deno_core::JsBuffer; use deno_core::OpState; use deno_core::ToJsBuffer; +use deno_core::op2; +use deno_core::parking_lot::Mutex; +use deno_core::url::Url; use serde::Deserialize; use serde::Serialize; use uuid::Uuid; @@ -308,20 +308,21 @@ pub fn op_blob_from_object_url( let blob_store = state .try_borrow::>() .ok_or(BlobError::BlobURLsNotSupported)?; - if let Some(blob) = blob_store.get_object_url(url) { - let parts = blob - .parts - .iter() - .map(|part| ReturnBlobPart { - uuid: blob_store.insert_part(part.clone()), - size: part.size(), - }) - .collect(); - Ok(Some(ReturnBlob { - media_type: blob.media_type.clone(), - parts, - })) - } else { - Ok(None) + match blob_store.get_object_url(url) { + Some(blob) => { + let parts = blob + .parts + .iter() + .map(|part| ReturnBlobPart { + uuid: blob_store.insert_part(part.clone()), + size: part.size(), + }) + .collect(); + Ok(Some(ReturnBlob { + media_type: blob.media_type.clone(), + parts, + })) + } + _ => Ok(None), } } diff --git a/ext/web/compression.rs b/ext/web/compression.rs index 865fe99c08..09bf175d2b 100644 --- a/ext/web/compression.rs +++ b/ext/web/compression.rs @@ -4,13 +4,13 @@ use std::cell::RefCell; use std::io::Write; use deno_core::op2; +use flate2::Compression; use flate2::write::DeflateDecoder; use flate2::write::DeflateEncoder; use flate2::write::GzDecoder; use flate2::write::GzEncoder; use flate2::write::ZlibDecoder; use flate2::write::ZlibEncoder; -use flate2::Compression; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum CompressionError { diff --git a/ext/web/lib.rs b/ext/web/lib.rs index 7475446bf5..c9adaf8330 100644 --- a/ext/web/lib.rs +++ b/ext/web/lib.rs @@ -12,12 +12,12 @@ use std::sync::Arc; pub use blob::BlobError; pub use compression::CompressionError; -use deno_core::op2; -use deno_core::url::Url; -use deno_core::v8; use deno_core::ByteString; use deno_core::ToJsBuffer; use deno_core::U16String; +use deno_core::op2; +use deno_core::url::Url; +use deno_core::v8; use encoding_rs::CoderResult; use encoding_rs::Decoder; use encoding_rs::DecoderResult; @@ -25,6 +25,10 @@ use encoding_rs::Encoding; pub use message_port::MessagePortError; pub use stream_resource::StreamResourceError; +pub use crate::blob::Blob; +pub use crate::blob::BlobPart; +pub use crate::blob::BlobStore; +pub use crate::blob::InMemoryBlobPart; use crate::blob::op_blob_create_object_url; use crate::blob::op_blob_create_part; use crate::blob::op_blob_from_object_url; @@ -32,10 +36,9 @@ use crate::blob::op_blob_read_part; use crate::blob::op_blob_remove_part; use crate::blob::op_blob_revoke_object_url; use crate::blob::op_blob_slice_part; -pub use crate::blob::Blob; -pub use crate::blob::BlobPart; -pub use crate::blob::BlobStore; -pub use crate::blob::InMemoryBlobPart; +pub use crate::message_port::JsMessageData; +pub use crate::message_port::MessagePort; +pub use crate::message_port::Transferable; pub use crate::message_port::create_entangled_message_port; pub use crate::message_port::deserialize_js_transferables; use crate::message_port::op_message_port_create_entangled; @@ -43,14 +46,11 @@ use crate::message_port::op_message_port_post_message; use crate::message_port::op_message_port_recv_message; use crate::message_port::op_message_port_recv_message_sync; pub use crate::message_port::serialize_transferables; -pub use crate::message_port::JsMessageData; -pub use crate::message_port::MessagePort; -pub use crate::message_port::Transferable; +pub use crate::timers::StartTime; +pub use crate::timers::TimersPermission; use crate::timers::op_defer; use crate::timers::op_now; use crate::timers::op_time_origin; -pub use crate::timers::StartTime; -pub use crate::timers::TimersPermission; deno_core::extension!(deno_web, deps = [ deno_webidl, deno_console, deno_url ], diff --git a/ext/web/message_port.rs b/ext/web/message_port.rs index b97d4de386..8c641eb67b 100644 --- a/ext/web/message_port.rs +++ b/ext/web/message_port.rs @@ -5,7 +5,6 @@ use std::cell::RefCell; use std::future::poll_fn; use std::rc::Rc; -use deno_core::op2; use deno_core::CancelFuture; use deno_core::CancelHandle; use deno_core::DetachedBuffer; @@ -13,12 +12,13 @@ use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::op2; use serde::Deserialize; use serde::Serialize; -use tokio::sync::mpsc::error::TryRecvError; -use tokio::sync::mpsc::unbounded_channel; use tokio::sync::mpsc::UnboundedReceiver; use tokio::sync::mpsc::UnboundedSender; +use tokio::sync::mpsc::error::TryRecvError; +use tokio::sync::mpsc::unbounded_channel; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum MessagePortError { diff --git a/ext/web/stream_resource.rs b/ext/web/stream_resource.rs index d554acd865..cce03a0177 100644 --- a/ext/web/stream_resource.rs +++ b/ext/web/stream_resource.rs @@ -3,8 +3,8 @@ use std::borrow::Cow; use std::cell::RefCell; use std::cell::RefMut; use std::ffi::c_void; -use std::future::poll_fn; use std::future::Future; +use std::future::poll_fn; use std::marker::PhantomData; use std::mem::MaybeUninit; use std::pin::Pin; @@ -14,10 +14,6 @@ use std::task::Poll; use std::task::Waker; use bytes::BytesMut; -use deno_core::external; -use deno_core::op2; -use deno_core::serde_v8::V8Slice; -use deno_core::unsync::TaskQueue; use deno_core::AsyncResult; use deno_core::BufView; use deno_core::CancelFuture; @@ -29,6 +25,10 @@ use deno_core::RcLike; use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; +use deno_core::external; +use deno_core::op2; +use deno_core::serde_v8::V8Slice; +use deno_core::unsync::TaskQueue; use futures::TryFutureExt; #[derive(Debug, thiserror::Error, deno_error::JsError)] @@ -120,10 +120,13 @@ impl BoundedBufferChannelInner { /// calling this. #[inline(always)] unsafe fn next_unsafe(&mut self) -> &mut V8Slice { - self - .buffers - .get_unchecked_mut(self.ring_consumer as usize) - .assume_init_mut() + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + self + .buffers + .get_unchecked_mut(self.ring_consumer as usize) + .assume_init_mut() + } } /// # Safety @@ -132,10 +135,13 @@ impl BoundedBufferChannelInner { /// calling this. #[inline(always)] unsafe fn take_next_unsafe(&mut self) -> V8Slice { - let res = std::ptr::read(self.next_unsafe()); - self.ring_consumer = (self.ring_consumer + 1) % BUFFER_CHANNEL_SIZE; + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe { + let res = std::ptr::read(self.next_unsafe()); + self.ring_consumer = (self.ring_consumer + 1) % BUFFER_CHANNEL_SIZE; - res + res + } } fn drain(&mut self, mut f: impl FnMut(V8Slice)) { @@ -370,7 +376,7 @@ struct ReadableStreamResource { } impl ReadableStreamResource { - pub fn cancel_handle(self: &Rc) -> impl RcLike { + pub fn cancel_handle(self: &Rc) -> impl RcLike + use<> { RcRef::map(self, |s| &s.cancel_handle).clone() } @@ -587,7 +593,7 @@ pub fn op_readable_stream_resource_close(sender: *const c_void) { pub fn op_readable_stream_resource_await_close( state: &mut OpState, #[smi] rid: ResourceId, -) -> impl Future { +) -> impl Future + use<> { let completion = state .resource_table .get::(rid) @@ -614,8 +620,8 @@ impl Drop for ReadableStreamResourceData { #[cfg(test)] mod tests { use std::cell::OnceCell; - use std::sync::atomic::AtomicUsize; use std::sync::OnceLock; + use std::sync::atomic::AtomicUsize; use std::time::Duration; use deno_core::v8; diff --git a/ext/web/timers.rs b/ext/web/timers.rs index 7929b6050e..28945382cd 100644 --- a/ext/web/timers.rs +++ b/ext/web/timers.rs @@ -7,8 +7,8 @@ use std::time::Instant; use std::time::SystemTime; use std::time::UNIX_EPOCH; -use deno_core::op2; use deno_core::OpState; +use deno_core::op2; pub trait TimersPermission { fn allow_hrtime(&mut self) -> bool; diff --git a/ext/webgpu/adapter.rs b/ext/webgpu/adapter.rs index 82d7874366..53a00e8be2 100644 --- a/ext/webgpu/adapter.rs +++ b/ext/webgpu/adapter.rs @@ -4,18 +4,18 @@ use std::collections::HashSet; use std::rc::Rc; use std::sync::Arc; -use deno_core::cppgc::SameObject; -use deno_core::op2; -use deno_core::v8; use deno_core::GarbageCollected; use deno_core::OpState; use deno_core::WebIDL; +use deno_core::cppgc::SameObject; +use deno_core::op2; +use deno_core::v8; use tokio::sync::Mutex; use super::device::GPUDevice; -use crate::webidl::features_to_feature_names; -use crate::webidl::GPUFeatureName; use crate::Instance; +use crate::webidl::GPUFeatureName; +use crate::webidl::features_to_feature_names; #[derive(WebIDL)] #[webidl(dictionary)] diff --git a/ext/webgpu/bind_group.rs b/ext/webgpu/bind_group.rs index 3cd6580563..109e23219b 100644 --- a/ext/webgpu/bind_group.rs +++ b/ext/webgpu/bind_group.rs @@ -2,6 +2,8 @@ use std::borrow::Cow; +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::v8::HandleScope; @@ -11,13 +13,11 @@ use deno_core::webidl::ContextFn; use deno_core::webidl::WebIdlConverter; use deno_core::webidl::WebIdlError; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; -use deno_core::WebIDL; +use crate::Instance; use crate::buffer::GPUBuffer; use crate::sampler::GPUSampler; use crate::texture::GPUTextureView; -use crate::Instance; pub struct GPUBindGroup { pub instance: Instance, diff --git a/ext/webgpu/bind_group_layout.rs b/ext/webgpu/bind_group_layout.rs index 7b50e6e05e..dd4397eb44 100644 --- a/ext/webgpu/bind_group_layout.rs +++ b/ext/webgpu/bind_group_layout.rs @@ -1,11 +1,11 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::op2; -use crate::texture::GPUTextureViewDimension; use crate::Instance; +use crate::texture::GPUTextureViewDimension; pub struct GPUBindGroupLayout { pub instance: Instance, diff --git a/ext/webgpu/buffer.rs b/ext/webgpu/buffer.rs index f1cef4f0d8..c5f1a4a2d9 100644 --- a/ext/webgpu/buffer.rs +++ b/ext/webgpu/buffer.rs @@ -4,12 +4,12 @@ use std::cell::RefCell; use std::rc::Rc; use std::time::Duration; +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::futures::channel::oneshot; use deno_core::op2; use deno_core::v8; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use deno_error::JsErrorBox; use wgpu_core::device::HostMap as MapMode; diff --git a/ext/webgpu/byow.rs b/ext/webgpu/byow.rs index da8f0c9ff2..1c6f94ba6d 100644 --- a/ext/webgpu/byow.rs +++ b/ext/webgpu/byow.rs @@ -10,14 +10,14 @@ use std::ffi::c_void; ))] use std::ptr::NonNull; +use deno_core::FromV8; +use deno_core::GarbageCollected; +use deno_core::OpState; use deno_core::cppgc::SameObject; use deno_core::op2; use deno_core::v8; use deno_core::v8::Local; use deno_core::v8::Value; -use deno_core::FromV8; -use deno_core::GarbageCollected; -use deno_core::OpState; use deno_error::JsErrorBox; use crate::surface::GPUCanvasContext; @@ -25,7 +25,9 @@ use crate::surface::GPUCanvasContext; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum ByowError { #[class(type)] - #[error("Cannot create surface outside of WebGPU context. Did you forget to call `navigator.gpu.requestAdapter()`?")] + #[error( + "Cannot create surface outside of WebGPU context. Did you forget to call `navigator.gpu.requestAdapter()`?" + )] WebGPUNotInitiated, #[class(type)] #[error("Invalid parameters")] @@ -215,7 +217,7 @@ impl<'a> FromV8<'a> for UnsafeWindowSurfaceOptions { _ => { return Err(JsErrorBox::type_error(format!( "Invalid system kind '{s}'" - ))) + ))); } }; diff --git a/ext/webgpu/command_buffer.rs b/ext/webgpu/command_buffer.rs index 36c7e39448..b24c6a6455 100644 --- a/ext/webgpu/command_buffer.rs +++ b/ext/webgpu/command_buffer.rs @@ -2,9 +2,9 @@ use std::cell::OnceCell; -use deno_core::op2; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::op2; use crate::Instance; diff --git a/ext/webgpu/command_encoder.rs b/ext/webgpu/command_encoder.rs index 31a887120f..3d7d717635 100644 --- a/ext/webgpu/command_encoder.rs +++ b/ext/webgpu/command_encoder.rs @@ -3,14 +3,15 @@ use std::borrow::Cow; use std::cell::RefCell; -use deno_core::cppgc::Ptr; -use deno_core::op2; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::cppgc::Ptr; +use deno_core::op2; use deno_error::JsErrorBox; use wgpu_core::command::PassChannel; use wgpu_types::TexelCopyBufferInfo; +use crate::Instance; use crate::buffer::GPUBuffer; use crate::command_buffer::GPUCommandBuffer; use crate::compute_pass::GPUComputePassEncoder; @@ -18,7 +19,6 @@ use crate::queue::GPUTexelCopyTextureInfo; use crate::render_pass::GPULoadOp; use crate::render_pass::GPURenderPassEncoder; use crate::webidl::GPUExtent3D; -use crate::Instance; pub struct GPUCommandEncoder { pub instance: Instance, diff --git a/ext/webgpu/compute_pass.rs b/ext/webgpu/compute_pass.rs index 9dd617968e..a3be292b18 100644 --- a/ext/webgpu/compute_pass.rs +++ b/ext/webgpu/compute_pass.rs @@ -3,6 +3,8 @@ use std::borrow::Cow; use std::cell::RefCell; +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::v8; @@ -10,8 +12,6 @@ use deno_core::webidl::IntOptions; use deno_core::webidl::Nullable; use deno_core::webidl::WebIdlConverter; use deno_core::webidl::WebIdlError; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use crate::Instance; diff --git a/ext/webgpu/compute_pipeline.rs b/ext/webgpu/compute_pipeline.rs index 1803c4b685..dd6ac7ee9d 100644 --- a/ext/webgpu/compute_pipeline.rs +++ b/ext/webgpu/compute_pipeline.rs @@ -1,16 +1,16 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use indexmap::IndexMap; +use crate::Instance; use crate::bind_group_layout::GPUBindGroupLayout; use crate::shader::GPUShaderModule; use crate::webidl::GPUPipelineLayoutOrGPUAutoLayoutMode; -use crate::Instance; pub struct GPUComputePipeline { pub instance: Instance, diff --git a/ext/webgpu/device.rs b/ext/webgpu/device.rs index 43d82e28eb..ddcc900579 100644 --- a/ext/webgpu/device.rs +++ b/ext/webgpu/device.rs @@ -5,11 +5,11 @@ use std::cell::RefCell; use std::num::NonZeroU64; use std::rc::Rc; +use deno_core::GarbageCollected; use deno_core::cppgc::SameObject; use deno_core::op2; use deno_core::v8; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; use deno_error::JsErrorBox; use wgpu_core::binding_model::BindingResource; use wgpu_core::pipeline::ProgrammableStageDescriptor; @@ -25,6 +25,7 @@ use super::queue::GPUQueue; use super::sampler::GPUSampler; use super::shader::GPUShaderModule; use super::texture::GPUTexture; +use crate::Instance; use crate::adapter::GPUAdapterInfo; use crate::adapter::GPUSupportedFeatures; use crate::adapter::GPUSupportedLimits; @@ -33,7 +34,6 @@ use crate::query_set::GPUQuerySet; use crate::render_bundle::GPURenderBundleEncoder; use crate::render_pipeline::GPURenderPipeline; use crate::webidl::features_to_feature_names; -use crate::Instance; pub struct GPUDevice { pub instance: Instance, @@ -282,7 +282,9 @@ impl GPUDevice { .count(); if n_entries != 1 { - return Err(JsErrorBox::type_error("Only one of 'buffer', 'sampler', 'texture' and 'storageTexture' may be specified")); + return Err(JsErrorBox::type_error( + "Only one of 'buffer', 'sampler', 'texture' and 'storageTexture' may be specified", + )); } let ty = if let Some(buffer) = entry.buffer { diff --git a/ext/webgpu/error.rs b/ext/webgpu/error.rs index c9dd7fa5e6..53d9d7cbed 100644 --- a/ext/webgpu/error.rs +++ b/ext/webgpu/error.rs @@ -17,10 +17,10 @@ use wgpu_core::command::CreateRenderBundleError; use wgpu_core::command::QueryError; use wgpu_core::command::RenderBundleError; use wgpu_core::command::RenderPassError; -use wgpu_core::device::queue::QueueSubmitError; -use wgpu_core::device::queue::QueueWriteError; use wgpu_core::device::DeviceError; use wgpu_core::device::WaitIdleError; +use wgpu_core::device::queue::QueueSubmitError; +use wgpu_core::device::queue::QueueWriteError; use wgpu_core::pipeline::CreateComputePipelineError; use wgpu_core::pipeline::CreateRenderPipelineError; use wgpu_core::pipeline::CreateShaderModuleError; diff --git a/ext/webgpu/lib.rs b/ext/webgpu/lib.rs index 3690b9d2ee..f22d2afb7e 100644 --- a/ext/webgpu/lib.rs +++ b/ext/webgpu/lib.rs @@ -6,11 +6,11 @@ use std::cell::RefCell; use std::rc::Rc; use std::sync::Arc; +use deno_core::GarbageCollected; +use deno_core::OpState; use deno_core::cppgc::SameObject; use deno_core::op2; use deno_core::v8; -use deno_core::GarbageCollected; -use deno_core::OpState; pub use wgpu_core; pub use wgpu_types; use wgpu_types::PowerPreference; diff --git a/ext/webgpu/pipeline_layout.rs b/ext/webgpu/pipeline_layout.rs index 15c9b4d4fc..c417c90059 100644 --- a/ext/webgpu/pipeline_layout.rs +++ b/ext/webgpu/pipeline_layout.rs @@ -1,10 +1,10 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use crate::Instance; diff --git a/ext/webgpu/query_set.rs b/ext/webgpu/query_set.rs index 5e581fed99..81c4660e20 100644 --- a/ext/webgpu/query_set.rs +++ b/ext/webgpu/query_set.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; -use deno_core::webidl::WebIdlInterfaceConverter; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::op2; +use deno_core::webidl::WebIdlInterfaceConverter; use deno_error::JsErrorBox; use crate::Instance; diff --git a/ext/webgpu/queue.rs b/ext/webgpu/queue.rs index 3a7eeccae2..c2a570b4e5 100644 --- a/ext/webgpu/queue.rs +++ b/ext/webgpu/queue.rs @@ -1,19 +1,19 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::futures::channel::oneshot; use deno_core::op2; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use deno_error::JsErrorBox; +use crate::Instance; use crate::buffer::GPUBuffer; use crate::command_buffer::GPUCommandBuffer; use crate::texture::GPUTexture; use crate::texture::GPUTextureAspect; use crate::webidl::GPUExtent3D; use crate::webidl::GPUOrigin3D; -use crate::Instance; pub struct GPUQueue { pub instance: Instance, diff --git a/ext/webgpu/render_bundle.rs b/ext/webgpu/render_bundle.rs index 8a8eabfb5f..fad2d57bc8 100644 --- a/ext/webgpu/render_bundle.rs +++ b/ext/webgpu/render_bundle.rs @@ -4,6 +4,8 @@ use std::borrow::Cow; use std::cell::RefCell; use std::num::NonZeroU64; +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::v8; @@ -12,13 +14,11 @@ use deno_core::webidl::Nullable; use deno_core::webidl::WebIdlConverter; use deno_core::webidl::WebIdlError; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use deno_error::JsErrorBox; +use crate::Instance; use crate::buffer::GPUBuffer; use crate::texture::GPUTextureFormat; -use crate::Instance; pub struct GPURenderBundleEncoder { pub instance: Instance, diff --git a/ext/webgpu/render_pass.rs b/ext/webgpu/render_pass.rs index 762bf2034d..f79b6394f4 100644 --- a/ext/webgpu/render_pass.rs +++ b/ext/webgpu/render_pass.rs @@ -4,6 +4,8 @@ use std::borrow::Cow; use std::cell::RefCell; use std::num::NonZeroU64; +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::v8; @@ -11,14 +13,12 @@ use deno_core::webidl::IntOptions; use deno_core::webidl::Nullable; use deno_core::webidl::WebIdlConverter; use deno_core::webidl::WebIdlError; -use deno_core::GarbageCollected; -use deno_core::WebIDL; +use crate::Instance; use crate::buffer::GPUBuffer; use crate::render_bundle::GPURenderBundle; use crate::texture::GPUTextureView; use crate::webidl::GPUColor; -use crate::Instance; pub struct GPURenderPassEncoder { pub instance: Instance, diff --git a/ext/webgpu/render_pipeline.rs b/ext/webgpu/render_pipeline.rs index eabc0ae787..1f6f4b0bd5 100644 --- a/ext/webgpu/render_pipeline.rs +++ b/ext/webgpu/render_pipeline.rs @@ -1,19 +1,19 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use deno_core::GarbageCollected; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::webidl::Nullable; use deno_core::webidl::WebIdlInterfaceConverter; -use deno_core::GarbageCollected; -use deno_core::WebIDL; use indexmap::IndexMap; +use crate::Instance; use crate::bind_group_layout::GPUBindGroupLayout; use crate::sampler::GPUCompareFunction; use crate::shader::GPUShaderModule; use crate::texture::GPUTextureFormat; use crate::webidl::GPUPipelineLayoutOrGPUAutoLayoutMode; -use crate::Instance; pub struct GPURenderPipeline { pub instance: Instance, diff --git a/ext/webgpu/sampler.rs b/ext/webgpu/sampler.rs index 2af3f9d421..cad920edc1 100644 --- a/ext/webgpu/sampler.rs +++ b/ext/webgpu/sampler.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; -use deno_core::webidl::WebIdlInterfaceConverter; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::op2; +use deno_core::webidl::WebIdlInterfaceConverter; use crate::Instance; diff --git a/ext/webgpu/shader.rs b/ext/webgpu/shader.rs index c3a92e4ef7..52ad52d591 100644 --- a/ext/webgpu/shader.rs +++ b/ext/webgpu/shader.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; -use deno_core::webidl::WebIdlInterfaceConverter; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::op2; +use deno_core::webidl::WebIdlInterfaceConverter; use crate::Instance; diff --git a/ext/webgpu/surface.rs b/ext/webgpu/surface.rs index 1c4aa8b01a..d64ea678fb 100644 --- a/ext/webgpu/surface.rs +++ b/ext/webgpu/surface.rs @@ -2,12 +2,12 @@ use std::cell::RefCell; -use deno_core::op2; -use deno_core::v8; +use deno_core::_ops::make_cppgc_object; use deno_core::GarbageCollected; use deno_core::WebIDL; -use deno_core::_ops::make_cppgc_object; use deno_core::cppgc::Ptr; +use deno_core::op2; +use deno_core::v8; use deno_error::JsErrorBox; use wgpu_types::SurfaceStatus; diff --git a/ext/webgpu/texture.rs b/ext/webgpu/texture.rs index 3b8f65e757..c17b8d09e3 100644 --- a/ext/webgpu/texture.rs +++ b/ext/webgpu/texture.rs @@ -1,9 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use deno_core::op2; -use deno_core::webidl::WebIdlInterfaceConverter; use deno_core::GarbageCollected; use deno_core::WebIDL; +use deno_core::op2; +use deno_core::webidl::WebIdlInterfaceConverter; use deno_error::JsErrorBox; use wgpu_types::AstcBlock; use wgpu_types::AstcChannel; diff --git a/ext/webgpu/webidl.rs b/ext/webgpu/webidl.rs index 5e94ad38d3..9a7e0f6ec1 100644 --- a/ext/webgpu/webidl.rs +++ b/ext/webgpu/webidl.rs @@ -3,6 +3,7 @@ use std::borrow::Cow; use std::collections::HashSet; +use deno_core::WebIDL; use deno_core::cppgc::Ptr; use deno_core::v8; use deno_core::webidl::ContextFn; @@ -10,7 +11,6 @@ use deno_core::webidl::IntOptions; use deno_core::webidl::WebIdlConverter; use deno_core::webidl::WebIdlError; use deno_core::webidl::WebIdlErrorKind; -use deno_core::WebIDL; use deno_error::JsErrorBox; #[derive(WebIDL)] @@ -65,7 +65,14 @@ impl<'a> WebIdlConverter<'a> for GPUExtent3D { }, )?; if !(conv.len() > 1 && conv.len() <= 3) { - return Err(WebIdlError::other(prefix, context, JsErrorBox::type_error(format!("A sequence of number used as a GPUExtent3D must have between 1 and 3 elements, received {} elements", conv.len())))); + return Err(WebIdlError::other( + prefix, + context, + JsErrorBox::type_error(format!( + "A sequence of number used as a GPUExtent3D must have between 1 and 3 elements, received {} elements", + conv.len() + )), + )); } let mut iter = conv.into_iter(); @@ -168,7 +175,14 @@ impl<'a> WebIdlConverter<'a> for GPUOrigin3D { }, )?; if conv.len() > 3 { - return Err(WebIdlError::other(prefix, context, JsErrorBox::type_error(format!("A sequence of number used as a GPUOrigin3D must have at most 3 elements, received {} elements", conv.len())))); + return Err(WebIdlError::other( + prefix, + context, + JsErrorBox::type_error(format!( + "A sequence of number used as a GPUOrigin3D must have at most 3 elements, received {} elements", + conv.len() + )), + )); } let mut iter = conv.into_iter(); @@ -253,7 +267,14 @@ impl<'a> WebIdlConverter<'a> for GPUColor { options, )?; if conv.len() != 4 { - return Err(WebIdlError::other(prefix, context, JsErrorBox::type_error(format!("A sequence of number used as a GPUColor must have exactly 4 elements, received {} elements", conv.len())))); + return Err(WebIdlError::other( + prefix, + context, + JsErrorBox::type_error(format!( + "A sequence of number used as a GPUColor must have exactly 4 elements, received {} elements", + conv.len() + )), + )); } let mut iter = conv.into_iter(); diff --git a/ext/webidl/benches/dict.rs b/ext/webidl/benches/dict.rs index 71493fd95a..142385b83b 100644 --- a/ext/webidl/benches/dict.rs +++ b/ext/webidl/benches/dict.rs @@ -2,8 +2,8 @@ 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; fn setup() -> Vec { diff --git a/ext/websocket/lib.rs b/ext/websocket/lib.rs index 8a53d20e8b..902491527d 100644 --- a/ext/websocket/lib.rs +++ b/ext/websocket/lib.rs @@ -8,10 +8,6 @@ use std::rc::Rc; use std::sync::Arc; use bytes::Bytes; -use deno_core::futures::TryFutureExt; -use deno_core::op2; -use deno_core::unsync::spawn; -use deno_core::url; use deno_core::AsyncMutFuture; use deno_core::AsyncRefCell; use deno_core::ByteString; @@ -23,15 +19,19 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; use deno_core::ToJsBuffer; +use deno_core::futures::TryFutureExt; +use deno_core::op2; +use deno_core::unsync::spawn; +use deno_core::url; use deno_error::JsErrorBox; use deno_net::raw::NetworkStream; use deno_permissions::PermissionCheckError; -use deno_tls::create_client_config; -use deno_tls::rustls::ClientConfig; -use deno_tls::rustls::ClientConnection; use deno_tls::RootCertStoreProvider; use deno_tls::SocketUse; use deno_tls::TlsKeys; +use deno_tls::create_client_config; +use deno_tls::rustls::ClientConfig; +use deno_tls::rustls::ClientConnection; use fastwebsockets::CloseCode; use fastwebsockets::FragmentCollectorRead; use fastwebsockets::Frame; @@ -39,18 +39,18 @@ use fastwebsockets::OpCode; use fastwebsockets::Role; use fastwebsockets::WebSocket; use fastwebsockets::WebSocketWrite; -use http::header::CONNECTION; -use http::header::UPGRADE; use http::HeaderName; use http::HeaderValue; use http::Method; use http::Request; use http::StatusCode; use http::Uri; +use http::header::CONNECTION; +use http::header::UPGRADE; use once_cell::sync::Lazy; -use rustls_tokio_stream::rustls::pki_types::ServerName; -use rustls_tokio_stream::rustls::RootCertStore; use rustls_tokio_stream::TlsStream; +use rustls_tokio_stream::rustls::RootCertStore; +use rustls_tokio_stream::rustls::pki_types::ServerName; use serde::Serialize; use tokio::io::AsyncRead; use tokio::io::AsyncWrite; @@ -632,13 +632,16 @@ fn send_binary(state: &mut OpState, rid: ResourceId, data: &[u8]) { resource.buffered.set(resource.buffered.get() + len); let lock = resource.reserve_lock(); deno_core::unsync::spawn(async move { - if let Err(err) = resource + match resource .write_frame(lock, Frame::new(true, OpCode::Binary, None, data.into())) .await { - resource.set_error(Some(err.to_string())); - } else { - resource.buffered.set(resource.buffered.get() - len); + Err(err) => { + resource.set_error(Some(err.to_string())); + } + _ => { + resource.buffered.set(resource.buffered.get() - len); + } } }); } @@ -672,16 +675,19 @@ pub fn op_ws_send_text( resource.buffered.set(resource.buffered.get() + len); let lock = resource.reserve_lock(); deno_core::unsync::spawn(async move { - if let Err(err) = resource + match resource .write_frame( lock, Frame::new(true, OpCode::Text, None, data.into_bytes().into()), ) .await { - resource.set_error(Some(err.to_string())); - } else { - resource.buffered.set(resource.buffered.get() - len); + Err(err) => { + resource.set_error(Some(err.to_string())); + } + _ => { + resource.buffered.set(resource.buffered.get() - len); + } } }); } diff --git a/ext/websocket/stream.rs b/ext/websocket/stream.rs index ef978d6556..f24d79687f 100644 --- a/ext/websocket/stream.rs +++ b/ext/websocket/stream.rs @@ -1,8 +1,8 @@ // Copyright 2018-2025 the Deno authors. MIT license. use std::io::ErrorKind; use std::pin::Pin; -use std::task::ready; use std::task::Poll; +use std::task::ready; use bytes::Buf; use bytes::Bytes; diff --git a/ext/webstorage/lib.rs b/ext/webstorage/lib.rs index 6b3a26ec5e..348cd23c79 100644 --- a/ext/webstorage/lib.rs +++ b/ext/webstorage/lib.rs @@ -4,13 +4,13 @@ use std::path::PathBuf; -use deno_core::op2; use deno_core::GarbageCollected; use deno_core::OpState; +use deno_core::op2; pub use rusqlite; -use rusqlite::params; use rusqlite::Connection; use rusqlite::OptionalExtension; +use rusqlite::params; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum WebStorageError { diff --git a/libs/config/deno_json/mod.rs b/libs/config/deno_json/mod.rs index c77ee20ed7..4c6a33b12d 100644 --- a/libs/config/deno_json/mod.rs +++ b/libs/config/deno_json/mod.rs @@ -13,31 +13,31 @@ use deno_path_util::url_to_file_path; use import_map::ImportMapWithDiagnostics; use indexmap::IndexMap; use jsonc_parser::ParseResult; -use serde::de; -use serde::de::Unexpected; -use serde::de::Visitor; use serde::Deserialize; use serde::Deserializer; use serde::Serialize; -use serde_json::json; +use serde::de; +use serde::de::Unexpected; +use serde::de::Visitor; use serde_json::Value; +use serde_json::json; use sys_traits::FsRead; use thiserror::Error; use url::Url; +use crate::UrlToFilePathError; use crate::glob::FilePatterns; use crate::glob::PathOrPatternSet; use crate::util::is_skippable_io_error; -use crate::UrlToFilePathError; mod ts; -pub use ts::parse_compiler_options; pub use ts::CompilerOptions; pub use ts::EmitConfigOptions; pub use ts::IgnoredCompilerOptions; pub use ts::ParsedCompilerOptions; pub use ts::RawJsxCompilerOptions; +pub use ts::parse_compiler_options; #[derive(Clone, Debug, Default, Deserialize, Hash, PartialEq)] #[serde(default, deny_unknown_fields)] @@ -133,7 +133,9 @@ impl SerializedLintConfig { let (include, exclude) = (self.include, self.exclude); let files = SerializedFilesConfig { include, exclude }; if !self.deprecated_files.is_null() { - log::warn!( "Warning: \"files\" configuration in \"lint\" was removed in Deno 2, use \"include\" and \"exclude\" instead."); + log::warn!( + "Warning: \"files\" configuration in \"lint\" was removed in Deno 2, use \"include\" and \"exclude\" instead." + ); } Ok(LintConfig { options: LintOptionsConfig { @@ -440,7 +442,9 @@ impl SerializedFmtConfig { space_surrounding_properties: self.space_surrounding_properties, }; if !self.deprecated_files.is_null() { - log::warn!( "Warning: \"files\" configuration in \"fmt\" was removed in Deno 2, use \"include\" and \"exclude\" instead."); + log::warn!( + "Warning: \"files\" configuration in \"fmt\" was removed in Deno 2, use \"include\" and \"exclude\" instead." + ); } Ok(FmtConfig { options: choose_fmt_options(options, self.deprecated_options), @@ -510,7 +514,9 @@ impl SerializedTestConfig { let (include, exclude) = (self.include, self.exclude); let files = SerializedFilesConfig { include, exclude }; if !self.deprecated_files.is_null() { - log::warn!( "Warning: \"files\" configuration in \"test\" was removed in Deno 2, use \"include\" and \"exclude\" instead."); + log::warn!( + "Warning: \"files\" configuration in \"test\" was removed in Deno 2, use \"include\" and \"exclude\" instead." + ); } Ok(TestConfig { files: files.into_resolved(config_file_specifier)?, @@ -588,7 +594,9 @@ impl SerializedBenchConfig { let (include, exclude) = (self.include, self.exclude); let files = SerializedFilesConfig { include, exclude }; if !self.deprecated_files.is_null() { - log::warn!( "Warning: \"files\" configuration in \"bench\" was removed in Deno 2, use \"include\" and \"exclude\" instead."); + log::warn!( + "Warning: \"files\" configuration in \"bench\" was removed in Deno 2, use \"include\" and \"exclude\" instead." + ); } Ok(BenchConfig { files: files.into_resolved(config_file_specifier)?, @@ -708,7 +716,7 @@ impl TaskDefinition { serde_json::from_value(value).map_err(serde::de::Error::custom)? } _ => { - return Err(serde::de::Error::custom("invalid task definition")) + return Err(serde::de::Error::custom("invalid task definition")); } }; map.insert(key, task_def); @@ -906,7 +914,9 @@ pub enum ConfigFileError { #[error(transparent)] CompilerOptionsParseError(CompilerOptionsParseError), #[class(type)] - #[error("Only file: specifiers are supported for security reasons in import maps stored in a deno.json. To use a remote import map, use the --import-map flag and \"deno.importMap\" in the language server config")] + #[error( + "Only file: specifiers are supported for security reasons in import maps stored in a deno.json. To use a remote import map, use the --import-map flag and \"deno.importMap\" in the language server config" + )] OnlyFileSpecifiersSupported, #[class(inherit)] #[error(transparent)] @@ -943,36 +953,48 @@ pub enum ConfigFileExportsError { suggestion: String, }, #[class(type)] - #[error("The {0} must only contain alphanumeric characters, underscores (_), dashes (-), dots (.), and slashes (/).")] + #[error( + "The {0} must only contain alphanumeric characters, underscores (_), dashes (-), dots (.), and slashes (/)." + )] KeyInvalidCharacter(Cow<'static, str>), #[class(type)] - #[error("The {0} must not contain double slashes (//), or parts consisting entirely of dots (.).")] + #[error( + "The {0} must not contain double slashes (//), or parts consisting entirely of dots (.)." + )] KeyTooManySlashesOrDots(Cow<'static, str>), #[class(type)] #[error("The path for the {0} must not be empty.")] ValueMustNotBeEmpty(Cow<'static, str>), #[class(type)] - #[error("The path '{value}' at the {key} could not be resolved as a relative path from the config file. Did you mean '{suggestion}'?")] + #[error( + "The path '{value}' at the {key} could not be resolved as a relative path from the config file. Did you mean '{suggestion}'?" + )] ValueCouldNotBeResolved { value: String, key: Cow<'static, str>, suggestion: String, }, #[class(type)] - #[error("The path '{value}' at the {key} must not end with '/'. Did you mean '{suggestion}'?")] + #[error( + "The path '{value}' at the {key} must not end with '/'. Did you mean '{suggestion}'?" + )] ValueMustNotEndWithSlash { value: String, key: Cow<'static, str>, suggestion: String, }, #[class(type)] - #[error("The path '{value}' at the {key} is missing a file extension. Add a file extension such as '.js' or '.ts'.")] + #[error( + "The path '{value}' at the {key} is missing a file extension. Add a file extension such as '.js' or '.ts'." + )] ValueMissingFileExtension { value: String, key: Cow<'static, str>, }, #[class(type)] - #[error("The path of the {key} must be a string, found invalid value '{value}'. Exports in deno.json do not support conditional exports.")] + #[error( + "The path of the {key} must be a string, found invalid value '{value}'. Exports in deno.json do not support conditional exports." + )] InvalidValueConditionalExports { key: Cow<'static, str>, value: Value, @@ -1017,9 +1039,13 @@ pub enum ToInvalidConfigError { pub enum ResolveTaskConfigError { #[error("Configuration file task names cannot be empty")] TaskNameEmpty, - #[error("Configuration file task names must only contain alpha-numeric characters, colons (:), underscores (_), or dashes (-). Task: {0}")] + #[error( + "Configuration file task names must only contain alpha-numeric characters, colons (:), underscores (_), or dashes (-). Task: {0}" + )] TaskNameInvalidCharacter(String), - #[error("Configuration file task names must start with an alphabetic character. Task: {0}")] + #[error( + "Configuration file task names must start with an alphabetic character. Task: {0}" + )] TaskNameInvalidStartingCharacter(String), #[class(inherit)] #[error(transparent)] @@ -1534,17 +1560,15 @@ impl ConfigFile { fn resolve_exclude_patterns( &self, ) -> Result, ToInvalidConfigError> { - let mut exclude: Vec = - if let Some(exclude) = self.json.exclude.clone() { - serde_json::from_value(exclude).map_err(|error| { - ToInvalidConfigError::Parse { - config: "exclude", - source: error, - } - })? - } else { - Vec::new() - }; + let mut exclude: Vec = match self.json.exclude.clone() { + Some(exclude) => serde_json::from_value(exclude).map_err(|error| { + ToInvalidConfigError::Parse { + config: "exclude", + source: error, + } + })?, + _ => Vec::new(), + }; if self.json.vendor == Some(true) { exclude.push("vendor".to_string()); @@ -1765,17 +1789,18 @@ impl ConfigFile { &self, ) -> Result>, ToInvalidConfigError> { - if let Some(config) = self.json.tasks.clone() { - let tasks_config: IndexMap = - TaskDefinition::deserialize_tasks(config).map_err(|error| { - ToInvalidConfigError::Parse { - config: "tasks", - source: error, - } - })?; - Ok(Some(tasks_config)) - } else { - Ok(None) + match self.json.tasks.clone() { + Some(config) => { + let tasks_config: IndexMap = + TaskDefinition::deserialize_tasks(config).map_err(|error| { + ToInvalidConfigError::Parse { + config: "tasks", + source: error, + } + })?; + Ok(Some(tasks_config)) + } + _ => Ok(None), } } @@ -1848,25 +1873,26 @@ impl ConfigFile { pub fn to_lock_config( &self, ) -> Result, ToLockConfigError> { - if let Some(config) = self.json.lock.clone() { - let mut lock_config: LockConfig = serde_json::from_value(config) - .map_err(|error| ToInvalidConfigError::Parse { - config: "lock", - source: error, - })?; - if let LockConfig::PathBuf(path) - | LockConfig::Object { - path: Some(path), .. - } = &mut lock_config - { - *path = url_to_file_path(&self.specifier)? - .parent() - .unwrap() - .join(&path); + match self.json.lock.clone() { + Some(config) => { + let mut lock_config: LockConfig = serde_json::from_value(config) + .map_err(|error| ToInvalidConfigError::Parse { + config: "lock", + source: error, + })?; + if let LockConfig::PathBuf(path) + | LockConfig::Object { + path: Some(path), .. + } = &mut lock_config + { + *path = url_to_file_path(&self.specifier)? + .parent() + .unwrap() + .join(&path); + } + Ok(Some(lock_config)) } - Ok(Some(lock_config)) - } else { - Ok(None) + _ => Ok(None), } } @@ -2303,17 +2329,17 @@ mod tests { #[test] fn task_name_invalid_chars() { run_task_error_test( - r#"{ + r#"{ "tasks": { "build": "deno test", "some%test": "deno bundle mod.ts" } }"#, - concat!( - "Configuration file task names must only contain alpha-numeric ", - "characters, colons (:), underscores (_), or dashes (-). Task: some%test", - ), - ); + concat!( + "Configuration file task names must only contain alpha-numeric ", + "characters, colons (:), underscores (_), or dashes (-). Task: some%test", + ), + ); } #[test] @@ -2358,8 +2384,10 @@ mod tests { #[test] fn files_pattern_matches_remote() { - assert!(FilePatterns::new_with_base(PathBuf::from("/")) - .matches_specifier(&Url::parse("https://example.com/mod.ts").unwrap())); + assert!( + FilePatterns::new_with_base(PathBuf::from("/")) + .matches_specifier(&Url::parse("https://example.com/mod.ts").unwrap()) + ); } #[test] diff --git a/libs/config/deno_json/ts.rs b/libs/config/deno_json/ts.rs index cb8028f15c..3c1d50926d 100644 --- a/libs/config/deno_json/ts.rs +++ b/libs/config/deno_json/ts.rs @@ -48,9 +48,18 @@ impl fmt::Display for IgnoredCompilerOptions { let mut codes = self.items.clone(); codes.sort_unstable(); if let Some(specifier) = &self.maybe_specifier { - write!(f, "Unsupported compiler options in \"{}\".\n The following options were ignored:\n {}", specifier, codes.join(", ")) + write!( + f, + "Unsupported compiler options in \"{}\".\n The following options were ignored:\n {}", + specifier, + codes.join(", ") + ) } else { - write!(f, "Unsupported compiler options provided.\n The following options were ignored:\n {}", codes.join(", ")) + write!( + f, + "Unsupported compiler options provided.\n The following options were ignored:\n {}", + codes.join(", ") + ) } } } diff --git a/libs/config/glob/collector.rs b/libs/config/glob/collector.rs index 23dd173300..e37378c0fb 100644 --- a/libs/config/glob/collector.rs +++ b/libs/config/glob/collector.rs @@ -13,11 +13,11 @@ use sys_traits::FsRead; use sys_traits::FsReadDir; use super::FilePatterns; -use crate::glob::gitignore::DirGitIgnores; -use crate::glob::gitignore::GitIgnoreTree; use crate::glob::FilePatternsMatch; use crate::glob::PathKind; use crate::glob::PathOrPattern; +use crate::glob::gitignore::DirGitIgnores; +use crate::glob::gitignore::GitIgnoreTree; #[derive(Debug, Clone)] pub struct WalkEntry<'a> { diff --git a/libs/config/glob/gitignore.rs b/libs/config/glob/gitignore.rs index dfc6a91da5..7a47e99a52 100644 --- a/libs/config/glob/gitignore.rs +++ b/libs/config/glob/gitignore.rs @@ -137,9 +137,9 @@ impl<'a, Sys: FsRead + FsMetadata> GitIgnoreTree<'a, Sys> { #[cfg(test)] mod test { - use sys_traits::impls::InMemorySys; use sys_traits::FsCreateDirAll; use sys_traits::FsWrite; + use sys_traits::impls::InMemorySys; use super::*; diff --git a/libs/config/glob/mod.rs b/libs/config/glob/mod.rs index 42f7595c8c..2595a889b6 100644 --- a/libs/config/glob/mod.rs +++ b/libs/config/glob/mod.rs @@ -105,7 +105,7 @@ impl FilePatterns { break; } PathGlobMatch::MatchedNegated => { - return FilePatternsMatch::Excluded + return FilePatternsMatch::Excluded; } PathGlobMatch::NotMatched => { // keep going @@ -311,7 +311,9 @@ pub enum PathOrPatternsMatch { #[derive(Debug, Error, JsError)] pub enum FromExcludeRelativePathOrPatternsError { #[class(type)] - #[error("The negation of '{negated_entry}' is never reached due to the higher priority '{entry}' exclude. Move '{negated_entry}' after '{entry}'.")] + #[error( + "The negation of '{negated_entry}' is never reached due to the higher priority '{entry}' exclude. Move '{negated_entry}' after '{entry}'." + )] HigherPriorityExclude { negated_entry: String, entry: String, @@ -958,11 +960,9 @@ mod test { let temp_dir = TempDir::new().unwrap(); let patterns = FilePatterns { base: temp_dir.path().to_path_buf(), - include: Some(PathOrPatternSet::new(vec![PathOrPattern::from_relative( - temp_dir.path(), - "./sub", - ) - .unwrap()])), + include: Some(PathOrPatternSet::new(vec![ + PathOrPattern::from_relative(temp_dir.path(), "./sub").unwrap(), + ])), exclude: PathOrPatternSet::new(vec![ PathOrPattern::from_relative(temp_dir.path(), "./sub/ignored").unwrap(), PathOrPattern::from_relative(temp_dir.path(), "!./sub/ignored/test/**") @@ -1004,11 +1004,9 @@ mod test { let temp_dir = TempDir::new().unwrap(); let patterns = FilePatterns { base: temp_dir.path().to_path_buf(), - include: Some(PathOrPatternSet::new(vec![PathOrPattern::from_relative( - temp_dir.path(), - "./sub/**", - ) - .unwrap()])), + include: Some(PathOrPatternSet::new(vec![ + PathOrPattern::from_relative(temp_dir.path(), "./sub/**").unwrap(), + ])), exclude: PathOrPatternSet::new(vec![ PathOrPattern::from_relative(temp_dir.path(), "./sub/ignored").unwrap(), PathOrPattern::from_relative(temp_dir.path(), "!./sub/ignored/test/**") @@ -1463,7 +1461,10 @@ mod test { // error for invalid url { let err = PathOrPattern::from_relative(&cwd, "https://raw.githubusercontent.com%2Fdyedgreen%2Fdeno-sqlite%2Frework_api%2Fmod.ts").unwrap_err(); - assert_eq!(format!("{:#}", err), "Invalid URL 'https://raw.githubusercontent.com%2Fdyedgreen%2Fdeno-sqlite%2Frework_api%2Fmod.ts'"); + assert_eq!( + format!("{:#}", err), + "Invalid URL 'https://raw.githubusercontent.com%2Fdyedgreen%2Fdeno-sqlite%2Frework_api%2Fmod.ts'" + ); assert_eq!( format!("{:#}", err.source().unwrap()), "invalid international domain name" diff --git a/libs/config/workspace/discovery.rs b/libs/config/workspace/discovery.rs index 82ea4db696..78e746e674 100644 --- a/libs/config/workspace/discovery.rs +++ b/libs/config/workspace/discovery.rs @@ -33,11 +33,11 @@ use super::WorkspaceDiscoverStart; use super::WorkspaceRc; use crate::deno_json::ConfigFile; use crate::deno_json::ConfigFileRc; -use crate::glob::is_glob_pattern; use crate::glob::FileCollector; use crate::glob::FilePatterns; use crate::glob::PathOrPattern; use crate::glob::PathOrPatternSet; +use crate::glob::is_glob_pattern; use crate::sync::new_rc; use crate::util::is_skippable_io_error; use crate::workspace::ConfigReadError; diff --git a/libs/config/workspace/mod.rs b/libs/config/workspace/mod.rs index a825bc151d..cb9884a935 100644 --- a/libs/config/workspace/mod.rs +++ b/libs/config/workspace/mod.rs @@ -17,15 +17,15 @@ use deno_path_util::url_from_directory_path; use deno_path_util::url_from_file_path; use deno_path_util::url_parent; use deno_path_util::url_to_file_path; -use deno_semver::package::PackageNv; -use deno_semver::package::PackageReq; use deno_semver::RangeSetOrTag; use deno_semver::Version; use deno_semver::VersionReq; -use discovery::discover_workspace_config_files; +use deno_semver::package::PackageNv; +use deno_semver::package::PackageReq; use discovery::ConfigFileDiscovery; use discovery::ConfigFolder; use discovery::DenoOrPkgJson; +use discovery::discover_workspace_config_files; use indexmap::IndexMap; use indexmap::IndexSet; use serde_json::json; @@ -35,6 +35,7 @@ use sys_traits::FsReadDir; use thiserror::Error; use url::Url; +use crate::UrlToFilePathError; use crate::deno_json; use crate::deno_json::BenchConfig; use crate::deno_json::CompilerOptionTypesDeserializeError; @@ -63,7 +64,6 @@ use crate::glob::PathOrPattern; use crate::glob::PathOrPatternParseError; use crate::glob::PathOrPatternSet; use crate::sync::new_rc; -use crate::UrlToFilePathError; mod discovery; @@ -125,11 +125,17 @@ pub struct WorkspaceLintConfig { #[derive(Debug, Error, JsError)] #[class(type)] pub enum ToMaybeJsxImportSourceConfigError { - #[error("'jsxImportSource' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n at {0}")] + #[error( + "'jsxImportSource' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n at {0}" + )] InvalidJsxImportSourceValue(Url), - #[error("'jsxImportSourceTypes' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n at {0}")] + #[error( + "'jsxImportSourceTypes' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n at {0}" + )] InvalidJsxImportSourceTypesValue(Url), - #[error("Unsupported 'jsx' compiler option value '{value}'. Supported: 'react-jsx', 'react-jsxdev', 'react', 'precompile'\n at {specifier}")] + #[error( + "Unsupported 'jsx' compiler option value '{value}'. Supported: 'react-jsx', 'react-jsxdev', 'react', 'precompile'\n at {specifier}" + )] InvalidJsxCompilerOption { value: String, specifier: Url }, } @@ -153,24 +159,34 @@ pub enum WorkspaceDiagnosticKind { "\"{0}\" field can only be specified in the workspace root deno.json file." )] RootOnlyOption(&'static str), - #[error("\"{0}\" field can only be specified in a workspace member deno.json file and not the workspace root file.")] + #[error( + "\"{0}\" field can only be specified in a workspace member deno.json file and not the workspace root file." + )] MemberOnlyOption(&'static str), #[error("\"workspaces\" field was ignored. Use \"workspace\" instead.")] InvalidWorkspacesOption, #[error("\"exports\" field should be specified when specifying a \"name\".")] MissingExports, - #[error("\"importMap\" field is ignored when \"imports\" or \"scopes\" are specified in the config file.")] + #[error( + "\"importMap\" field is ignored when \"imports\" or \"scopes\" are specified in the config file." + )] ImportMapReferencingImportMap, - #[error("\"imports\" and \"scopes\" field is ignored when \"importMap\" is specified in the root config file.")] + #[error( + "\"imports\" and \"scopes\" field is ignored when \"importMap\" is specified in the root config file." + )] MemberImportsScopesIgnored, - #[error("`\"nodeModulesDir\": {previous}` is deprecated in Deno 2.0. Use `\"nodeModulesDir\": \"{suggestion}\"` instead.")] + #[error( + "`\"nodeModulesDir\": {previous}` is deprecated in Deno 2.0. Use `\"nodeModulesDir\": \"{suggestion}\"` instead." + )] DeprecatedNodeModulesDirOption { previous: bool, suggestion: NodeModulesDirMode, }, #[error("\"patch\" property was renamed to \"links\".")] DeprecatedPatch, - #[error("Invalid workspace member name \"{name}\". Ensure the name is in the format '@scope/name'.")] + #[error( + "Invalid workspace member name \"{name}\". Ensure the name is in the format '@scope/name'." + )] InvalidMemberName { name: String }, } @@ -236,11 +252,15 @@ pub enum ResolveWorkspaceMemberErrorKind { NotFoundPackageJson { dir_url: Url }, #[error("Could not find config file for workspace member in '{}'. Ensure you specify the directory and not the configuration file in the workspace member.", .dir_url)] NotFoundMaybeSpecifiedFile { dir_url: Url }, - #[error("Workspace member must be nested in a directory under the workspace.\n Member: {member_url}\n Workspace: {workspace_url}")] + #[error( + "Workspace member must be nested in a directory under the workspace.\n Member: {member_url}\n Workspace: {workspace_url}" + )] NonDescendant { workspace_url: Url, member_url: Url }, #[error("Cannot specify a workspace member twice ('{}').", .member)] Duplicate { member: String }, - #[error("The '{name}' package ('{deno_json_url}') cannot have the same name as the package at '{other_deno_json_url}'.")] + #[error( + "The '{name}' package ('{deno_json_url}') cannot have the same name as the package at '{other_deno_json_url}'." + )] DuplicatePackageName { name: String, deno_json_url: Url, @@ -322,7 +342,9 @@ pub enum WorkspaceDiscoverErrorKind { source: ResolveWorkspaceLinkError, }, #[class(type)] - #[error("Command resolved to multiple config files. Ensure all specified paths are within the same workspace.\n First: {base_workspace_url}\n Second: {other_workspace_url}")] + #[error( + "Command resolved to multiple config files. Ensure all specified paths are within the same workspace.\n First: {base_workspace_url}\n Second: {other_workspace_url}" + )] MultipleWorkspaces { base_workspace_url: Url, other_workspace_url: Url, @@ -334,7 +356,9 @@ pub enum WorkspaceDiscoverErrorKind { #[error(transparent)] PathToUrl(#[from] deno_path_util::PathToUrlError), #[class(type)] - #[error("Config file must be a member of the workspace.\n Config: {config_url}\n Workspace: {workspace_url}")] + #[error( + "Config file must be a member of the workspace.\n Config: {config_url}\n Workspace: {workspace_url}" + )] ConfigNotWorkspaceMember { workspace_url: Url, config_url: Url }, } @@ -1626,10 +1650,13 @@ impl WorkspaceDirectory { // root first if let Some(root) = &config.root { // read from root deno.json - if let Some(compiler_options) = root.to_compiler_options()? { - merge(compiler_options, &mut result); - } else { - try_merge_from_ts_config(&root.dir_path(), &mut result); + match root.to_compiler_options()? { + Some(compiler_options) => { + merge(compiler_options, &mut result); + } + _ => { + try_merge_from_ts_config(&root.dir_path(), &mut result); + } } } else if let Some(pkg_json) = &self.pkg_json { // if root deno.json doesn't exist, but package.json does, try read from @@ -1640,11 +1667,16 @@ impl WorkspaceDirectory { } // then read from member deno.json - if let Some(compiler_options) = config.member.to_compiler_options()? { - merge(compiler_options, &mut result); - } else if self.is_config_at_root() { - // config is root, so try to discover tsconfig - try_merge_from_ts_config(&config.member.dir_path(), &mut result); + match config.member.to_compiler_options()? { + Some(compiler_options) => { + merge(compiler_options, &mut result); + } + _ => { + if self.is_config_at_root() { + // config is root, so try to discover tsconfig + try_merge_from_ts_config(&config.member.dir_path(), &mut result); + } + } } } else if let Some(pkg_json) = &self.pkg_json { if let Some(pkg_json) = &pkg_json.root { @@ -1765,7 +1797,7 @@ impl WorkspaceDirectory { .unwrap_or_else(|| config.member.specifier.clone()) }, }, - ) + ); } }; Ok(Some(JsxImportSourceConfig { @@ -2703,7 +2735,9 @@ pub mod test { assert_contains!( workspace_config_err.to_string(), - &format!("Remove the reference to the current config file (\"{reference}\") in \"workspaces\".") + &format!( + "Remove the reference to the current config file (\"{reference}\") in \"workspaces\"." + ) ); } } @@ -3534,9 +3568,11 @@ pub mod test { ); // will match because it was unexcluded in the member - assert!(lint_config - .files - .matches_path(&root_dir().join("member/vendor"), PathKind::Directory)) + assert!( + lint_config + .files + .matches_path(&root_dir().join("member/vendor"), PathKind::Directory) + ) } #[test] @@ -4668,7 +4704,12 @@ pub mod test { ); // no deno.json in this folder, so should error let err = workspace_at_start_dir_err(&sys, &root_dir().join("package")); - assert_eq!(err.to_string(), normalize_err_text("Could not find config file for workspace member in '[ROOT_DIR_URL]/member/'.")); + assert_eq!( + err.to_string(), + normalize_err_text( + "Could not find config file for workspace member in '[ROOT_DIR_URL]/member/'." + ) + ); } #[test] @@ -4682,10 +4723,13 @@ pub mod test { ); // no deno.json in this folder and the name was deno.json so give an error let err = workspace_at_start_dir_err(&sys, &root_dir().join("package")); - assert_eq!(err.to_string(), normalize_err_text(concat!( - "Could not find config file for workspace member in '[ROOT_DIR_URL]/member/deno.json/'. ", - "Ensure you specify the directory and not the configuration file in the workspace member." - ))); + assert_eq!( + err.to_string(), + normalize_err_text(concat!( + "Could not find config file for workspace member in '[ROOT_DIR_URL]/member/deno.json/'. ", + "Ensure you specify the directory and not the configuration file in the workspace member." + )) + ); } #[test] @@ -4884,7 +4928,12 @@ pub mod test { // no package.json in this folder, so should error sys.fs_insert_json(root_dir().join("member/deno.json"), json!({})); let err = workspace_at_start_dir_err(&sys, &root_dir().join("package")); - assert_eq!(err.to_string(), normalize_err_text("Could not find package.json for workspace member in '[ROOT_DIR_URL]/member/'.")); + assert_eq!( + err.to_string(), + normalize_err_text( + "Could not find package.json for workspace member in '[ROOT_DIR_URL]/member/'." + ) + ); } #[test] @@ -4898,7 +4947,12 @@ pub mod test { ); // no package.json in this folder, so should error let err = workspace_at_start_dir_err(&sys, &root_dir().join("package")); - assert_eq!(err.to_string(), normalize_err_text("Could not find package.json for workspace member in '[ROOT_DIR_URL]/member/'.")); + assert_eq!( + err.to_string(), + normalize_err_text( + "Could not find package.json for workspace member in '[ROOT_DIR_URL]/member/'." + ) + ); } #[test] @@ -5130,8 +5184,8 @@ pub mod test { } #[test] - fn test_npm_workspace_start_deno_json_part_of_workspace_sub_folder_other_deno_json( - ) { + fn test_npm_workspace_start_deno_json_part_of_workspace_sub_folder_other_deno_json() + { let sys = InMemorySys::default(); sys.fs_insert_json( root_dir().join("package.json"), @@ -6285,11 +6339,18 @@ pub mod test { ); let deno_json = member.workspace.root_deno_json().unwrap(); assert_eq!( - member.to_maybe_jsx_import_source_config().err().unwrap().to_string(), - format!(concat!( - "Unsupported 'jsx' compiler option value 'preserve'. Supported: 'react-jsx', 'react-jsxdev', 'react', 'precompile'\n", - " at {}", - ), deno_json.specifier), + member + .to_maybe_jsx_import_source_config() + .err() + .unwrap() + .to_string(), + format!( + concat!( + "Unsupported 'jsx' compiler option value 'preserve'. Supported: 'react-jsx', 'react-jsxdev', 'react', 'precompile'\n", + " at {}", + ), + deno_json.specifier + ), ); } @@ -6304,11 +6365,18 @@ pub mod test { ); let deno_json = member.workspace.root_deno_json().unwrap(); assert_eq!( - member.to_maybe_jsx_import_source_config().err().unwrap().to_string(), - format!(concat!( - "'jsxImportSource' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", - " at {}", - ), deno_json.specifier), + member + .to_maybe_jsx_import_source_config() + .err() + .unwrap() + .to_string(), + format!( + concat!( + "'jsxImportSource' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", + " at {}", + ), + deno_json.specifier + ), ); } { @@ -6320,11 +6388,18 @@ pub mod test { ); let deno_json = member.workspace.root_deno_json().unwrap(); assert_eq!( - member.to_maybe_jsx_import_source_config().err().unwrap().to_string(), - format!(concat!( - "'jsxImportSource' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", - " at {}", - ), deno_json.specifier), + member + .to_maybe_jsx_import_source_config() + .err() + .unwrap() + .to_string(), + format!( + concat!( + "'jsxImportSource' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", + " at {}", + ), + deno_json.specifier + ), ); } } @@ -6340,11 +6415,18 @@ pub mod test { ); let deno_json = member.workspace.root_deno_json().unwrap(); assert_eq!( - member.to_maybe_jsx_import_source_config().err().unwrap().to_string(), - format!(concat!( - "'jsxImportSourceTypes' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", - " at {}", - ), deno_json.specifier), + member + .to_maybe_jsx_import_source_config() + .err() + .unwrap() + .to_string(), + format!( + concat!( + "'jsxImportSourceTypes' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", + " at {}", + ), + deno_json.specifier + ), ); } { @@ -6356,11 +6438,18 @@ pub mod test { ); let deno_json = member.workspace.root_deno_json().unwrap(); assert_eq!( - member.to_maybe_jsx_import_source_config().err().unwrap().to_string(), - format!(concat!( - "'jsxImportSourceTypes' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", - " at {}", - ), deno_json.specifier), + member + .to_maybe_jsx_import_source_config() + .err() + .unwrap() + .to_string(), + format!( + concat!( + "'jsxImportSourceTypes' is only supported when 'jsx' is set to 'react-jsx' or 'react-jsxdev'.\n", + " at {}", + ), + deno_json.specifier + ), ); } } diff --git a/libs/crypto/ffi.rs b/libs/crypto/ffi.rs index 49666119ef..6919070518 100644 --- a/libs/crypto/ffi.rs +++ b/libs/crypto/ffi.rs @@ -4,11 +4,7 @@ pub struct PKey(pub *mut aws_lc_sys::EVP_PKEY); impl PKey { pub fn from_ptr(ptr: *mut aws_lc_sys::EVP_PKEY) -> Option { - if ptr.is_null() { - None - } else { - Some(Self(ptr)) - } + if ptr.is_null() { None } else { Some(Self(ptr)) } } pub fn as_ptr(&self) -> *mut aws_lc_sys::EVP_PKEY { diff --git a/libs/node_resolver/analyze.rs b/libs/node_resolver/analyze.rs index b97e47b9d5..046d9cf2e1 100644 --- a/libs/node_resolver/analyze.rs +++ b/libs/node_resolver/analyze.rs @@ -8,10 +8,10 @@ use std::path::PathBuf; use deno_error::JsErrorBox; use deno_path_util::url_to_file_path; -use futures::future::LocalBoxFuture; -use futures::stream::FuturesUnordered; use futures::FutureExt; use futures::StreamExt; +use futures::future::LocalBoxFuture; +use futures::stream::FuturesUnordered; use once_cell::sync::Lazy; use serde::Deserialize; use serde::Serialize; @@ -20,8 +20,6 @@ use sys_traits::FsMetadata; use sys_traits::FsRead; use url::Url; -use crate::errors::ModuleNotFoundError; -use crate::resolution::NodeResolverRc; use crate::InNpmPackageChecker; use crate::IsBuiltInNodeModuleChecker; use crate::NodeResolutionKind; @@ -31,6 +29,8 @@ use crate::PathClean; use crate::ResolutionMode; use crate::UrlOrPath; use crate::UrlOrPathRef; +use crate::errors::ModuleNotFoundError; +use crate::resolution::NodeResolverRc; #[derive(Debug, Clone)] pub enum CjsAnalysis<'a> { @@ -114,12 +114,12 @@ pub struct CjsModuleExportAnalyzer< } impl< - TCjsCodeAnalyzer: CjsCodeAnalyzer, - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: FsCanonicalize + FsMetadata + FsRead, - > + TCjsCodeAnalyzer: CjsCodeAnalyzer, + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: FsCanonicalize + FsMetadata + FsRead, +> CjsModuleExportAnalyzer< TCjsCodeAnalyzer, TInNpmPackageChecker, @@ -164,7 +164,7 @@ impl< let analysis = match analysis { CjsAnalysis::Esm(source, _) => { - return Ok(ResolvedCjsAnalysis::Esm(source)) + return Ok(ResolvedCjsAnalysis::Esm(source)); } CjsAnalysis::Cjs(analysis) => analysis, }; @@ -505,7 +505,9 @@ pub enum TranslateCjsToEsmError { #[derive(Debug, thiserror::Error, deno_error::JsError)] #[class(generic)] -#[error("Could not load '{reexport}' ({reexport_specifier}) referenced from {referrer}")] +#[error( + "Could not load '{reexport}' ({reexport_specifier}) referenced from {referrer}" +)] pub struct CjsAnalysisCouldNotLoadError { reexport: String, reexport_specifier: Url, @@ -556,12 +558,12 @@ pub enum NodeCodeTranslatorMode { } impl< - TCjsCodeAnalyzer: CjsCodeAnalyzer, - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: FsCanonicalize + FsMetadata + FsRead, - > + TCjsCodeAnalyzer: CjsCodeAnalyzer, + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: FsCanonicalize + FsMetadata + FsRead, +> NodeCodeTranslator< TCjsCodeAnalyzer, TInNpmPackageChecker, diff --git a/libs/node_resolver/errors.rs b/libs/node_resolver/errors.rs index 1b4fd68298..4b75bcb758 100644 --- a/libs/node_resolver/errors.rs +++ b/libs/node_resolver/errors.rs @@ -10,9 +10,9 @@ use deno_path_util::UrlToFilePathError; use thiserror::Error; use url::Url; -use crate::path::UrlOrPath; use crate::NodeResolutionKind; use crate::ResolutionMode; +use crate::path::UrlOrPath; #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] #[allow(non_camel_case_types)] @@ -1025,8 +1025,11 @@ mod test { subpath: "./jsx-runtime".to_string(), maybe_referrer: None, resolution_kind: NodeResolutionKind::Types - }.to_string(), - format!("[ERR_PACKAGE_PATH_NOT_EXPORTED] Package subpath './jsx-runtime' is not defined for types by \"exports\" in 'test_path{separator_char}package.json'") + } + .to_string(), + format!( + "[ERR_PACKAGE_PATH_NOT_EXPORTED] Package subpath './jsx-runtime' is not defined for types by \"exports\" in 'test_path{separator_char}package.json'" + ) ); assert_eq!( PackagePathNotExportedError { @@ -1034,8 +1037,11 @@ mod test { subpath: ".".to_string(), maybe_referrer: None, resolution_kind: NodeResolutionKind::Types - }.to_string(), - format!("[ERR_PACKAGE_PATH_NOT_EXPORTED] No \"exports\" main defined for types in 'test_path{separator_char}package.json'") + } + .to_string(), + format!( + "[ERR_PACKAGE_PATH_NOT_EXPORTED] No \"exports\" main defined for types in 'test_path{separator_char}package.json'" + ) ); } } diff --git a/libs/node_resolver/lib.rs b/libs/node_resolver/lib.rs index b03f16ac15..0c821dcb8f 100644 --- a/libs/node_resolver/lib.rs +++ b/libs/node_resolver/lib.rs @@ -14,9 +14,9 @@ mod resolution; mod sync; +pub use builtin_modules::DENO_SUPPORTED_BUILTIN_NODE_MODULES; pub use builtin_modules::DenoIsBuiltInNodeModuleChecker; pub use builtin_modules::IsBuiltInNodeModuleChecker; -pub use builtin_modules::DENO_SUPPORTED_BUILTIN_NODE_MODULES; pub use cache::NodeResolutionCache; pub use cache::NodeResolutionCacheRc; pub use deno_package_json::PackageJson; @@ -29,9 +29,7 @@ pub use package_json::PackageJsonThreadLocalCache; pub use path::PathClean; pub use path::UrlOrPath; pub use path::UrlOrPathRef; -pub use resolution::parse_npm_pkg_name; -pub use resolution::resolve_specifier_into_node_modules; -pub use resolution::types_package_name; +pub use resolution::IMPORT_CONDITIONS; pub use resolution::NodeConditionOptions; pub use resolution::NodeResolution; pub use resolution::NodeResolutionKind; @@ -39,6 +37,8 @@ pub use resolution::NodeResolver; pub use resolution::NodeResolverOptions; pub use resolution::NodeResolverRc; pub use resolution::NodeResolverSys; -pub use resolution::ResolutionMode; -pub use resolution::IMPORT_CONDITIONS; pub use resolution::REQUIRE_CONDITIONS; +pub use resolution::ResolutionMode; +pub use resolution::parse_npm_pkg_name; +pub use resolution::resolve_specifier_into_node_modules; +pub use resolution::types_package_name; diff --git a/libs/node_resolver/resolution.rs b/libs/node_resolver/resolution.rs index d94a7418b2..7ac59338e6 100644 --- a/libs/node_resolver/resolution.rs +++ b/libs/node_resolver/resolution.rs @@ -5,8 +5,8 @@ use std::fmt::Debug; use std::path::Path; use std::path::PathBuf; -use anyhow::bail; use anyhow::Error as AnyError; +use anyhow::bail; use deno_media_type::MediaType; use deno_package_json::PackageJson; use deno_path_util::url_to_file_path; @@ -20,6 +20,11 @@ use sys_traits::FsMetadata; use sys_traits::FsRead; use url::Url; +use crate::InNpmPackageChecker; +use crate::IsBuiltInNodeModuleChecker; +use crate::NpmPackageFolderResolver; +use crate::PackageJsonResolverRc; +use crate::PathClean; use crate::cache::NodeResolutionSys; use crate::errors; use crate::errors::DataUrlReferrerError; @@ -54,11 +59,6 @@ use crate::errors::UnsupportedDirImportError; use crate::errors::UnsupportedEsmUrlSchemeError; use crate::path::UrlOrPath; use crate::path::UrlOrPathRef; -use crate::InNpmPackageChecker; -use crate::IsBuiltInNodeModuleChecker; -use crate::NpmPackageFolderResolver; -use crate::PackageJsonResolverRc; -use crate::PathClean; pub static IMPORT_CONDITIONS: &[Cow<'static, str>] = &[ Cow::Borrowed("deno"), @@ -292,11 +292,11 @@ pub struct NodeResolver< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: NodeResolverSys, - > + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: NodeResolverSys, +> NodeResolver< TInNpmPackageChecker, TIsBuiltInNodeModuleChecker, @@ -2407,9 +2407,9 @@ impl<'a, TSys: FsMetadata> TypesVersions<'a, TSys> { #[cfg(test)] mod tests { use serde_json::json; - use sys_traits::impls::InMemorySys; use sys_traits::FsCreateDirAll; use sys_traits::FsWrite; + use sys_traits::impls::InMemorySys; use super::*; diff --git a/libs/npm_cache/lib.rs b/libs/npm_cache/lib.rs index e4855fcbaa..35fc26da77 100644 --- a/libs/npm_cache/lib.rs +++ b/libs/npm_cache/lib.rs @@ -9,12 +9,12 @@ use std::sync::Arc; use deno_cache_dir::file_fetcher::CacheSetting; use deno_cache_dir::npm::NpmCacheDir; use deno_error::JsErrorBox; -use deno_npm::npm_rc::ResolvedNpmRc; use deno_npm::NpmPackageCacheFolderId; +use deno_npm::npm_rc::ResolvedNpmRc; use deno_path_util::fs::atomic_write_file_with_retries; -use deno_semver::package::PackageNv; use deno_semver::StackString; use deno_semver::Version; +use deno_semver::package::PackageNv; use parking_lot::Mutex; use sys_traits::FsCanonicalize; use sys_traits::FsCreateDirAll; @@ -37,13 +37,13 @@ mod rt; mod tarball; mod tarball_extract; -pub use fs_util::hard_link_dir_recursive; -pub use fs_util::hard_link_file; pub use fs_util::HardLinkDirRecursiveError; pub use fs_util::HardLinkFileError; -pub use registry_info::get_package_url; +pub use fs_util::hard_link_dir_recursive; +pub use fs_util::hard_link_file; pub use registry_info::RegistryInfoProvider; pub use registry_info::SerializedCachedPackageInfo; +pub use registry_info::get_package_url; pub use remote::maybe_auth_header_value_for_npm_registry; pub use tarball::EnsurePackageError; pub use tarball::TarballCache; @@ -364,7 +364,9 @@ pub enum WithFolderSyncLockError { source: std::io::Error, }, #[class(inherit)] - #[error("Error creating package sync lock file at '{path}'. Maybe try manually deleting this folder.")] + #[error( + "Error creating package sync lock file at '{path}'. Maybe try manually deleting this folder." + )] CreateLockFile { path: PathBuf, #[source] @@ -375,7 +377,9 @@ pub enum WithFolderSyncLockError { #[error(transparent)] Action(#[from] JsErrorBox), #[class(generic)] - #[error("Failed setting up package cache directory for {package}, then failed cleaning it up.\n\nOriginal error:\n\n{error}\n\nRemove error:\n\n{remove_error}\n\nPlease manually delete this folder or you will run into issues using this package in the future:\n\n{output_folder}")] + #[error( + "Failed setting up package cache directory for {package}, then failed cleaning it up.\n\nOriginal error:\n\n{error}\n\nRemove error:\n\n{remove_error}\n\nPlease manually delete this folder or you will run into issues using this package in the future:\n\n{output_folder}" + )] SetUpPackageCacheDir { package: Box, error: Box, diff --git a/libs/npm_cache/registry_info.rs b/libs/npm_cache/registry_info.rs index 6d3f87e50d..e20c8e4145 100644 --- a/libs/npm_cache/registry_info.rs +++ b/libs/npm_cache/registry_info.rs @@ -11,21 +11,21 @@ use deno_npm::registry::NpmPackageInfo; use deno_npm::registry::NpmRegistryApi; use deno_npm::registry::NpmRegistryPackageInfoLoadError; use deno_unsync::sync::AtomicFlag; -use futures::future::LocalBoxFuture; use futures::FutureExt; +use futures::future::LocalBoxFuture; use parking_lot::Mutex; use serde::Deserialize; use serde::Serialize; use url::Url; -use crate::remote::maybe_auth_header_value_for_npm_registry; -use crate::rt::spawn_blocking; -use crate::rt::MultiRuntimeAsyncValueCreator; use crate::NpmCache; use crate::NpmCacheHttpClient; use crate::NpmCacheHttpClientResponse; use crate::NpmCacheSetting; use crate::NpmCacheSys; +use crate::remote::maybe_auth_header_value_for_npm_registry; +use crate::rt::MultiRuntimeAsyncValueCreator; +use crate::rt::spawn_blocking; type LoadResult = Result>; type LoadFuture = LocalBoxFuture<'static, LoadResult>; @@ -183,7 +183,7 @@ impl match cache_item { MemoryCacheItem::FsCached(info) => return Ok(Some(info)), MemoryCacheItem::MemoryCached(maybe_info) => { - return maybe_info.map_err(LoadPackageInfoInnerError) + return maybe_info.map_err(LoadPackageInfoInnerError); } MemoryCacheItem::Pending(value_creator) => { (value_creator, mem_cache.clear_id) @@ -240,7 +240,7 @@ impl Ok(maybe_auth_header_value) => maybe_auth_header_value, Err(err) => { return std::future::ready(Err(Arc::new(JsErrorBox::from_err(err)))) - .boxed_local() + .boxed_local(); } }; let name = name.to_string(); @@ -250,11 +250,11 @@ impl || downloader.previously_loaded_packages.lock().contains(&name) { // attempt to load from the file cache - if let Some(cached_info) = downloader.cache.load_package_info(&name).await.map_err(JsErrorBox::from_err)? { + match downloader.cache.load_package_info(&name).await.map_err(JsErrorBox::from_err)? { Some(cached_info) => { return Ok(FutureResult::SavedFsCache(Arc::new(cached_info.info))); - } else { + } _ => { None - } + }} } else { downloader.cache.load_package_info(&name).await.ok().flatten() }; diff --git a/libs/npm_cache/remote.rs b/libs/npm_cache/remote.rs index ed74e5637a..56156a80ff 100644 --- a/libs/npm_cache/remote.rs +++ b/libs/npm_cache/remote.rs @@ -1,7 +1,7 @@ // Copyright 2018-2025 the Deno authors. MIT license. -use base64::prelude::BASE64_STANDARD; use base64::Engine; +use base64::prelude::BASE64_STANDARD; use deno_npm::npm_rc::RegistryConfig; #[derive(Debug, thiserror::Error, deno_error::JsError)] diff --git a/libs/npm_cache/tarball.rs b/libs/npm_cache/tarball.rs index 7554375b8b..91cafd14b1 100644 --- a/libs/npm_cache/tarball.rs +++ b/libs/npm_cache/tarball.rs @@ -7,21 +7,21 @@ use deno_error::JsErrorBox; use deno_npm::npm_rc::ResolvedNpmRc; use deno_npm::registry::NpmPackageVersionDistInfo; use deno_semver::package::PackageNv; -use futures::future::LocalBoxFuture; use futures::FutureExt; +use futures::future::LocalBoxFuture; use parking_lot::Mutex; use url::Url; -use crate::remote::maybe_auth_header_value_for_npm_registry; -use crate::rt::spawn_blocking; -use crate::rt::MultiRuntimeAsyncValueCreator; -use crate::tarball_extract::verify_and_extract_tarball; -use crate::tarball_extract::TarballExtractionMode; use crate::NpmCache; use crate::NpmCacheHttpClient; use crate::NpmCacheHttpClientResponse; use crate::NpmCacheSetting; use crate::NpmCacheSys; +use crate::remote::maybe_auth_header_value_for_npm_registry; +use crate::rt::MultiRuntimeAsyncValueCreator; +use crate::rt::spawn_blocking; +use crate::tarball_extract::TarballExtractionMode; +use crate::tarball_extract::verify_and_extract_tarball; type LoadResult = Result<(), Arc>; type LoadFuture = LocalBoxFuture<'static, LoadResult>; diff --git a/libs/npm_cache/tarball_extract.rs b/libs/npm_cache/tarball_extract.rs index 7c92d72c2b..cba3057386 100644 --- a/libs/npm_cache/tarball_extract.rs +++ b/libs/npm_cache/tarball_extract.rs @@ -5,8 +5,8 @@ use std::io::ErrorKind; use std::path::Path; use std::path::PathBuf; -use base64::prelude::BASE64_STANDARD; use base64::Engine; +use base64::prelude::BASE64_STANDARD; use deno_npm::registry::NpmPackageVersionDistInfo; use deno_npm::registry::NpmPackageVersionDistInfoIntegrity; use deno_semver::package::PackageNv; @@ -52,15 +52,17 @@ pub enum VerifyAndExtractTarballError { } pub fn verify_and_extract_tarball( - sys: &(impl FsCanonicalize - + FsCreateDirAll - + FsMetadata - + FsOpen - + FsRename - + FsRemoveDirAll - + FsRemoveFile - + SystemRandom - + ThreadSleep), + sys: &( + impl FsCanonicalize + + FsCreateDirAll + + FsMetadata + + FsOpen + + FsRename + + FsRemoveDirAll + + FsRemoveFile + + SystemRandom + + ThreadSleep + ), package_nv: &PackageNv, data: &[u8], dist_info: &NpmPackageVersionDistInfo, @@ -138,7 +140,9 @@ pub enum TarballIntegrityError { package: Box, integrity: String, }, - #[error("Tarball checksum did not match what was provided by npm registry for {package}.\n\nExpected: {expected}\nActual: {actual}")] + #[error( + "Tarball checksum did not match what was provided by npm registry for {package}.\n\nExpected: {expected}\nActual: {actual}" + )] MismatchedChecksum { package: Box, expected: String, @@ -364,8 +368,7 @@ mod test { name: "package".into(), version: Version::parse_from_npm("1.0.0").unwrap(), }; - let actual_checksum = - "z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg=="; + let actual_checksum = "z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg=="; assert_eq!( verify_tarball_integrity( &package, @@ -416,17 +419,21 @@ mod test { ) .unwrap_err() .to_string(), - format!("Tarball checksum did not match what was provided by npm registry for package@1.0.0.\n\nExpected: test\nActual: {actual_checksum}"), + format!( + "Tarball checksum did not match what was provided by npm registry for package@1.0.0.\n\nExpected: test\nActual: {actual_checksum}" + ), + ); + assert!( + verify_tarball_integrity( + &package, + &Vec::new(), + &NpmPackageVersionDistInfoIntegrity::Integrity { + algorithm: "sha512", + base64_hash: actual_checksum, + }, + ) + .is_ok() ); - assert!(verify_tarball_integrity( - &package, - &Vec::new(), - &NpmPackageVersionDistInfoIntegrity::Integrity { - algorithm: "sha512", - base64_hash: actual_checksum, - }, - ) - .is_ok()); let actual_hex = "da39a3ee5e6b4b0d3255bfef95601890afd80709"; assert_eq!( verify_tarball_integrity( @@ -436,14 +443,18 @@ mod test { ) .unwrap_err() .to_string(), - format!("Tarball checksum did not match what was provided by npm registry for package@1.0.0.\n\nExpected: test\nActual: {actual_hex}"), + format!( + "Tarball checksum did not match what was provided by npm registry for package@1.0.0.\n\nExpected: test\nActual: {actual_hex}" + ), + ); + assert!( + verify_tarball_integrity( + &package, + &Vec::new(), + &NpmPackageVersionDistInfoIntegrity::LegacySha1Hex(actual_hex), + ) + .is_ok() ); - assert!(verify_tarball_integrity( - &package, - &Vec::new(), - &NpmPackageVersionDistInfoIntegrity::LegacySha1Hex(actual_hex), - ) - .is_ok()); } #[test] diff --git a/libs/npm_installer/bin_entries.rs b/libs/npm_installer/bin_entries.rs index 42877fe1b7..3fc4f96342 100644 --- a/libs/npm_installer/bin_entries.rs +++ b/libs/npm_installer/bin_entries.rs @@ -6,10 +6,10 @@ use std::collections::VecDeque; use std::path::Path; use std::path::PathBuf; -use deno_npm::resolution::NpmResolutionSnapshot; use deno_npm::NpmPackageExtraInfo; use deno_npm::NpmPackageId; use deno_npm::NpmResolutionPackage; +use deno_npm::resolution::NpmResolutionSnapshot; use sys_traits::FsCreateDirAll; use sys_traits::FsFileMetadata; use sys_traits::FsFileSetPermissions; diff --git a/libs/npm_installer/extra_info.rs b/libs/npm_installer/extra_info.rs index c45a358734..2dd0566dd9 100644 --- a/libs/npm_installer/extra_info.rs +++ b/libs/npm_installer/extra_info.rs @@ -4,9 +4,9 @@ use std::path::Path; use std::sync::Arc; use deno_error::JsErrorBox; -use deno_npm::registry::NpmRegistryApi; use deno_npm::NpmPackageExtraInfo; use deno_npm::NpmResolutionPackage; +use deno_npm::registry::NpmRegistryApi; use deno_resolver::workspace::WorkspaceNpmLinkPackages; use deno_semver::package::PackageNv; use parking_lot::RwLock; diff --git a/libs/npm_installer/factory.rs b/libs/npm_installer/factory.rs index 33841ed5ba..7d2e4fc06e 100644 --- a/libs/npm_installer/factory.rs +++ b/libs/npm_installer/factory.rs @@ -16,6 +16,9 @@ use deno_resolver::lockfile::LockfileLock; use deno_resolver::lockfile::LockfileNpmPackageInfoApiAdapter; use futures::FutureExt; +use crate::LifecycleScriptsConfig; +use crate::NpmInstaller; +use crate::Reporter; use crate::graph::NpmCachingStrategy; use crate::graph::NpmDenoGraphResolver; use crate::initializer::NpmResolutionInitializer; @@ -23,9 +26,6 @@ use crate::initializer::NpmResolverManagedSnapshotOption; use crate::lifecycle_scripts::LifecycleScriptsExecutor; use crate::package_json::NpmInstallDepsProvider; use crate::resolution::NpmResolutionInstaller; -use crate::LifecycleScriptsConfig; -use crate::NpmInstaller; -use crate::Reporter; // todo(https://github.com/rust-lang/rust/issues/109737): remove once_cell after get_or_try_init is stabilized type Deferred = once_cell::sync::OnceCell; @@ -80,10 +80,10 @@ pub struct NpmInstallerFactory< } impl< - TNpmCacheHttpClient: NpmCacheHttpClient, - TReporter: Reporter, - TSys: NpmInstallerFactorySys, - > NpmInstallerFactory + TNpmCacheHttpClient: NpmCacheHttpClient, + TReporter: Reporter, + TSys: NpmInstallerFactorySys, +> NpmInstallerFactory { pub fn new( resolver_factory: Arc>, diff --git a/libs/npm_installer/global.rs b/libs/npm_installer/global.rs index b8b85cd798..7741fa57c8 100644 --- a/libs/npm_installer/global.rs +++ b/libs/npm_installer/global.rs @@ -14,15 +14,15 @@ use deno_npm_cache::NpmCacheSys; use deno_npm_cache::TarballCache; use deno_resolver::npm::managed::NpmResolutionCell; use deno_terminal::colors; -use futures::stream::FuturesUnordered; use futures::StreamExt; +use futures::stream::FuturesUnordered; use sys_traits::OpenOptions; -use crate::lifecycle_scripts::LifecycleScripts; -use crate::lifecycle_scripts::LifecycleScriptsStrategy; use crate::LifecycleScriptsConfig; use crate::NpmPackageFsInstaller; use crate::PackageCaching; +use crate::lifecycle_scripts::LifecycleScripts; +use crate::lifecycle_scripts::LifecycleScriptsStrategy; /// Resolves packages from the global npm cache. pub struct GlobalNpmPackageInstaller< @@ -196,7 +196,11 @@ impl LifecycleScriptsStrategy &self, packages: &[(&NpmResolutionPackage, PathBuf)], ) -> std::result::Result<(), std::io::Error> { - log::warn!("{} The following packages contained npm lifecycle scripts ({}) that were not executed:", colors::yellow("Warning"), colors::gray("preinstall/install/postinstall")); + log::warn!( + "{} The following packages contained npm lifecycle scripts ({}) that were not executed:", + colors::yellow("Warning"), + colors::gray("preinstall/install/postinstall") + ); for (package, _) in packages { log::warn!("┠─ {}", colors::gray(format!("npm:{}", package.id.nv))); } @@ -205,7 +209,12 @@ impl LifecycleScriptsStrategy "┠─ {}", colors::italic("This may cause the packages to not work correctly.") ); - log::warn!("┠─ {}", colors::italic("Lifecycle scripts are only supported when using a `node_modules` directory.")); + log::warn!( + "┠─ {}", + colors::italic( + "Lifecycle scripts are only supported when using a `node_modules` directory." + ) + ); log::warn!( "┠─ {}", colors::italic("Enable it in your deno config file:") diff --git a/libs/npm_installer/initializer.rs b/libs/npm_installer/initializer.rs index 72a93a5018..cc0e94ed17 100644 --- a/libs/npm_installer/initializer.rs +++ b/libs/npm_installer/initializer.rs @@ -54,7 +54,9 @@ impl NpmResolutionInitializer { #[cfg(debug_assertions)] pub fn debug_assert_initialized(&self) { if !matches!(*self.sync_state.lock(), SyncState::Success) { - panic!("debug assert: npm resolution must be initialized before calling this code"); + panic!( + "debug assert: npm resolution must be initialized before calling this code" + ); } } diff --git a/libs/npm_installer/lib.rs b/libs/npm_installer/lib.rs index f975d42c5a..74296c7d91 100644 --- a/libs/npm_installer/lib.rs +++ b/libs/npm_installer/lib.rs @@ -5,9 +5,9 @@ use std::path::PathBuf; use std::sync::Arc; use deno_error::JsErrorBox; +use deno_npm::NpmSystemInfo; use deno_npm::registry::NpmPackageInfo; use deno_npm::registry::NpmRegistryPackageInfoLoadError; -use deno_npm::NpmSystemInfo; use deno_npm_cache::NpmCache; use deno_npm_cache::NpmCacheHttpClient; use deno_resolver::lockfile::LockfileLock; diff --git a/libs/npm_installer/lifecycle_scripts.rs b/libs/npm_installer/lifecycle_scripts.rs index cb238f4b0e..8d1a33abab 100644 --- a/libs/npm_installer/lifecycle_scripts.rs +++ b/libs/npm_installer/lifecycle_scripts.rs @@ -7,12 +7,12 @@ use std::path::PathBuf; use anyhow::Error as AnyError; use deno_error::JsErrorBox; -use deno_npm::resolution::NpmResolutionSnapshot; use deno_npm::NpmPackageExtraInfo; use deno_npm::NpmResolutionPackage; -use deno_semver::package::PackageNv; +use deno_npm::resolution::NpmResolutionSnapshot; use deno_semver::SmallStackString; use deno_semver::Version; +use deno_semver::package::PackageNv; use sys_traits::FsMetadata; use crate::CachedNpmPackageExtraInfoProvider; diff --git a/libs/npm_installer/local.rs b/libs/npm_installer/local.rs index f2d9e5a642..ed638ac799 100644 --- a/libs/npm_installer/local.rs +++ b/libs/npm_installer/local.rs @@ -5,11 +5,11 @@ use std::borrow::Cow; use std::cell::RefCell; use std::cmp::Ordering; -use std::collections::hash_map::Entry; use std::collections::BTreeMap; use std::collections::BTreeSet; use std::collections::HashMap; use std::collections::HashSet; +use std::collections::hash_map::Entry; use std::path::Path; use std::path::PathBuf; use std::rc::Rc; @@ -18,23 +18,23 @@ use std::sync::Arc; use anyhow::Error as AnyError; use async_trait::async_trait; use deno_error::JsErrorBox; -use deno_npm::resolution::NpmResolutionSnapshot; use deno_npm::NpmResolutionPackage; use deno_npm::NpmSystemInfo; -use deno_npm_cache::hard_link_file; +use deno_npm::resolution::NpmResolutionSnapshot; use deno_npm_cache::NpmCache; use deno_npm_cache::NpmCacheHttpClient; use deno_npm_cache::NpmCacheSys; use deno_npm_cache::TarballCache; +use deno_npm_cache::hard_link_file; use deno_path_util::fs::atomic_write_file_with_retries; use deno_resolver::npm::get_package_folder_id_folder_name; use deno_resolver::npm::managed::NpmResolutionCell; -use deno_semver::package::PackageNv; use deno_semver::StackString; +use deno_semver::package::PackageNv; use deno_terminal::colors; -use futures::stream::FuturesUnordered; use futures::FutureExt; use futures::StreamExt; +use futures::stream::FuturesUnordered; use parking_lot::Mutex; use serde::Deserialize; use serde::Serialize; @@ -43,21 +43,6 @@ use sys_traits::FsMetadata; use sys_traits::FsOpen; use sys_traits::FsWrite; -use crate::bin_entries::EntrySetupOutcome; -use crate::bin_entries::SetupBinEntrySys; -use crate::flag::LaxSingleProcessFsFlag; -use crate::flag::LaxSingleProcessFsFlagSys; -use crate::fs::clone_dir_recursive; -use crate::fs::symlink_dir; -use crate::fs::CloneDirRecursiveSys; -use crate::lifecycle_scripts::has_lifecycle_scripts; -use crate::lifecycle_scripts::is_running_lifecycle_script; -use crate::lifecycle_scripts::LifecycleScripts; -use crate::lifecycle_scripts::LifecycleScriptsExecutor; -use crate::lifecycle_scripts::LifecycleScriptsExecutorOptions; -use crate::lifecycle_scripts::LifecycleScriptsStrategy; -use crate::package_json::NpmInstallDepsProvider; -use crate::process_state::NpmProcessState; use crate::BinEntries; use crate::CachedNpmPackageExtraInfoProvider; use crate::ExpectedExtraInfo; @@ -66,6 +51,21 @@ use crate::NpmPackageExtraInfoProvider; use crate::NpmPackageFsInstaller; use crate::PackageCaching; use crate::Reporter; +use crate::bin_entries::EntrySetupOutcome; +use crate::bin_entries::SetupBinEntrySys; +use crate::flag::LaxSingleProcessFsFlag; +use crate::flag::LaxSingleProcessFsFlagSys; +use crate::fs::CloneDirRecursiveSys; +use crate::fs::clone_dir_recursive; +use crate::fs::symlink_dir; +use crate::lifecycle_scripts::LifecycleScripts; +use crate::lifecycle_scripts::LifecycleScriptsExecutor; +use crate::lifecycle_scripts::LifecycleScriptsExecutorOptions; +use crate::lifecycle_scripts::LifecycleScriptsStrategy; +use crate::lifecycle_scripts::has_lifecycle_scripts; +use crate::lifecycle_scripts::is_running_lifecycle_script; +use crate::package_json::NpmInstallDepsProvider; +use crate::process_state::NpmProcessState; #[sys_traits::auto_impl] pub trait LocalNpmInstallSys: @@ -100,10 +100,10 @@ pub struct LocalNpmPackageInstaller< } impl< - THttpClient: NpmCacheHttpClient, - TReporter: Reporter, - TSys: LocalNpmInstallSys, - > std::fmt::Debug for LocalNpmPackageInstaller + THttpClient: NpmCacheHttpClient, + TReporter: Reporter, + TSys: LocalNpmInstallSys, +> std::fmt::Debug for LocalNpmPackageInstaller { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("LocalNpmPackageInstaller") @@ -121,10 +121,10 @@ impl< } impl< - THttpClient: NpmCacheHttpClient, - TReporter: Reporter, - TSys: LocalNpmInstallSys, - > LocalNpmPackageInstaller + THttpClient: NpmCacheHttpClient, + TReporter: Reporter, + TSys: LocalNpmInstallSys, +> LocalNpmPackageInstaller { #[allow(clippy::too_many_arguments)] pub fn new( @@ -583,20 +583,27 @@ impl< // 5. Create symlinks for package json dependencies { for remote in self.npm_install_deps_provider.remote_pkgs() { - let remote_pkg = if let Ok(remote_pkg) = - snapshot.resolve_pkg_from_pkg_req(&remote.req) - { - remote_pkg - } else if remote.req.version_req.tag().is_some() { - // couldn't find a match, and `resolve_best_package_id` - // panics if you give it a tag - continue; - } else if let Some(remote_id) = snapshot - .resolve_best_package_id(&remote.req.name, &remote.req.version_req) - { - snapshot.package_from_id(&remote_id).unwrap() - } else { - continue; // skip, package not found + let remote_pkg = match snapshot.resolve_pkg_from_pkg_req(&remote.req) { + Ok(remote_pkg) => remote_pkg, + _ => { + if remote.req.version_req.tag().is_some() { + // couldn't find a match, and `resolve_best_package_id` + // panics if you give it a tag + continue; + } else { + match snapshot.resolve_best_package_id( + &remote.req.name, + &remote.req.version_req, + ) { + Some(remote_id) => { + snapshot.package_from_id(&remote_id).unwrap() + } + _ => { + continue; // skip, package not found + } + } + } + } }; let Some(remote_alias) = &remote.alias else { continue; @@ -875,10 +882,10 @@ impl< #[async_trait(?Send)] impl< - THttpClient: NpmCacheHttpClient, - TReporter: Reporter, - TSys: LocalNpmInstallSys, - > NpmPackageFsInstaller + THttpClient: NpmCacheHttpClient, + TReporter: Reporter, + TSys: LocalNpmInstallSys, +> NpmPackageFsInstaller for LocalNpmPackageInstaller { async fn cache_packages<'a>( @@ -1014,7 +1021,11 @@ impl LifecycleScriptsStrategy packages: &[(&NpmResolutionPackage, std::path::PathBuf)], ) -> Result<(), std::io::Error> { if !packages.is_empty() { - log::warn!("{} The following packages contained npm lifecycle scripts ({}) that were not executed:", colors::yellow("Warning"), colors::gray("preinstall/install/postinstall")); + log::warn!( + "{} The following packages contained npm lifecycle scripts ({}) that were not executed:", + colors::yellow("Warning"), + colors::gray("preinstall/install/postinstall") + ); for (package, _) in packages { log::warn!("┠─ {}", colors::gray(format!("npm:{}", package.id.nv))); @@ -1025,7 +1036,12 @@ impl LifecycleScriptsStrategy "┠─ {}", colors::italic("This may cause the packages to not work correctly.") ); - log::warn!("┖─ {}", colors::italic("To run lifecycle scripts, use the `--allow-scripts` flag with `deno install`:")); + log::warn!( + "┖─ {}", + colors::italic( + "To run lifecycle scripts, use the `--allow-scripts` flag with `deno install`:" + ) + ); let packages_comma_separated = packages .iter() .map(|(p, _)| format!("npm:{}", p.id.nv)) @@ -1233,10 +1249,12 @@ pub enum SymlinkPackageDirError { } fn symlink_package_dir( - sys: &(impl sys_traits::FsSymlinkDir - + sys_traits::FsRemoveDirAll - + sys_traits::FsCreateDirAll - + sys_traits::FsCreateJunction), + sys: &( + impl sys_traits::FsSymlinkDir + + sys_traits::FsRemoveDirAll + + sys_traits::FsCreateDirAll + + sys_traits::FsCreateJunction + ), old_path: &Path, new_path: &Path, ) -> Result<(), SymlinkPackageDirError> { @@ -1378,25 +1396,31 @@ mod test { let mut cache = LocalSetupCache::load(sys.clone(), cache_bin_path.clone()); assert!(cache.insert_deno_symlink("package-a", "package-a@1.0.0")); assert!(cache.insert_root_symlink("package-a", "package-a@1.0.0")); - assert!(cache - .with_dep("package-a") - .insert("package-b", "package-b@1.0.0")); + assert!( + cache + .with_dep("package-a") + .insert("package-b", "package-b@1.0.0") + ); assert!(cache.save()); let mut cache = LocalSetupCache::load(sys.clone(), cache_bin_path.clone()); assert!(!cache.insert_deno_symlink("package-a", "package-a@1.0.0")); assert!(!cache.insert_root_symlink("package-a", "package-a@1.0.0")); - assert!(!cache - .with_dep("package-a") - .insert("package-b", "package-b@1.0.0")); + assert!( + !cache + .with_dep("package-a") + .insert("package-b", "package-b@1.0.0") + ); assert!(!cache.save()); assert!(cache.insert_root_symlink("package-b", "package-b@0.2.0")); assert!(cache.save()); let mut cache = LocalSetupCache::load(sys, cache_bin_path); cache.remove_dep("package-a"); - assert!(cache - .with_dep("package-a") - .insert("package-b", "package-b@1.0.0")); + assert!( + cache + .with_dep("package-a") + .insert("package-b", "package-b@1.0.0") + ); } } diff --git a/libs/npm_installer/package_json.rs b/libs/npm_installer/package_json.rs index d85c6e06d9..757a5f74b5 100644 --- a/libs/npm_installer/package_json.rs +++ b/libs/npm_installer/package_json.rs @@ -7,13 +7,13 @@ use deno_config::workspace::Workspace; use deno_package_json::PackageJsonDepValue; use deno_package_json::PackageJsonDepValueParseError; use deno_package_json::PackageJsonDepWorkspaceReq; +use deno_semver::StackString; +use deno_semver::Version; +use deno_semver::VersionReq; use deno_semver::npm::NpmPackageReqReference; use deno_semver::package::PackageName; use deno_semver::package::PackageNv; use deno_semver::package::PackageReq; -use deno_semver::StackString; -use deno_semver::Version; -use deno_semver::VersionReq; use serde_json; use thiserror::Error; use url::Url; diff --git a/libs/npm_installer/resolution.rs b/libs/npm_installer/resolution.rs index 15b9eab677..24f4c23618 100644 --- a/libs/npm_installer/resolution.rs +++ b/libs/npm_installer/resolution.rs @@ -6,6 +6,7 @@ use capacity_builder::StringBuilder; use deno_error::JsErrorBox; use deno_lockfile::NpmPackageDependencyLockfileInfo; use deno_lockfile::NpmPackageLockfileInfo; +use deno_npm::NpmResolutionPackage; use deno_npm::registry::NpmPackageInfo; use deno_npm::registry::NpmRegistryApi; use deno_npm::registry::NpmRegistryPackageInfoLoadError; @@ -13,7 +14,6 @@ use deno_npm::resolution::AddPkgReqsOptions; use deno_npm::resolution::DefaultTarballUrlProvider; use deno_npm::resolution::NpmResolutionError; use deno_npm::resolution::NpmResolutionSnapshot; -use deno_npm::NpmResolutionPackage; use deno_npm_cache::NpmCacheHttpClient; use deno_npm_cache::NpmCacheSys; use deno_npm_cache::RegistryInfoProvider; @@ -22,12 +22,12 @@ use deno_resolver::lockfile::LockfileLock; use deno_resolver::lockfile::LockfileSys; use deno_resolver::npm::managed::NpmResolutionCell; use deno_resolver::workspace::WorkspaceNpmLinkPackages; -use deno_semver::jsr::JsrDepPackageReq; -use deno_semver::package::PackageNv; -use deno_semver::package::PackageReq; use deno_semver::SmallStackString; use deno_semver::StackString; use deno_semver::VersionReq; +use deno_semver::jsr::JsrDepPackageReq; +use deno_semver::package::PackageNv; +use deno_semver::package::PackageReq; use deno_terminal::colors; use deno_unsync::sync::TaskQueue; @@ -57,10 +57,8 @@ pub struct NpmResolutionInstaller< update_queue: TaskQueue, } -impl< - TNpmCacheHttpClient: NpmCacheHttpClient, - TSys: NpmResolutionInstallerSys, - > NpmResolutionInstaller +impl + NpmResolutionInstaller { pub fn new( registry_info_provider: Arc< diff --git a/libs/package_json/lib.rs b/libs/package_json/lib.rs index 6b6c5d2072..6805115967 100644 --- a/libs/package_json/lib.rs +++ b/libs/package_json/lib.rs @@ -10,11 +10,11 @@ use std::path::PathBuf; use boxed_error::Boxed; use deno_error::JsError; -use deno_semver::npm::NpmVersionReqParseError; -use deno_semver::package::PackageReq; use deno_semver::StackString; use deno_semver::VersionReq; use deno_semver::VersionReqSpecifierParseError; +use deno_semver::npm::NpmVersionReqParseError; +use deno_semver::package::PackageReq; use indexmap::IndexMap; use serde::Serialize; use serde_json::Map; @@ -120,12 +120,12 @@ impl PackageJsonDepValue { return Ok(Self::JsrReq(PackageReq { name: name.into(), version_req, - })) + })); } Err(err) => { return Err( PackageJsonDepValueParseErrorKind::JsrVersionReq(err).into_box(), - ) + ); } } } @@ -199,7 +199,9 @@ pub enum PackageJsonLoadError { #[inherit] source: serde_json::Error, }, - #[error("\"exports\" cannot contains some keys starting with '.' and some not.\nThe exports object must either be an object of package subpath keys\nor an object of main entry condition name keys only.")] + #[error( + "\"exports\" cannot contains some keys starting with '.' and some not.\nThe exports object must either be an object of package subpath keys\nor an object of main entry condition name keys only." + )] #[class(type)] InvalidExports, } @@ -240,10 +242,9 @@ impl PackageJson { maybe_cache: Option<&dyn PackageJsonCache>, path: &Path, ) -> Result { - if let Some(item) = maybe_cache.and_then(|c| c.get(path)) { - Ok(item) - } else { - match sys.fs_read_to_string_lossy(path) { + match maybe_cache.and_then(|c| c.get(path)) { + Some(item) => Ok(item), + _ => match sys.fs_read_to_string_lossy(path) { Ok(file_text) => { let pkg_json = PackageJson::load_from_string(path.to_path_buf(), &file_text)?; @@ -257,7 +258,7 @@ impl PackageJson { path: path.to_path_buf(), source: err, }), - } + }, } } diff --git a/libs/resolver/cache/disk_cache.rs b/libs/resolver/cache/disk_cache.rs index 19fd9083fa..5d948318ca 100644 --- a/libs/resolver/cache/disk_cache.rs +++ b/libs/resolver/cache/disk_cache.rs @@ -7,8 +7,8 @@ use std::path::PathBuf; use std::path::Prefix; use std::str; -use deno_cache_dir::url_to_filename; use deno_cache_dir::CACHE_PERM; +use deno_cache_dir::url_to_filename; use deno_path_util::fs::atomic_write_file_with_retries; use sys_traits::FsRead; use url::Host; diff --git a/libs/resolver/cache/emit.rs b/libs/resolver/cache/emit.rs index 08db2d1321..2ed3241f28 100644 --- a/libs/resolver/cache/emit.rs +++ b/libs/resolver/cache/emit.rs @@ -5,8 +5,8 @@ use std::hash::Hash; use std::hash::Hasher; use std::path::PathBuf; -use anyhow::anyhow; use anyhow::Error as AnyError; +use anyhow::anyhow; use deno_unsync::sync::AtomicFlag; use url::Url; diff --git a/libs/resolver/cjs/mod.rs b/libs/resolver/cjs/mod.rs index 489db27936..009e540116 100644 --- a/libs/resolver/cjs/mod.rs +++ b/libs/resolver/cjs/mod.rs @@ -1,10 +1,10 @@ // Copyright 2018-2025 the Deno authors. MIT license. use deno_media_type::MediaType; -use node_resolver::errors::ClosestPkgJsonError; use node_resolver::InNpmPackageChecker; use node_resolver::PackageJsonResolverRc; use node_resolver::ResolutionMode; +use node_resolver::errors::ClosestPkgJsonError; use sys_traits::FsRead; use url::Url; diff --git a/libs/resolver/deno_json.rs b/libs/resolver/deno_json.rs index 6436357a15..de1ea8cccc 100644 --- a/libs/resolver/deno_json.rs +++ b/libs/resolver/deno_json.rs @@ -8,12 +8,11 @@ use std::path::Path; use std::path::PathBuf; use std::rc::Rc; -use deno_config::deno_json::parse_compiler_options; use deno_config::deno_json::CompilerOptions; use deno_config::deno_json::CompilerOptionsParseError; use deno_config::deno_json::CompilerOptionsWithIgnoredOptions; +use deno_config::deno_json::parse_compiler_options; use deno_config::glob::PathOrPatternSet; -use deno_config::workspace::get_base_compiler_options_for_emit; use deno_config::workspace::CompilerOptionsSource; use deno_config::workspace::CompilerOptionsSourceKind; use deno_config::workspace::CompilerOptionsType; @@ -21,6 +20,7 @@ use deno_config::workspace::JsxImportSourceConfig; use deno_config::workspace::JsxImportSourceSpecifierConfig; use deno_config::workspace::ToMaybeJsxImportSourceConfigError; use deno_config::workspace::TsTypeLib; +use deno_config::workspace::get_base_compiler_options_for_emit; use deno_path_util::normalize_path; use deno_path_util::url_from_file_path; use deno_path_util::url_to_file_path; diff --git a/libs/resolver/display.rs b/libs/resolver/display.rs index d635d5d9ad..01ccccce35 100644 --- a/libs/resolver/display.rs +++ b/libs/resolver/display.rs @@ -6,8 +6,8 @@ use std::fmt::Write as _; use deno_terminal::colors; -use dissimilar::diff as difference; use dissimilar::Chunk; +use dissimilar::diff as difference; /// Print diff of the same file_path, before and after formatting. /// diff --git a/libs/resolver/emit.rs b/libs/resolver/emit.rs index 443c62df89..289b153507 100644 --- a/libs/resolver/emit.rs +++ b/libs/resolver/emit.rs @@ -16,9 +16,9 @@ use deno_error::JsErrorBox; use deno_graph::MediaType; use deno_graph::Module; use deno_graph::ModuleGraph; -use futures::stream::FuturesUnordered; use futures::FutureExt; use futures::StreamExt; +use futures::stream::FuturesUnordered; use node_resolver::InNpmPackageChecker; use url::Url; diff --git a/libs/resolver/factory.rs b/libs/resolver/factory.rs index 5077691230..f7a69657aa 100644 --- a/libs/resolver/factory.rs +++ b/libs/resolver/factory.rs @@ -6,11 +6,11 @@ use std::path::PathBuf; use anyhow::bail; use boxed_error::Boxed; -use deno_cache_dir::npm::NpmCacheDir; use deno_cache_dir::DenoDirResolutionError; use deno_cache_dir::GlobalHttpCacheRc; use deno_cache_dir::GlobalOrLocalHttpCache; use deno_cache_dir::LocalHttpCache; +use deno_cache_dir::npm::NpmCacheDir; use deno_config::deno_json::NodeModulesDirMode; use deno_config::workspace::FolderConfigs; use deno_config::workspace::VendorEnablement; @@ -24,19 +24,25 @@ pub use deno_npm::NpmSystemInfo; use deno_path_util::fs::canonicalize_path_maybe_not_exists; use deno_path_util::normalize_path; use futures::future::FutureExt; -use node_resolver::analyze::CjsModuleExportAnalyzerRc; -use node_resolver::analyze::NodeCodeTranslator; -use node_resolver::analyze::NodeCodeTranslatorRc; -use node_resolver::cache::NodeResolutionSys; use node_resolver::DenoIsBuiltInNodeModuleChecker; use node_resolver::NodeResolver; use node_resolver::NodeResolverOptions; use node_resolver::NodeResolverRc; use node_resolver::PackageJsonResolver; use node_resolver::PackageJsonResolverRc; +use node_resolver::analyze::CjsModuleExportAnalyzerRc; +use node_resolver::analyze::NodeCodeTranslator; +use node_resolver::analyze::NodeCodeTranslatorRc; +use node_resolver::cache::NodeResolutionSys; use thiserror::Error; use url::Url; +use crate::DefaultRawDenoResolverRc; +use crate::DenoResolverOptions; +use crate::NodeAndNpmResolvers; +use crate::NpmCacheDirRc; +use crate::RawDenoResolver; +use crate::WorkspaceResolverRc; use crate::cache::DenoDir; use crate::cache::DenoDirOptions; use crate::cache::DenoDirProvider; @@ -44,12 +50,12 @@ use crate::cache::DenoDirProviderRc; use crate::cache::DenoDirSys; use crate::cache::EmitCache; use crate::cache::EmitCacheRc; -use crate::cjs::analyzer::DenoCjsCodeAnalyzer; -use crate::cjs::analyzer::NodeAnalysisCacheRc; -use crate::cjs::analyzer::NullNodeAnalysisCache; use crate::cjs::CjsTracker; use crate::cjs::CjsTrackerRc; use crate::cjs::IsCjsResolutionMode; +use crate::cjs::analyzer::DenoCjsCodeAnalyzer; +use crate::cjs::analyzer::NodeAnalysisCacheRc; +use crate::cjs::analyzer::NullNodeAnalysisCache; use crate::collections::FolderScopedMap; use crate::deno_json::CompilerOptionsResolver; use crate::deno_json::CompilerOptionsResolverRc; @@ -57,9 +63,6 @@ use crate::import_map::WorkspaceExternalImportMapLoader; use crate::import_map::WorkspaceExternalImportMapLoaderRc; use crate::lockfile::LockfileLock; use crate::lockfile::LockfileLockRc; -use crate::npm::managed::ManagedInNpmPkgCheckerCreateOptions; -use crate::npm::managed::ManagedNpmResolverCreateOptions; -use crate::npm::managed::NpmResolutionCellRc; use crate::npm::ByonmNpmResolverCreateOptions; use crate::npm::CreateInNpmPkgCheckerOptions; use crate::npm::DenoInNpmPackageChecker; @@ -68,24 +71,21 @@ use crate::npm::NpmReqResolverOptions; use crate::npm::NpmReqResolverRc; use crate::npm::NpmResolver; use crate::npm::NpmResolverCreateOptions; -use crate::npmrc::discover_npmrc_from_workspace; +use crate::npm::managed::ManagedInNpmPkgCheckerCreateOptions; +use crate::npm::managed::ManagedNpmResolverCreateOptions; +use crate::npm::managed::NpmResolutionCellRc; use crate::npmrc::NpmRcDiscoverError; use crate::npmrc::ResolvedNpmRcRc; -use crate::sync::new_rc; +use crate::npmrc::discover_npmrc_from_workspace; use crate::sync::MaybeSend; use crate::sync::MaybeSync; +use crate::sync::new_rc; use crate::workspace::FsCacheOptions; use crate::workspace::PackageJsonDepResolution; use crate::workspace::SloppyImportsOptions; use crate::workspace::WorkspaceNpmLinkPackages; use crate::workspace::WorkspaceNpmLinkPackagesRc; use crate::workspace::WorkspaceResolver; -use crate::DefaultRawDenoResolverRc; -use crate::DenoResolverOptions; -use crate::NodeAndNpmResolvers; -use crate::NpmCacheDirRc; -use crate::RawDenoResolver; -use crate::WorkspaceResolverRc; // todo(https://github.com/rust-lang/rust/issues/109737): remove once_cell after get_or_try_init is stabilized #[cfg(feature = "sync")] diff --git a/libs/resolver/file_fetcher.rs b/libs/resolver/file_fetcher.rs index a78959a853..6006b42e12 100644 --- a/libs/resolver/file_fetcher.rs +++ b/libs/resolver/file_fetcher.rs @@ -5,6 +5,9 @@ use std::collections::HashMap; use std::path::PathBuf; use boxed_error::Boxed; +use deno_cache_dir::GlobalHttpCacheRc; +use deno_cache_dir::GlobalHttpCacheSys; +use deno_cache_dir::HttpCacheRc; use deno_cache_dir::file_fetcher::AuthTokens; use deno_cache_dir::file_fetcher::BlobStore; use deno_cache_dir::file_fetcher::CacheSetting; @@ -16,9 +19,6 @@ use deno_cache_dir::file_fetcher::FileOrRedirect; use deno_cache_dir::file_fetcher::HttpClient; use deno_cache_dir::file_fetcher::TooManyRedirectsError; use deno_cache_dir::file_fetcher::UnsupportedSchemeError; -use deno_cache_dir::GlobalHttpCacheRc; -use deno_cache_dir::GlobalHttpCacheSys; -use deno_cache_dir::HttpCacheRc; use deno_error::JsError; use deno_error::JsErrorBox; use deno_graph::source::CacheInfo; @@ -30,8 +30,8 @@ use deno_graph::source::LoaderChecksum; use deno_permissions::CheckSpecifierKind; use deno_permissions::PermissionCheckError; use deno_permissions::PermissionsContainer; -use futures::future::LocalBoxFuture; use futures::FutureExt; +use futures::future::LocalBoxFuture; use http::header; use node_resolver::InNpmPackageChecker; use parking_lot::Mutex; @@ -170,10 +170,10 @@ pub struct PermissionedFileFetcher< } impl< - TBlobStore: BlobStore, - TSys: PermissionedFileFetcherSys, - THttpClient: HttpClient, - > PermissionedFileFetcher + TBlobStore: BlobStore, + TSys: PermissionedFileFetcherSys, + THttpClient: HttpClient, +> PermissionedFileFetcher { pub fn new( blob_store: TBlobStore, @@ -430,10 +430,10 @@ pub struct DenoGraphLoader< } impl< - TBlobStore: BlobStore + 'static, - TSys: DenoGraphLoaderSys + 'static, - THttpClient: HttpClient + 'static, - > DenoGraphLoader + TBlobStore: BlobStore + 'static, + TSys: DenoGraphLoaderSys + 'static, + THttpClient: HttpClient + 'static, +> DenoGraphLoader { pub fn new( file_fetcher: PermissionedFileFetcherRc, @@ -590,10 +590,10 @@ impl< } impl< - TBlobStore: BlobStore + 'static, - TSys: DenoGraphLoaderSys + 'static, - THttpClient: HttpClient + 'static, - > Loader for DenoGraphLoader + TBlobStore: BlobStore + 'static, + TSys: DenoGraphLoaderSys + 'static, + THttpClient: HttpClient + 'static, +> Loader for DenoGraphLoader { fn cache_info_enabled(&self) -> bool { self.cache_info_enabled @@ -678,11 +678,8 @@ struct LoadStrategy< } #[async_trait::async_trait(?Send)] -impl< - TBlobStore: BlobStore, - TSys: DenoGraphLoaderSys, - THttpClient: HttpClient, - > LoadOrCacheStrategy for LoadStrategy +impl + LoadOrCacheStrategy for LoadStrategy { type Response = deno_graph::source::LoadResponse; @@ -734,11 +731,8 @@ struct CacheStrategy< } #[async_trait::async_trait(?Send)] -impl< - TBlobStore: BlobStore, - TSys: DenoGraphLoaderSys, - THttpClient: HttpClient, - > LoadOrCacheStrategy for CacheStrategy +impl + LoadOrCacheStrategy for CacheStrategy { type Response = deno_graph::source::CacheResponse; diff --git a/libs/resolver/graph.rs b/libs/resolver/graph.rs index 357a8d41cc..1456e45c9e 100644 --- a/libs/resolver/graph.rs +++ b/libs/resolver/graph.rs @@ -3,9 +3,9 @@ use std::borrow::Cow; use boxed_error::Boxed; -use deno_graph::source::ResolveError; use deno_graph::Module; use deno_graph::Resolution; +use deno_graph::source::ResolveError; use deno_semver::npm::NpmPackageNvReference; use deno_semver::npm::NpmPackageReqReference; use deno_semver::package::PackageReq; @@ -17,13 +17,13 @@ use node_resolver::NpmPackageFolderResolver; use node_resolver::UrlOrPath; use url::Url; +use crate::DenoResolveError; +use crate::DenoResolverSys; +use crate::RawDenoResolverRc; use crate::cjs::CjsTracker; use crate::deno_json::JsxImportSourceConfigResolver; use crate::npm; use crate::workspace::MappedResolutionDiagnostic; -use crate::DenoResolveError; -use crate::DenoResolverSys; -use crate::RawDenoResolverRc; #[allow(clippy::disallowed_types)] pub type FoundPackageJsonDepFlagRc = @@ -180,11 +180,11 @@ pub struct DenoResolver< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: DenoResolverSys, - > std::fmt::Debug + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: DenoResolverSys, +> std::fmt::Debug for DenoResolver< TInNpmPackageChecker, TIsBuiltInNodeModuleChecker, @@ -198,11 +198,11 @@ impl< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: DenoResolverSys, - > + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: DenoResolverSys, +> DenoResolver< TInNpmPackageChecker, TIsBuiltInNodeModuleChecker, @@ -289,23 +289,24 @@ impl< None => { if options.maintain_npm_specifiers { specifier.into_owned() - } else if let Ok(reference) = - NpmPackageReqReference::from_specifier(&specifier) - { - if let Some(url) = - self.resolver.resolve_non_workspace_npm_req_ref_to_file( - &reference, - referrer, - options.mode, - options.kind, - )? - { - url.into_url()? - } else { - specifier.into_owned() - } } else { - specifier.into_owned() + match NpmPackageReqReference::from_specifier(&specifier) { + Ok(reference) => { + if let Some(url) = + self.resolver.resolve_non_workspace_npm_req_ref_to_file( + &reference, + referrer, + options.mode, + options.kind, + )? + { + url.into_url()? + } else { + specifier.into_owned() + } + } + _ => specifier.into_owned(), + } } } }; @@ -439,11 +440,11 @@ pub struct DenoGraphResolverAdapter< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: DenoResolverSys, - > std::fmt::Debug + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: DenoResolverSys, +> std::fmt::Debug for DenoGraphResolverAdapter< '_, TInNpmPackageChecker, @@ -458,11 +459,11 @@ impl< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: DenoResolverSys, - > deno_graph::source::Resolver + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: DenoResolverSys, +> deno_graph::source::Resolver for DenoGraphResolverAdapter< '_, TInNpmPackageChecker, diff --git a/libs/resolver/lib.rs b/libs/resolver/lib.rs index 39fdc4e334..aa23cc428e 100644 --- a/libs/resolver/lib.rs +++ b/libs/resolver/lib.rs @@ -12,9 +12,6 @@ use deno_error::JsError; use deno_package_json::PackageJsonDepValue; use deno_package_json::PackageJsonDepValueParseError; use deno_semver::npm::NpmPackageReqReference; -use node_resolver::errors::NodeResolveError; -use node_resolver::errors::PackageSubpathResolveError; -use node_resolver::errors::UnknownBuiltInNodeModuleError; pub use node_resolver::DenoIsBuiltInNodeModuleChecker; use node_resolver::InNpmPackageChecker; use node_resolver::IsBuiltInNodeModuleChecker; @@ -25,6 +22,9 @@ use node_resolver::NodeResolverRc; use node_resolver::NpmPackageFolderResolver; use node_resolver::ResolutionMode; use node_resolver::UrlOrPath; +use node_resolver::errors::NodeResolveError; +use node_resolver::errors::PackageSubpathResolveError; +use node_resolver::errors::UnknownBuiltInNodeModuleError; use npm::NodeModulesOutOfDateError; use npm::NpmReqResolverRc; use npm::ResolveIfForNpmPackageErrorKind; @@ -127,10 +127,14 @@ impl DenoResolveError { #[derive(Debug, Error, JsError)] pub enum DenoResolveErrorKind { #[class(type)] - #[error("Importing from the vendor directory is not permitted. Use a remote specifier instead or disable vendoring.")] + #[error( + "Importing from the vendor directory is not permitted. Use a remote specifier instead or disable vendoring." + )] InvalidVendorFolderImport, #[class(type)] - #[error("Importing npm packages via a file: specifier is only supported with --node-modules-dir=manual")] + #[error( + "Importing npm packages via a file: specifier is only supported with --node-modules-dir=manual" + )] UnsupportedPackageJsonFileSpecifier, #[class(type)] #[error("JSR specifiers are not yet supported in package.json")] @@ -270,11 +274,11 @@ pub struct RawDenoResolver< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: DenoResolverSys, - > + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: DenoResolverSys, +> RawDenoResolver< TInNpmPackageChecker, TIsBuiltInNodeModuleChecker, @@ -584,7 +588,7 @@ impl< url: res.into_url()?, maybe_diagnostic, found_package_json_dep, - }) + }); } NodeResolution::BuiltIn(ref _module) => { if self.bare_node_builtins { diff --git a/libs/resolver/lockfile.rs b/libs/resolver/lockfile.rs index 2a4a44b6c3..b651255096 100644 --- a/libs/resolver/lockfile.rs +++ b/libs/resolver/lockfile.rs @@ -19,8 +19,8 @@ use deno_semver::jsr::JsrDepPackageReq; use deno_semver::jsr::JsrPackageReqReference; use deno_semver::npm::NpmPackageReqReference; use deno_semver::package::PackageNv; -use futures::stream::FuturesOrdered; use futures::TryStreamExt; +use futures::stream::FuturesOrdered; use indexmap::IndexMap; use node_resolver::PackageJson; use parking_lot::Mutex; @@ -475,7 +475,9 @@ impl LockfileLock { let diff = crate::display::diff(&contents, &new_contents); // has an extra newline at the end let diff = diff.trim_end(); - Err(JsErrorBox::generic(format!("The lockfile is out of date. Run `deno install --frozen=false`, or rerun with `--frozen=false` to update it.\nchanges:\n{diff}"))) + Err(JsErrorBox::generic(format!( + "The lockfile is out of date. Run `deno install --frozen=false`, or rerun with `--frozen=false` to update it.\nchanges:\n{diff}" + ))) } else { Ok(()) } @@ -630,11 +632,11 @@ fn values_to_set<'a>( } fn value_to_dep_req(value: &str) -> Option { - if let Ok(req_ref) = JsrPackageReqReference::from_str(value) { - Some(JsrDepPackageReq::jsr(req_ref.into_inner().req)) - } else if let Ok(req_ref) = NpmPackageReqReference::from_str(value) { - Some(JsrDepPackageReq::npm(req_ref.into_inner().req)) - } else { - None + match JsrPackageReqReference::from_str(value) { + Ok(req_ref) => Some(JsrDepPackageReq::jsr(req_ref.into_inner().req)), + _ => match NpmPackageReqReference::from_str(value) { + Ok(req_ref) => Some(JsrDepPackageReq::npm(req_ref.into_inner().req)), + _ => None, + }, } } diff --git a/libs/resolver/npm/byonm.rs b/libs/resolver/npm/byonm.rs index 3600b2810d..3f478d82a3 100644 --- a/libs/resolver/npm/byonm.rs +++ b/libs/resolver/npm/byonm.rs @@ -8,18 +8,18 @@ use deno_package_json::PackageJson; use deno_package_json::PackageJsonDepValue; use deno_package_json::PackageJsonRc; use deno_path_util::url_to_file_path; -use deno_semver::package::PackageReq; use deno_semver::StackString; use deno_semver::Version; +use deno_semver::package::PackageReq; +use node_resolver::InNpmPackageChecker; +use node_resolver::NpmPackageFolderResolver; +use node_resolver::PackageJsonResolverRc; +use node_resolver::UrlOrPathRef; use node_resolver::cache::NodeResolutionSys; use node_resolver::errors::PackageFolderResolveError; use node_resolver::errors::PackageFolderResolveIoError; use node_resolver::errors::PackageJsonLoadError; use node_resolver::errors::PackageNotFoundError; -use node_resolver::InNpmPackageChecker; -use node_resolver::NpmPackageFolderResolver; -use node_resolver::PackageJsonResolverRc; -use node_resolver::UrlOrPathRef; use sys_traits::FsCanonicalize; use sys_traits::FsDirEntry; use sys_traits::FsMetadata; diff --git a/libs/resolver/npm/local.rs b/libs/resolver/npm/local.rs index b05864b856..e644076423 100644 --- a/libs/resolver/npm/local.rs +++ b/libs/resolver/npm/local.rs @@ -4,8 +4,8 @@ use std::borrow::Cow; use deno_cache_dir::npm::mixed_case_package_name_decode; use deno_npm::NpmPackageCacheFolderId; -use deno_semver::package::PackageNv; use deno_semver::StackString; +use deno_semver::package::PackageNv; #[inline] pub fn get_package_folder_id_folder_name( diff --git a/libs/resolver/npm/managed/global.rs b/libs/resolver/npm/managed/global.rs index b365d33b9e..87425db1c6 100644 --- a/libs/resolver/npm/managed/global.rs +++ b/libs/resolver/npm/managed/global.rs @@ -6,18 +6,18 @@ use std::path::PathBuf; use deno_npm::NpmPackageCacheFolderId; use deno_npm::NpmPackageId; -use deno_semver::package::PackageNv; use deno_semver::StackString; use deno_semver::Version; +use deno_semver::package::PackageNv; +use node_resolver::NpmPackageFolderResolver; +use node_resolver::UrlOrPathRef; use node_resolver::errors::PackageFolderResolveError; use node_resolver::errors::PackageNotFoundError; use node_resolver::errors::ReferrerNotFoundError; -use node_resolver::NpmPackageFolderResolver; -use node_resolver::UrlOrPathRef; use url::Url; -use super::resolution::NpmResolutionCellRc; use super::NpmCacheDirRc; +use super::resolution::NpmResolutionCellRc; use crate::npmrc::ResolvedNpmRcRc; /// Resolves packages from the global npm cache. diff --git a/libs/resolver/npm/managed/local.rs b/libs/resolver/npm/managed/local.rs index 6caab5a8d3..cac82df70f 100644 --- a/libs/resolver/npm/managed/local.rs +++ b/libs/resolver/npm/managed/local.rs @@ -10,12 +10,12 @@ use deno_npm::NpmPackageCacheFolderId; use deno_npm::NpmPackageId; use deno_path_util::fs::canonicalize_path_maybe_not_exists; use deno_path_util::url_from_directory_path; +use node_resolver::NpmPackageFolderResolver; +use node_resolver::UrlOrPathRef; use node_resolver::errors::PackageFolderResolveError; use node_resolver::errors::PackageFolderResolveIoError; use node_resolver::errors::PackageNotFoundError; use node_resolver::errors::ReferrerNotFoundError; -use node_resolver::NpmPackageFolderResolver; -use node_resolver::UrlOrPathRef; use sys_traits::FsCanonicalize; use sys_traits::FsMetadata; use url::Url; diff --git a/libs/resolver/npm/managed/mod.rs b/libs/resolver/npm/managed/mod.rs index 8b7fae4cdc..7d5d9dd650 100644 --- a/libs/resolver/npm/managed/mod.rs +++ b/libs/resolver/npm/managed/mod.rs @@ -8,12 +8,12 @@ mod resolution; use std::path::Path; use std::path::PathBuf; -use deno_npm::resolution::PackageCacheFolderIdNotFoundError; -use deno_npm::resolution::PackageNvNotFoundError; -use deno_npm::resolution::PackageReqNotFoundError; use deno_npm::NpmPackageCacheFolderId; use deno_npm::NpmPackageId; use deno_npm::NpmSystemInfo; +use deno_npm::resolution::PackageCacheFolderIdNotFoundError; +use deno_npm::resolution::PackageNvNotFoundError; +use deno_npm::resolution::PackageReqNotFoundError; use deno_path_util::fs::canonicalize_path_maybe_not_exists; use deno_semver::package::PackageNv; use deno_semver::package::PackageReq; @@ -29,8 +29,8 @@ use self::global::GlobalNpmPackageResolver; use self::local::LocalNpmPackageResolver; pub use self::resolution::NpmResolutionCell; pub use self::resolution::NpmResolutionCellRc; -use crate::npmrc::ResolvedNpmRcRc; use crate::NpmCacheDirRc; +use crate::npmrc::ResolvedNpmRcRc; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum ResolvePkgFolderFromDenoModuleError { diff --git a/libs/resolver/npm/managed/resolution.rs b/libs/resolver/npm/managed/resolution.rs index 1732ae1fb7..72c0183dd3 100644 --- a/libs/resolver/npm/managed/resolution.rs +++ b/libs/resolver/npm/managed/resolution.rs @@ -1,5 +1,9 @@ // Copyright 2018-2025 the Deno authors. MIT license. +use deno_npm::NpmPackageCacheFolderId; +use deno_npm::NpmPackageId; +use deno_npm::NpmResolutionPackage; +use deno_npm::NpmSystemInfo; use deno_npm::resolution::NpmPackagesPartitioned; use deno_npm::resolution::NpmResolutionSnapshot; use deno_npm::resolution::PackageCacheFolderIdNotFoundError; @@ -7,10 +11,6 @@ use deno_npm::resolution::PackageNotFoundFromReferrerError; use deno_npm::resolution::PackageNvNotFoundError; use deno_npm::resolution::PackageReqNotFoundError; use deno_npm::resolution::ValidSerializedNpmResolutionSnapshot; -use deno_npm::NpmPackageCacheFolderId; -use deno_npm::NpmPackageId; -use deno_npm::NpmResolutionPackage; -use deno_npm::NpmSystemInfo; use deno_semver::package::PackageNv; use deno_semver::package::PackageReq; use parking_lot::RwLock; diff --git a/libs/resolver/npm/mod.rs b/libs/resolver/npm/mod.rs index 76a01252a3..745b0c0e3d 100644 --- a/libs/resolver/npm/mod.rs +++ b/libs/resolver/npm/mod.rs @@ -11,15 +11,6 @@ use deno_semver::npm::NpmPackageReqReference; use deno_semver::package::PackageNv; use deno_semver::package::PackageReq; use deno_semver::package::PackageReqReference; -use node_resolver::errors::NodeResolveError; -use node_resolver::errors::NodeResolveErrorKind; -use node_resolver::errors::PackageFolderResolveErrorKind; -use node_resolver::errors::PackageFolderResolveIoError; -use node_resolver::errors::PackageNotFoundError; -use node_resolver::errors::PackageResolveErrorKind; -use node_resolver::errors::PackageSubpathResolveError; -use node_resolver::errors::TypesNotFoundError; -use node_resolver::types_package_name; use node_resolver::InNpmPackageChecker; use node_resolver::IsBuiltInNodeModuleChecker; use node_resolver::NodeResolution; @@ -29,6 +20,15 @@ use node_resolver::NpmPackageFolderResolver; use node_resolver::ResolutionMode; use node_resolver::UrlOrPath; use node_resolver::UrlOrPathRef; +use node_resolver::errors::NodeResolveError; +use node_resolver::errors::NodeResolveErrorKind; +use node_resolver::errors::PackageFolderResolveErrorKind; +use node_resolver::errors::PackageFolderResolveIoError; +use node_resolver::errors::PackageNotFoundError; +use node_resolver::errors::PackageResolveErrorKind; +use node_resolver::errors::PackageSubpathResolveError; +use node_resolver::errors::TypesNotFoundError; +use node_resolver::types_package_name; use thiserror::Error; use url::Url; @@ -39,15 +39,15 @@ pub use self::byonm::ByonmNpmResolverRc; pub use self::byonm::ByonmResolvePkgFolderFromDenoReqError; pub use self::local::get_package_folder_id_folder_name; pub use self::local::normalize_pkg_name_for_node_modules_deno_folder; -use self::managed::create_managed_in_npm_pkg_checker; use self::managed::ManagedInNpmPackageChecker; use self::managed::ManagedInNpmPkgCheckerCreateOptions; pub use self::managed::ManagedNpmResolver; use self::managed::ManagedNpmResolverCreateOptions; pub use self::managed::ManagedNpmResolverRc; -use crate::sync::new_rc; +use self::managed::create_managed_in_npm_pkg_checker; use crate::sync::MaybeSend; use crate::sync::MaybeSync; +use crate::sync::new_rc; mod byonm; mod local; @@ -91,7 +91,10 @@ impl InNpmPackageChecker for DenoInNpmPackageChecker { #[derive(Debug, Error, JsError)] #[class(generic)] -#[error("Could not resolve \"{}\", but found it in a package.json. Deno expects the node_modules/ directory to be up to date. Did you forget to run `deno install`?", specifier)] +#[error( + "Could not resolve \"{}\", but found it in a package.json. Deno expects the node_modules/ directory to be up to date. Did you forget to run `deno install`?", + specifier +)] pub struct NodeModulesOutOfDateError { pub specifier: String, } @@ -364,11 +367,11 @@ pub struct NpmReqResolver< } impl< - TInNpmPackageChecker: InNpmPackageChecker, - TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, - TNpmPackageFolderResolver: NpmPackageFolderResolver, - TSys: NpmResolverSys, - > + TInNpmPackageChecker: InNpmPackageChecker, + TIsBuiltInNodeModuleChecker: IsBuiltInNodeModuleChecker, + TNpmPackageFolderResolver: NpmPackageFolderResolver, + TSys: NpmResolverSys, +> NpmReqResolver< TInNpmPackageChecker, TIsBuiltInNodeModuleChecker, diff --git a/libs/resolver/npmrc.rs b/libs/resolver/npmrc.rs index 2b402cf592..e654fc7efc 100644 --- a/libs/resolver/npmrc.rs +++ b/libs/resolver/npmrc.rs @@ -155,9 +155,9 @@ fn discover_npmrc( Ok(None) => {} Err(err) if err.source.kind() == std::io::ErrorKind::PermissionDenied => { log::debug!( - "Skipping .npmrc in home directory due to permission denied error. {:#}", - err - ); + "Skipping .npmrc in home directory due to permission denied error. {:#}", + err + ); } Err(err) => { return Err(err.into()); diff --git a/libs/resolver/workspace.rs b/libs/resolver/workspace.rs index 17a36a08f2..6531792069 100644 --- a/libs/resolver/workspace.rs +++ b/libs/resolver/workspace.rs @@ -24,21 +24,21 @@ use deno_package_json::PackageJsonRc; use deno_path_util::url_from_directory_path; use deno_path_util::url_from_file_path; use deno_path_util::url_to_file_path; -use deno_semver::jsr::JsrPackageReqReference; -use deno_semver::package::PackageName; -use deno_semver::package::PackageReq; use deno_semver::RangeSetOrTag; use deno_semver::SmallStackString; use deno_semver::StackString; use deno_semver::Version; use deno_semver::VersionReq; +use deno_semver::jsr::JsrPackageReqReference; +use deno_semver::package::PackageName; +use deno_semver::package::PackageReq; use deno_terminal::colors; -use import_map::specifier::SpecifierError; use import_map::ImportMap; use import_map::ImportMapDiagnostic; use import_map::ImportMapError; use import_map::ImportMapErrorKind; use import_map::ImportMapWithDiagnostics; +use import_map::specifier::SpecifierError; use indexmap::IndexMap; use node_resolver::NodeResolutionKind; use serde::Deserialize; @@ -49,8 +49,8 @@ use sys_traits::FsRead; use thiserror::Error; use url::Url; -use crate::sync::new_rc; use crate::sync::MaybeDashMap; +use crate::sync::new_rc; #[allow(clippy::disallowed_types)] type UrlRc = crate::sync::MaybeArc; @@ -268,7 +268,9 @@ where pub enum WorkspaceResolvePkgJsonFolderErrorKind { #[error("Could not find package.json with name '{0}' in workspace.")] NotFound(String), - #[error("Found package.json in workspace, but version '{1}' didn't satisy constraint '{0}'.")] + #[error( + "Found package.json in workspace, but version '{1}' didn't satisy constraint '{0}'." + )] VersionNotSatisfied(VersionReq, Version), } @@ -654,10 +656,22 @@ pub enum CompilerOptionsRootDirsDiagnostic { impl fmt::Display for CompilerOptionsRootDirsDiagnostic { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - Self::InvalidType(s) => write!(f, "Invalid value for \"compilerOptions.rootDirs\" (\"{s}\"). Expected a string."), - Self::InvalidEntryType(s, i) => write!(f, "Invalid value for \"compilerOptions.rootDirs[{i}]\" (\"{s}\"). Expected a string."), - Self::UnexpectedError(s, message) => write!(f, "Unexpected error while parsing \"compilerOptions.rootDirs\" (\"{s}\"): {message}"), - Self::UnexpectedEntryError(s, i, message) => write!(f, "Unexpected error while parsing \"compilerOptions.rootDirs[{i}]\" (\"{s}\"): {message}"), + Self::InvalidType(s) => write!( + f, + "Invalid value for \"compilerOptions.rootDirs\" (\"{s}\"). Expected a string." + ), + Self::InvalidEntryType(s, i) => write!( + f, + "Invalid value for \"compilerOptions.rootDirs[{i}]\" (\"{s}\"). Expected a string." + ), + Self::UnexpectedError(s, message) => write!( + f, + "Unexpected error while parsing \"compilerOptions.rootDirs\" (\"{s}\"): {message}" + ), + Self::UnexpectedEntryError(s, i, message) => write!( + f, + "Unexpected error while parsing \"compilerOptions.rootDirs[{i}]\" (\"{s}\"): {message}" + ), } } } @@ -1527,25 +1541,28 @@ impl WorkspaceResolver { PackageJsonDepWorkspaceReq::VersionReq(version_req) => { match version_req.inner() { RangeSetOrTag::RangeSet(set) => { - if let Some(version) = pkg_json + match pkg_json .version .as_ref() .and_then(|v| Version::parse_from_npm(v).ok()) { - if set.satisfies(&version) { - Ok(pkg_json.dir_path()) - } else { - Err( + Some(version) => { + if set.satisfies(&version) { + Ok(pkg_json.dir_path()) + } else { + Err( WorkspaceResolvePkgJsonFolderErrorKind::VersionNotSatisfied( version_req.clone(), version, ) .into(), ) + } + } + _ => { + // just match it + Ok(pkg_json.dir_path()) } - } else { - // just match it - Ok(pkg_json.dir_path()) } } RangeSetOrTag::Tag(_) => { @@ -1656,10 +1673,10 @@ impl WorkspaceNpmLinkPackages { for pkg_json in workspace.link_pkg_jsons() { let Some(name) = pkg_json.name.as_ref() else { log::warn!( - "{} Link package ignored because package.json was missing name field.\n at {}", - colors::yellow("Warning"), - pkg_json.path.display(), - ); + "{} Link package ignored because package.json was missing name field.\n at {}", + colors::yellow("Warning"), + pkg_json.path.display(), + ); continue; }; match pkg_json_to_version_info(pkg_json) { @@ -1687,7 +1704,9 @@ enum PkgJsonToVersionInfoError { "Linked package ignored because package.json was missing version field." )] VersionMissing, - #[error("Linked package ignored because package.json version field could not be parsed.")] + #[error( + "Linked package ignored because package.json version field could not be parsed." + )] VersionInvalid { #[source] source: deno_semver::npm::NpmVersionParseError, @@ -1765,8 +1784,8 @@ mod test { use deno_path_util::url_from_file_path; use deno_semver::VersionReq; use serde_json::json; - use sys_traits::impls::InMemorySys; use sys_traits::FsCanonicalize; + use sys_traits::impls::InMemorySys; use url::Url; use super::*; @@ -2893,11 +2912,11 @@ mod test { let diagnostics = workspace.workspace.diagnostics(); assert_eq!(diagnostics.len(), 1); - assert!(diagnostics - .first() - .unwrap() - .to_string() - .starts_with(r#"Invalid workspace member name "@deno-test/libs/math"."#)); + assert!( + diagnostics.first().unwrap().to_string().starts_with( + r#"Invalid workspace member name "@deno-test/libs/math"."# + ) + ); } fn create_resolver( diff --git a/runtime/examples/extension/main.rs b/runtime/examples/extension/main.rs index 93b8599bc2..6847bccd20 100644 --- a/runtime/examples/extension/main.rs +++ b/runtime/examples/extension/main.rs @@ -7,10 +7,10 @@ use std::path::Path; use std::rc::Rc; use std::sync::Arc; -use deno_core::error::AnyError; -use deno_core::op2; use deno_core::FsModuleLoader; use deno_core::ModuleSpecifier; +use deno_core::error::AnyError; +use deno_core::op2; use deno_fs::RealFs; use deno_resolver::npm::DenoInNpmPackageChecker; use deno_resolver::npm::NpmResolver; diff --git a/runtime/features/build.rs b/runtime/features/build.rs index a20cb2c43c..09740877c5 100644 --- a/runtime/features/build.rs +++ b/runtime/features/build.rs @@ -32,7 +32,7 @@ export const unstableIds = { use crate::structs::UnstableFeatureDefinition; use crate::structs::UnstableFeatureKind; -pub static UNSTABLE_FEATURES: &[UnstableFeatureDefinition] = &[", +pub static UNSTABLE_FEATURES: &[UnstableFeatureDefinition] = &[\n", ); let mut descriptions = data::FEATURE_DESCRIPTIONS.to_vec(); diff --git a/runtime/features/data.rs b/runtime/features/data.rs index ef6dbd8f3d..08f4d1f20e 100644 --- a/runtime/features/data.rs +++ b/runtime/features/data.rs @@ -223,5 +223,5 @@ pub static FEATURE_DESCRIPTIONS: &[UnstableFeatureDescription] = &[ kind: UnstableFeatureKind::Runtime, config_option: ConfigFileOption::SameAsFlagName, env_var: None, - } + }, ]; diff --git a/runtime/features/gen.rs b/runtime/features/gen.rs index c46bbc9a2f..89ceba7862 100644 --- a/runtime/features/gen.rs +++ b/runtime/features/gen.rs @@ -6,7 +6,8 @@ use crate::structs::UnstableFeatureDefinition; use crate::structs::UnstableFeatureKind; -pub static UNSTABLE_FEATURES: &[UnstableFeatureDefinition] = &[ UnstableFeatureDefinition { +pub static UNSTABLE_FEATURES: &[UnstableFeatureDefinition] = &[ + UnstableFeatureDefinition { name: "bare-node-builtins", flag_name: "unstable-bare-node-builtins", help_text: "Enable unstable bare node builtins feature", diff --git a/runtime/features/lib.rs b/runtime/features/lib.rs index c362f94298..dc0168dc3c 100644 --- a/runtime/features/lib.rs +++ b/runtime/features/lib.rs @@ -1,12 +1,12 @@ // Copyright 2018-2025 the Deno authors. MIT license. -mod gen; +mod r#gen; mod structs; use std::collections::BTreeSet; -pub use gen::UNSTABLE_ENV_VAR_NAMES; -pub use gen::UNSTABLE_FEATURES; +pub use r#gen::UNSTABLE_ENV_VAR_NAMES; +pub use r#gen::UNSTABLE_FEATURES; pub use structs::UnstableFeatureKind; pub const JS_SOURCE: deno_core::FastStaticString = diff --git a/runtime/fmt_errors.rs b/runtime/fmt_errors.rs index ae953af795..c0e6141d9b 100644 --- a/runtime/fmt_errors.rs +++ b/runtime/fmt_errors.rs @@ -4,8 +4,8 @@ use std::fmt::Write as _; use color_print::cformat; use color_print::cstr; -use deno_core::error::format_frame; use deno_core::error::JsError; +use deno_core::error::format_frame; use deno_terminal::colors; #[derive(Debug, Clone)] @@ -122,7 +122,8 @@ fn format_maybe_source_line( if column_number as usize > source_line.len() { return format!( "\n{} Couldn't format source line: Column {} is out of bounds (source may have changed at runtime)", - colors::yellow("Warning"), column_number, + colors::yellow("Warning"), + column_number, ); } @@ -318,14 +319,22 @@ fn get_suggestions_for_terminal_errors(e: &JsError) -> Vec { } return vec![ FixSuggestion::info_multiline(&[ - cstr!("Deno supports CommonJS modules in .cjs files, or when the closest"), - cstr!("package.json has a \"type\": \"commonjs\" option.") + cstr!( + "Deno supports CommonJS modules in .cjs files, or when the closest" + ), + cstr!( + "package.json has a \"type\": \"commonjs\" option." + ), ]), FixSuggestion::hint_multiline(&[ "Rewrite this module to ESM,", cstr!("or change the file extension to .cjs,"), - cstr!("or add package.json next to the file with \"type\": \"commonjs\" option,"), - cstr!("or pass --unstable-detect-cjs flag to detect CommonJS when loading."), + cstr!( + "or add package.json next to the file with \"type\": \"commonjs\" option," + ), + cstr!( + "or pass --unstable-detect-cjs flag to detect CommonJS when loading." + ), ]), FixSuggestion::docs("https://docs.deno.com/go/commonjs"), ]; @@ -405,11 +414,9 @@ fn get_suggestions_for_terminal_errors(e: &JsError) -> Vec { ), ]; } else if msg.contains("client error (Connect): invalid peer certificate") { - return vec![ - FixSuggestion::hint( - "Run again with the `--unsafely-ignore-certificate-errors` flag to bypass certificate errors.", - ), - ]; + return vec![FixSuggestion::hint( + "Run again with the `--unsafely-ignore-certificate-errors` flag to bypass certificate errors.", + )]; // Try to capture errors like: // ``` // Uncaught Error: Cannot find module '../build/Release/canvas.node' @@ -422,18 +429,14 @@ fn get_suggestions_for_terminal_errors(e: &JsError) -> Vec { && msg.contains(".node'") { return vec![ - FixSuggestion::info_multiline( - &[ - "Trying to execute an npm package using Node-API addons,", - "these packages require local `node_modules` directory to be present." - ] - ), - FixSuggestion::hint_multiline( - &[ - "Add `\"nodeModulesDir\": \"auto\" option to `deno.json`, and then run", - "`deno install --allow-scripts=npm: --entrypoint