summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cli/args/mod.rs8
-rw-r--r--cli/lsp/testing/execution.rs4
-rw-r--r--cli/main.rs96
-rw-r--r--cli/module_loader.rs4
-rw-r--r--cli/proc_state.rs78
-rw-r--r--cli/tools/bench.rs26
-rw-r--r--cli/tools/doc.rs2
-rw-r--r--cli/tools/fmt.rs4
-rw-r--r--cli/tools/lint.rs6
-rw-r--r--cli/tools/task.rs6
-rw-r--r--cli/tools/test.rs28
-rw-r--r--cli/tools/vendor/mod.rs8
12 files changed, 138 insertions, 132 deletions
diff --git a/cli/args/mod.rs b/cli/args/mod.rs
index 757c6a8f4..17bbf0603 100644
--- a/cli/args/mod.rs
+++ b/cli/args/mod.rs
@@ -44,16 +44,16 @@ use crate::file_fetcher::CacheSetting;
use crate::lockfile::Lockfile;
use crate::version;
-/// Holds the common configuration used by many sub commands
+/// Holds the common options used by many sub commands
/// and provides some helper function for creating common objects.
-pub struct RootConfig {
- // the source of the configuration is a detail the rest of the
+pub struct CliOptions {
+ // the source of the options is a detail the rest of the
// application need not concern itself with, so keep these private
flags: Flags,
maybe_config_file: Option<ConfigFile>,
}
-impl RootConfig {
+impl CliOptions {
pub fn from_flags(flags: Flags) -> Result<Self, AnyError> {
if let Some(insecure_allowlist) =
flags.unsafely_ignore_certificate_errors.as_ref()
diff --git a/cli/lsp/testing/execution.rs b/cli/lsp/testing/execution.rs
index 94301e198..366eedd6d 100644
--- a/cli/lsp/testing/execution.rs
+++ b/cli/lsp/testing/execution.rs
@@ -315,7 +315,7 @@ impl TestRun {
let flags = flags_from_vec(args.into_iter().map(String::from).collect())?;
let ps = proc_state::ProcState::build(flags).await?;
let permissions =
- Permissions::from_options(&ps.config.permissions_options());
+ Permissions::from_options(&ps.options.permissions_options());
test::check_specifiers(
&ps,
permissions.clone(),
@@ -331,7 +331,7 @@ impl TestRun {
let sender = TestEventSender::new(sender);
let (concurrent_jobs, fail_fast) =
- if let DenoSubcommand::Test(test_flags) = ps.config.sub_command() {
+ if let DenoSubcommand::Test(test_flags) = ps.options.sub_command() {
(
test_flags.concurrent_jobs.into(),
test_flags.fail_fast.map(|count| count.into()),
diff --git a/cli/main.rs b/cli/main.rs
index ede162d1b..4c7fa8f53 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -70,7 +70,7 @@ use crate::proc_state::ProcState;
use crate::resolver::ImportMapResolver;
use crate::resolver::JsxResolver;
-use args::RootConfig;
+use args::CliOptions;
use deno_ast::MediaType;
use deno_core::error::generic_error;
use deno_core::error::AnyError;
@@ -109,7 +109,7 @@ use std::sync::Arc;
fn create_web_worker_preload_module_callback(
ps: ProcState,
) -> Arc<PreloadModuleCb> {
- let compat = ps.config.compat();
+ let compat = ps.options.compat();
Arc::new(move |mut worker| {
let fut = async move {
@@ -144,30 +144,30 @@ fn create_web_worker_callback(
let options = WebWorkerOptions {
bootstrap: BootstrapOptions {
- args: ps.config.argv().clone(),
+ args: ps.options.argv().clone(),
cpu_count: std::thread::available_parallelism()
.map(|p| p.get())
.unwrap_or(1),
debug_flag: ps
- .config
+ .options
.log_level()
.map_or(false, |l| l == log::Level::Debug),
- enable_testing_features: ps.config.enable_testing_features(),
+ enable_testing_features: ps.options.enable_testing_features(),
location: Some(args.main_module.clone()),
no_color: !colors::use_color(),
is_tty: colors::is_tty(),
runtime_version: version::deno(),
ts_version: version::TYPESCRIPT.to_string(),
- unstable: ps.config.unstable(),
+ unstable: ps.options.unstable(),
user_agent: version::get_user_agent(),
},
extensions,
unsafely_ignore_certificate_errors: ps
- .config
+ .options
.unsafely_ignore_certificate_errors()
.map(ToOwned::to_owned),
root_cert_store: Some(ps.root_cert_store.clone()),
- seed: ps.config.seed(),
+ seed: ps.options.seed(),
module_loader,
create_web_worker_cb,
preload_module_cb,
@@ -204,14 +204,14 @@ pub fn create_main_worker(
let module_loader = CliModuleLoader::new(ps.clone());
let maybe_inspector_server = ps.maybe_inspector_server.clone();
- let should_break_on_first_statement = ps.config.inspect_brk().is_some();
+ let should_break_on_first_statement = ps.options.inspect_brk().is_some();
let create_web_worker_cb =
create_web_worker_callback(ps.clone(), stdio.clone());
let web_worker_preload_module_cb =
create_web_worker_preload_module_callback(ps.clone());
- let maybe_storage_key = ps.config.resolve_storage_key(&main_module);
+ let maybe_storage_key = ps.options.resolve_storage_key(&main_module);
let origin_storage_dir = maybe_storage_key.map(|key| {
ps.dir
.root
@@ -225,30 +225,30 @@ pub fn create_main_worker(
let options = WorkerOptions {
bootstrap: BootstrapOptions {
- args: ps.config.argv().clone(),
+ args: ps.options.argv().clone(),
cpu_count: std::thread::available_parallelism()
.map(|p| p.get())
.unwrap_or(1),
debug_flag: ps
- .config
+ .options
.log_level()
.map_or(false, |l| l == log::Level::Debug),
- enable_testing_features: ps.config.enable_testing_features(),
- location: ps.config.location_flag().map(ToOwned::to_owned),
+ enable_testing_features: ps.options.enable_testing_features(),
+ location: ps.options.location_flag().map(ToOwned::to_owned),
no_color: !colors::use_color(),
is_tty: colors::is_tty(),
runtime_version: version::deno(),
ts_version: version::TYPESCRIPT.to_string(),
- unstable: ps.config.unstable(),
+ unstable: ps.options.unstable(),
user_agent: version::get_user_agent(),
},
extensions,
unsafely_ignore_certificate_errors: ps
- .config
+ .options
.unsafely_ignore_certificate_errors()
.map(ToOwned::to_owned),
root_cert_store: Some(ps.root_cert_store.clone()),
- seed: ps.config.seed(),
+ seed: ps.options.seed(),
source_map_getter: Some(Box::new(ps.clone())),
format_js_error_fn: Some(Arc::new(format_js_error)),
create_web_worker_cb,
@@ -460,7 +460,7 @@ async fn info_command(
let maybe_import_map_resolver =
ps.maybe_import_map.clone().map(ImportMapResolver::new);
let maybe_jsx_resolver = ps
- .config
+ .options
.to_maybe_jsx_import_source_module()
.map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone()));
let maybe_resolver = if maybe_jsx_resolver.is_some() {
@@ -489,7 +489,7 @@ async fn info_command(
}
} else {
// If it was just "deno info" print location of caches and exit
- print_cache_info(&ps, info_flags.json, ps.config.location_flag())?;
+ print_cache_info(&ps, info_flags.json, ps.options.location_flag())?;
}
Ok(0)
}
@@ -548,7 +548,7 @@ async fn cache_command(
cache_flags: CacheFlags,
) -> Result<i32, AnyError> {
let ps = ProcState::build(flags).await?;
- let lib = ps.config.ts_type_lib_window();
+ let lib = ps.options.ts_type_lib_window();
for file in cache_flags.files {
let specifier = resolve_url_or_path(&file)?;
@@ -617,7 +617,7 @@ async fn eval_command(
// to allow module access by TS compiler.
ps.file_fetcher.insert_cached(file);
debug!("main_module {}", &main_module);
- if ps.config.compat() {
+ if ps.options.compat() {
worker.execute_side_module(&compat::GLOBAL_URL).await?;
}
worker.execute_main_module(&main_module).await?;
@@ -645,11 +645,11 @@ async fn create_graph_and_maybe_check(
Permissions::allow_all(),
);
let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone());
- let maybe_imports = ps.config.to_maybe_imports()?;
+ let maybe_imports = ps.options.to_maybe_imports()?;
let maybe_import_map_resolver =
ps.maybe_import_map.clone().map(ImportMapResolver::new);
let maybe_jsx_resolver = ps
- .config
+ .options
.to_maybe_jsx_import_source_module()
.map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone()));
let maybe_resolver = if maybe_jsx_resolver.is_some() {
@@ -673,36 +673,36 @@ async fn create_graph_and_maybe_check(
.await,
);
- let check_js = ps.config.check_js();
+ let check_js = ps.options.check_js();
graph_valid(
&graph,
- ps.config.type_check_mode() != TypeCheckMode::None,
+ ps.options.type_check_mode() != TypeCheckMode::None,
check_js,
)?;
graph_lock_or_exit(&graph);
- if ps.config.type_check_mode() != TypeCheckMode::None {
+ if ps.options.type_check_mode() != TypeCheckMode::None {
let ts_config_result =
- ps.config.resolve_ts_config_for_emit(TsConfigType::Check {
+ ps.options.resolve_ts_config_for_emit(TsConfigType::Check {
tsc_emit: false,
- lib: ps.config.ts_type_lib_window(),
+ lib: ps.options.ts_type_lib_window(),
})?;
if let Some(ignored_options) = ts_config_result.maybe_ignored_options {
eprintln!("{}", ignored_options);
}
- let maybe_config_specifier = ps.config.maybe_config_file_specifier();
+ let maybe_config_specifier = ps.options.maybe_config_file_specifier();
let check_result = emit::check_and_maybe_emit(
&graph.roots,
Arc::new(RwLock::new(graph.as_ref().into())),
&ps.dir.gen_cache,
emit::CheckOptions {
- type_check_mode: ps.config.type_check_mode(),
+ type_check_mode: ps.options.type_check_mode(),
debug,
emit_with_diagnostics: false,
maybe_config_specifier,
ts_config: ts_config_result.ts_config,
log_checks: true,
- reload: ps.config.reload_flag(),
+ reload: ps.options.reload_flag(),
reload_exclusions: Default::default(),
},
)?;
@@ -721,9 +721,10 @@ fn bundle_module_graph(
) -> Result<deno_emit::BundleEmit, AnyError> {
info!("{} {}", colors::green("Bundle"), graph.roots[0].0);
- let ts_config_result =
- ps.config.resolve_ts_config_for_emit(TsConfigType::Bundle)?;
- if ps.config.type_check_mode() == TypeCheckMode::None {
+ let ts_config_result = ps
+ .options
+ .resolve_ts_config_for_emit(TsConfigType::Bundle)?;
+ if ps.options.type_check_mode() == TypeCheckMode::None {
if let Some(ignored_options) = ts_config_result.maybe_ignored_options {
eprintln!("{}", ignored_options);
}
@@ -744,16 +745,16 @@ async fn bundle_command(
bundle_flags: BundleFlags,
) -> Result<i32, AnyError> {
let debug = flags.log_level == Some(log::Level::Debug);
- let root_config = Arc::new(RootConfig::from_flags(flags)?);
+ let cli_options = Arc::new(CliOptions::from_flags(flags)?);
let resolver = |_| {
- let root_config = root_config.clone();
+ let cli_options = cli_options.clone();
let source_file1 = bundle_flags.source_file.clone();
let source_file2 = bundle_flags.source_file.clone();
async move {
let module_specifier = resolve_url_or_path(&source_file1)?;
debug!(">>>>> bundle START");
- let ps = ProcState::from_root_config(root_config).await?;
+ let ps = ProcState::from_options(cli_options).await?;
let graph =
create_graph_and_maybe_check(module_specifier, &ps, debug).await?;
@@ -767,7 +768,7 @@ async fn bundle_command(
.collect();
if let Ok(Some(import_map_path)) = ps
- .config
+ .options
.resolve_import_map_path()
.map(|ms| ms.and_then(|ref s| s.to_file_path().ok()))
{
@@ -829,13 +830,13 @@ async fn bundle_command(
}
};
- if root_config.watch_paths().is_some() {
+ if cli_options.watch_paths().is_some() {
file_watcher::watch_func(
resolver,
operation,
file_watcher::PrintConfig {
job_name: "Bundle".to_string(),
- clear_screen: !root_config.no_clear_screen(),
+ clear_screen: !cli_options.no_clear_screen(),
},
)
.await?;
@@ -864,7 +865,7 @@ async fn format_command(
flags: Flags,
fmt_flags: FmtFlags,
) -> Result<i32, AnyError> {
- let config = RootConfig::from_flags(flags)?;
+ let config = CliOptions::from_flags(flags)?;
if fmt_flags.files.len() == 1 && fmt_flags.files[0].to_string_lossy() == "-" {
let maybe_fmt_config = config.to_fmt_config()?;
@@ -888,11 +889,11 @@ async fn repl_command(
let mut worker = create_main_worker(
&ps,
main_module.clone(),
- Permissions::from_options(&ps.config.permissions_options()),
+ Permissions::from_options(&ps.options.permissions_options()),
vec![],
Default::default(),
);
- if ps.config.compat() {
+ if ps.options.compat() {
worker.execute_side_module(&compat::GLOBAL_URL).await?;
compat::add_global_require(&mut worker.js_runtime, main_module.as_str())?;
worker.run_event_loop(false).await?;
@@ -909,7 +910,7 @@ async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
let mut worker = create_main_worker(
&ps.clone(),
main_module.clone(),
- Permissions::from_options(&ps.config.permissions_options()),
+ Permissions::from_options(&ps.options.permissions_options()),
vec![],
Default::default(),
);
@@ -930,7 +931,7 @@ async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
ps.file_fetcher.insert_cached(source_file);
debug!("main_module {}", main_module);
- if ps.config.compat() {
+ if ps.options.compat() {
worker.execute_side_module(&compat::GLOBAL_URL).await?;
}
worker.execute_main_module(&main_module).await?;
@@ -1078,7 +1079,8 @@ async fn run_command(
// probably call `ProcState::resolve` instead
let main_module = resolve_url_or_path(&run_flags.script)?;
let ps = ProcState::build(flags).await?;
- let permissions = Permissions::from_options(&ps.config.permissions_options());
+ let permissions =
+ Permissions::from_options(&ps.options.permissions_options());
let mut worker = create_main_worker(
&ps,
main_module.clone(),
@@ -1104,7 +1106,7 @@ async fn run_command(
debug!("main_module {}", main_module);
- if ps.config.compat() {
+ if ps.options.compat() {
// TODO(bartlomieju): fix me
assert_eq!(main_module.scheme(), "file");
diff --git a/cli/module_loader.rs b/cli/module_loader.rs
index eda693ee9..cf94a4767 100644
--- a/cli/module_loader.rs
+++ b/cli/module_loader.rs
@@ -27,7 +27,7 @@ pub struct CliModuleLoader {
impl CliModuleLoader {
pub fn new(ps: ProcState) -> Rc<Self> {
Rc::new(CliModuleLoader {
- lib: ps.config.ts_type_lib_window(),
+ lib: ps.options.ts_type_lib_window(),
root_permissions: Permissions::allow_all(),
ps,
})
@@ -35,7 +35,7 @@ impl CliModuleLoader {
pub fn new_for_worker(ps: ProcState, permissions: Permissions) -> Rc<Self> {
Rc::new(CliModuleLoader {
- lib: ps.config.ts_type_lib_worker(),
+ lib: ps.options.ts_type_lib_worker(),
root_permissions: permissions,
ps,
})
diff --git a/cli/proc_state.rs b/cli/proc_state.rs
index e857a2184..47b4ac752 100644
--- a/cli/proc_state.rs
+++ b/cli/proc_state.rs
@@ -1,8 +1,8 @@
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+use crate::args::CliOptions;
use crate::args::DenoSubcommand;
use crate::args::Flags;
-use crate::args::RootConfig;
use crate::args::TypeCheckMode;
use crate::cache;
use crate::compat;
@@ -68,7 +68,7 @@ pub struct Inner {
pub dir: deno_dir::DenoDir,
pub coverage_dir: Option<String>,
pub file_fetcher: FileFetcher,
- pub config: Arc<RootConfig>,
+ pub options: Arc<CliOptions>,
graph_data: Arc<RwLock<GraphData>>,
pub lockfile: Option<Arc<Mutex<Lockfile>>>,
pub maybe_import_map: Option<Arc<ImportMap>>,
@@ -91,13 +91,13 @@ impl Deref for ProcState {
impl ProcState {
pub async fn build(flags: Flags) -> Result<Self, AnyError> {
- Self::from_root_config(Arc::new(RootConfig::from_flags(flags)?)).await
+ Self::from_options(Arc::new(CliOptions::from_flags(flags)?)).await
}
- pub async fn from_root_config(
- root_config: Arc<RootConfig>,
+ pub async fn from_options(
+ options: Arc<CliOptions>,
) -> Result<Self, AnyError> {
- Self::build_with_sender(root_config, None).await
+ Self::build_with_sender(options, None).await
}
pub async fn build_for_file_watcher(
@@ -105,18 +105,18 @@ impl ProcState {
files_to_watch_sender: tokio::sync::mpsc::UnboundedSender<Vec<PathBuf>>,
) -> Result<Self, AnyError> {
// resolve the config each time
- let root_config = Arc::new(RootConfig::from_flags(flags)?);
+ let cli_options = Arc::new(CliOptions::from_flags(flags)?);
let ps =
- Self::build_with_sender(root_config, Some(files_to_watch_sender.clone()))
+ Self::build_with_sender(cli_options, Some(files_to_watch_sender.clone()))
.await?;
// Add the extra files listed in the watch flag
- if let Some(watch_paths) = ps.config.watch_paths() {
+ if let Some(watch_paths) = ps.options.watch_paths() {
files_to_watch_sender.send(watch_paths.clone()).unwrap();
}
if let Ok(Some(import_map_path)) = ps
- .config
+ .options
.resolve_import_map_path()
.map(|ms| ms.and_then(|ref s| s.to_file_path().ok()))
{
@@ -127,33 +127,33 @@ impl ProcState {
}
async fn build_with_sender(
- root_config: Arc<RootConfig>,
+ cli_options: Arc<CliOptions>,
maybe_sender: Option<tokio::sync::mpsc::UnboundedSender<Vec<PathBuf>>>,
) -> Result<Self, AnyError> {
let blob_store = BlobStore::default();
let broadcast_channel = InMemoryBroadcastChannel::default();
let shared_array_buffer_store = SharedArrayBufferStore::default();
let compiled_wasm_module_store = CompiledWasmModuleStore::default();
- let dir = root_config.resolve_deno_dir()?;
+ let dir = cli_options.resolve_deno_dir()?;
let deps_cache_location = dir.root.join("deps");
let http_cache = http_cache::HttpCache::new(&deps_cache_location);
- let root_cert_store = root_config.resolve_root_cert_store()?;
- let cache_usage = root_config.cache_setting();
+ let root_cert_store = cli_options.resolve_root_cert_store()?;
+ let cache_usage = cli_options.cache_setting();
let file_fetcher = FileFetcher::new(
http_cache,
cache_usage,
- !root_config.no_remote(),
+ !cli_options.no_remote(),
Some(root_cert_store.clone()),
blob_store.clone(),
- root_config
+ cli_options
.unsafely_ignore_certificate_errors()
.map(ToOwned::to_owned),
)?;
- let lockfile = root_config
+ let lockfile = cli_options
.resolve_lock_file()?
.map(|f| Arc::new(Mutex::new(f)));
- let maybe_import_map_specifier = root_config.resolve_import_map_path()?;
+ let maybe_import_map_specifier = cli_options.resolve_import_map_path()?;
let maybe_import_map =
if let Some(import_map_specifier) = maybe_import_map_specifier {
@@ -172,9 +172,9 @@ impl ProcState {
};
let maybe_inspector_server =
- root_config.resolve_inspector_server().map(Arc::new);
+ cli_options.resolve_inspector_server().map(Arc::new);
- let coverage_dir = root_config
+ let coverage_dir = cli_options
.coverage_dir()
.map(ToOwned::to_owned)
.or_else(|| env::var("DENO_UNSTABLE_COVERAGE_DIR").ok());
@@ -186,12 +186,12 @@ impl ProcState {
);
let maybe_import_map_resolver =
maybe_import_map.clone().map(ImportMapResolver::new);
- let maybe_jsx_resolver = root_config
+ let maybe_jsx_resolver = cli_options
.to_maybe_jsx_import_source_module()
.map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone()));
let maybe_resolver: Option<
Arc<dyn deno_graph::source::Resolver + Send + Sync>,
- > = if root_config.compat() {
+ > = if cli_options.compat() {
Some(Arc::new(node_resolver))
} else if let Some(jsx_resolver) = maybe_jsx_resolver {
// the JSX resolver offloads to the import map if present, otherwise uses
@@ -212,7 +212,7 @@ impl ProcState {
Ok(ProcState(Arc::new(Inner {
dir,
coverage_dir,
- config: root_config,
+ options: cli_options,
file_fetcher,
graph_data: Default::default(),
lockfile,
@@ -276,7 +276,7 @@ impl ProcState {
// TODO(bartlomieju): this is very make-shift, is there an existing API
// that we could include it like with "maybe_imports"?
- let roots = if self.config.compat() {
+ let roots = if self.options.compat() {
let mut r = vec![(compat::GLOBAL_URL.clone(), ModuleKind::Esm)];
r.extend(roots);
r
@@ -285,12 +285,12 @@ impl ProcState {
};
if !reload_on_watch {
let graph_data = self.graph_data.read();
- if self.config.type_check_mode() == TypeCheckMode::None
+ if self.options.type_check_mode() == TypeCheckMode::None
|| graph_data.is_type_checked(&roots, &lib)
{
if let Some(result) = graph_data.check(
&roots,
- self.config.type_check_mode() != TypeCheckMode::None,
+ self.options.type_check_mode() != TypeCheckMode::None,
false,
) {
return result;
@@ -304,7 +304,7 @@ impl ProcState {
dynamic_permissions.clone(),
);
let maybe_locker = as_maybe_locker(self.lockfile.clone());
- let maybe_imports = self.config.to_maybe_imports()?;
+ let maybe_imports = self.options.to_maybe_imports()?;
struct ProcStateLoader<'a> {
inner: &'a mut cache::FetchCacher,
@@ -399,17 +399,17 @@ impl ProcState {
{
let mut graph_data = self.graph_data.write();
graph_data.add_graph(&graph, reload_on_watch);
- let check_js = self.config.check_js();
+ let check_js = self.options.check_js();
graph_data
.check(
&roots,
- self.config.type_check_mode() != TypeCheckMode::None,
+ self.options.type_check_mode() != TypeCheckMode::None,
check_js,
)
.unwrap()?;
}
- let config_type = if self.config.type_check_mode() == TypeCheckMode::None {
+ let config_type = if self.options.type_check_mode() == TypeCheckMode::None {
TsConfigType::Emit
} else {
TsConfigType::Check {
@@ -419,30 +419,30 @@ impl ProcState {
};
let ts_config_result =
- self.config.resolve_ts_config_for_emit(config_type)?;
+ self.options.resolve_ts_config_for_emit(config_type)?;
if let Some(ignored_options) = ts_config_result.maybe_ignored_options {
log::warn!("{}", ignored_options);
}
- if self.config.type_check_mode() == TypeCheckMode::None {
+ if self.options.type_check_mode() == TypeCheckMode::None {
let options = emit::EmitOptions {
ts_config: ts_config_result.ts_config,
- reload: self.config.reload_flag(),
+ reload: self.options.reload_flag(),
reload_exclusions,
};
let emit_result = emit::emit(&graph, &self.dir.gen_cache, options)?;
log::debug!("{}", emit_result.stats);
} else {
- let maybe_config_specifier = self.config.maybe_config_file_specifier();
+ let maybe_config_specifier = self.options.maybe_config_file_specifier();
let options = emit::CheckOptions {
- type_check_mode: self.config.type_check_mode(),
- debug: self.config.log_level() == Some(log::Level::Debug),
+ type_check_mode: self.options.type_check_mode(),
+ debug: self.options.log_level() == Some(log::Level::Debug),
emit_with_diagnostics: false,
maybe_config_specifier,
ts_config: ts_config_result.ts_config,
log_checks: true,
- reload: self.config.reload_flag(),
+ reload: self.options.reload_flag(),
reload_exclusions,
};
let emit_result = emit::check_and_maybe_emit(
@@ -457,7 +457,7 @@ impl ProcState {
log::debug!("{}", emit_result.stats);
}
- if self.config.type_check_mode() != TypeCheckMode::None {
+ if self.options.type_check_mode() != TypeCheckMode::None {
let mut graph_data = self.graph_data.write();
graph_data.set_type_checked(&roots, lib);
}
@@ -502,7 +502,7 @@ impl ProcState {
// and `Deno.core.evalContext` API. Ideally we should always have a referrer filled
// but sadly that's not the case due to missing APIs in V8.
let referrer = if referrer.is_empty()
- && matches!(self.config.sub_command(), DenoSubcommand::Repl(_))
+ && matches!(self.options.sub_command(), DenoSubcommand::Repl(_))
{
deno_core::resolve_url_or_path("./$deno$repl.ts").unwrap()
} else {
diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs
index d2cf4f00b..9dfe2cd37 100644
--- a/cli/tools/bench.rs
+++ b/cli/tools/bench.rs
@@ -336,7 +336,7 @@ async fn check_specifiers(
permissions: Permissions,
specifiers: Vec<ModuleSpecifier>,
) -> Result<(), AnyError> {
- let lib = ps.config.ts_type_lib_window();
+ let lib = ps.options.ts_type_lib_window();
ps.prepare_module_load(
specifiers,
false,
@@ -366,7 +366,7 @@ async fn bench_specifier(
vec![ops::bench::init(
channel.clone(),
filter,
- ps.config.unstable(),
+ ps.options.unstable(),
)],
Default::default(),
);
@@ -424,7 +424,7 @@ async fn bench_specifiers(
specifiers: Vec<ModuleSpecifier>,
options: BenchSpecifierOptions,
) -> Result<(), AnyError> {
- let log_level = ps.config.log_level();
+ let log_level = ps.options.log_level();
let (sender, mut receiver) = unbounded_channel::<BenchEvent>();
@@ -527,7 +527,8 @@ pub async fn run_benchmarks(
bench_flags: BenchFlags,
) -> Result<(), AnyError> {
let ps = ProcState::build(flags).await?;
- let permissions = Permissions::from_options(&ps.config.permissions_options());
+ let permissions =
+ Permissions::from_options(&ps.options.permissions_options());
let specifiers = collect_specifiers(
bench_flags.include.unwrap_or_else(|| vec![".".to_string()]),
&bench_flags.ignore.clone(),
@@ -540,7 +541,7 @@ pub async fn run_benchmarks(
check_specifiers(&ps, permissions.clone(), specifiers.clone()).await?;
- let compat = ps.config.compat();
+ let compat = ps.options.compat();
bench_specifiers(
ps,
permissions,
@@ -561,12 +562,13 @@ pub async fn run_benchmarks_with_watch(
bench_flags: BenchFlags,
) -> Result<(), AnyError> {
let ps = ProcState::build(flags).await?;
- let permissions = Permissions::from_options(&ps.config.permissions_options());
+ let permissions =
+ Permissions::from_options(&ps.options.permissions_options());
let include = bench_flags.include.unwrap_or_else(|| vec![".".to_string()]);
let ignore = bench_flags.ignore.clone();
let paths_to_watch: Vec<_> = include.iter().map(PathBuf::from).collect();
- let no_check = ps.config.type_check_mode() == TypeCheckMode::None;
+ let no_check = ps.options.type_check_mode() == TypeCheckMode::None;
let resolver = |changed: Option<Vec<PathBuf>>| {
let mut cache = cache::FetchCacher::new(
@@ -582,15 +584,15 @@ pub async fn run_benchmarks_with_watch(
let maybe_import_map_resolver =
ps.maybe_import_map.clone().map(ImportMapResolver::new);
let maybe_jsx_resolver = ps
- .config
+ .options
.to_maybe_jsx_import_source_module()
.map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone()));
let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone());
- let maybe_imports_result = ps.config.to_maybe_imports();
+ let maybe_imports_result = ps.options.to_maybe_imports();
let files_changed = changed.is_some();
let include = include.clone();
let ignore = ignore.clone();
- let check_js = ps.config.check_js();
+ let check_js = ps.options.check_js();
async move {
let bench_modules =
@@ -734,7 +736,7 @@ pub async fn run_benchmarks_with_watch(
check_specifiers(&ps, permissions.clone(), specifiers.clone()).await?;
let specifier_options = BenchSpecifierOptions {
- compat_mode: ps.config.compat(),
+ compat_mode: ps.options.compat(),
filter: filter.clone(),
};
bench_specifiers(ps, permissions.clone(), specifiers, specifier_options)
@@ -749,7 +751,7 @@ pub async fn run_benchmarks_with_watch(
operation,
file_watcher::PrintConfig {
job_name: "Bench".to_string(),
- clear_screen: !ps.config.no_clear_screen(),
+ clear_screen: !ps.options.no_clear_screen(),
},
)
.await?;
diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs
index 068a98389..fbb784f98 100644
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@@ -122,7 +122,7 @@ pub async fn print_docs(
doc_parser.parse_source(
&source_file_specifier,
MediaType::Dts,
- get_types(ps.config.unstable()).into(),
+ get_types(ps.options.unstable()).into(),
)
} else {
let module_specifier = resolve_url_or_path(&source_file)?;
diff --git a/cli/tools/fmt.rs b/cli/tools/fmt.rs
index 267b21d88..585bf6e92 100644
--- a/cli/tools/fmt.rs
+++ b/cli/tools/fmt.rs
@@ -7,10 +7,10 @@
//! the future it can be easily extended to provide
//! the same functions as ops available in JS runtime.
+use crate::args::CliOptions;
use crate::args::FmtFlags;
use crate::args::FmtOptionsConfig;
use crate::args::ProseWrap;
-use crate::args::RootConfig;
use crate::colors;
use crate::diff::diff;
use crate::file_watcher;
@@ -43,7 +43,7 @@ use super::incremental_cache::IncrementalCache;
/// Format JavaScript/TypeScript files.
pub async fn format(
- config: &RootConfig,
+ config: &CliOptions,
fmt_flags: FmtFlags,
) -> Result<(), AnyError> {
let maybe_fmt_config = config.to_fmt_config()?;
diff --git a/cli/tools/lint.rs b/cli/tools/lint.rs
index 4e8f8fb0c..61129b752 100644
--- a/cli/tools/lint.rs
+++ b/cli/tools/lint.rs
@@ -76,7 +76,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
let mut exclude_files = ignore.clone();
let ps = ProcState::build(flags).await?;
- let maybe_lint_config = ps.config.to_lint_config()?;
+ let maybe_lint_config = ps.options.to_lint_config()?;
if let Some(lint_config) = maybe_lint_config.as_ref() {
if include_files.is_empty() {
@@ -202,7 +202,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
Ok(())
};
- if ps.config.watch_paths().is_some() {
+ if ps.options.watch_paths().is_some() {
if args.len() == 1 && args[0].to_string_lossy() == "-" {
return Err(generic_error(
"Lint watch on standard input is not supported.",
@@ -213,7 +213,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> {
operation,
file_watcher::PrintConfig {
job_name: "Lint".to_string(),
- clear_screen: !ps.config.no_clear_screen(),
+ clear_screen: !ps.options.no_clear_screen(),
},
)
.await?;
diff --git a/cli/tools/task.rs b/cli/tools/task.rs
index fa9f30d7d..88a0f5be0 100644
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@@ -30,8 +30,8 @@ pub async fn execute_script(
crate::colors::yellow("Warning"),
);
let ps = ProcState::build(flags).await?;
- let tasks_config = ps.config.resolve_tasks_config()?;
- let config_file_url = ps.config.maybe_config_file_specifier().unwrap();
+ let tasks_config = ps.options.resolve_tasks_config()?;
+ let config_file_url = ps.options.maybe_config_file_specifier().unwrap();
let config_file_path = if config_file_url.scheme() == "file" {
config_file_url.to_file_path().unwrap()
} else {
@@ -52,7 +52,7 @@ pub async fn execute_script(
if let Some(script) = maybe_script {
let additional_args = ps
- .config
+ .options
.argv()
.iter()
// surround all the additional arguments in double quotes
diff --git a/cli/tools/test.rs b/cli/tools/test.rs
index 3b3f8dc4b..ab6ded1b0 100644
--- a/cli/tools/test.rs
+++ b/cli/tools/test.rs
@@ -1020,7 +1020,7 @@ pub async fn check_specifiers(
permissions: Permissions,
specifiers: Vec<(ModuleSpecifier, TestMode)>,
) -> Result<(), AnyError> {
- let lib = ps.config.ts_type_lib_window();
+ let lib = ps.options.ts_type_lib_window();
let inline_files = fetch_inline_files(
ps.clone(),
specifiers
@@ -1088,7 +1088,7 @@ async fn test_specifiers(
specifiers_with_mode: Vec<(ModuleSpecifier, TestMode)>,
options: TestSpecifierOptions,
) -> Result<(), AnyError> {
- let log_level = ps.config.log_level();
+ let log_level = ps.options.log_level();
let specifiers_with_mode = if let Some(seed) = options.shuffle {
let mut rng = SmallRng::seed_from_u64(seed);
let mut specifiers_with_mode = specifiers_with_mode.clone();
@@ -1333,7 +1333,8 @@ pub async fn run_tests(
test_flags: TestFlags,
) -> Result<(), AnyError> {
let ps = ProcState::build(flags).await?;
- let permissions = Permissions::from_options(&ps.config.permissions_options());
+ let permissions =
+ Permissions::from_options(&ps.options.permissions_options());
let specifiers_with_mode = fetch_specifiers_with_test_mode(
&ps,
test_flags.include.unwrap_or_else(|| vec![".".to_string()]),
@@ -1353,7 +1354,7 @@ pub async fn run_tests(
return Ok(());
}
- let compat = ps.config.compat();
+ let compat = ps.options.compat();
test_specifiers(
ps,
permissions,
@@ -1377,12 +1378,13 @@ pub async fn run_tests_with_watch(
test_flags: TestFlags,
) -> Result<(), AnyError> {
let ps = ProcState::build(flags).await?;
- let permissions = Permissions::from_options(&ps.config.permissions_options());
+ let permissions =
+ Permissions::from_options(&ps.options.permissions_options());
let include = test_flags.include.unwrap_or_else(|| vec![".".to_string()]);
let ignore = test_flags.ignore.clone();
let paths_to_watch: Vec<_> = include.iter().map(PathBuf::from).collect();
- let no_check = ps.config.type_check_mode() == TypeCheckMode::None;
+ let no_check = ps.options.type_check_mode() == TypeCheckMode::None;
let resolver = |changed: Option<Vec<PathBuf>>| {
let mut cache = cache::FetchCacher::new(
@@ -1398,15 +1400,15 @@ pub async fn run_tests_with_watch(
let maybe_import_map_resolver =
ps.maybe_import_map.clone().map(ImportMapResolver::new);
let maybe_jsx_resolver = ps
- .config
+ .options
.to_maybe_jsx_import_source_module()
.map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone()));
let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone());
- let maybe_imports_result = ps.config.to_maybe_imports();
+ let maybe_imports_result = ps.options.to_maybe_imports();
let files_changed = changed.is_some();
let include = include.clone();
let ignore = ignore.clone();
- let check_js = ps.config.check_js();
+ let check_js = ps.options.check_js();
async move {
let test_modules = if test_flags.doc {
@@ -1535,9 +1537,9 @@ pub async fn run_tests_with_watch(
})
};
- let root_config = ps.config.clone();
+ let cli_options = ps.options.clone();
let operation = |modules_to_reload: Vec<(ModuleSpecifier, ModuleKind)>| {
- let root_config = root_config.clone();
+ let cli_options = cli_options.clone();
let filter = test_flags.filter.clone();
let include = include.clone();
let ignore = ignore.clone();
@@ -1571,7 +1573,7 @@ pub async fn run_tests_with_watch(
permissions.clone(),
specifiers_with_mode,
TestSpecifierOptions {
- compat_mode: root_config.compat(),
+ compat_mode: cli_options.compat(),
concurrent_jobs: test_flags.concurrent_jobs,
fail_fast: test_flags.fail_fast,
filter: filter.clone(),
@@ -1590,7 +1592,7 @@ pub async fn run_tests_with_watch(
operation,
file_watcher::PrintConfig {
job_name: "Test".to_string(),
- clear_screen: !root_config.no_clear_screen(),
+ clear_screen: !cli_options.no_clear_screen(),
},
)
.await?;
diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs
index fc7684b5b..7c36b5074 100644
--- a/cli/tools/vendor/mod.rs
+++ b/cli/tools/vendor/mod.rs
@@ -134,12 +134,12 @@ fn validate_output_dir(
fn maybe_update_config_file(output_dir: &Path, ps: &ProcState) -> bool {
assert!(output_dir.is_absolute());
- let config_file_specifier = match ps.config.maybe_config_file_specifier() {
+ let config_file_specifier = match ps.options.maybe_config_file_specifier() {
Some(f) => f,
None => return false,
};
let fmt_config = ps
- .config
+ .options
.to_fmt_config()
.unwrap_or_default()
.unwrap_or_default();
@@ -263,11 +263,11 @@ async fn create_graph(
Permissions::allow_all(),
);
let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone());
- let maybe_imports = ps.config.to_maybe_imports()?;
+ let maybe_imports = ps.options.to_maybe_imports()?;
let maybe_import_map_resolver =
ps.maybe_import_map.clone().map(ImportMapResolver::new);
let maybe_jsx_resolver = ps
- .config
+ .options
.to_maybe_jsx_import_source_module()
.map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone()));
let maybe_resolver = if maybe_jsx_resolver.is_some() {
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 10:17:26 +0000