development/deno
development/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno synced 2024-10-03 23:03:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(lsp): use CliGraphResolver in documents params (#23499)

Browse source
This commit is contained in:
Nayeem Rahman 2024-04-22 23:55:20 +01:00 committed by GitHub
parent 5990f05360
commit c67c87b2ae
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 69 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

165
cli/lsp/documents.rs
View file

@ -279,6 +279,7 @@ pub struct DocumentOpenData {
#[derive(Debug)] #[derive(Debug)]
pub struct Document { pub struct Document {
/// Contains the last-known-good set of dependencies from parsing the module. /// Contains the last-known-good set of dependencies from parsing the module.
config: Arc<Config>,
dependencies: Arc<IndexMap<String, deno_graph::Dependency>>, dependencies: Arc<IndexMap<String, deno_graph::Dependency>>,
maybe_types_dependency: Option<Arc<deno_graph::TypesDependency>>, maybe_types_dependency: Option<Arc<deno_graph::TypesDependency>>,
maybe_fs_version: Option<String>, maybe_fs_version: Option<String>,
@ -292,6 +293,7 @@ pub struct Document {
media_type: MediaType, media_type: MediaType,
/// Present if and only if this is an open document. /// Present if and only if this is an open document.
open_data: Option<DocumentOpenData>, open_data: Option<DocumentOpenData>,
resolver: Arc<CliGraphResolver>,
specifier: ModuleSpecifier, specifier: ModuleSpecifier,
text_info: SourceTextInfo, text_info: SourceTextInfo,
} }
@ -305,10 +307,9 @@ impl Document {
maybe_lsp_version: Option<i32>, maybe_lsp_version: Option<i32>,
maybe_language_id: Option<LanguageId>, maybe_language_id: Option<LanguageId>,
maybe_headers: Option<HashMap<String, String>>, maybe_headers: Option<HashMap<String, String>>,
resolver: &dyn deno_graph::source::Resolver, resolver: Arc<CliGraphResolver>,
maybe_node_resolver: Option<&CliNodeResolver>, maybe_node_resolver: Option<&CliNodeResolver>,
npm_resolver: &dyn deno_graph::source::NpmResolver, config: Arc<Config>,
config: &Config,
cache: &Arc<dyn HttpCache>, cache: &Arc<dyn HttpCache>,
) -> Arc<Self> { ) -> Arc<Self> {
let text_info = SourceTextInfo::new(content); let text_info = SourceTextInfo::new(content);
@ -325,8 +326,7 @@ impl Document {
text_info.clone(), text_info.clone(),
maybe_headers.as_ref(), maybe_headers.as_ref(),
media_type, media_type,
resolver, &resolver,
npm_resolver,
) )
} else { } else {
(None, None) (None, None)
@ -341,8 +341,9 @@ impl Document {
.and_then(|m| Some(Arc::new(m.maybe_types_dependency.clone()?))); .and_then(|m| Some(Arc::new(m.maybe_types_dependency.clone()?)));
let line_index = Arc::new(LineIndex::new(text_info.text_str())); let line_index = Arc::new(LineIndex::new(text_info.text_str()));
let maybe_test_module_fut = let maybe_test_module_fut =
get_maybe_test_module_fut(maybe_parsed_source.as_ref(), config); get_maybe_test_module_fut(maybe_parsed_source.as_ref(), &config);
Arc::new(Self { Arc::new(Self {
config,
dependencies, dependencies,
maybe_types_dependency, maybe_types_dependency,
maybe_fs_version: calculate_fs_version(cache, &specifier), maybe_fs_version: calculate_fs_version(cache, &specifier),
@ -356,18 +357,20 @@ impl Document {
lsp_version: v, lsp_version: v,
maybe_parsed_source, maybe_parsed_source,
}), }),
text_info, resolver,
specifier, specifier,
text_info,
}) })
} }
fn with_new_resolver( fn with_new_config(
&self, &self,
resolver: &dyn deno_graph::source::Resolver, resolver: Arc<CliGraphResolver>,
maybe_node_resolver: Option<&CliNodeResolver>, maybe_node_resolver: Option<&CliNodeResolver>,
npm_resolver: &dyn deno_graph::source::NpmResolver, config: Arc<Config>,
config: &Config,
) -> Arc<Self> { ) -> Arc<Self> {
let graph_resolver = resolver.as_graph_resolver();
let npm_resolver = resolver.as_graph_npm_resolver();
let media_type = resolve_media_type( let media_type = resolve_media_type(
&self.specifier, &self.specifier,
self.maybe_headers.as_ref(), self.maybe_headers.as_ref(),
@ -385,8 +388,7 @@ impl Document {
&self.specifier, &self.specifier,
&parsed_source_result, &parsed_source_result,
self.maybe_headers.as_ref(), self.maybe_headers.as_ref(),
resolver, &resolver,
npm_resolver,
) )
.ok(); .ok();
dependencies = maybe_module dependencies = maybe_module
@ -398,7 +400,7 @@ impl Document {
.and_then(|m| Some(Arc::new(m.maybe_types_dependency.clone()?))); .and_then(|m| Some(Arc::new(m.maybe_types_dependency.clone()?)));
maybe_parsed_source = Some(parsed_source_result); maybe_parsed_source = Some(parsed_source_result);
maybe_test_module_fut = maybe_test_module_fut =
get_maybe_test_module_fut(maybe_parsed_source.as_ref(), config); get_maybe_test_module_fut(maybe_parsed_source.as_ref(), &config);
} else { } else {
dependencies = Arc::new( dependencies = Arc::new(
self self
@ -407,13 +409,13 @@ impl Document {
.map(|(s, d)| { .map(|(s, d)| {
( (
s.clone(), s.clone(),
d.with_new_resolver(s, Some(resolver), Some(npm_resolver)), d.with_new_resolver(s, Some(graph_resolver), Some(npm_resolver)),
) )
}) })
.collect(), .collect(),
); );
maybe_types_dependency = self.maybe_types_dependency.as_ref().map(|d| { maybe_types_dependency = self.maybe_types_dependency.as_ref().map(|d| {
Arc::new(d.with_new_resolver(Some(resolver), Some(npm_resolver))) Arc::new(d.with_new_resolver(Some(graph_resolver), Some(npm_resolver)))
}); });
maybe_parsed_source = self.maybe_parsed_source(); maybe_parsed_source = self.maybe_parsed_source();
maybe_test_module_fut = self maybe_test_module_fut = self
@ -422,6 +424,7 @@ impl Document {
.filter(|_| config.specifier_enabled_for_test(&self.specifier)); .filter(|_| config.specifier_enabled_for_test(&self.specifier));
} }
Arc::new(Self { Arc::new(Self {
config,
// updated properties // updated properties
dependencies, dependencies,
maybe_types_dependency, maybe_types_dependency,
@ -437,8 +440,9 @@ impl Document {
lsp_version: d.lsp_version, lsp_version: d.lsp_version,
maybe_parsed_source, maybe_parsed_source,
}), }),
text_info: self.text_info.clone(), resolver,
specifier: self.specifier.clone(), specifier: self.specifier.clone(),
text_info: self.text_info.clone(),
}) })
} }
@ -446,9 +450,6 @@ impl Document {
&self, &self,
version: i32, version: i32,
changes: Vec<lsp::TextDocumentContentChangeEvent>, changes: Vec<lsp::TextDocumentContentChangeEvent>,
resolver: &dyn deno_graph::source::Resolver,
npm_resolver: &dyn deno_graph::source::NpmResolver,
config: &Config,
) -> Result<Arc<Self>, AnyError> { ) -> Result<Arc<Self>, AnyError> {
let mut content = self.text_info.text_str().to_string(); let mut content = self.text_info.text_str().to_string();
let mut line_index = self.line_index.clone(); let mut line_index = self.line_index.clone();
@ -479,8 +480,7 @@ impl Document {
text_info.clone(), text_info.clone(),
self.maybe_headers.as_ref(), self.maybe_headers.as_ref(),
media_type, media_type,
resolver, self.resolver.as_ref(),
npm_resolver,
) )
} else { } else {
(None, None) (None, None)
@ -500,8 +500,9 @@ impl Document {
Arc::new(LineIndex::new(text_info.text_str())) Arc::new(LineIndex::new(text_info.text_str()))
}; };
let maybe_test_module_fut = let maybe_test_module_fut =
get_maybe_test_module_fut(maybe_parsed_source.as_ref(), config); get_maybe_test_module_fut(maybe_parsed_source.as_ref(), &self.config);
Ok(Arc::new(Self { Ok(Arc::new(Self {
config: self.config.clone(),
specifier: self.specifier.clone(), specifier: self.specifier.clone(),
maybe_fs_version: self.maybe_fs_version.clone(), maybe_fs_version: self.maybe_fs_version.clone(),
maybe_language_id: self.maybe_language_id, maybe_language_id: self.maybe_language_id,
@ -517,11 +518,13 @@ impl Document {
lsp_version: version, lsp_version: version,
maybe_parsed_source, maybe_parsed_source,
}), }),
resolver: self.resolver.clone(),
})) }))
} }
pub fn closed(&self, cache: &Arc<dyn HttpCache>) -> Arc<Self> { pub fn closed(&self, cache: &Arc<dyn HttpCache>) -> Arc<Self> {
Arc::new(Self { Arc::new(Self {
config: self.config.clone(),
specifier: self.specifier.clone(), specifier: self.specifier.clone(),
maybe_fs_version: calculate_fs_version(cache, &self.specifier), maybe_fs_version: calculate_fs_version(cache, &self.specifier),
maybe_language_id: self.maybe_language_id, maybe_language_id: self.maybe_language_id,
@ -536,11 +539,13 @@ impl Document {
maybe_test_module_fut: self.maybe_test_module_fut.clone(), maybe_test_module_fut: self.maybe_test_module_fut.clone(),
media_type: self.media_type, media_type: self.media_type,
open_data: None, open_data: None,
resolver: self.resolver.clone(),
}) })
} }
pub fn saved(&self, cache: &Arc<dyn HttpCache>) -> Arc<Self> { pub fn saved(&self, cache: &Arc<dyn HttpCache>) -> Arc<Self> {
Arc::new(Self { Arc::new(Self {
config: self.config.clone(),
specifier: self.specifier.clone(), specifier: self.specifier.clone(),
maybe_fs_version: calculate_fs_version(cache, &self.specifier), maybe_fs_version: calculate_fs_version(cache, &self.specifier),
maybe_language_id: self.maybe_language_id, maybe_language_id: self.maybe_language_id,
@ -555,6 +560,7 @@ impl Document {
maybe_test_module_fut: self.maybe_test_module_fut.clone(), maybe_test_module_fut: self.maybe_test_module_fut.clone(),
media_type: self.media_type, media_type: self.media_type,
open_data: self.open_data.clone(), open_data: self.open_data.clone(),
resolver: self.resolver.clone(),
}) })
} }
@ -777,12 +783,11 @@ struct FileSystemDocuments {
impl FileSystemDocuments { impl FileSystemDocuments {
pub fn get( pub fn get(
&self, &self,
cache: &Arc<dyn HttpCache>,
resolver: &dyn deno_graph::source::Resolver,
specifier: &ModuleSpecifier, specifier: &ModuleSpecifier,
resolver: &Arc<CliGraphResolver>,
maybe_node_resolver: Option<&CliNodeResolver>, maybe_node_resolver: Option<&CliNodeResolver>,
npm_resolver: &dyn deno_graph::source::NpmResolver, config: &Arc<Config>,
config: &Config, cache: &Arc<dyn HttpCache>,
) -> Option<Arc<Document>> { ) -> Option<Arc<Document>> {
let new_fs_version = calculate_fs_version(cache, specifier); let new_fs_version = calculate_fs_version(cache, specifier);
let old_doc = self.docs.get(specifier).map(|v| v.value().clone()); let old_doc = self.docs.get(specifier).map(|v| v.value().clone());
@ -800,12 +805,11 @@ impl FileSystemDocuments {
if dirty { if dirty {
// attempt to update the file on the file system // attempt to update the file on the file system
self.refresh_document( self.refresh_document(
cache,
resolver,
specifier, specifier,
resolver,
maybe_node_resolver, maybe_node_resolver,
npm_resolver,
config, config,
cache,
) )
} else { } else {
old_doc old_doc
@ -816,12 +820,11 @@ impl FileSystemDocuments {
/// returning the document. /// returning the document.
fn refresh_document( fn refresh_document(
&self, &self,
cache: &Arc<dyn HttpCache>,
resolver: &dyn deno_graph::source::Resolver,
specifier: &ModuleSpecifier, specifier: &ModuleSpecifier,
resolver: &Arc<CliGraphResolver>,
maybe_node_resolver: Option<&CliNodeResolver>, maybe_node_resolver: Option<&CliNodeResolver>,
npm_resolver: &dyn deno_graph::source::NpmResolver, config: &Arc<Config>,
config: &Config, cache: &Arc<dyn HttpCache>,
) -> Option<Arc<Document>> { ) -> Option<Arc<Document>> {
let doc = if specifier.scheme() == "file" { let doc = if specifier.scheme() == "file" {
let path = specifier_to_file_path(specifier).ok()?; let path = specifier_to_file_path(specifier).ok()?;
@ -834,10 +837,9 @@ impl FileSystemDocuments {
None, None,
None, None,
None, None,
resolver, resolver.clone(),
maybe_node_resolver, maybe_node_resolver,
npm_resolver, config.clone(),
config,
cache, cache,
) )
} else if specifier.scheme() == "data" { } else if specifier.scheme() == "data" {
@ -851,10 +853,9 @@ impl FileSystemDocuments {
None, None,
None, None,
None, None,
resolver, resolver.clone(),
maybe_node_resolver, maybe_node_resolver,
npm_resolver, config.clone(),
config,
cache, cache,
) )
} else { } else {
@ -881,10 +882,9 @@ impl FileSystemDocuments {
None, None,
None, None,
maybe_headers, maybe_headers,
resolver, resolver.clone(),
maybe_node_resolver, maybe_node_resolver,
npm_resolver, config.clone(),
config,
cache, cache,
) )
}; };
@ -1002,8 +1002,6 @@ impl Documents {
language_id: LanguageId, language_id: LanguageId,
content: Arc<str>, content: Arc<str>,
) -> Arc<Document> { ) -> Arc<Document> {
let resolver = self.get_resolver();
let npm_resolver = self.get_npm_resolver();
let document = Document::new( let document = Document::new(
specifier.clone(), specifier.clone(),
content, content,
@ -1013,10 +1011,9 @@ impl Documents {
// the cache for remote modules here in order to get the // the cache for remote modules here in order to get the
// x-typescript-types? // x-typescript-types?
None, None,
resolver, self.resolver.clone(),
self.maybe_node_resolver.as_deref(), self.maybe_node_resolver.as_deref(),
npm_resolver, self.config.clone(),
self.config.as_ref(),
&self.cache, &self.cache,
); );
@ -1048,13 +1045,7 @@ impl Documents {
)) ))
})?; })?;
self.dirty = true; self.dirty = true;
let doc = doc.with_change( let doc = doc.with_change(version, changes)?;
version,
changes,
self.get_resolver(),
self.get_npm_resolver(),
self.config.as_ref(),
)?;
self.open_docs.insert(doc.specifier().clone(), doc.clone()); self.open_docs.insert(doc.specifier().clone(), doc.clone());
Ok(doc) Ok(doc)
} }
@ -1101,7 +1092,8 @@ impl Documents {
referrer: &ModuleSpecifier, referrer: &ModuleSpecifier,
) -> bool { ) -> bool {
let maybe_specifier = self let maybe_specifier = self
.get_resolver() .resolver
.as_graph_resolver()
.resolve( .resolve(
specifier, specifier,
&deno_graph::Range { &deno_graph::Range {
@ -1214,12 +1206,11 @@ impl Documents {
Some(document.clone()) Some(document.clone())
} else { } else {
self.file_system_docs.get( self.file_system_docs.get(
&self.cache,
self.get_resolver(),
&specifier, &specifier,
&self.resolver,
self.maybe_node_resolver.as_deref(), self.maybe_node_resolver.as_deref(),
self.get_npm_resolver(), &self.config,
self.config.as_ref(), &self.cache,
) )
} }
} }
@ -1333,7 +1324,7 @@ impl Documents {
maybe_npm, maybe_npm,
referrer, referrer,
)); ));
} else if let Ok(specifier) = self.get_resolver().resolve( } else if let Ok(specifier) = self.resolver.as_graph_resolver().resolve(
specifier, specifier,
&deno_graph::Range { &deno_graph::Range {
specifier: referrer.clone(), specifier: referrer.clone(),
@ -1408,7 +1399,7 @@ impl Documents {
self.lockfile = config.tree.root_lockfile().cloned(); self.lockfile = config.tree.root_lockfile().cloned();
self.redirect_resolver = self.redirect_resolver =
Arc::new(RedirectResolver::new(self.cache.clone())); Arc::new(RedirectResolver::new(self.cache.clone()));
let resolver = self.resolver.as_graph_resolver(); let graph_resolver = self.resolver.as_graph_resolver();
let npm_resolver = self.resolver.as_graph_npm_resolver(); let npm_resolver = self.resolver.as_graph_npm_resolver();
self.imports = Arc::new( self.imports = Arc::new(
if let Some(Ok(imports)) = config_file.map(|cf| cf.to_maybe_imports()) { if let Some(Ok(imports)) = config_file.map(|cf| cf.to_maybe_imports()) {
@ -1418,7 +1409,7 @@ impl Documents {
let graph_import = GraphImport::new( let graph_import = GraphImport::new(
&referrer, &referrer,
imports, imports,
Some(resolver), Some(graph_resolver),
Some(npm_resolver), Some(npm_resolver),
); );
(referrer, graph_import) (referrer, graph_import)
@ -1450,22 +1441,20 @@ impl Documents {
if !config.specifier_enabled(doc.specifier()) { if !config.specifier_enabled(doc.specifier()) {
continue; continue;
} }
*doc = doc.with_new_resolver( *doc = doc.with_new_config(
resolver, self.resolver.clone(),
self.maybe_node_resolver.as_deref(), self.maybe_node_resolver.as_deref(),
npm_resolver, self.config.clone(),
self.config.as_ref(),
); );
} }
for mut doc in self.file_system_docs.docs.iter_mut() { for mut doc in self.file_system_docs.docs.iter_mut() {
if !config.specifier_enabled(doc.specifier()) { if !config.specifier_enabled(doc.specifier()) {
continue; continue;
} }
*doc.value_mut() = doc.with_new_resolver( *doc.value_mut() = doc.with_new_config(
resolver, self.resolver.clone(),
self.maybe_node_resolver.as_deref(), self.maybe_node_resolver.as_deref(),
npm_resolver, self.config.clone(),
self.config.as_ref(),
); );
} }
self.open_docs = open_docs; self.open_docs = open_docs;
@ -1482,12 +1471,11 @@ impl Documents {
&& !fs_docs.docs.contains_key(specifier) && !fs_docs.docs.contains_key(specifier)
{ {
fs_docs.refresh_document( fs_docs.refresh_document(
&self.cache,
resolver,
specifier, specifier,
&self.resolver,
self.maybe_node_resolver.as_deref(), self.maybe_node_resolver.as_deref(),
npm_resolver, &self.config,
self.config.as_ref(), &self.cache,
); );
} }
} }
@ -1564,14 +1552,6 @@ impl Documents {
self.dirty = false; self.dirty = false;
} }
fn get_resolver(&self) -> &dyn deno_graph::source::Resolver {
self.resolver.as_graph_resolver()
}
fn get_npm_resolver(&self) -> &dyn deno_graph::source::NpmResolver {
self.resolver.as_graph_npm_resolver()
}
fn resolve_dependency( fn resolve_dependency(
&self, &self,
specifier: &ModuleSpecifier, specifier: &ModuleSpecifier,
@ -1726,17 +1706,11 @@ fn parse_and_analyze_module(
text_info: SourceTextInfo, text_info: SourceTextInfo,
maybe_headers: Option<&HashMap<String, String>>, maybe_headers: Option<&HashMap<String, String>>,
media_type: MediaType, media_type: MediaType,
resolver: &dyn deno_graph::source::Resolver, resolver: &CliGraphResolver,
npm_resolver: &dyn deno_graph::source::NpmResolver,
) -> (Option<ParsedSourceResult>, Option<ModuleResult>) { ) -> (Option<ParsedSourceResult>, Option<ModuleResult>) {
let parsed_source_result = parse_source(specifier, text_info, media_type); let parsed_source_result = parse_source(specifier, text_info, media_type);
let module_result = analyze_module( let module_result =
specifier, analyze_module(specifier, &parsed_source_result, maybe_headers, resolver);
&parsed_source_result,
maybe_headers,
resolver,
npm_resolver,
);
(Some(parsed_source_result), Some(module_result)) (Some(parsed_source_result), Some(module_result))
} }
@ -1759,8 +1733,7 @@ fn analyze_module(
specifier: &ModuleSpecifier, specifier: &ModuleSpecifier,
parsed_source_result: &ParsedSourceResult, parsed_source_result: &ParsedSourceResult,
maybe_headers: Option<&HashMap<String, String>>, maybe_headers: Option<&HashMap<String, String>>,
resolver: &dyn deno_graph::source::Resolver, resolver: &CliGraphResolver,
npm_resolver: &dyn deno_graph::source::NpmResolver,
) -> ModuleResult { ) -> ModuleResult {
match parsed_source_result { match parsed_source_result {
Ok(parsed_source) => Ok(deno_graph::parse_module_from_ast( Ok(parsed_source) => Ok(deno_graph::parse_module_from_ast(
@ -1772,8 +1745,8 @@ fn analyze_module(
// use a null file system because there's no need to bother resolving // use a null file system because there's no need to bother resolving
// dynamic imports like import(`./dir/${something}`) in the LSP // dynamic imports like import(`./dir/${something}`) in the LSP
file_system: &deno_graph::source::NullFileSystem, file_system: &deno_graph::source::NullFileSystem,
maybe_resolver: Some(resolver), maybe_resolver: Some(resolver.as_graph_resolver()),
maybe_npm_resolver: Some(npm_resolver), maybe_npm_resolver: Some(resolver.as_graph_npm_resolver()),
}, },
)), )),
Err(err) => Err(deno_graph::ModuleGraphError::ModuleError( Err(err) => Err(deno_graph::ModuleGraphError::ModuleError(