diff options
Diffstat (limited to 'cli')
| -rw-r--r-- | cli/Cargo.toml | 20 | ||||
| -rw-r--r-- | cli/cache/module_info.rs | 11 | ||||
| -rw-r--r-- | cli/cache/parsed_source.rs | 30 | ||||
| -rw-r--r-- | cli/graph_util.rs | 130 | ||||
| -rw-r--r-- | cli/lsp/analysis.rs | 2 | ||||
| -rw-r--r-- | cli/module_loader.rs | 6 | ||||
| -rw-r--r-- | cli/tools/doc.rs | 31 | ||||
| -rw-r--r-- | cli/tools/lint.rs | 26 | ||||
| -rw-r--r-- | cli/tools/repl/session.rs | 2 |
9 files changed, 153 insertions, 105 deletions
diff --git a/cli/Cargo.toml b/cli/Cargo.toml index f43115496..ae6a11398 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -60,16 +60,18 @@ deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "dep_gra deno_cache_dir = "=0.6.1" deno_config = "=0.6.5" deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] } -deno_doc = { version = "=0.85.0", features = ["html"] } -deno_emit = "=0.32.0" -deno_graph = "=0.62.2" -deno_lint = { version = "=0.52.2", features = ["docs"] } +deno_doc = { version = "=0.89.0", features = ["html"] } +deno_emit = "=0.33.0" +deno_graph = "=0.63.0" +deno_lint = { version = "=0.53.0", features = ["docs"] } deno_lockfile.workspace = true -deno_npm = "0.15.3" +deno_npm = "=0.15.3" deno_runtime = { workspace = true, features = ["dont_create_runtime_snapshot", "include_js_files_for_snapshotting"] } -deno_semver = "0.5.1" +# todo(dsherret): investigate https://github.com/denoland/deno_semver/commit/98f9174baef199809295077b3b68c9fa58defb9b causing +# lsp_completions_auto_import_and_quick_fix_with_import_map to fail when bumping this version +deno_semver = "=0.5.1" deno_task_shell = "=0.14.0" -eszip = "=0.56.0" +eszip = "=0.57.0" napi_sym.workspace = true async-trait.workspace = true @@ -91,7 +93,7 @@ dotenvy = "0.15.7" dprint-plugin-json = "=0.19.1" dprint-plugin-jupyter = "=0.1.2" dprint-plugin-markdown = "=0.16.3" -dprint-plugin-typescript = "=0.88.7" +dprint-plugin-typescript = "=0.88.8" encoding_rs.workspace = true env_logger = "=0.10.0" fancy-regex = "=0.10.0" @@ -100,7 +102,7 @@ flate2.workspace = true fs3.workspace = true glob = "0.3.1" hex.workspace = true -import_map = { version = "=0.18.0", features = ["ext"] } +import_map = { version = "=0.18.1", features = ["ext"] } indexmap.workspace = true jsonc-parser = { version = "=0.23.0", features = ["serde"] } lazy-regex.workspace = true diff --git a/cli/cache/module_info.rs b/cli/cache/module_info.rs index 9240b2387..4a80774f6 100644 --- a/cli/cache/module_info.rs +++ b/cli/cache/module_info.rs @@ -6,11 +6,9 @@ use deno_ast::MediaType; use deno_ast::ModuleSpecifier; use deno_core::error::AnyError; use deno_core::serde_json; -use deno_graph::CapturingModuleParser; use deno_graph::DefaultModuleAnalyzer; use deno_graph::ModuleInfo; use deno_graph::ModuleParser; -use deno_graph::ParsedSourceStore; use deno_runtime::deno_webstorage::rusqlite::params; use super::cache_db::CacheDB; @@ -115,19 +113,18 @@ impl ModuleInfoCache { pub fn as_module_analyzer<'a>( &'a self, - parser: Option<&'a dyn ModuleParser>, - store: &'a dyn ParsedSourceStore, + parser: &'a dyn ModuleParser, ) -> ModuleInfoCacheModuleAnalyzer<'a> { ModuleInfoCacheModuleAnalyzer { module_info_cache: self, - parser: CapturingModuleParser::new(parser, store), + parser, } } } pub struct ModuleInfoCacheModuleAnalyzer<'a> { module_info_cache: &'a ModuleInfoCache, - parser: CapturingModuleParser<'a>, + parser: &'a dyn ModuleParser, } impl<'a> deno_graph::ModuleAnalyzer for ModuleInfoCacheModuleAnalyzer<'a> { @@ -156,7 +153,7 @@ impl<'a> deno_graph::ModuleAnalyzer for ModuleInfoCacheModuleAnalyzer<'a> { } // otherwise, get the module info from the parsed source cache - let analyzer = DefaultModuleAnalyzer::new(&self.parser); + let analyzer = DefaultModuleAnalyzer::new(self.parser); let module_info = analyzer.analyze(specifier, source, media_type)?; // then attempt to cache it diff --git a/cli/cache/parsed_source.rs b/cli/cache/parsed_source.rs index 021c37f1b..77f2e5953 100644 --- a/cli/cache/parsed_source.rs +++ b/cli/cache/parsed_source.rs @@ -9,6 +9,7 @@ use deno_ast::ParsedSource; use deno_core::parking_lot::Mutex; use deno_graph::CapturingModuleParser; use deno_graph::ModuleParser; +use deno_graph::ParseOptions; #[derive(Default)] pub struct ParsedSourceCache { @@ -37,7 +38,13 @@ impl ParsedSourceCache { ) -> deno_core::anyhow::Result<ParsedSource, deno_ast::Diagnostic> { let parser = self.as_capturing_parser(); // this will conditionally parse because it's using a CapturingModuleParser - parser.parse_module(specifier, source, media_type) + parser.parse_module(ParseOptions { + specifier, + source, + media_type, + // don't bother enabling because this method is currently only used for emitting + scope_analysis: false, + }) } /// Frees the parsed source from memory. @@ -50,10 +57,6 @@ impl ParsedSourceCache { pub fn as_capturing_parser(&self) -> CapturingModuleParser { CapturingModuleParser::new(None, self) } - - pub fn as_store(self: &Arc<Self>) -> Arc<dyn deno_graph::ParsedSourceStore> { - self.clone() - } } /// It's ok that this is racy since in non-LSP situations @@ -76,4 +79,21 @@ impl deno_graph::ParsedSourceStore for ParsedSourceCache { ) -> Option<ParsedSource> { self.sources.lock().get(specifier).cloned() } + + fn get_scope_analysis_parsed_source( + &self, + specifier: &deno_graph::ModuleSpecifier, + ) -> Option<ParsedSource> { + let mut sources = self.sources.lock(); + let parsed_source = sources.get(specifier)?; + if parsed_source.has_scope_analysis() { + Some(parsed_source.clone()) + } else { + // upgrade to have scope analysis + let parsed_source = sources.remove(specifier).unwrap(); + let parsed_source = parsed_source.into_with_scope_analysis(); + sources.insert(specifier.clone(), parsed_source.clone()); + Some(parsed_source) + } + } } diff --git a/cli/graph_util.rs b/cli/graph_util.rs index b4f4b939a..53861415c 100644 --- a/cli/graph_util.rs +++ b/cli/graph_util.rs @@ -21,6 +21,7 @@ use crate::util::path::specifier_to_file_path; use crate::util::sync::TaskQueue; use crate::util::sync::TaskQueuePermit; +use deno_config::ConfigFile; use deno_core::anyhow::bail; use deno_core::anyhow::Context; use deno_core::error::custom_error; @@ -32,7 +33,6 @@ use deno_graph::source::Loader; use deno_graph::source::ResolveError; use deno_graph::GraphKind; use deno_graph::Module; -use deno_graph::ModuleAnalyzer; use deno_graph::ModuleError; use deno_graph::ModuleGraph; use deno_graph::ModuleGraphError; @@ -193,8 +193,11 @@ pub fn graph_lock_or_exit(graph: &ModuleGraph, lockfile: &mut Lockfile) { pub struct CreateGraphOptions<'a> { pub graph_kind: GraphKind, pub roots: Vec<ModuleSpecifier>, - pub loader: &'a mut dyn Loader, - pub analyzer: &'a dyn ModuleAnalyzer, + /// Whether to do fast check on workspace members. This is mostly only + /// useful when publishing. + pub workspace_fast_check: bool, + /// Specify `None` to use the default CLI loader. + pub loader: Option<&'a mut dyn Loader>, } pub struct ModuleGraphBuilder { @@ -261,14 +264,12 @@ impl ModuleGraphBuilder { roots: Vec<ModuleSpecifier>, loader: &mut dyn Loader, ) -> Result<deno_graph::ModuleGraph, AnyError> { - let store = self.parsed_source_cache.as_store(); - let analyzer = self.module_info_cache.as_module_analyzer(None, &*store); self .create_graph_with_options(CreateGraphOptions { graph_kind, roots, - loader, - analyzer: &analyzer, + loader: Some(loader), + workspace_fast_check: false, }) .await } @@ -277,14 +278,23 @@ impl ModuleGraphBuilder { &self, options: CreateGraphOptions<'_>, ) -> Result<deno_graph::ModuleGraph, AnyError> { - let maybe_imports = self.options.to_maybe_imports()?; - let maybe_workspace_config = self.options.maybe_workspace_config(); - let workspace_members = if let Some(wc) = maybe_workspace_config { - workspace_config_to_workspace_members(wc)? - } else { - vec![] - }; + enum MutLoaderRef<'a> { + Borrowed(&'a mut dyn Loader), + Owned(cache::FetchCacher), + } + + impl<'a> MutLoaderRef<'a> { + pub fn as_mut_loader(&mut self) -> &mut dyn Loader { + match self { + Self::Borrowed(loader) => *loader, + Self::Owned(loader) => loader, + } + } + } + let parser = self.parsed_source_cache.as_capturing_parser(); + let analyzer = self.module_info_cache.as_module_analyzer(&parser); + let maybe_imports = self.options.to_maybe_imports()?; let cli_resolver = self.resolver.clone(); let graph_resolver = cli_resolver.as_graph_resolver(); let graph_npm_resolver = cli_resolver.as_graph_npm_resolver(); @@ -292,22 +302,28 @@ impl ModuleGraphBuilder { .maybe_file_watcher_reporter .as_ref() .map(|r| r.as_reporter()); + let mut loader = match options.loader { + Some(loader) => MutLoaderRef::Borrowed(loader), + None => MutLoaderRef::Owned(self.create_graph_loader()), + }; let mut graph = ModuleGraph::new(options.graph_kind); self .build_graph_with_npm_resolution( &mut graph, options.roots, - options.loader, + loader.as_mut_loader(), deno_graph::BuildOptions { is_dynamic: false, imports: maybe_imports, resolver: Some(graph_resolver), file_system: Some(&DenoGraphFsAdapter(self.fs.as_ref())), npm_resolver: Some(graph_npm_resolver), - module_analyzer: Some(options.analyzer), + module_analyzer: Some(&analyzer), + module_parser: Some(&parser), reporter: maybe_file_watcher_reporter, - workspace_members, + workspace_fast_check: options.workspace_fast_check, + workspace_members: self.get_deno_graph_workspace_members()?, }, ) .await?; @@ -327,17 +343,11 @@ impl ModuleGraphBuilder { ) -> Result<Arc<deno_graph::ModuleGraph>, AnyError> { let mut cache = self.create_graph_loader(); let maybe_imports = self.options.to_maybe_imports()?; - let maybe_workspace_config = self.options.maybe_workspace_config(); - let workspace_members = if let Some(wc) = maybe_workspace_config { - workspace_config_to_workspace_members(wc)? - } else { - vec![] - }; let cli_resolver = self.resolver.clone(); let graph_resolver = cli_resolver.as_graph_resolver(); let graph_npm_resolver = cli_resolver.as_graph_npm_resolver(); - let store = self.parsed_source_cache.as_store(); - let analyzer = self.module_info_cache.as_module_analyzer(None, &*store); + let parser = self.parsed_source_cache.as_capturing_parser(); + let analyzer = self.module_info_cache.as_module_analyzer(&parser); let graph_kind = self.options.type_check_mode().as_graph_kind(); let mut graph = ModuleGraph::new(graph_kind); let maybe_file_watcher_reporter = self @@ -357,8 +367,10 @@ impl ModuleGraphBuilder { resolver: Some(graph_resolver), npm_resolver: Some(graph_npm_resolver), module_analyzer: Some(&analyzer), + module_parser: Some(&parser), reporter: maybe_file_watcher_reporter, - workspace_members, + workspace_fast_check: false, + workspace_members: self.get_deno_graph_workspace_members()?, }, ) .await?; @@ -391,6 +403,30 @@ impl ModuleGraphBuilder { Ok(graph) } + fn get_deno_graph_workspace_members( + &self, + ) -> Result<Vec<deno_graph::WorkspaceMember>, AnyError> { + let maybe_workspace_config = self.options.maybe_workspace_config(); + if let Some(wc) = maybe_workspace_config { + workspace_config_to_workspace_members(wc) + } else { + Ok( + self + .options + .maybe_config_file() + .as_ref() + .and_then(|c| match config_to_workspace_member(c) { + Ok(m) => Some(vec![m]), + Err(e) => { + log::debug!("Deno config was not a package: {:#}", e); + None + } + }) + .unwrap_or_default(), + ) + } + } + pub async fn build_graph_with_npm_resolution<'a>( &self, graph: &mut ModuleGraph, @@ -435,7 +471,7 @@ impl ModuleGraphBuilder { .strip_prefix("jsr:") .and_then(|value| PackageNv::from_str(value).ok()) { - graph.packages.add(key, value); + graph.packages.add_nv(key, value); } } } @@ -777,36 +813,34 @@ pub fn workspace_config_to_workspace_members( .members .iter() .map(|member| { - workspace_member_config_try_into_workspace_member(member).with_context( - || { - format!( - "Failed to resolve configuration for '{}' workspace member at '{}'", - member.member_name, - member.config_file.specifier.as_str() - ) - }, - ) + config_to_workspace_member(&member.config_file).with_context(|| { + format!( + "Failed to resolve configuration for '{}' workspace member at '{}'", + member.member_name, + member.config_file.specifier.as_str() + ) + }) }) .collect() } -fn workspace_member_config_try_into_workspace_member( - config: &deno_config::WorkspaceMemberConfig, +fn config_to_workspace_member( + config: &ConfigFile, ) -> Result<deno_graph::WorkspaceMember, AnyError> { let nv = deno_semver::package::PackageNv { - name: config.package_name.clone(), - version: deno_semver::Version::parse_standard(&config.package_version)?, + name: match &config.json.name { + Some(name) => name.clone(), + None => bail!("Missing 'name' field in config file."), + }, + version: match &config.json.version { + Some(name) => deno_semver::Version::parse_standard(name)?, + None => bail!("Missing 'version' field in config file."), + }, }; Ok(deno_graph::WorkspaceMember { - base: ModuleSpecifier::from_directory_path(&config.path).unwrap(), + base: config.specifier.join("./").unwrap(), nv, - exports: config - .config_file - .to_exports_config()? - .into_map() - // todo(dsherret): deno_graph should use an IndexMap - .into_iter() - .collect(), + exports: config.to_exports_config()?.into_map(), }) } diff --git a/cli/lsp/analysis.rs b/cli/lsp/analysis.rs index 88ca47f67..5301fbeea 100644 --- a/cli/lsp/analysis.rs +++ b/cli/lsp/analysis.rs @@ -133,7 +133,7 @@ pub fn get_lint_references( parsed_source: &deno_ast::ParsedSource, lint_rules: Vec<&'static dyn LintRule>, ) -> Result<Vec<Reference>, AnyError> { - let linter = create_linter(parsed_source.media_type(), lint_rules); + let linter = create_linter(lint_rules); let lint_diagnostics = linter.lint_with_ast(parsed_source); Ok( diff --git a/cli/module_loader.rs b/cli/module_loader.rs index 9a2c511ff..6fbeb8770 100644 --- a/cli/module_loader.rs +++ b/cli/module_loader.rs @@ -138,8 +138,8 @@ impl ModuleLoadPreparer { .as_ref() .map(|r| r.as_reporter()); - let store = self.parsed_source_cache.as_store(); - let analyzer = self.module_info_cache.as_module_analyzer(None, &*store); + let parser = self.parsed_source_cache.as_capturing_parser(); + let analyzer = self.module_info_cache.as_module_analyzer(&parser); log::debug!("Creating module graph."); let mut graph_update_permit = @@ -163,8 +163,10 @@ impl ModuleLoadPreparer { file_system: Some(&DenoGraphFsAdapter(self.fs.as_ref())), resolver: Some(graph_resolver), npm_resolver: Some(graph_npm_resolver), + module_parser: Some(&parser), module_analyzer: Some(&analyzer), reporter: maybe_file_watcher_reporter, + workspace_fast_check: false, workspace_members, }, ) diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs index b8d6b8a87..7b06dce05 100644 --- a/cli/tools/doc.rs +++ b/cli/tools/doc.rs @@ -10,7 +10,6 @@ use crate::display::write_json_to_stdout; use crate::display::write_to_stdout_ignore_sigpipe; use crate::factory::CliFactory; use crate::graph_util::graph_lock_or_exit; -use crate::graph_util::CreateGraphOptions; use crate::tsc::get_types_declaration_file_text; use crate::util::fs::collect_specifiers; use crate::util::glob::FilePatterns; @@ -20,10 +19,9 @@ use deno_core::anyhow::Context; use deno_core::error::AnyError; use deno_core::futures::FutureExt; use deno_doc as doc; -use deno_graph::CapturingModuleParser; -use deno_graph::DefaultParsedSourceStore; use deno_graph::GraphKind; use deno_graph::ModuleAnalyzer; +use deno_graph::ModuleParser; use deno_graph::ModuleSpecifier; use doc::DocDiagnostic; use indexmap::IndexMap; @@ -35,7 +33,7 @@ use std::sync::Arc; async fn generate_doc_nodes_for_builtin_types( doc_flags: DocFlags, cli_options: &Arc<CliOptions>, - capturing_parser: CapturingModuleParser<'_>, + parser: &dyn ModuleParser, analyzer: &dyn ModuleAnalyzer, ) -> Result<IndexMap<ModuleSpecifier, Vec<doc::DocNode>>, AnyError> { let source_file_specifier = @@ -65,7 +63,7 @@ async fn generate_doc_nodes_for_builtin_types( .await; let doc_parser = doc::DocParser::new( &graph, - capturing_parser, + parser, doc::DocParserOptions { diagnostics: false, private: doc_flags.private, @@ -80,19 +78,16 @@ pub async fn doc(flags: Flags, doc_flags: DocFlags) -> Result<(), AnyError> { let factory = CliFactory::from_flags(flags).await?; let cli_options = factory.cli_options(); let module_info_cache = factory.module_info_cache()?; - let source_parser = deno_graph::DefaultModuleParser::new_for_analysis(); - let store = DefaultParsedSourceStore::default(); - let analyzer = - module_info_cache.as_module_analyzer(Some(&source_parser), &store); - let capturing_parser = - CapturingModuleParser::new(Some(&source_parser), &store); + let parsed_source_cache = factory.parsed_source_cache(); + let capturing_parser = parsed_source_cache.as_capturing_parser(); + let analyzer = module_info_cache.as_module_analyzer(&capturing_parser); let doc_nodes_by_url = match doc_flags.source_files { DocSourceFileFlag::Builtin => { generate_doc_nodes_for_builtin_types( doc_flags.clone(), cli_options, - capturing_parser, + &capturing_parser, &analyzer, ) .await? @@ -123,14 +118,8 @@ pub async fn doc(flags: Flags, doc_flags: DocFlags) -> Result<(), AnyError> { }, |_, _| true, )?; - let mut loader = module_graph_builder.create_graph_loader(); let graph = module_graph_builder - .create_graph_with_options(CreateGraphOptions { - graph_kind: GraphKind::TypesOnly, - roots: module_specifiers.clone(), - loader: &mut loader, - analyzer: &analyzer, - }) + .create_graph(GraphKind::TypesOnly, module_specifiers.clone()) .await?; if let Some(lockfile) = maybe_lockfile { @@ -139,7 +128,7 @@ pub async fn doc(flags: Flags, doc_flags: DocFlags) -> Result<(), AnyError> { let doc_parser = doc::DocParser::new( &graph, - capturing_parser, + &capturing_parser, doc::DocParserOptions { private: doc_flags.private, diagnostics: doc_flags.lint, @@ -168,7 +157,7 @@ pub async fn doc(flags: Flags, doc_flags: DocFlags) -> Result<(), AnyError> { let deno_ns = generate_doc_nodes_for_builtin_types( doc_flags.clone(), cli_options, - capturing_parser, + &capturing_parser, &analyzer, ) .await?; diff --git a/cli/tools/lint.rs b/cli/tools/lint.rs index a91f14ad8..52890ae24 100644 --- a/cli/tools/lint.rs +++ b/cli/tools/lint.rs @@ -23,6 +23,7 @@ use deno_core::error::AnyError; use deno_core::error::JsStackFrame; use deno_core::serde_json; use deno_lint::diagnostic::LintDiagnostic; +use deno_lint::linter::LintFileOptions; use deno_lint::linter::Linter; use deno_lint::linter::LinterBuilder; use deno_lint::rules; @@ -249,14 +250,10 @@ pub fn print_rules_list(json: bool, maybe_rules_tags: Option<Vec<String>>) { } } -pub fn create_linter( - media_type: MediaType, - rules: Vec<&'static dyn LintRule>, -) -> Linter { +pub fn create_linter(rules: Vec<&'static dyn LintRule>) -> Linter { LinterBuilder::default() .ignore_file_directive("deno-lint-ignore-file") .ignore_diagnostic_directive("deno-lint-ignore") - .media_type(media_type) .rules(rules) .build() } @@ -266,12 +263,16 @@ fn lint_file( source_code: String, lint_rules: Vec<&'static dyn LintRule>, ) -> Result<(Vec<LintDiagnostic>, String), AnyError> { - let file_name = file_path.to_string_lossy().to_string(); + let filename = file_path.to_string_lossy().to_string(); let media_type = MediaType::from_path(file_path); - let linter = create_linter(media_type, lint_rules); + let linter = create_linter(lint_rules); - let (_, file_diagnostics) = linter.lint(file_name, source_code.clone())?; + let (_, file_diagnostics) = linter.lint_file(LintFileOptions { + filename, + media_type, + source_code: source_code.clone(), + })?; Ok((file_diagnostics, source_code)) } @@ -287,10 +288,13 @@ fn lint_stdin( return Err(generic_error("Failed to read from stdin")); } - let linter = create_linter(MediaType::TypeScript, lint_rules); + let linter = create_linter(lint_rules); - let (_, file_diagnostics) = - linter.lint(STDIN_FILE_NAME.to_string(), source_code.clone())?; + let (_, file_diagnostics) = linter.lint_file(LintFileOptions { + filename: STDIN_FILE_NAME.to_string(), + source_code: source_code.clone(), + media_type: MediaType::TypeScript, + })?; Ok((file_diagnostics, source_code)) } diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs index 83cc60dd0..696f5c065 100644 --- a/cli/tools/repl/session.rs +++ b/cli/tools/repl/session.rs @@ -839,7 +839,7 @@ fn analyze_jsx_pragmas( let mut analyzed_pragmas = AnalyzedJsxPragmas::default(); - for c in parsed_source.get_leading_comments().iter() { + for c in parsed_source.get_leading_comments()?.iter() { if c.kind != CommentKind::Block { continue; // invalid } |