diff options
Diffstat (limited to 'cli/main.rs')
| -rw-r--r-- | cli/main.rs | 223 |
1 files changed, 89 insertions, 134 deletions
diff --git a/cli/main.rs b/cli/main.rs index de44add17..ede162d1b 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -36,7 +36,6 @@ mod version; mod windows_util; use crate::args::flags_from_vec; -use crate::args::resolve_import_map_specifier; use crate::args::BenchFlags; use crate::args::BundleFlags; use crate::args::CacheFlags; @@ -60,6 +59,7 @@ use crate::args::TypeCheckMode; use crate::args::UninstallFlags; use crate::args::UpgradeFlags; use crate::args::VendorFlags; +use crate::emit::TsConfigType; use crate::file_fetcher::File; use crate::file_watcher::ResolutionResult; use crate::fmt_errors::format_js_error; @@ -70,6 +70,7 @@ use crate::proc_state::ProcState; use crate::resolver::ImportMapResolver; use crate::resolver::JsxResolver; +use args::RootConfig; use deno_ast::MediaType; use deno_core::error::generic_error; use deno_core::error::AnyError; @@ -108,7 +109,7 @@ use std::sync::Arc; fn create_web_worker_preload_module_callback( ps: ProcState, ) -> Arc<PreloadModuleCb> { - let compat = ps.flags.compat; + let compat = ps.config.compat(); Arc::new(move |mut worker| { let fut = async move { @@ -143,30 +144,30 @@ fn create_web_worker_callback( let options = WebWorkerOptions { bootstrap: BootstrapOptions { - args: ps.flags.argv.clone(), + args: ps.config.argv().clone(), cpu_count: std::thread::available_parallelism() .map(|p| p.get()) .unwrap_or(1), debug_flag: ps - .flags - .log_level + .config + .log_level() .map_or(false, |l| l == log::Level::Debug), - enable_testing_features: ps.flags.enable_testing_features, + enable_testing_features: ps.config.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.flags.unstable, + unstable: ps.config.unstable(), user_agent: version::get_user_agent(), }, extensions, unsafely_ignore_certificate_errors: ps - .flags - .unsafely_ignore_certificate_errors - .clone(), - root_cert_store: ps.root_cert_store.clone(), - seed: ps.flags.seed, + .config + .unsafely_ignore_certificate_errors() + .map(ToOwned::to_owned), + root_cert_store: Some(ps.root_cert_store.clone()), + seed: ps.config.seed(), module_loader, create_web_worker_cb, preload_module_cb, @@ -203,31 +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.flags.inspect_brk.is_some(); + let should_break_on_first_statement = ps.config.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 = if let Some(location) = &ps.flags.location { - // if a location is set, then the ascii serialization of the location is - // used, unless the origin is opaque, and then no storage origin is set, as - // we can't expect the origin to be reproducible - let storage_origin = location.origin().ascii_serialization(); - if storage_origin == "null" { - None - } else { - Some(storage_origin) - } - } else if let Some(config_file) = &ps.maybe_config_file { - // otherwise we will use the path to the config file - Some(config_file.specifier.to_string()) - } else { - // otherwise we will use the path to the main module - Some(main_module.to_string()) - }; - + let maybe_storage_key = ps.config.resolve_storage_key(&main_module); let origin_storage_dir = maybe_storage_key.map(|key| { ps.dir .root @@ -241,27 +225,30 @@ pub fn create_main_worker( let options = WorkerOptions { bootstrap: BootstrapOptions { - args: ps.flags.argv.clone(), + args: ps.config.argv().clone(), cpu_count: std::thread::available_parallelism() .map(|p| p.get()) .unwrap_or(1), - debug_flag: ps.flags.log_level.map_or(false, |l| l == log::Level::Debug), - enable_testing_features: ps.flags.enable_testing_features, - location: ps.flags.location.clone(), + debug_flag: ps + .config + .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), no_color: !colors::use_color(), is_tty: colors::is_tty(), runtime_version: version::deno(), ts_version: version::TYPESCRIPT.to_string(), - unstable: ps.flags.unstable, + unstable: ps.config.unstable(), user_agent: version::get_user_agent(), }, extensions, unsafely_ignore_certificate_errors: ps - .flags - .unsafely_ignore_certificate_errors - .clone(), - root_cert_store: ps.root_cert_store.clone(), - seed: ps.flags.seed, + .config + .unsafely_ignore_certificate_errors() + .map(ToOwned::to_owned), + root_cert_store: Some(ps.root_cert_store.clone()), + seed: ps.config.seed(), source_map_getter: Some(Box::new(ps.clone())), format_js_error_fn: Some(Arc::new(format_js_error)), create_web_worker_cb, @@ -412,7 +399,7 @@ async fn compile_command( )?; let module_specifier = resolve_url_or_path(&compile_flags.source_file)?; - let ps = ProcState::build(Arc::new(flags)).await?; + let ps = ProcState::build(flags).await?; let deno_dir = &ps.dir; let output_path = @@ -460,7 +447,7 @@ async fn info_command( flags: Flags, info_flags: InfoFlags, ) -> Result<i32, AnyError> { - let ps = ProcState::build(Arc::new(flags)).await?; + let ps = ProcState::build(flags).await?; if let Some(specifier) = info_flags.file { let specifier = resolve_url_or_path(&specifier)?; let mut cache = cache::FetchCacher::new( @@ -472,10 +459,10 @@ async fn info_command( let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone()); let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); - let maybe_jsx_resolver = ps.maybe_config_file.as_ref().and_then(|cf| { - cf.to_maybe_jsx_import_source_module() - .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())) - }); + let maybe_jsx_resolver = ps + .config + .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() { maybe_jsx_resolver.as_ref().map(|jr| jr.as_resolver()) } else { @@ -502,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.flags.location.as_ref())?; + print_cache_info(&ps, info_flags.json, ps.config.location_flag())?; } Ok(0) } @@ -516,7 +503,7 @@ async fn install_command( preload_flags.inspect_brk = None; let permissions = Permissions::from_options(&preload_flags.permissions_options()); - let ps = ProcState::build(Arc::new(preload_flags)).await?; + let ps = ProcState::build(preload_flags).await?; let main_module = resolve_url_or_path(&install_flags.module_url)?; let mut worker = create_main_worker( &ps, @@ -560,19 +547,15 @@ async fn cache_command( flags: Flags, cache_flags: CacheFlags, ) -> Result<i32, AnyError> { - let lib = if flags.unstable { - emit::TypeLib::UnstableDenoWindow - } else { - emit::TypeLib::DenoWindow - }; - let ps = ProcState::build(Arc::new(flags)).await?; + let ps = ProcState::build(flags).await?; + let lib = ps.config.ts_type_lib_window(); for file in cache_flags.files { let specifier = resolve_url_or_path(&file)?; ps.prepare_module_load( vec![specifier], false, - lib.clone(), + lib, Permissions::allow_all(), Permissions::allow_all(), false, @@ -605,7 +588,7 @@ async fn eval_command( let main_module = resolve_url_or_path(&format!("./$deno$eval.{}", eval_flags.ext))?; let permissions = Permissions::from_options(&flags.permissions_options()); - let ps = ProcState::build(Arc::new(flags)).await?; + let ps = ProcState::build(flags).await?; let mut worker = create_main_worker( &ps, main_module.clone(), @@ -634,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.flags.compat { + if ps.config.compat() { worker.execute_side_module(&compat::GLOBAL_URL).await?; } worker.execute_main_module(&main_module).await?; @@ -662,17 +645,13 @@ async fn create_graph_and_maybe_check( Permissions::allow_all(), ); let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone()); - let maybe_imports = if let Some(config_file) = &ps.maybe_config_file { - config_file.to_maybe_imports()? - } else { - None - }; + let maybe_imports = ps.config.to_maybe_imports()?; let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); - let maybe_jsx_resolver = ps.maybe_config_file.as_ref().and_then(|cf| { - cf.to_maybe_jsx_import_source_module() - .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())) - }); + let maybe_jsx_resolver = ps + .config + .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() { maybe_jsx_resolver.as_ref().map(|jr| jr.as_resolver()) } else { @@ -694,49 +673,36 @@ async fn create_graph_and_maybe_check( .await, ); - let check_js = ps - .maybe_config_file - .as_ref() - .map(|cf| cf.get_check_js()) - .unwrap_or(false); + let check_js = ps.config.check_js(); graph_valid( &graph, - ps.flags.type_check_mode != TypeCheckMode::None, + ps.config.type_check_mode() != TypeCheckMode::None, check_js, )?; graph_lock_or_exit(&graph); - if ps.flags.type_check_mode != TypeCheckMode::None { - let lib = if ps.flags.unstable { - emit::TypeLib::UnstableDenoWindow - } else { - emit::TypeLib::DenoWindow - }; - let (ts_config, maybe_ignored_options) = emit::get_ts_config( - emit::ConfigType::Check { + if ps.config.type_check_mode() != TypeCheckMode::None { + let ts_config_result = + ps.config.resolve_ts_config_for_emit(TsConfigType::Check { tsc_emit: false, - lib, - }, - ps.maybe_config_file.as_ref(), - None, - )?; - if let Some(ignored_options) = maybe_ignored_options { + lib: ps.config.ts_type_lib_window(), + })?; + if let Some(ignored_options) = ts_config_result.maybe_ignored_options { eprintln!("{}", ignored_options); } - let maybe_config_specifier = - ps.maybe_config_file.as_ref().map(|cf| cf.specifier.clone()); + let maybe_config_specifier = ps.config.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.flags.type_check_mode.clone(), + type_check_mode: ps.config.type_check_mode(), debug, emit_with_diagnostics: false, maybe_config_specifier, - ts_config, + ts_config: ts_config_result.ts_config, log_checks: true, - reload: ps.flags.reload, + reload: ps.config.reload_flag(), reload_exclusions: Default::default(), }, )?; @@ -752,17 +718,13 @@ async fn create_graph_and_maybe_check( fn bundle_module_graph( graph: &deno_graph::ModuleGraph, ps: &ProcState, - flags: &Flags, ) -> Result<deno_emit::BundleEmit, AnyError> { info!("{} {}", colors::green("Bundle"), graph.roots[0].0); - let (ts_config, maybe_ignored_options) = emit::get_ts_config( - emit::ConfigType::Bundle, - ps.maybe_config_file.as_ref(), - None, - )?; - if flags.type_check_mode == TypeCheckMode::None { - if let Some(ignored_options) = maybe_ignored_options { + let ts_config_result = + ps.config.resolve_ts_config_for_emit(TsConfigType::Bundle)?; + if ps.config.type_check_mode() == TypeCheckMode::None { + if let Some(ignored_options) = ts_config_result.maybe_ignored_options { eprintln!("{}", ignored_options); } } @@ -771,7 +733,7 @@ fn bundle_module_graph( graph, deno_emit::BundleOptions { bundle_type: deno_emit::BundleType::Module, - emit_options: ts_config.into(), + emit_options: ts_config_result.ts_config.into(), emit_ignore_directives: true, }, ) @@ -782,16 +744,16 @@ async fn bundle_command( bundle_flags: BundleFlags, ) -> Result<i32, AnyError> { let debug = flags.log_level == Some(log::Level::Debug); - let flags = Arc::new(flags); + let root_config = Arc::new(RootConfig::from_flags(flags)?); let resolver = |_| { - let flags = flags.clone(); + let root_config = root_config.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::build(flags).await?; + let ps = ProcState::from_root_config(root_config).await?; let graph = create_graph_and_maybe_check(module_specifier, &ps, debug).await?; @@ -804,11 +766,10 @@ async fn bundle_command( }) .collect(); - if let Ok(Some(import_map_path)) = resolve_import_map_specifier( - ps.flags.import_map_path.as_deref(), - ps.maybe_config_file.as_ref(), - ) - .map(|ms| ms.and_then(|ref s| s.to_file_path().ok())) + if let Ok(Some(import_map_path)) = ps + .config + .resolve_import_map_path() + .map(|ms| ms.and_then(|ref s| s.to_file_path().ok())) { paths_to_watch.push(import_map_path); } @@ -830,7 +791,7 @@ async fn bundle_command( let operation = |(ps, graph): (ProcState, Arc<deno_graph::ModuleGraph>)| { let out_file = bundle_flags.out_file.clone(); async move { - let bundle_output = bundle_module_graph(graph.as_ref(), &ps, &ps.flags)?; + let bundle_output = bundle_module_graph(graph.as_ref(), &ps)?; debug!(">>>>> bundle END"); if let Some(out_file) = out_file.as_ref() { @@ -868,13 +829,13 @@ async fn bundle_command( } }; - if flags.watch.is_some() { + if root_config.watch_paths().is_some() { file_watcher::watch_func( resolver, operation, file_watcher::PrintConfig { job_name: "Bundle".to_string(), - clear_screen: !flags.no_clear_screen, + clear_screen: !root_config.no_clear_screen(), }, ) .await?; @@ -903,14 +864,10 @@ async fn format_command( flags: Flags, fmt_flags: FmtFlags, ) -> Result<i32, AnyError> { - let ps = ProcState::build(Arc::new(flags)).await?; - let maybe_fmt_config = if let Some(config_file) = &ps.maybe_config_file { - config_file.to_fmt_config()? - } else { - None - }; + let config = RootConfig::from_flags(flags)?; if fmt_flags.files.len() == 1 && fmt_flags.files[0].to_string_lossy() == "-" { + let maybe_fmt_config = config.to_fmt_config()?; tools::fmt::format_stdin( fmt_flags, maybe_fmt_config.map(|c| c.options).unwrap_or_default(), @@ -918,8 +875,7 @@ async fn format_command( return Ok(0); } - tools::fmt::format(ps.flags.as_ref(), fmt_flags, maybe_fmt_config, &ps.dir) - .await?; + tools::fmt::format(&config, fmt_flags).await?; Ok(0) } @@ -928,16 +884,15 @@ async fn repl_command( repl_flags: ReplFlags, ) -> Result<i32, AnyError> { let main_module = resolve_url_or_path("./$deno$repl.ts").unwrap(); - let permissions = Permissions::from_options(&flags.permissions_options()); - let ps = ProcState::build(Arc::new(flags)).await?; + let ps = ProcState::build(flags).await?; let mut worker = create_main_worker( &ps, main_module.clone(), - permissions, + Permissions::from_options(&ps.config.permissions_options()), vec![], Default::default(), ); - if ps.flags.compat { + if ps.config.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?; @@ -949,13 +904,12 @@ async fn repl_command( } async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> { - let ps = ProcState::build(Arc::new(flags)).await?; - let permissions = Permissions::from_options(&ps.flags.permissions_options()); + let ps = ProcState::build(flags).await?; let main_module = resolve_url_or_path("./$deno$stdin.ts").unwrap(); let mut worker = create_main_worker( &ps.clone(), main_module.clone(), - permissions, + Permissions::from_options(&ps.config.permissions_options()), vec![], Default::default(), ); @@ -976,7 +930,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.flags.compat { + if ps.config.compat() { worker.execute_side_module(&compat::GLOBAL_URL).await?; } worker.execute_main_module(&main_module).await?; @@ -1068,8 +1022,9 @@ async fn run_with_watch(flags: Flags, script: String) -> Result<i32, AnyError> { let flags = flags.clone(); let permissions = Permissions::from_options(&flags.permissions_options()); async move { - let ps = ProcState::build_for_file_watcher(flags.clone(), sender.clone()) - .await?; + let ps = + ProcState::build_for_file_watcher((*flags).clone(), sender.clone()) + .await?; // We make use an module executor guard to ensure that unload is always fired when an // operation is called. let mut executor = FileWatcherModuleExecutor::new( @@ -1122,8 +1077,8 @@ async fn run_command( // map specified and bare specifier is used on the command line - this should // probably call `ProcState::resolve` instead let main_module = resolve_url_or_path(&run_flags.script)?; - let ps = ProcState::build(Arc::new(flags)).await?; - let permissions = Permissions::from_options(&ps.flags.permissions_options()); + let ps = ProcState::build(flags).await?; + let permissions = Permissions::from_options(&ps.config.permissions_options()); let mut worker = create_main_worker( &ps, main_module.clone(), @@ -1149,7 +1104,7 @@ async fn run_command( debug!("main_module {}", main_module); - if ps.flags.compat { + if ps.config.compat() { // TODO(bartlomieju): fix me assert_eq!(main_module.scheme(), "file"); @@ -1280,7 +1235,7 @@ async fn vendor_command( flags: Flags, vendor_flags: VendorFlags, ) -> Result<i32, AnyError> { - let ps = ProcState::build(Arc::new(flags)).await?; + let ps = ProcState::build(flags).await?; tools::vendor::vendor(ps, vendor_flags).await?; Ok(0) } |