language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-08-27 22:14:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
deno/cli/lsp/documents.rs

2114 lines
59 KiB
Rust
Raw Permalink Blame History

// Copyright 2018-2025 the Deno authors. MIT license.
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::collections::HashMap;
use std::collections::HashSet;
use std::fs;
use std::future::Future;
use std::ops::Range;
use std::path::PathBuf;
use std::pin::Pin;
use std::str::FromStr;
use std::sync::Arc;
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_core::error::AnyError;
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;
use deno_runtime::deno_node;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;
use deno_semver::package::PackageReq;
use indexmap::IndexMap;
use indexmap::IndexSet;
use lsp_types::Uri;
use node_resolver::cache::NodeResolutionThreadLocalCache;
use node_resolver::NodeResolutionKind;
use node_resolver::ResolutionMode;
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::config::Config;
use super::logging::lsp_warn;
use super::resolver::LspResolver;
use super::resolver::ScopeDepInfo;
use super::resolver::SingleReferrerGraphResolver;
use super::testing::TestCollector;
use super::testing::TestModule;
use super::text::LineIndex;
use super::tsc::NavigationTree;
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)]
pub struct OpenDocument {
pub uri: Arc<Uri>,
pub text: Arc<str>,
pub line_index: Arc<LineIndex>,
pub version: i32,
pub language_id: LanguageId,
pub fs_version_on_open: Option<String>,
}
impl OpenDocument {
fn new(
uri: Uri,
version: i32,
language_id: LanguageId,
text: Arc<str>,
) -> Self {
let line_index = Arc::new(LineIndex::new(&text));
let fs_version_on_open = uri_to_file_path(&uri)
.ok()
.and_then(calculate_fs_version_at_path);
OpenDocument {
uri: Arc::new(uri),
text,
line_index,
version,
language_id,
fs_version_on_open,
}
}
fn with_change(
&self,
version: i32,
changes: Vec<lsp::TextDocumentContentChangeEvent>,
) -> Result<Self, AnyError> {
let mut text = self.text.to_string();
let mut line_index = self.line_index.clone();
let mut index_valid = IndexValid::All;
for change in changes {
if let Some(range) = change.range {
if !index_valid.covers(range.start.line) {
line_index = Arc::new(LineIndex::new(&text));
}
index_valid = IndexValid::UpTo(range.start.line);
let range = line_index.get_text_range(range)?;
text.replace_range(Range::<usize>::from(range), &change.text);
} else {
text = change.text;
index_valid = IndexValid::UpTo(0);
}
}
let text: Arc<str> = text.into();
let line_index = if index_valid == IndexValid::All {
line_index
} else {
Arc::new(LineIndex::new(&text))
};
Ok(OpenDocument {
uri: self.uri.clone(),
text,
line_index,
version,
language_id: self.language_id,
fs_version_on_open: self.fs_version_on_open.clone(),
})
}
pub fn is_diagnosable(&self) -> bool {
self.language_id.is_diagnosable()
}
pub fn is_file_like(&self) -> bool {
uri_is_file_like(&self.uri)
}
pub fn script_version(&self) -> String {
let fs_version = self.fs_version_on_open.as_deref().unwrap_or("1");
format!("{fs_version}+{}", self.version)
}
}
fn remote_url_to_uri(url: &Url) -> Option<Uri> {
if !matches!(url.scheme(), "http" | "https") {
return None;
}
let mut string = String::with_capacity(url.as_str().len() + 6);
string.push_str("deno:/");
string.push_str(url.scheme());
for p in url[Position::BeforeHost..].split('/') {
string.push('/');
string.push_str(
&percent_encoding::utf8_percent_encode(p, COMPONENT).to_string(),
);
}
Uri::from_str(&string)
.inspect_err(|err| {
lsp_warn!("Couldn't convert remote URL \"{url}\" to URI: {err}")
})
.ok()
}
fn asset_url_to_uri(url: &Url) -> Option<Uri> {
if url.scheme() != "asset" {
return None;
}
Uri::from_str(&format!("deno:/asset{}", url.path()))
.inspect_err(|err| {
lsp_warn!("Couldn't convert asset URL \"{url}\" to URI: {err}")
})
.ok()
}
fn data_url_to_uri(url: &Url) -> Option<Uri> {
let data_url = deno_media_type::data_url::RawDataUrl::parse(url).ok()?;
let media_type = data_url.media_type();
let extension = if media_type == MediaType::Unknown {
""
} else {
media_type.as_ts_extension()
};
let mut file_name_str = url.path().to_string();
if let Some(query) = url.query() {
file_name_str.push('?');
file_name_str.push_str(query);
}
let hash = deno_lib::util::checksum::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}")
})
.ok()
}
#[derive(Debug, Clone)]
pub enum DocumentText {
Static(&'static str),
Arc(Arc<str>),
}
impl DocumentText {
/// Will clone the string if static.
pub fn to_arc(&self) -> Arc<str> {
match self {
Self::Static(s) => (*s).into(),
Self::Arc(s) => s.clone(),
}
}
}
impl std::ops::Deref for DocumentText {
type Target = str;
fn deref(&self) -> &Self::Target {
match self {
Self::Static(s) => s,
Self::Arc(s) => s,
}
}
}
impl Serialize for DocumentText {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
(self as &str).serialize(serializer)
}
}
#[derive(Debug, Clone)]
pub enum ServerDocumentKind {
Fs {
fs_version: String,
text: Arc<str>,
},
RemoteUrl {
url: Arc<Url>,
fs_cache_version: String,
text: Arc<str>,
},
DataUrl {
url: Arc<Url>,
text: Arc<str>,
},
Asset {
url: Arc<Url>,
text: &'static str,
},
}
#[derive(Debug)]
pub struct ServerDocument {
pub uri: Arc<Uri>,
pub media_type: MediaType,
pub line_index: Arc<LineIndex>,
pub kind: ServerDocumentKind,
}
impl ServerDocument {
fn load(uri: &Uri) -> Option<Self> {
let scheme = uri.scheme()?;
if scheme.eq_lowercase("file") {
let url = uri_to_url(uri);
let path = url_to_file_path(&url).ok()?;
let bytes = fs::read(&path).ok()?;
let media_type = MediaType::from_specifier(&url);
let text: Arc<str> =
bytes_to_content(&url, media_type, bytes, None).ok()?.into();
let fs_version = calculate_fs_version_at_path(&path)?;
let line_index = Arc::new(LineIndex::new(&text));
return Some(Self {
uri: Arc::new(uri.clone()),
media_type,
line_index,
kind: ServerDocumentKind::Fs { fs_version, text },
});
}
None
}
fn remote_url(
uri: &Uri,
url: Arc<Url>,
scope: Option<&Url>,
cache: &LspCache,
) -> Option<Self> {
let media_type = MediaType::from_specifier(&url);
let http_cache = cache.for_specifier(scope);
let cache_key = http_cache.cache_item_key(&url).ok()?;
let cache_entry = http_cache.get(&cache_key, None).ok()??;
let (_, maybe_charset) =
deno_graph::source::resolve_media_type_and_charset_from_headers(
&url,
Some(&cache_entry.metadata.headers),
);
let fs_cache_version = (|| {
let modified = http_cache.read_modified_time(&cache_key).ok()??;
let duration = modified.duration_since(SystemTime::UNIX_EPOCH).ok()?;
Some(duration.as_millis().to_string())
})()
.unwrap_or_else(|| "1".to_string());
let text: Arc<str> = bytes_to_content(
&url,
media_type,
cache_entry.content.into_owned(),
maybe_charset,
)
.ok()?
.into();
let line_index = Arc::new(LineIndex::new(&text));
Some(Self {
uri: Arc::new(uri.clone()),
media_type,
line_index,
kind: ServerDocumentKind::RemoteUrl {
url,
fs_cache_version,
text,
},
})
}
fn asset(name: &str, text: &'static str) -> Self {
let url = Arc::new(Url::parse(&format!("asset:///{name}")).unwrap());
let uri = asset_url_to_uri(&url).unwrap();
let media_type = MediaType::from_specifier(&url);
let line_index = Arc::new(LineIndex::new(text));
Self {
uri: Arc::new(uri),
media_type,
line_index,
kind: ServerDocumentKind::Asset { url, text },
}
}
fn data_url(uri: &Uri, url: Arc<Url>) -> Option<Self> {
let raw_data_url =
deno_media_type::data_url::RawDataUrl::parse(&url).ok()?;
let media_type = raw_data_url.media_type();
let text: Arc<str> = raw_data_url.decode().ok()?.into();
let line_index = Arc::new(LineIndex::new(&text));
Some(Self {
uri: Arc::new(uri.clone()),
media_type,
line_index,
kind: ServerDocumentKind::DataUrl { url, text },
})
}
pub fn text(&self) -> DocumentText {
match &self.kind {
ServerDocumentKind::Fs { text, .. } => DocumentText::Arc(text.clone()),
ServerDocumentKind::RemoteUrl { text, .. } => {
DocumentText::Arc(text.clone())
}
ServerDocumentKind::DataUrl { text, .. } => {
DocumentText::Arc(text.clone())
}
ServerDocumentKind::Asset { text, .. } => DocumentText::Static(text),
}
}
pub fn is_diagnosable(&self) -> bool {
media_type_is_diagnosable(self.media_type)
}
pub fn is_file_like(&self) -> bool {
uri_is_file_like(&self.uri)
}
pub fn script_version(&self) -> String {
match &self.kind {
ServerDocumentKind::Fs { fs_version, .. } => fs_version.clone(),
ServerDocumentKind::RemoteUrl {
fs_cache_version, ..
} => fs_cache_version.clone(),
ServerDocumentKind::DataUrl { .. } => "1".to_string(),
ServerDocumentKind::Asset { .. } => "1".to_string(),
}
}
}
#[derive(Debug)]
pub struct AssetDocuments {
inner: HashMap<Arc<Uri>, Arc<ServerDocument>>,
}
impl AssetDocuments {
pub fn get(&self, k: &Uri) -> Option<&Arc<ServerDocument>> {
self.inner.get(k)
}
}
pub static ASSET_DOCUMENTS: Lazy<AssetDocuments> =
Lazy::new(|| AssetDocuments {
inner: crate::tsc::LAZILY_LOADED_STATIC_ASSETS
.iter()
.map(|(k, v)| {
let doc = Arc::new(ServerDocument::asset(k, v.as_str()));
let uri = doc.uri.clone();
(uri, doc)
})
.collect(),
});
#[derive(Debug, Clone)]
pub enum Document {
Open(Arc<OpenDocument>),
Server(Arc<ServerDocument>),
}
impl Document {
pub fn open(&self) -> Option<&Arc<OpenDocument>> {
match self {
Self::Open(d) => Some(d),
Self::Server(_) => None,
}
}
pub fn server(&self) -> Option<&Arc<ServerDocument>> {
match self {
Self::Open(_) => None,
Self::Server(d) => Some(d),
}
}
pub fn uri(&self) -> &Arc<Uri> {
match self {
Self::Open(d) => &d.uri,
Self::Server(d) => &d.uri,
}
}
pub fn text(&self) -> DocumentText {
match self {
Self::Open(d) => DocumentText::Arc(d.text.clone()),
Self::Server(d) => d.text(),
}
}
pub fn line_index(&self) -> &Arc<LineIndex> {
match self {
Self::Open(d) => &d.line_index,
Self::Server(d) => &d.line_index,
}
}
pub fn script_version(&self) -> String {
match self {
Self::Open(d) => d.script_version(),
Self::Server(d) => d.script_version(),
}
}
pub fn is_diagnosable(&self) -> bool {
match self {
Self::Open(d) => d.is_diagnosable(),
Self::Server(d) => d.is_diagnosable(),
}
}
pub fn is_file_like(&self) -> bool {
match self {
Self::Open(d) => d.is_file_like(),
Self::Server(d) => d.is_file_like(),
}
}
}
#[derive(Debug, Default, Clone)]
pub struct Documents {
open: IndexMap<Uri, Arc<OpenDocument>>,
server: Arc<DashMap<Uri, Arc<ServerDocument>>>,
file_like_uris_by_url: Arc<DashMap<Url, Arc<Uri>>>,
/// These URLs can not be recovered from the URIs we assign them without these
/// maps. We want to be able to discard old documents from here but keep these
/// mappings.
data_urls_by_uri: Arc<DashMap<Uri, Arc<Url>>>,
remote_urls_by_uri: Arc<DashMap<Uri, Arc<Url>>>,
}
impl Documents {
pub fn open(
&mut self,
uri: Uri,
version: i32,
language_id: LanguageId,
text: Arc<str>,
) -> Arc<OpenDocument> {
self.server.remove(&uri);
let doc =
Arc::new(OpenDocument::new(uri.clone(), version, language_id, text));
self.open.insert(uri, doc.clone());
if !doc.uri.scheme().is_some_and(|s| s.eq_lowercase("file")) {
let url = uri_to_url(&doc.uri);
if url.scheme() == "file" {
self.file_like_uris_by_url.insert(url, doc.uri.clone());
}
}
doc
}
pub fn change(
&mut self,
uri: &Uri,
version: i32,
changes: Vec<lsp::TextDocumentContentChangeEvent>,
) -> Result<Arc<OpenDocument>, AnyError> {
let Some((uri, doc)) = self.open.shift_remove_entry(uri) else {
return Err(
JsErrorBox::new(
"NotFound",
format!(
"The URI \"{}\" does not refer to an open document.",
uri.as_str()
),
)
.into(),
);
};
let doc = Arc::new(doc.with_change(version, changes)?);
self.open.insert(uri, doc.clone());
Ok(doc)
}
pub fn close(&mut self, uri: &Uri) -> Result<Arc<OpenDocument>, AnyError> {
self.file_like_uris_by_url.retain(|_, u| u.as_ref() != uri);
self.open.shift_remove(uri).ok_or_else(|| {
JsErrorBox::new(
"NotFound",
format!(
"The URI \"{}\" does not refer to an open document.",
uri.as_str()
),
)
.into()
})
}
pub fn get(&self, uri: &Uri) -> Option<Document> {
if let Some(doc) = self.open.get(uri) {
return Some(Document::Open(doc.clone()));
}
if let Some(doc) = ASSET_DOCUMENTS.get(uri) {
return Some(Document::Server(doc.clone()));
}
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 = Arc::new(doc);
self.server.insert(uri.clone(), doc.clone());
Some(Document::Server(doc))
}
/// This will not create any server entries, only retrieve existing entries.
pub fn inspect(&self, uri: &Uri) -> Option<Document> {
if let Some(doc) = self.open.get(uri) {
return Some(Document::Open(doc.clone()));
}
if let Some(doc) = self.server.get(uri) {
return Some(Document::Server(doc.clone()));
}
None
}
pub fn get_for_specifier(
&self,
specifier: &Url,
scope: Option<&Url>,
cache: &LspCache,
) -> Option<Document> {
let scheme = specifier.scheme();
if scheme == "file" {
let uri = self
.file_like_uris_by_url
.get(specifier)
.map(|e| e.value().clone())
.or_else(|| url_to_uri(specifier).ok().map(Arc::new))?;
self.get(&uri)
} else if scheme == "asset" {
let uri = asset_url_to_uri(specifier)?;
self.get(&uri)
} else if scheme == "http" || scheme == "https" {
if let Some(vendored_specifier) =
cache.vendored_specifier(specifier, scope)
{
let uri = url_to_uri(&vendored_specifier).ok()?;
self.get(&uri)
} else {
let uri = remote_url_to_uri(specifier)?;
if let Some(doc) = self.server.get(&uri) {
return Some(Document::Server(doc.clone()));
}
let url = Arc::new(specifier.clone());
self.remote_urls_by_uri.insert(uri.clone(), url.clone());
let doc =
Arc::new(ServerDocument::remote_url(&uri, url, scope, cache)?);
self.server.insert(uri, doc.clone());
Some(Document::Server(doc))
}
} else if scheme == "data" {
let uri = data_url_to_uri(specifier)?;
if let Some(doc) = self.server.get(&uri) {
return Some(Document::Server(doc.clone()));
}
let url = Arc::new(specifier.clone());
self.data_urls_by_uri.insert(uri.clone(), url.clone());
let doc = Arc::new(ServerDocument::data_url(&uri, url)?);
self.server.insert(uri, doc.clone());
Some(Document::Server(doc))
} else {
None
}
}
pub fn open_docs(&self) -> impl Iterator<Item = &Arc<OpenDocument>> {
self.open.values()
}
pub fn server_docs(&self) -> Vec<Arc<ServerDocument>> {
self.server.iter().map(|e| e.value().clone()).collect()
}
pub fn docs(&self) -> Vec<Document> {
self
.open
.values()
.map(|d| Document::Open(d.clone()))
.chain(
self
.server
.iter()
.map(|e| Document::Server(e.value().clone())),
)
.collect()
}
pub fn filtered_docs(
&self,
predicate: impl FnMut(&Document) -> bool,
) -> Vec<Document> {
self
.open
.values()
.map(|d| Document::Open(d.clone()))
.chain(
self
.server
.iter()
.map(|e| Document::Server(e.value().clone())),
)
.filter(predicate)
.collect()
}
pub fn remove_server_doc(&self, uri: &Uri) {
self.server.remove(uri);
}
}
#[derive(Debug)]
pub struct DocumentModuleOpenData {
pub version: i32,
pub parsed_source: Option<ParsedSourceResult>,
}
#[derive(Debug)]
pub struct DocumentModule {
pub uri: Arc<Uri>,
pub open_data: Option<DocumentModuleOpenData>,
pub script_version: String,
pub specifier: Arc<Url>,
pub scope: Option<Arc<Url>>,
pub media_type: MediaType,
pub headers: Option<HashMap<String, String>>,
pub text: DocumentText,
pub line_index: Arc<LineIndex>,
pub resolution_mode: ResolutionMode,
pub dependencies: Arc<IndexMap<String, deno_graph::Dependency>>,
pub types_dependency: Option<Arc<TypesDependency>>,
pub navigation_tree: tokio::sync::OnceCell<Arc<NavigationTree>>,
pub semantic_tokens_full: tokio::sync::OnceCell<lsp::SemanticTokens>,
text_info_cell: once_cell::sync::OnceCell<SourceTextInfo>,
test_module_fut: Option<TestModuleFut>,
}
impl DocumentModule {
pub fn new(
document: &Document,
specifier: Arc<Url>,
scope: Option<Arc<Url>>,
resolver: &LspResolver,
config: &Config,
cache: &LspCache,
) -> Self {
let text = document.text();
let headers = matches!(specifier.scheme(), "http" | "https")
.then(|| {
let http_cache = cache.for_specifier(scope.as_deref());
let cache_key = http_cache.cache_item_key(&specifier).ok()?;
let cache_entry = http_cache.get(&cache_key, None).ok()??;
Some(cache_entry.metadata.headers)
})
.flatten();
let media_type = resolve_media_type(
&specifier,
headers.as_ref(),
document.open().map(|d| d.language_id),
);
let (parsed_source, maybe_module, resolution_mode) =
if media_type_is_diagnosable(media_type) {
parse_and_analyze_module(
specifier.as_ref().clone(),
text.to_arc(),
headers.as_ref(),
media_type,
scope.as_deref(),
resolver,
)
} else {
(None, None, ResolutionMode::Import)
};
let maybe_module = maybe_module.and_then(Result::ok);
let dependencies = maybe_module
.as_ref()
.map(|m| Arc::new(m.dependencies.clone()))
.unwrap_or_default();
let types_dependency = maybe_module
.as_ref()
.and_then(|m| Some(Arc::new(m.maybe_types_dependency.clone()?)));
let test_module_fut =
get_maybe_test_module_fut(parsed_source.as_ref(), config);
DocumentModule {
uri: document.uri().clone(),
open_data: document.open().map(|d| DocumentModuleOpenData {
version: d.version,
parsed_source,
}),
script_version: document.script_version(),
specifier,
scope,
media_type,
headers,
text,
line_index: document.line_index().clone(),
resolution_mode,
dependencies,
types_dependency,
navigation_tree: Default::default(),
semantic_tokens_full: Default::default(),
text_info_cell: Default::default(),
test_module_fut,
}
}
pub fn is_diagnosable(&self) -> bool {
media_type_is_diagnosable(self.media_type)
}
pub fn dependency_at_position(
&self,
position: &lsp::Position,
) -> Option<(&str, &deno_graph::Dependency, &deno_graph::Range)> {
let position = deno_graph::Position {
line: position.line as usize,
character: position.character as usize,
};
self
.dependencies
.iter()
.find_map(|(s, dep)| dep.includes(position).map(|r| (s.as_str(), dep, r)))
}
pub fn text_info(&self) -> &SourceTextInfo {
// try to get the text info from the parsed source and if
// not then create one in the cell
self
.open_data
.as_ref()
.and_then(|d| d.parsed_source.as_ref())
.and_then(|p| p.as_ref().ok())
.map(|p| p.text_info_lazy())
.unwrap_or_else(|| {
self
.text_info_cell
.get_or_init(|| SourceTextInfo::new(self.text.to_arc()))
})
}
pub async fn test_module(&self) -> Option<Arc<TestModule>> {
self.test_module_fut.clone()?.await
}
}
type DepInfoByScope = BTreeMap<Option<Arc<Url>>, Arc<ScopeDepInfo>>;
#[derive(Debug, Default)]
struct WeakDocumentModuleMap {
open: RwLock<PtrWeakKeyHashMap<Weak<OpenDocument>, Arc<DocumentModule>>>,
server: RwLock<PtrWeakKeyHashMap<Weak<ServerDocument>, Arc<DocumentModule>>>,
by_specifier: RwLock<WeakValueHashMap<Arc<Url>, Weak<DocumentModule>>>,
}
impl WeakDocumentModuleMap {
fn get(&self, document: &Document) -> Option<Arc<DocumentModule>> {
match document {
Document::Open(d) => self.open.read().get(d).cloned(),
Document::Server(d) => self.server.read().get(d).cloned(),
}
}
fn get_for_specifier(&self, specifier: &Url) -> Option<Arc<DocumentModule>> {
self.by_specifier.read().get(specifier)
}
fn contains_specifier(&self, specifier: &Url) -> bool {
self.by_specifier.read().contains_key(specifier)
}
fn inspect_values(&self) -> Vec<Arc<DocumentModule>> {
self
.open
.read()
.values()
.cloned()
.chain(self.server.read().values().cloned())
.collect()
}
fn insert(
&self,
document: &Document,
module: Arc<DocumentModule>,
) -> Option<Arc<DocumentModule>> {
match document {
Document::Open(d) => {
self.open.write().insert(d.clone(), module.clone());
}
Document::Server(d) => {
self.server.write().insert(d.clone(), module.clone());
}
}
self
.by_specifier
.write()
.insert(module.specifier.clone(), module.clone());
Some(module)
}
fn remove_expired(&self) {
// IMPORTANT: Maintain this order based on weak ref relations.
self.open.write().remove_expired();
self.server.write().remove_expired();
self.by_specifier.write().remove_expired();
}
}
#[derive(Debug, Default, Clone)]
pub struct DocumentModules {
pub documents: Documents,
config: Arc<Config>,
resolver: Arc<LspResolver>,
cache: Arc<LspCache>,
workspace_files: Arc<IndexSet<PathBuf>>,
dep_info_by_scope: once_cell::sync::OnceCell<Arc<DepInfoByScope>>,
modules_unscoped: Arc<WeakDocumentModuleMap>,
modules_by_scope: Arc<BTreeMap<Arc<Url>, Arc<WeakDocumentModuleMap>>>,
}
impl DocumentModules {
pub fn update_config(
&mut self,
config: &Config,
resolver: &Arc<LspResolver>,
cache: &LspCache,
workspace_files: &Arc<IndexSet<PathBuf>>,
) {
self.config = Arc::new(config.clone());
self.cache = Arc::new(cache.clone());
self.resolver = resolver.clone();
self.workspace_files = workspace_files.clone();
self.modules_unscoped = Default::default();
self.modules_by_scope = Arc::new(
self
.config
.tree
.data_by_scope()
.keys()
.map(|s| (s.clone(), Default::default()))
.collect(),
);
self.dep_info_by_scope = Default::default();
node_resolver::PackageJsonThreadLocalCache::clear();
NodeResolutionThreadLocalCache::clear();
// Clean up non-existent documents.
self.documents.server.retain(|_, d| {
let Some(module) =
self.inspect_primary_module(&Document::Server(d.clone()))
else {
return false;
};
let Ok(path) = url_to_file_path(&module.specifier) else {
// Remove non-file schemed docs (deps). They may not be dependencies
// anymore after updating resolvers.
return false;
};
if !config.specifier_enabled(&module.specifier) {
return false;
}
path.is_file()
});
}
pub fn open_document(
&mut self,
uri: Uri,
version: i32,
language_id: LanguageId,
text: Arc<str>,
) -> Arc<OpenDocument> {
self.dep_info_by_scope = Default::default();
self.documents.open(uri, version, language_id, text)
}
pub fn change_document(
&mut self,
uri: &Uri,
version: i32,
changes: Vec<lsp::TextDocumentContentChangeEvent>,
) -> Result<Arc<OpenDocument>, AnyError> {
self.dep_info_by_scope = Default::default();
let document = self.documents.change(uri, version, changes)?;
Ok(document)
}
/// Returns if the document is diagnosable.
pub fn close_document(
&mut self,
uri: &Uri,
) -> Result<Arc<OpenDocument>, AnyError> {
self.dep_info_by_scope = Default::default();
let document = self.documents.close(uri)?;
// If applicable, try to load the closed document as a server document so
// it's still included as a ts root etc..
if uri.scheme().is_some_and(|s| s.eq_lowercase("file"))
&& self.config.uri_enabled(uri)
{
self.documents.get(uri);
}
Ok(document)
}
pub fn release(&self, specifier: &Url, scope: Option<&Url>) {
let Some(module) = self.module_for_specifier(specifier, scope) else {
return;
};
self.documents.remove_server_doc(&module.uri);
}
fn module_inner(
&self,
document: &Document,
specifier: Option<&Arc<Url>>,
scope: Option<&Url>,
) -> Option<Arc<DocumentModule>> {
let modules = self.modules_for_scope(scope)?;
if let Some(module) = modules.get(document) {
return Some(module);
}
let specifier = specifier
.cloned()
.or_else(|| {
if let Some(document) = document.server() {
match &document.kind {
ServerDocumentKind::Fs { .. } => {}
ServerDocumentKind::RemoteUrl { url, .. } => {
return Some(url.clone())
}
ServerDocumentKind::DataUrl { url, .. } => {
return Some(url.clone())
}
ServerDocumentKind::Asset { url, .. } => return Some(url.clone()),
}
}
None
})
.or_else(|| {
let uri = document.uri();
let url = uri_to_url(uri);
if url.scheme() != "file" {
return None;
}
if uri.scheme().is_some_and(|s| s.eq_lowercase("file")) {
if let Some(remote_specifier) = self.cache.unvendored_specifier(&url)
{
return Some(Arc::new(remote_specifier));
}
}
Some(Arc::new(url))
})?;
let module = Arc::new(DocumentModule::new(
document,
specifier,
scope.cloned().map(Arc::new),
&self.resolver,
&self.config,
&self.cache,
));
modules.insert(document, module.clone());
Some(module)
}
pub fn module(
&self,
document: &Document,
scope: Option<&Url>,
) -> Option<Arc<DocumentModule>> {
self.module_inner(document, None, scope)
}
pub fn module_for_specifier(
&self,
specifier: &Url,
scope: Option<&Url>,
) -> Option<Arc<DocumentModule>> {
let specifier = if let Ok(jsr_req_ref) =
JsrPackageReqReference::from_specifier(specifier)
{
Cow::Owned(self.resolver.jsr_to_resource_url(&jsr_req_ref, scope)?)
} else {
Cow::Borrowed(specifier)
};
let specifier = self.resolver.resolve_redirects(&specifier, scope)?;
let document =
self
.documents
.get_for_specifier(&specifier, scope, &self.cache)?;
self.module_inner(&document, Some(&Arc::new(specifier)), scope)
}
pub fn primary_module(
&self,
document: &Document,
) -> Option<Arc<DocumentModule>> {
if let Some(scope) = self.primary_scope(document.uri()) {
return self.module(document, scope.map(|s| s.as_ref()));
}
for modules in self.modules_by_scope.values() {
if let Some(module) = modules.get(document) {
return Some(module);
}
}
self.modules_unscoped.get(document)
}
pub fn workspace_file_modules_by_scope(
&self,
) -> BTreeMap<Option<Arc<Url>>, Vec<Arc<DocumentModule>>> {
let mut modules_with_scopes = BTreeMap::new();
for path in self
.workspace_files
.iter()
.take(self.config.settings.unscoped.document_preload_limit)
{
let Ok(url) = Url::from_file_path(path) else {
continue;
};
let scope = self.config.tree.scope_for_specifier(&url).cloned();
let Some(document) =
self
.documents
.get_for_specifier(&url, scope.as_deref(), &self.cache)
else {
continue;
};
if document.open().is_none()
&& (!self.config.specifier_enabled(&url)
|| self.resolver.in_node_modules(&url)
|| self.cache.in_cache_directory(&url))
{
continue;
}
let Some(module) = self.module(&document, scope.as_deref()) else {
continue;
};
modules_with_scopes.insert(document.uri().clone(), (module, scope));
}
// Include files that aren't in `self.workspace_files` for whatever reason.
for document in self.documents.docs() {
let uri = document.uri();
if modules_with_scopes.contains_key(uri) {
continue;
}
let url = uri_to_url(uri);
if document.open().is_none()
&& (url.scheme() != "file"
|| !self.config.specifier_enabled(&url)
|| self.resolver.in_node_modules(&url)
|| self.cache.in_cache_directory(&url))
{
continue;
}
let scope = self.config.tree.scope_for_specifier(&url).cloned();
let Some(module) = self.module(&document, scope.as_deref()) else {
continue;
};
modules_with_scopes.insert(document.uri().clone(), (module, scope));
}
let mut result = BTreeMap::new();
for (module, scope) in modules_with_scopes.into_values() {
(result.entry(scope).or_default() as &mut Vec<_>).push(module);
}
result
}
/// This will not create any module entries, only retrieve existing entries.
pub fn inspect_module_for_specifier(
&self,
specifier: &Url,
scope: Option<&Url>,
) -> Option<Arc<DocumentModule>> {
let specifier = if let Ok(jsr_req_ref) =
JsrPackageReqReference::from_specifier(specifier)
{
Cow::Owned(self.resolver.jsr_to_resource_url(&jsr_req_ref, scope)?)
} else {
Cow::Borrowed(specifier)
};
let specifier = self.resolver.resolve_redirects(&specifier, scope)?;
let modules = self.modules_for_scope(scope)?;
modules.get_for_specifier(&specifier)
}
/// This will not create any module entries, only retrieve existing entries.
pub fn inspect_primary_module(
&self,
document: &Document,
) -> Option<Arc<DocumentModule>> {
if let Some(scope) = self.primary_scope(document.uri()) {
return self
.modules_for_scope(scope.map(|s| s.as_ref()))?
.get(document);
}
for modules in self.modules_by_scope.values() {
if let Some(module) = modules.get(document) {
return Some(module);
}
}
self.modules_unscoped.get(document)
}
/// This will not create any module entries, only retrieve existing entries.
pub fn inspect_modules_by_scope(
&self,
document: &Document,
) -> BTreeMap<Option<Arc<Url>>, Arc<DocumentModule>> {
let mut result = BTreeMap::new();
for (scope, modules) in self.modules_by_scope.iter() {
if let Some(module) = modules.get(document) {
result.insert(Some(scope.clone()), module);
}
}
if let Some(module) = self.modules_unscoped.get(document) {
result.insert(None, module);
}
result
}
/// This will not store any module entries, only retrieve existing entries or
/// create temporary entries for scopes where one doesn't exist.
pub fn inspect_or_temp_modules_by_scope(
&self,
document: &Document,
) -> BTreeMap<Option<Arc<Url>>, Arc<DocumentModule>> {
let mut result = BTreeMap::new();
for (scope, modules) in self.modules_by_scope.iter() {
let module = modules.get(document).unwrap_or_else(|| {
Arc::new(DocumentModule::new(
document,
Arc::new(uri_to_url(document.uri())),
Some(scope.clone()),
&self.resolver,
&self.config,
&self.cache,
))
});
result.insert(Some(scope.clone()), module);
}
let module = self.modules_unscoped.get(document).unwrap_or_else(|| {
Arc::new(DocumentModule::new(
document,
Arc::new(uri_to_url(document.uri())),
None,
&self.resolver,
&self.config,
&self.cache,
))
});
result.insert(None, module);
result
}
fn modules_for_scope(
&self,
scope: Option<&Url>,
) -> Option<&Arc<WeakDocumentModuleMap>> {
match scope {
Some(s) => Some(self.modules_by_scope.get(s)?),
None => Some(&self.modules_unscoped),
}
}
fn primary_scope(&self, uri: &Uri) -> Option<Option<&Arc<Url>>> {
let url = uri_to_url(uri);
if url.scheme() == "file" && !self.cache.in_global_cache_directory(&url) {
let scope = self.config.tree.scope_for_specifier(&url);
return Some(scope);
}
None
}
pub fn remove_expired_modules(&self) {
self.modules_unscoped.remove_expired();
for modules in self.modules_by_scope.values() {
modules.remove_expired();
}
}
pub fn scopes(&self) -> BTreeSet<Option<Arc<Url>>> {
self
.modules_by_scope
.keys()
.cloned()
.map(Some)
.chain([None])
.collect()
}
pub fn specifier_exists(&self, specifier: &Url, scope: Option<&Url>) -> bool {
if let Some(modules) = self.modules_for_scope(scope) {
if modules.contains_specifier(specifier) {
return true;
}
}
if specifier.scheme() == "file" {
return url_to_file_path(specifier)
.map(|p| p.is_file())
.unwrap_or(false);
}
if specifier.scheme() == "data" {
return true;
}
if self.cache.for_specifier(scope).contains(specifier) {
return true;
}
false
}
pub fn dep_info_by_scope(
&self,
) -> Arc<BTreeMap<Option<Arc<Url>>, Arc<ScopeDepInfo>>> {
type ScopeEntry<'a> =
(Option<&'a Arc<Url>>, &'a Arc<WeakDocumentModuleMap>);
let dep_info_from_scope_entry = |(scope, modules): ScopeEntry<'_>| {
let mut dep_info = ScopeDepInfo::default();
let mut visit_module = |module: &DocumentModule| {
for dependency in module.dependencies.values() {
let code_specifier = dependency.get_code();
let type_specifier = dependency.get_type();
if let Some(dep) = code_specifier {
if dep.scheme() == "node" {
dep_info.has_node_specifier = true;
}
if let Ok(reference) = NpmPackageReqReference::from_specifier(dep) {
dep_info.npm_reqs.insert(reference.into_inner().req);
}
}
if let Some(dep) = type_specifier {
if let Ok(reference) = NpmPackageReqReference::from_specifier(dep) {
dep_info.npm_reqs.insert(reference.into_inner().req);
}
}
if dependency.maybe_deno_types_specifier.is_some() {
if let (Some(code_specifier), Some(type_specifier)) =
(code_specifier, type_specifier)
{
if MediaType::from_specifier(type_specifier).is_declaration() {
dep_info
.deno_types_to_code_resolutions
.insert(type_specifier.clone(), code_specifier.clone());
}
}
}
}
if let Some(dep) = module
.types_dependency
.as_ref()
.and_then(|d| d.dependency.maybe_specifier())
{
if let Ok(reference) = NpmPackageReqReference::from_specifier(dep) {
dep_info.npm_reqs.insert(reference.into_inner().req);
}
}
};
for module in modules.inspect_values() {
visit_module(&module);
}
let config_data =
scope.and_then(|s| self.config.tree.data_by_scope().get(s));
if let Some(config_data) = config_data {
(|| {
let member_dir = &config_data.member_dir;
let jsx_config =
member_dir.to_maybe_jsx_import_source_config().ok()??;
let import_source_types = jsx_config.import_source_types.as_ref()?;
let import_source = jsx_config.import_source.as_ref()?;
let cli_resolver =
self.resolver.as_cli_resolver(scope.map(|s| s.as_ref()));
let type_specifier = cli_resolver
.resolve(
&import_source_types.specifier,
&import_source_types.base,
deno_graph::Position::zeroed(),
// todo(dsherret): this is wrong because it doesn't consider CJS referrers
ResolutionMode::Import,
NodeResolutionKind::Types,
)
.ok()?;
let code_specifier = cli_resolver
.resolve(
&import_source.specifier,
&import_source.base,
deno_graph::Position::zeroed(),
// todo(dsherret): this is wrong because it doesn't consider CJS referrers
ResolutionMode::Import,
NodeResolutionKind::Execution,
)
.ok()?;
dep_info
.deno_types_to_code_resolutions
.insert(type_specifier, code_specifier);
Some(())
})();
// fill the reqs from the lockfile
if let Some(lockfile) = config_data.lockfile.as_ref() {
let lockfile = lockfile.lock();
for dep_req in lockfile.content.packages.specifiers.keys() {
if dep_req.kind == deno_semver::package::PackageKind::Npm {
dep_info.npm_reqs.insert(dep_req.req.clone());
}
}
}
}
if dep_info.has_node_specifier
&& !dep_info.npm_reqs.iter().any(|r| r.name == "@types/node")
{
dep_info
.npm_reqs
.insert(PackageReq::from_str("@types/node").unwrap());
}
(scope.cloned(), Arc::new(dep_info))
};
self
.dep_info_by_scope
.get_or_init(|| {
NodeResolutionThreadLocalCache::clear();
// Ensure at least module entries for workspace files are initialized.
self.workspace_file_modules_by_scope();
Arc::new(
self
.modules_by_scope
.iter()
.map(|(s, m)| (Some(s), m))
.chain([(None, &self.modules_unscoped)])
.map(dep_info_from_scope_entry)
.collect(),
)
})
.clone()
}
pub fn scopes_with_node_specifier(&self) -> HashSet<Option<Arc<Url>>> {
self
.dep_info_by_scope()
.iter()
.filter(|(_, i)| i.has_node_specifier)
.map(|(s, _)| s.clone())
.collect::<HashSet<_>>()
}
#[cfg_attr(feature = "lsp-tracing", tracing::instrument(skip_all))]
pub fn resolve(
&self,
// (is_cjs: bool, raw_specifier: String)
raw_specifiers: &[(bool, String)],
referrer: &Url,
scope: Option<&Url>,
) -> Vec<Option<(Url, MediaType)>> {
let referrer_module = self.module_for_specifier(referrer, scope);
let dependencies = referrer_module.as_ref().map(|d| &d.dependencies);
let mut results = Vec::new();
for (is_cjs, raw_specifier) in raw_specifiers {
let resolution_mode = match is_cjs {
true => ResolutionMode::Require,
false => ResolutionMode::Import,
};
if raw_specifier.starts_with("asset:") {
if let Ok(specifier) = resolve_url(raw_specifier) {
let media_type = MediaType::from_specifier(&specifier);
results.push(Some((specifier, media_type)));
} else {
results.push(None);
}
} else if let Some(dep) =
dependencies.as_ref().and_then(|d| d.get(raw_specifier))
{
if let Some(specifier) = dep.maybe_type.maybe_specifier() {
results.push(self.resolve_dependency(
specifier,
referrer,
resolution_mode,
scope,
));
} else if let Some(specifier) = dep.maybe_code.maybe_specifier() {
results.push(self.resolve_dependency(
specifier,
referrer,
resolution_mode,
scope,
));
} else {
results.push(None);
}
} else if let Ok(specifier) =
self.resolver.as_cli_resolver(scope).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);
}
}
results
}
#[cfg_attr(feature = "lsp-tracing", tracing::instrument(skip_all))]
pub fn resolve_dependency(
&self,
specifier: &Url,
referrer: &Url,
resolution_mode: ResolutionMode,
scope: Option<&Url>,
) -> Option<(Url, MediaType)> {
if let Some(module_name) = specifier.as_str().strip_prefix("node:") {
if deno_node::is_builtin_node_module(module_name) {
// return itself for node: specifiers because during type checking
// we resolve to the ambient modules in the @types/node package
// rather than deno_std/node
return Some((specifier.clone(), MediaType::Dts));
}
}
let mut specifier = specifier.clone();
let mut media_type = None;
if let Ok(npm_ref) = NpmPackageReqReference::from_specifier(&specifier) {
let (s, mt) = self.resolver.npm_to_file_url(
&npm_ref,
referrer,
resolution_mode,
scope,
)?;
specifier = s;
media_type = Some(mt);
}
let Some(module) = self.module_for_specifier(&specifier, scope) else {
let media_type =
media_type.unwrap_or_else(|| MediaType::from_specifier(&specifier));
return Some((specifier, media_type));
};
if let Some(types) = module
.types_dependency
.as_ref()
.and_then(|d| d.dependency.maybe_specifier())
{
self.resolve_dependency(types, &specifier, module.resolution_mode, scope)
} else {
Some((module.specifier.as_ref().clone(), module.media_type))
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LanguageId {
JavaScript,
Jsx,
TypeScript,
Tsx,
Json,
JsonC,
Markdown,
Html,
Css,
Scss,
Sass,
Less,
Yaml,
Sql,
Svelte,
Vue,
Astro,
Vento,
Nunjucks,
Unknown,
}
impl LanguageId {
pub fn as_extension(&self) -> Option<&'static str> {
match self {
LanguageId::JavaScript => Some("js"),
LanguageId::Jsx => Some("jsx"),
LanguageId::TypeScript => Some("ts"),
LanguageId::Tsx => Some("tsx"),
LanguageId::Json => Some("json"),
LanguageId::JsonC => Some("jsonc"),
LanguageId::Markdown => Some("md"),
LanguageId::Html => Some("html"),
LanguageId::Css => Some("css"),
LanguageId::Scss => Some("scss"),
LanguageId::Sass => Some("sass"),
LanguageId::Less => Some("less"),
LanguageId::Yaml => Some("yaml"),
LanguageId::Sql => Some("sql"),
LanguageId::Svelte => Some("svelte"),
LanguageId::Vue => Some("vue"),
LanguageId::Astro => Some("astro"),
LanguageId::Vento => Some("vto"),
LanguageId::Nunjucks => Some("njk"),
LanguageId::Unknown => None,
}
}
pub fn as_content_type(&self) -> Option<&'static str> {
match self {
LanguageId::JavaScript => Some("application/javascript"),
LanguageId::Jsx => Some("text/jsx"),
LanguageId::TypeScript => Some("application/typescript"),
LanguageId::Tsx => Some("text/tsx"),
LanguageId::Json | LanguageId::JsonC => Some("application/json"),
LanguageId::Markdown => Some("text/markdown"),
LanguageId::Html => Some("text/html"),
LanguageId::Css => Some("text/css"),
LanguageId::Scss => None,
LanguageId::Sass => None,
LanguageId::Less => None,
LanguageId::Yaml => Some("application/yaml"),
LanguageId::Sql => None,
LanguageId::Svelte => None,
LanguageId::Vue => None,
LanguageId::Astro => None,
LanguageId::Vento => None,
LanguageId::Nunjucks => None,
LanguageId::Unknown => None,
}
}
fn is_diagnosable(&self) -> bool {
matches!(
self,
Self::JavaScript | Self::Jsx | Self::TypeScript | Self::Tsx
)
}
}
impl FromStr for LanguageId {
type Err = AnyError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"javascript" => Ok(Self::JavaScript),
"javascriptreact" | "jsx" => Ok(Self::Jsx),
"typescript" => Ok(Self::TypeScript),
"typescriptreact" | "tsx" => Ok(Self::Tsx),
"json" => Ok(Self::Json),
"jsonc" => Ok(Self::JsonC),
"markdown" => Ok(Self::Markdown),
"html" => Ok(Self::Html),
"css" => Ok(Self::Css),
"scss" => Ok(Self::Scss),
"sass" => Ok(Self::Sass),
"less" => Ok(Self::Less),
"yaml" => Ok(Self::Yaml),
"sql" => Ok(Self::Sql),
"svelte" => Ok(Self::Svelte),
"vue" => Ok(Self::Vue),
"astro" => Ok(Self::Astro),
"vento" => Ok(Self::Vento),
"nunjucks" => Ok(Self::Nunjucks),
_ => Ok(Self::Unknown),
}
}
}
#[derive(Debug, PartialEq, Eq)]
enum IndexValid {
All,
UpTo(u32),
}
impl IndexValid {
fn covers(&self, line: u32) -> bool {
match *self {
IndexValid::UpTo(to) => to > line,
IndexValid::All => true,
}
}
}
type ModuleResult = Result<deno_graph::JsModule, deno_graph::ModuleGraphError>;
type ParsedSourceResult = Result<ParsedSource, deno_ast::ParseDiagnostic>;
type TestModuleFut =
Shared<Pin<Box<dyn Future<Output = Option<Arc<TestModule>>> + Send>>>;
fn media_type_is_diagnosable(media_type: MediaType) -> bool {
matches!(
media_type,
MediaType::JavaScript
| MediaType::Jsx
| MediaType::Mjs
| MediaType::Cjs
| MediaType::TypeScript
| MediaType::Tsx
| MediaType::Mts
| MediaType::Cts
| MediaType::Dts
| MediaType::Dmts
| MediaType::Dcts
)
}
fn get_maybe_test_module_fut(
maybe_parsed_source: Option<&ParsedSourceResult>,
config: &Config,
) -> Option<TestModuleFut> {
if !config.testing_api_capable() {
return None;
}
let parsed_source = maybe_parsed_source?.as_ref().ok()?.clone();
let specifier = parsed_source.specifier();
if specifier.scheme() != "file"
|| specifier.as_str().contains("/node_modules/")
{
return None;
}
if !media_type_is_diagnosable(parsed_source.media_type()) {
return None;
}
if !config.specifier_enabled_for_test(specifier) {
return None;
}
let handle = tokio::task::spawn_blocking(move || {
let mut collector = TestCollector::new(
parsed_source.specifier().clone(),
parsed_source.text_info_lazy().clone(),
);
parsed_source.program().visit_with(&mut collector);
Arc::new(collector.take())
})
.map(Result::ok)
.boxed()
.shared();
Some(handle)
}
fn resolve_media_type(
specifier: &ModuleSpecifier,
maybe_headers: Option<&HashMap<String, String>>,
maybe_language_id: Option<LanguageId>,
) -> MediaType {
if let Some(language_id) = maybe_language_id {
return MediaType::from_specifier_and_content_type(
specifier,
language_id.as_content_type(),
);
}
if maybe_headers.is_some() {
return MediaType::from_specifier_and_headers(specifier, maybe_headers);
}
MediaType::from_specifier(specifier)
}
/// Loader that will look at the open documents.
pub struct OpenDocumentsGraphLoader<'a> {
pub inner_loader: &'a mut dyn deno_graph::source::Loader,
pub open_modules: &'a HashMap<Arc<Url>, Arc<DocumentModule>>,
}
impl OpenDocumentsGraphLoader<'_> {
fn load_from_docs(
&self,
specifier: &ModuleSpecifier,
) -> Option<deno_graph::source::LoadFuture> {
if specifier.scheme() == "file" {
if let Some(doc) = self.open_modules.get(specifier) {
return Some(
future::ready(Ok(Some(deno_graph::source::LoadResponse::Module {
content: Arc::from(doc.text.as_bytes().to_owned()),
specifier: doc.specifier.as_ref().clone(),
maybe_headers: None,
})))
.boxed_local(),
);
}
}
None
}
}
impl deno_graph::source::Loader for OpenDocumentsGraphLoader<'_> {
fn load(
&self,
specifier: &ModuleSpecifier,
options: deno_graph::source::LoadOptions,
) -> deno_graph::source::LoadFuture {
match self.load_from_docs(specifier) {
Some(fut) => fut,
None => self.inner_loader.load(specifier, options),
}
}
fn cache_module_info(
&self,
specifier: &deno_ast::ModuleSpecifier,
media_type: MediaType,
source: &Arc<[u8]>,
module_info: &deno_graph::ModuleInfo,
) {
self.inner_loader.cache_module_info(
specifier,
media_type,
source,
module_info,
)
}
}
fn parse_and_analyze_module(
specifier: ModuleSpecifier,
text: Arc<str>,
maybe_headers: Option<&HashMap<String, String>>,
media_type: MediaType,
file_referrer: Option<&ModuleSpecifier>,
resolver: &LspResolver,
) -> (
Option<ParsedSourceResult>,
Option<ModuleResult>,
ResolutionMode,
) {
let parsed_source_result = parse_source(specifier.clone(), text, media_type);
let (module_result, resolution_mode) = analyze_module(
specifier,
&parsed_source_result,
maybe_headers,
file_referrer,
resolver,
);
(
Some(parsed_source_result),
Some(module_result),
resolution_mode,
)
}
fn parse_source(
specifier: ModuleSpecifier,
text: Arc<str>,
media_type: MediaType,
) -> ParsedSourceResult {
deno_ast::parse_program(deno_ast::ParseParams {
specifier,
text,
media_type,
capture_tokens: true,
scope_analysis: true,
maybe_syntax: None,
})
}
fn analyze_module(
specifier: ModuleSpecifier,
parsed_source_result: &ParsedSourceResult,
maybe_headers: Option<&HashMap<String, String>>,
file_referrer: Option<&ModuleSpecifier>,
resolver: &LspResolver,
) -> (ModuleResult, ResolutionMode) {
match parsed_source_result {
Ok(parsed_source) => {
let npm_resolver = resolver.as_graph_npm_resolver(file_referrer);
let cli_resolver = resolver.as_cli_resolver(file_referrer);
let is_cjs_resolver = resolver.as_is_cjs_resolver(file_referrer);
let config_data = resolver.as_config_data(file_referrer);
let valid_referrer = specifier.clone();
let jsx_import_source_config =
config_data.and_then(|d| d.maybe_jsx_import_source_config());
let module_resolution_mode = is_cjs_resolver.get_lsp_resolution_mode(
&specifier,
Some(parsed_source.compute_is_script()),
);
let resolver = SingleReferrerGraphResolver {
valid_referrer: &valid_referrer,
module_resolution_mode,
cli_resolver,
jsx_import_source_config: jsx_import_source_config.as_ref(),
};
(
Ok(deno_graph::parse_module_from_ast(
deno_graph::ParseModuleFromAstOptions {
graph_kind: deno_graph::GraphKind::TypesOnly,
specifier,
maybe_headers,
parsed_source,
// use a null file system because there's no need to bother resolving
// dynamic imports like import(`./dir/${something}`) in the LSP
file_system: &deno_graph::source::NullFileSystem,
jsr_url_provider: &CliJsrUrlProvider,
maybe_resolver: Some(&resolver),
maybe_npm_resolver: Some(npm_resolver.as_ref()),
},
)),
module_resolution_mode,
)
}
Err(err) => (
Err(deno_graph::ModuleGraphError::ModuleError(
deno_graph::ModuleError::ParseErr(specifier, err.clone()),
)),
ResolutionMode::Import,
),
}
}
fn bytes_to_content(
specifier: &ModuleSpecifier,
media_type: MediaType,
bytes: Vec<u8>,
maybe_charset: Option<&str>,
) -> Result<String, AnyError> {
if media_type == MediaType::Wasm {
// we use the dts representation for Wasm modules
Ok(deno_graph::source::wasm::wasm_module_to_dts(&bytes)?)
} else {
let charset = maybe_charset.unwrap_or_else(|| {
deno_media_type::encoding::detect_charset(specifier, &bytes)
});
Ok(deno_media_type::encoding::decode_owned_source(
charset, bytes,
)?)
}
}
#[cfg(test)]
mod tests {
use deno_config::deno_json::ConfigFile;
use deno_core::serde_json;
use deno_core::serde_json::json;
use pretty_assertions::assert_eq;
use test_util::TempDir;
use super::*;
use crate::lsp::cache::LspCache;
async fn setup() -> (DocumentModules, LspCache, TempDir) {
let temp_dir = TempDir::new();
temp_dir.create_dir_all(".deno_dir");
let cache = LspCache::new(Some(temp_dir.url().join(".deno_dir").unwrap()));
let config = Config::default();
let resolver =
Arc::new(LspResolver::from_config(&config, &cache, None).await);
let mut document_modules = DocumentModules::default();
document_modules.update_config(
&config,
&resolver,
&cache,
&Default::default(),
);
(document_modules, cache, temp_dir)
}
#[tokio::test]
async fn test_documents_open_close() {
let (mut document_modules, _, _) = setup().await;
let uri = Uri::from_str("file:///a.ts").unwrap();
let content = r#"import * as b from "./b.ts";
console.log(b);
"#;
document_modules.open_document(
uri.clone(),
1,
"javascript".parse().unwrap(),
content.into(),
);
let document = document_modules
.documents
.get(&uri)
.unwrap()
.open()
.cloned()
.unwrap();
assert_eq!(document.uri.as_ref(), &uri);
assert_eq!(document.text.as_ref(), content);
assert_eq!(document.version, 1);
assert_eq!(document.language_id, LanguageId::JavaScript);
assert!(document.is_diagnosable());
assert!(document.is_file_like());
document_modules.close_document(&uri).unwrap();
assert!(document_modules.documents.get(&uri).is_none());
}
#[tokio::test]
async fn test_documents_change() {
let (mut document_modules, _, _) = setup().await;
let uri = Uri::from_str("file:///a.ts").unwrap();
let content = r#"import * as b from "./b.ts";
console.log(b);
"#;
document_modules.open_document(
uri.clone(),
1,
"javascript".parse().unwrap(),
content.into(),
);
document_modules
.change_document(
&uri,
2,
vec![lsp::TextDocumentContentChangeEvent {
range: Some(lsp::Range {
start: lsp::Position {
line: 1,
character: 13,
},
end: lsp::Position {
line: 1,
character: 13,
},
}),
range_length: None,
text: r#", "hello deno""#.to_string(),
}],
)
.unwrap();
assert_eq!(
document_modules
.documents
.get(&uri)
.unwrap()
.text()
.as_ref() as &str,
r#"import * as b from "./b.ts";
console.log(b, "hello deno");
"#
);
}
#[tokio::test]
async fn test_documents_refresh_dependencies_config_change() {
// it should never happen that a user of this API causes this to happen,
// but we'll guard against it anyway
let (mut document_modules, cache, temp_dir) = setup().await;
let file1_path = temp_dir.path().join("file1.ts");
let file1_specifier = temp_dir.url().join("file1.ts").unwrap();
fs::write(&file1_path, "").unwrap();
let file2_path = temp_dir.path().join("file2.ts");
let file2_specifier = temp_dir.url().join("file2.ts").unwrap();
fs::write(&file2_path, "").unwrap();
let file3_path = temp_dir.path().join("file3.ts");
let file3_specifier = temp_dir.url().join("file3.ts").unwrap();
fs::write(&file3_path, "").unwrap();
let mut config = Config::new_with_roots([temp_dir.url()]);
let workspace_settings =
serde_json::from_str(r#"{ "enable": true }"#).unwrap();
config.set_workspace_settings(workspace_settings, vec![]);
let workspace_files = Arc::new(
[&file1_specifier, &file2_specifier, &file3_specifier]
.into_iter()
.map(|s| s.to_file_path().unwrap())
.collect::<IndexSet<_>>(),
);
let document = document_modules.open_document(
url_to_uri(&file1_specifier).unwrap(),
1,
LanguageId::TypeScript,
"import {} from 'test';".into(),
);
// set the initial import map and point to file 2
{
config
.tree
.inject_config_file(
ConfigFile::new(
&json!({
"imports": {
"test": "./file2.ts",
},
})
.to_string(),
config.root_url().unwrap().join("deno.json").unwrap(),
)
.unwrap(),
)
.await;
let resolver =
Arc::new(LspResolver::from_config(&config, &cache, None).await);
document_modules.update_config(
&config,
&resolver,
&cache,
&workspace_files,
);
let module = document_modules
.primary_module(&Document::Open(document.clone()))
.unwrap();
assert_eq!(
module
.dependencies
.get("test")
.unwrap()
.maybe_code
.maybe_specifier()
.map(ToOwned::to_owned),
Some(file2_specifier),
);
}
// now point at file 3
{
config
.tree
.inject_config_file(
ConfigFile::new(
&json!({
"imports": {
"test": "./file3.ts",
},
})
.to_string(),
config.root_url().unwrap().join("deno.json").unwrap(),
)
.unwrap(),
)
.await;
let resolver =
Arc::new(LspResolver::from_config(&config, &cache, None).await);
document_modules.update_config(
&config,
&resolver,
&cache,
&workspace_files,
);
// check the document's dependencies
let module = document_modules
.primary_module(&Document::Open(document.clone()))
.unwrap();
assert_eq!(
module
.dependencies
.get("test")
.unwrap()
.maybe_code
.maybe_specifier()
.map(ToOwned::to_owned),
Some(file3_specifier),
);
}
}
}
Reference in a new issue View git blame Copy permalink