mirror of
https://github.com/denoland/deno.git
synced 2025-09-22 18:32:28 +00:00
bb6c27e4cc
Previously, to get the svelte template (`npx sv create`) to work under Deno, a knowledgeable user would have to convert the compiler options under `.svelte-kit/tsconfig.json` to a `deno.json`. This catches up Deno's tsconfig support so they don't have to change anything.
1780 lines
58 KiB
Rust
1780 lines
58 KiB
Rust
// Copyright 2018-2025 the Deno authors. MIT license.
|
|
|
|
use std::collections::HashMap;
|
|
use std::str::FromStr;
|
|
use std::sync::Arc;
|
|
use std::thread;
|
|
|
|
use console_static_text::ansi::strip_ansi_codes;
|
|
use deno_ast::MediaType;
|
|
use deno_core::ModuleSpecifier;
|
|
use deno_core::anyhow::anyhow;
|
|
use deno_core::error::AnyError;
|
|
use deno_core::futures::StreamExt;
|
|
use deno_core::parking_lot::RwLock;
|
|
use deno_core::resolve_url;
|
|
use deno_core::serde::Deserialize;
|
|
use deno_core::serde_json;
|
|
use deno_core::serde_json::json;
|
|
use deno_core::url::Url;
|
|
use deno_graph::Resolution;
|
|
use deno_graph::ResolutionError;
|
|
use deno_graph::SpecifierError;
|
|
use deno_graph::source::ResolveError;
|
|
use deno_resolver::deno_json::CompilerOptionsKey;
|
|
use deno_resolver::graph::enhanced_resolution_error_message;
|
|
use deno_resolver::workspace::sloppy_imports_resolve;
|
|
use deno_runtime::deno_node;
|
|
use deno_runtime::tokio_util::create_basic_runtime;
|
|
use deno_semver::jsr::JsrPackageReqReference;
|
|
use deno_semver::npm::NpmPackageReqReference;
|
|
use deno_semver::package::PackageReq;
|
|
use import_map::ImportMap;
|
|
use import_map::ImportMapErrorKind;
|
|
use log::error;
|
|
use lsp_types::Uri;
|
|
use node_resolver::NodeResolutionKind;
|
|
use tokio::sync::mpsc;
|
|
use tokio_util::sync::CancellationToken;
|
|
use tokio_util::task::AbortOnDropHandle;
|
|
use tower_lsp::lsp_types as lsp;
|
|
|
|
use super::analysis;
|
|
use super::analysis::import_map_lookup;
|
|
use super::client::Client;
|
|
use super::documents::Document;
|
|
use super::documents::DocumentModule;
|
|
use super::documents::DocumentModules;
|
|
use super::language_server;
|
|
use super::language_server::StateSnapshot;
|
|
use super::performance::Performance;
|
|
use super::tsc::TsServer;
|
|
use crate::lsp::documents::OpenDocument;
|
|
use crate::lsp::language_server::OnceCellMap;
|
|
use crate::lsp::lint::LspLinter;
|
|
use crate::lsp::logging::lsp_warn;
|
|
use crate::lsp::urls::uri_to_url;
|
|
use crate::sys::CliSys;
|
|
use crate::tsc::DiagnosticCategory;
|
|
use crate::type_checker::ambient_modules_to_regex_string;
|
|
use crate::util::path::to_percent_decoded_str;
|
|
|
|
#[derive(Debug)]
|
|
pub struct DiagnosticsUpdateMessage {
|
|
pub snapshot: Arc<StateSnapshot>,
|
|
}
|
|
|
|
#[derive(Debug, Hash, PartialEq, Eq, Copy, Clone)]
|
|
pub enum DiagnosticSource {
|
|
Deno,
|
|
Lint,
|
|
Ts,
|
|
}
|
|
|
|
impl DiagnosticSource {
|
|
pub fn as_lsp_source(&self) -> &'static str {
|
|
match self {
|
|
Self::Deno => "deno",
|
|
Self::Lint => "deno-lint",
|
|
Self::Ts => "deno-ts",
|
|
}
|
|
}
|
|
}
|
|
|
|
fn should_send_diagnostic_batch_notifications() -> bool {
|
|
deno_lib::args::has_flag_env_var(
|
|
"DENO_INTERNAL_DIAGNOSTIC_BATCH_NOTIFICATIONS",
|
|
)
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct DocumentDiagnosticsState {
|
|
version: i32,
|
|
ts_diagnostics: Arc<Vec<lsp::Diagnostic>>,
|
|
no_cache_diagnostics: Arc<Vec<lsp::Diagnostic>>,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct DiagnosticsState {
|
|
documents: RwLock<HashMap<Uri, DocumentDiagnosticsState>>,
|
|
}
|
|
|
|
impl DiagnosticsState {
|
|
fn update(&self, uri: &Uri, version: i32, diagnostics: &[lsp::Diagnostic]) {
|
|
let mut specifiers = self.documents.write();
|
|
let current_version = specifiers.get(uri).map(|s| s.version);
|
|
if let Some(current_version) = current_version
|
|
&& version < current_version
|
|
{
|
|
return;
|
|
}
|
|
let mut ts_diagnostics = vec![];
|
|
let mut no_cache_diagnostics = vec![];
|
|
for diagnostic in diagnostics {
|
|
if diagnostic.source.as_deref()
|
|
== Some(DiagnosticSource::Ts.as_lsp_source())
|
|
{
|
|
ts_diagnostics.push(diagnostic.clone());
|
|
}
|
|
if diagnostic.code
|
|
== Some(lsp::NumberOrString::String("no-cache".to_string()))
|
|
|| diagnostic.code
|
|
== Some(lsp::NumberOrString::String("not-installed-jsr".to_string()))
|
|
|| diagnostic.code
|
|
== Some(lsp::NumberOrString::String("not-installed-npm".to_string()))
|
|
{
|
|
no_cache_diagnostics.push(diagnostic.clone());
|
|
}
|
|
}
|
|
specifiers.insert(
|
|
uri.clone(),
|
|
DocumentDiagnosticsState {
|
|
version,
|
|
ts_diagnostics: Arc::new(ts_diagnostics),
|
|
no_cache_diagnostics: Arc::new(no_cache_diagnostics),
|
|
},
|
|
);
|
|
}
|
|
|
|
pub fn clear(&self, uri: &Uri) {
|
|
self.documents.write().remove(uri);
|
|
}
|
|
|
|
pub fn ts_diagnostics(&self, uri: &Uri) -> Arc<Vec<lsp::Diagnostic>> {
|
|
self
|
|
.documents
|
|
.read()
|
|
.get(uri)
|
|
.map(|s| s.ts_diagnostics.clone())
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub fn has_no_cache_diagnostics(&self, uri: &Uri) -> bool {
|
|
self
|
|
.documents
|
|
.read()
|
|
.get(uri)
|
|
.map(|s| !s.no_cache_diagnostics.is_empty())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
pub fn no_cache_diagnostics(&self, uri: &Uri) -> Arc<Vec<lsp::Diagnostic>> {
|
|
self
|
|
.documents
|
|
.read()
|
|
.get(uri)
|
|
.map(|s| s.no_cache_diagnostics.clone())
|
|
.unwrap_or_default()
|
|
}
|
|
}
|
|
|
|
pub struct DiagnosticsServer {
|
|
channel: Option<mpsc::UnboundedSender<DiagnosticsUpdateMessage>>,
|
|
client: Client,
|
|
performance: Arc<Performance>,
|
|
ts_server: Arc<TsServer>,
|
|
pub state: Arc<DiagnosticsState>,
|
|
}
|
|
|
|
impl std::fmt::Debug for DiagnosticsServer {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("DiagnosticsServer")
|
|
.field("channel", &self.channel)
|
|
.field("client", &self.client)
|
|
.field("performance", &self.performance)
|
|
.field("ts_server", &self.ts_server)
|
|
.field("state", &self.state)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
impl DiagnosticsServer {
|
|
pub fn new(
|
|
client: Client,
|
|
performance: Arc<Performance>,
|
|
ts_server: Arc<TsServer>,
|
|
) -> Self {
|
|
DiagnosticsServer {
|
|
channel: Default::default(),
|
|
client,
|
|
performance,
|
|
ts_server,
|
|
state: Default::default(),
|
|
}
|
|
}
|
|
|
|
#[allow(unused_must_use)]
|
|
pub fn start(&mut self) {
|
|
let (tx, mut rx) = mpsc::unbounded_channel::<DiagnosticsUpdateMessage>();
|
|
self.channel = Some(tx);
|
|
let client = self.client.clone();
|
|
let state = self.state.clone();
|
|
let performance = self.performance.clone();
|
|
let ts_server = self.ts_server.clone();
|
|
let should_send_batch_notifications =
|
|
should_send_diagnostic_batch_notifications();
|
|
|
|
let _join_handle = thread::spawn(move || {
|
|
let runtime = create_basic_runtime();
|
|
|
|
runtime.block_on(async {
|
|
let ambient_modules_regex_cache = Arc::new(OnceCellMap::<
|
|
(CompilerOptionsKey, Option<Arc<Uri>>),
|
|
Option<regex::Regex>,
|
|
>::new());
|
|
let mut _previous_handle;
|
|
while let Some(message) = rx.recv().await {
|
|
let _mark = performance.measure_scope("lsp.update_diagnostics");
|
|
let client = client.clone();
|
|
let state = state.clone();
|
|
let ts_server = ts_server.clone();
|
|
let ambient_modules_regex_cache = ambient_modules_regex_cache.clone();
|
|
let join_handle = tokio::task::spawn(async move {
|
|
let token = CancellationToken::new();
|
|
let _drop_guard = token.drop_guard_ref();
|
|
let DiagnosticsUpdateMessage { snapshot } = message;
|
|
if should_send_batch_notifications {
|
|
client.send_diagnostic_batch_start_notification();
|
|
}
|
|
let open_docs =
|
|
snapshot.document_modules.documents.open_docs().cloned();
|
|
deno_core::futures::stream::iter(open_docs.map(|document| {
|
|
let snapshot = snapshot.clone();
|
|
let ts_server = ts_server.clone();
|
|
let ambient_modules_regex_cache =
|
|
ambient_modules_regex_cache.clone();
|
|
let token = token.clone();
|
|
AbortOnDropHandle::new(tokio::task::spawn(async move {
|
|
let diagnostics = generate_document_diagnostics(
|
|
&document,
|
|
&snapshot,
|
|
&ts_server,
|
|
&ambient_modules_regex_cache,
|
|
&token,
|
|
)
|
|
.await
|
|
.unwrap_or_else(|err| {
|
|
lsp_warn!(
|
|
"Couldn't generate diagnostics for \"{}\": {err:#}",
|
|
document.uri.as_str()
|
|
);
|
|
vec![]
|
|
});
|
|
(document, diagnostics)
|
|
}))
|
|
}))
|
|
.buffered(
|
|
std::thread::available_parallelism()
|
|
.map(From::from)
|
|
.unwrap_or(8),
|
|
)
|
|
.for_each(|result| async {
|
|
let (document, diagnostics) = match result {
|
|
Ok(r) => r,
|
|
Err(err) => {
|
|
lsp_warn!("Diagnostics task join error: {err:#}");
|
|
return;
|
|
}
|
|
};
|
|
publish_document_diagnostics(
|
|
&document,
|
|
diagnostics,
|
|
&client,
|
|
&state,
|
|
&token,
|
|
)
|
|
.await
|
|
})
|
|
.await;
|
|
if should_send_batch_notifications {
|
|
client.send_diagnostic_batch_end_notification();
|
|
}
|
|
});
|
|
_previous_handle = AbortOnDropHandle::new(join_handle);
|
|
}
|
|
})
|
|
});
|
|
}
|
|
|
|
pub fn update(
|
|
&self,
|
|
message: DiagnosticsUpdateMessage,
|
|
) -> Result<(), AnyError> {
|
|
// todo(dsherret): instead of queuing up messages, it would be better to
|
|
// instead only store the latest message (ex. maybe using a
|
|
// tokio::sync::watch::channel)
|
|
if let Some(tx) = &self.channel {
|
|
tx.send(message).map_err(|err| err.into())
|
|
} else {
|
|
Err(anyhow!("diagnostics server not started"))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'a crate::tsc::DiagnosticCategory> for lsp::DiagnosticSeverity {
|
|
fn from(category: &'a crate::tsc::DiagnosticCategory) -> Self {
|
|
match category {
|
|
crate::tsc::DiagnosticCategory::Error => lsp::DiagnosticSeverity::ERROR,
|
|
crate::tsc::DiagnosticCategory::Warning => {
|
|
lsp::DiagnosticSeverity::WARNING
|
|
}
|
|
crate::tsc::DiagnosticCategory::Suggestion => {
|
|
lsp::DiagnosticSeverity::HINT
|
|
}
|
|
crate::tsc::DiagnosticCategory::Message => {
|
|
lsp::DiagnosticSeverity::INFORMATION
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'a crate::tsc::Position> for lsp::Position {
|
|
fn from(pos: &'a crate::tsc::Position) -> Self {
|
|
Self {
|
|
line: pos.line as u32,
|
|
character: pos.character as u32,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_diagnostic_message(diagnostic: &crate::tsc::Diagnostic) -> String {
|
|
if let Some(message) = diagnostic.message_text.clone() {
|
|
message
|
|
} else if let Some(message_chain) = diagnostic.message_chain.clone() {
|
|
message_chain.format_message(0)
|
|
} else {
|
|
"[missing message]".to_string()
|
|
}
|
|
}
|
|
|
|
fn to_lsp_range(
|
|
start: &crate::tsc::Position,
|
|
end: &crate::tsc::Position,
|
|
) -> lsp::Range {
|
|
lsp::Range {
|
|
start: start.into(),
|
|
end: end.into(),
|
|
}
|
|
}
|
|
|
|
fn to_lsp_related_information(
|
|
related_information: &Option<Vec<crate::tsc::Diagnostic>>,
|
|
module: &DocumentModule,
|
|
document_modules: &DocumentModules,
|
|
) -> Option<Vec<lsp::DiagnosticRelatedInformation>> {
|
|
related_information.as_ref().map(|related| {
|
|
related
|
|
.iter()
|
|
.filter_map(|ri| {
|
|
if let (Some(file_name), Some(start), Some(end)) =
|
|
(&ri.file_name, &ri.start, &ri.end)
|
|
{
|
|
let uri = resolve_url(file_name)
|
|
.ok()
|
|
.and_then(|s| {
|
|
document_modules.module_for_specifier(
|
|
&s,
|
|
module.scope.as_deref(),
|
|
Some(&module.compiler_options_key),
|
|
)
|
|
})
|
|
.map(|m| m.uri.as_ref().clone())
|
|
.unwrap_or_else(|| Uri::from_str("unknown:").unwrap());
|
|
Some(lsp::DiagnosticRelatedInformation {
|
|
location: lsp::Location {
|
|
uri,
|
|
range: to_lsp_range(start, end),
|
|
},
|
|
message: get_diagnostic_message(ri),
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect()
|
|
})
|
|
}
|
|
|
|
pub fn ts_json_to_diagnostics(
|
|
diagnostics: Vec<crate::tsc::Diagnostic>,
|
|
module: &DocumentModule,
|
|
document_modules: &DocumentModules,
|
|
) -> Vec<lsp::Diagnostic> {
|
|
diagnostics
|
|
.iter()
|
|
.filter_map(|d| {
|
|
if let (Some(start), Some(end)) = (&d.start, &d.end) {
|
|
Some(lsp::Diagnostic {
|
|
range: to_lsp_range(start, end),
|
|
severity: Some((&d.category).into()),
|
|
code: Some(lsp::NumberOrString::Number(d.code as i32)),
|
|
code_description: None,
|
|
source: Some(DiagnosticSource::Ts.as_lsp_source().to_string()),
|
|
message: get_diagnostic_message(d),
|
|
related_information: to_lsp_related_information(
|
|
&d.related_information,
|
|
module,
|
|
document_modules,
|
|
),
|
|
tags: match d.code {
|
|
// These are codes that indicate the variable is unused.
|
|
2695 | 6133 | 6138 | 6192 | 6196 | 6198 | 6199 | 6205 | 7027
|
|
| 7028 => Some(vec![lsp::DiagnosticTag::UNNECESSARY]),
|
|
// These are codes that indicated the variable is deprecated.
|
|
2789 | 6385 | 6387 => Some(vec![lsp::DiagnosticTag::DEPRECATED]),
|
|
_ => None,
|
|
},
|
|
data: None,
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn generate_document_lint_diagnostics(
|
|
module: &DocumentModule,
|
|
linter: &LspLinter,
|
|
token: CancellationToken,
|
|
) -> Vec<lsp::Diagnostic> {
|
|
if !module.is_diagnosable()
|
|
|| !linter
|
|
.lint_config
|
|
.files
|
|
.matches_specifier(&module.specifier)
|
|
{
|
|
return Vec::new();
|
|
}
|
|
match &module
|
|
.open_data
|
|
.as_ref()
|
|
.and_then(|d| d.parsed_source.as_ref())
|
|
{
|
|
Some(Ok(parsed_source)) => {
|
|
match analysis::get_lint_references(parsed_source, &linter.inner, token) {
|
|
Ok(references) => references
|
|
.into_iter()
|
|
.map(|r| r.to_diagnostic())
|
|
.collect::<Vec<_>>(),
|
|
_ => Vec::new(),
|
|
}
|
|
}
|
|
Some(Err(_)) => Vec::new(),
|
|
None => {
|
|
error!("Missing file contents for: {}", &module.specifier);
|
|
Vec::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct DiagnosticDataSpecifier {
|
|
pub specifier: ModuleSpecifier,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct DiagnosticDataStrSpecifier {
|
|
pub specifier: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct DiagnosticDataRedirect {
|
|
pub redirect: ModuleSpecifier,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct DiagnosticDataNoLocal {
|
|
pub to: ModuleSpecifier,
|
|
pub message: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct DiagnosticDataImportMapRemap {
|
|
pub from: String,
|
|
pub to: String,
|
|
}
|
|
|
|
/// An enum which represents diagnostic errors which originate from Deno itself.
|
|
pub enum DenoDiagnostic {
|
|
/// A `x-deno-warning` is associated with the specifier and should be displayed
|
|
/// as a warning to the user.
|
|
DenoWarn(String),
|
|
/// An informational diagnostic that indicates an existing specifier can be
|
|
/// remapped to an import map import specifier.
|
|
ImportMapRemap { from: String, to: String },
|
|
/// The import assertion type is incorrect.
|
|
InvalidAttributeType(String),
|
|
/// A module requires an attribute type to be a valid import.
|
|
NoAttributeType,
|
|
/// A remote module was not found in the cache.
|
|
NoCache(ModuleSpecifier),
|
|
/// A jsr package reference was not found in the cache.
|
|
NotInstalledJsr(PackageReq, ModuleSpecifier),
|
|
/// An npm package reference was not found in the cache.
|
|
NotInstalledNpm(PackageReq, ModuleSpecifier),
|
|
/// An npm package reference was not exported by its package.
|
|
NoExportNpm(NpmPackageReqReference),
|
|
/// A local module was not found on the local file system.
|
|
NoLocal(ModuleSpecifier),
|
|
/// An error occurred when resolving the specifier string.
|
|
ResolutionError(deno_graph::ResolutionError),
|
|
/// Unknown `node:` specifier.
|
|
UnknownNodeSpecifier(ModuleSpecifier),
|
|
/// Bare specifier is used for `node:` specifier
|
|
BareNodeSpecifier(String),
|
|
}
|
|
|
|
impl DenoDiagnostic {
|
|
fn code(&self) -> &str {
|
|
match self {
|
|
Self::DenoWarn(_) => "deno-warn",
|
|
Self::ImportMapRemap { .. } => "import-map-remap",
|
|
Self::InvalidAttributeType(_) => "invalid-attribute-type",
|
|
Self::NoAttributeType => "no-attribute-type",
|
|
Self::NoCache(_) => "no-cache",
|
|
Self::NotInstalledJsr(_, _) => "not-installed-jsr",
|
|
Self::NotInstalledNpm(_, _) => "not-installed-npm",
|
|
Self::NoExportNpm(_) => "no-export-npm",
|
|
Self::NoLocal(_) => "no-local",
|
|
Self::ResolutionError(err) => {
|
|
if deno_resolver::graph::get_resolution_error_bare_node_specifier(err)
|
|
.is_some()
|
|
{
|
|
"import-node-prefix-missing"
|
|
} else {
|
|
match err {
|
|
ResolutionError::InvalidDowngrade { .. } => "invalid-downgrade",
|
|
ResolutionError::InvalidJsrHttpsTypesImport { .. } => {
|
|
"invalid-jsr-https-types-import"
|
|
}
|
|
ResolutionError::InvalidLocalImport { .. } => {
|
|
"invalid-local-import"
|
|
}
|
|
ResolutionError::InvalidSpecifier { error, .. } => match error {
|
|
SpecifierError::ImportPrefixMissing { .. } => {
|
|
"import-prefix-missing"
|
|
}
|
|
SpecifierError::InvalidUrl(_) => "invalid-url",
|
|
},
|
|
ResolutionError::ResolverError { .. } => "resolver-error",
|
|
}
|
|
}
|
|
}
|
|
Self::UnknownNodeSpecifier(_) => "resolver-error",
|
|
Self::BareNodeSpecifier(_) => "import-node-prefix-missing",
|
|
}
|
|
}
|
|
|
|
/// A "static" method which for a diagnostic that originated from the
|
|
/// structure returns a code action which can resolve the diagnostic.
|
|
pub fn get_code_action(
|
|
uri: &Uri,
|
|
specifier: &ModuleSpecifier,
|
|
diagnostic: &lsp::Diagnostic,
|
|
) -> Result<lsp::CodeAction, AnyError> {
|
|
if let Some(lsp::NumberOrString::String(code)) = &diagnostic.code {
|
|
let code_action = match code.as_str() {
|
|
"import-map-remap" => {
|
|
let data = diagnostic
|
|
.data
|
|
.clone()
|
|
.ok_or_else(|| anyhow!("Diagnostic is missing data"))?;
|
|
let DiagnosticDataImportMapRemap { from, to } =
|
|
serde_json::from_value(data)?;
|
|
lsp::CodeAction {
|
|
title: format!("Update \"{from}\" to \"{to}\" to use import map."),
|
|
kind: Some(lsp::CodeActionKind::QUICKFIX),
|
|
diagnostics: Some(vec![diagnostic.clone()]),
|
|
edit: Some(lsp::WorkspaceEdit {
|
|
changes: Some(HashMap::from([(
|
|
uri.clone(),
|
|
vec![lsp::TextEdit {
|
|
new_text: format!("\"{to}\""),
|
|
range: diagnostic.range,
|
|
}],
|
|
)])),
|
|
..Default::default()
|
|
}),
|
|
..Default::default()
|
|
}
|
|
}
|
|
"no-attribute-type" => lsp::CodeAction {
|
|
title: "Insert import attribute.".to_string(),
|
|
kind: Some(lsp::CodeActionKind::QUICKFIX),
|
|
diagnostics: Some(vec![diagnostic.clone()]),
|
|
edit: Some(lsp::WorkspaceEdit {
|
|
changes: Some(HashMap::from([(
|
|
uri.clone(),
|
|
vec![lsp::TextEdit {
|
|
new_text: " with { type: \"json\" }".to_string(),
|
|
range: lsp::Range {
|
|
start: diagnostic.range.end,
|
|
end: diagnostic.range.end,
|
|
},
|
|
}],
|
|
)])),
|
|
..Default::default()
|
|
}),
|
|
..Default::default()
|
|
},
|
|
"no-cache" | "not-installed-jsr" | "not-installed-npm" => {
|
|
let data = diagnostic
|
|
.data
|
|
.clone()
|
|
.ok_or_else(|| anyhow!("Diagnostic is missing data"))?;
|
|
let data: DiagnosticDataSpecifier = serde_json::from_value(data)?;
|
|
let title = if matches!(
|
|
code.as_str(),
|
|
"not-installed-jsr" | "not-installed-npm"
|
|
) {
|
|
format!("Install \"{}\" and its dependencies.", data.specifier)
|
|
} else {
|
|
format!("Cache \"{}\" and its dependencies.", data.specifier)
|
|
};
|
|
lsp::CodeAction {
|
|
title,
|
|
kind: Some(lsp::CodeActionKind::QUICKFIX),
|
|
diagnostics: Some(vec![diagnostic.clone()]),
|
|
command: Some(lsp::Command {
|
|
title: "".to_string(),
|
|
command: "deno.cache".to_string(),
|
|
arguments: Some(vec![json!([data.specifier]), json!(&specifier)]),
|
|
}),
|
|
..Default::default()
|
|
}
|
|
}
|
|
"no-local" => {
|
|
let data = diagnostic
|
|
.data
|
|
.clone()
|
|
.ok_or_else(|| anyhow!("Diagnostic is missing data"))?;
|
|
let data: DiagnosticDataNoLocal = serde_json::from_value(data)?;
|
|
lsp::CodeAction {
|
|
title: data.message,
|
|
kind: Some(lsp::CodeActionKind::QUICKFIX),
|
|
diagnostics: Some(vec![diagnostic.clone()]),
|
|
edit: Some(lsp::WorkspaceEdit {
|
|
changes: Some(HashMap::from([(
|
|
uri.clone(),
|
|
vec![lsp::TextEdit {
|
|
new_text: format!(
|
|
"\"{}\"",
|
|
relative_specifier(&data.to, specifier)
|
|
),
|
|
range: diagnostic.range,
|
|
}],
|
|
)])),
|
|
..Default::default()
|
|
}),
|
|
..Default::default()
|
|
}
|
|
}
|
|
"redirect" => {
|
|
let data = diagnostic
|
|
.data
|
|
.clone()
|
|
.ok_or_else(|| anyhow!("Diagnostic is missing data"))?;
|
|
let data: DiagnosticDataRedirect = serde_json::from_value(data)?;
|
|
lsp::CodeAction {
|
|
title: "Update specifier to its redirected specifier.".to_string(),
|
|
kind: Some(lsp::CodeActionKind::QUICKFIX),
|
|
diagnostics: Some(vec![diagnostic.clone()]),
|
|
edit: Some(lsp::WorkspaceEdit {
|
|
changes: Some(HashMap::from([(
|
|
uri.clone(),
|
|
vec![lsp::TextEdit {
|
|
new_text: format!(
|
|
"\"{}\"",
|
|
specifier_text_for_redirected(&data.redirect, specifier)
|
|
),
|
|
range: diagnostic.range,
|
|
}],
|
|
)])),
|
|
..Default::default()
|
|
}),
|
|
..Default::default()
|
|
}
|
|
}
|
|
"import-node-prefix-missing" => {
|
|
let data = diagnostic
|
|
.data
|
|
.clone()
|
|
.ok_or_else(|| anyhow!("Diagnostic is missing data"))?;
|
|
let data: DiagnosticDataStrSpecifier = serde_json::from_value(data)?;
|
|
lsp::CodeAction {
|
|
title: format!("Update specifier to node:{}", data.specifier),
|
|
kind: Some(lsp::CodeActionKind::QUICKFIX),
|
|
diagnostics: Some(vec![diagnostic.clone()]),
|
|
edit: Some(lsp::WorkspaceEdit {
|
|
changes: Some(HashMap::from([(
|
|
uri.clone(),
|
|
vec![lsp::TextEdit {
|
|
new_text: format!("\"node:{}\"", data.specifier),
|
|
range: diagnostic.range,
|
|
}],
|
|
)])),
|
|
..Default::default()
|
|
}),
|
|
..Default::default()
|
|
}
|
|
}
|
|
_ => {
|
|
return Err(anyhow!(
|
|
"Unsupported diagnostic code (\"{}\") provided.",
|
|
code
|
|
));
|
|
}
|
|
};
|
|
Ok(code_action)
|
|
} else {
|
|
Err(anyhow!("Unsupported diagnostic code provided."))
|
|
}
|
|
}
|
|
|
|
/// Given a reference to the code from an LSP diagnostic, determine if the
|
|
/// diagnostic is fixable or not
|
|
pub fn is_fixable(diagnostic: &lsp_types::Diagnostic) -> bool {
|
|
if let Some(lsp::NumberOrString::String(code)) = &diagnostic.code {
|
|
match code.as_str() {
|
|
"import-map-remap"
|
|
| "no-cache"
|
|
| "not-installed-jsr"
|
|
| "not-installed-npm"
|
|
| "no-attribute-type"
|
|
| "redirect"
|
|
| "import-node-prefix-missing" => true,
|
|
"no-local" => diagnostic.data.is_some(),
|
|
_ => false,
|
|
}
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Convert to an lsp Diagnostic when the range the diagnostic applies to is
|
|
/// provided.
|
|
pub fn to_lsp_diagnostic(&self, range: &lsp::Range) -> lsp::Diagnostic {
|
|
fn no_local_message(
|
|
specifier: &ModuleSpecifier,
|
|
suggestion_message: Option<String>,
|
|
) -> String {
|
|
let mut message = format!(
|
|
"Unable to load a local module: {}\n",
|
|
to_percent_decoded_str(specifier.as_ref())
|
|
);
|
|
if let Some(suggestion_message) = suggestion_message {
|
|
message.push_str(&suggestion_message);
|
|
message.push('.');
|
|
} else {
|
|
message.push_str("Please check the file path.");
|
|
}
|
|
message
|
|
}
|
|
|
|
let (severity, message, data) = match self {
|
|
Self::DenoWarn(message) => (lsp::DiagnosticSeverity::WARNING, message.to_string(), None),
|
|
Self::ImportMapRemap { from, to } => (lsp::DiagnosticSeverity::HINT, format!("The import specifier can be remapped to \"{to}\" which will resolve it via the active import map."), Some(json!({ "from": from, "to": to }))),
|
|
Self::InvalidAttributeType(assert_type) => (lsp::DiagnosticSeverity::ERROR, format!("The module is a JSON module and expected an attribute type of \"json\". Instead got \"{assert_type}\"."), None),
|
|
Self::NoAttributeType => (lsp::DiagnosticSeverity::ERROR, "The module is a JSON module and not being imported with an import attribute. Consider adding `with { type: \"json\" }` to the import statement.".to_string(), None),
|
|
Self::NoCache(specifier) => (lsp::DiagnosticSeverity::ERROR, format!("Uncached or missing remote URL: {specifier}"), Some(json!({ "specifier": specifier }))),
|
|
Self::NotInstalledJsr(pkg_req, specifier) => (lsp::DiagnosticSeverity::ERROR, format!("JSR package \"{pkg_req}\" is not installed or doesn't exist."), Some(json!({ "specifier": specifier }))),
|
|
Self::NotInstalledNpm(pkg_req, specifier) => (lsp::DiagnosticSeverity::ERROR, format!("npm package \"{pkg_req}\" is not installed or doesn't exist."), Some(json!({ "specifier": specifier }))),
|
|
Self::NoExportNpm(pkg_ref) => (lsp::DiagnosticSeverity::ERROR, format!("NPM package \"{}\" does not define an export \"{}\".", pkg_ref.req(), pkg_ref.sub_path().unwrap_or(".")), None),
|
|
Self::NoLocal(specifier) => {
|
|
let sloppy_resolution = sloppy_imports_resolve(specifier, deno_resolver::workspace::ResolutionKind::Execution, CliSys::default());
|
|
let data = sloppy_resolution.as_ref().map(|(resolved, sloppy_reason)| {
|
|
json!({
|
|
"specifier": specifier,
|
|
"to": resolved,
|
|
"message": sloppy_reason.quick_fix_message_for_specifier(resolved),
|
|
})
|
|
});
|
|
(lsp::DiagnosticSeverity::ERROR, no_local_message(specifier, sloppy_resolution.as_ref().map(|(resolved, sloppy_reason)| sloppy_reason.suggestion_message_for_specifier(resolved))), data)
|
|
},
|
|
Self::ResolutionError(err) => {
|
|
let message = strip_ansi_codes(&enhanced_resolution_error_message(err)).into_owned();
|
|
(
|
|
lsp::DiagnosticSeverity::ERROR,
|
|
message,
|
|
deno_resolver::graph::get_resolution_error_bare_node_specifier(err)
|
|
.map(|specifier| json!({ "specifier": specifier }))
|
|
)},
|
|
Self::UnknownNodeSpecifier(specifier) => (lsp::DiagnosticSeverity::ERROR, format!("No such built-in module: node:{}", specifier.path()), None),
|
|
Self::BareNodeSpecifier(specifier) => (lsp::DiagnosticSeverity::WARNING, format!("\"{0}\" is resolved to \"node:{0}\". If you want to use a built-in Node module, add a \"node:\" prefix.", specifier), Some(json!({ "specifier": specifier }))),
|
|
};
|
|
lsp::Diagnostic {
|
|
range: *range,
|
|
severity: Some(severity),
|
|
code: Some(lsp::NumberOrString::String(self.code().to_string())),
|
|
source: Some(DiagnosticSource::Deno.as_lsp_source().to_string()),
|
|
message,
|
|
data,
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn specifier_text_for_redirected(redirect: &Url, referrer: &Url) -> String {
|
|
if redirect.scheme() == "file" && referrer.scheme() == "file" {
|
|
// use a relative specifier when it's going to a file url
|
|
relative_specifier(redirect, referrer)
|
|
} else {
|
|
redirect.to_string()
|
|
}
|
|
}
|
|
|
|
fn relative_specifier(specifier: &Url, referrer: &Url) -> String {
|
|
match referrer.make_relative(specifier) {
|
|
Some(relative) => {
|
|
if relative.starts_with('.') {
|
|
relative
|
|
} else {
|
|
format!("./{}", relative)
|
|
}
|
|
}
|
|
None => specifier.to_string(),
|
|
}
|
|
}
|
|
|
|
fn maybe_ambient_import_specifier(
|
|
diagnostic: &DenoDiagnostic,
|
|
) -> Option<String> {
|
|
match diagnostic {
|
|
DenoDiagnostic::NoCache(url) | DenoDiagnostic::NoLocal(url) => {
|
|
Some(url.to_string())
|
|
}
|
|
DenoDiagnostic::ResolutionError(err) => {
|
|
maybe_ambient_specifier_resolution_err(err)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn maybe_ambient_specifier_resolution_err(
|
|
err: &ResolutionError,
|
|
) -> Option<String> {
|
|
match err {
|
|
ResolutionError::InvalidDowngrade { .. }
|
|
| ResolutionError::InvalidJsrHttpsTypesImport { .. }
|
|
| ResolutionError::InvalidLocalImport { .. } => None,
|
|
ResolutionError::InvalidSpecifier { error, .. } => match error {
|
|
SpecifierError::InvalidUrl(..) => None,
|
|
SpecifierError::ImportPrefixMissing { specifier, .. } => {
|
|
Some(specifier.to_string())
|
|
}
|
|
},
|
|
ResolutionError::ResolverError { error, .. } => match &**error {
|
|
ResolveError::Specifier(specifier_error) => match specifier_error {
|
|
SpecifierError::InvalidUrl(..) => None,
|
|
SpecifierError::ImportPrefixMissing { specifier, .. } => {
|
|
Some(specifier.to_string())
|
|
}
|
|
},
|
|
ResolveError::ImportMap(import_map_error) => {
|
|
match import_map_error.as_kind() {
|
|
ImportMapErrorKind::UnmappedBareSpecifier(spec, _) => {
|
|
Some(spec.clone())
|
|
}
|
|
ImportMapErrorKind::JsonParse(_)
|
|
| ImportMapErrorKind::ImportMapNotObject
|
|
| ImportMapErrorKind::ImportsFieldNotObject
|
|
| ImportMapErrorKind::ScopesFieldNotObject
|
|
| ImportMapErrorKind::ScopePrefixNotObject(_)
|
|
| ImportMapErrorKind::BlockedByNullEntry(_)
|
|
| ImportMapErrorKind::SpecifierResolutionFailure { .. }
|
|
| ImportMapErrorKind::SpecifierBacktracksAbovePrefix { .. } => None,
|
|
}
|
|
}
|
|
ResolveError::Other(..) => None,
|
|
},
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn diagnose_resolution(
|
|
snapshot: &language_server::StateSnapshot,
|
|
dependency_key: &str,
|
|
resolution: &Resolution,
|
|
is_dynamic: bool,
|
|
maybe_assert_type: Option<&str>,
|
|
referrer_module: &DocumentModule,
|
|
import_map: Option<&ImportMap>,
|
|
) -> (Vec<DenoDiagnostic>, Vec<DenoDiagnostic>) {
|
|
let mut diagnostics = vec![];
|
|
let mut deferred_diagnostics = vec![];
|
|
match resolution {
|
|
Resolution::Ok(resolved) => {
|
|
let specifier = &resolved.specifier;
|
|
let scoped_resolver = snapshot
|
|
.resolver
|
|
.get_scoped_resolver(referrer_module.scope.as_deref());
|
|
let managed_npm_resolver =
|
|
scoped_resolver.as_maybe_managed_npm_resolver();
|
|
for (_, headers) in scoped_resolver.redirect_chain_headers(specifier) {
|
|
if let Some(message) = headers.get("x-deno-warning") {
|
|
diagnostics.push(DenoDiagnostic::DenoWarn(message.clone()));
|
|
}
|
|
}
|
|
match snapshot.document_modules.module_for_specifier(
|
|
specifier,
|
|
referrer_module.scope.as_deref(),
|
|
Some(&referrer_module.compiler_options_key),
|
|
) {
|
|
Some(module) => {
|
|
if let Some(headers) = &module.headers
|
|
&& let Some(message) = headers.get("x-deno-warning")
|
|
{
|
|
diagnostics.push(DenoDiagnostic::DenoWarn(message.clone()));
|
|
}
|
|
if module.media_type == MediaType::Json {
|
|
match maybe_assert_type {
|
|
// The module has the correct assertion type, no diagnostic
|
|
Some("json" | "text" | "bytes") => (),
|
|
// The dynamic import statement is missing an attribute type, which
|
|
// we might not be able to statically detect, therefore we will
|
|
// not provide a potentially incorrect diagnostic.
|
|
None if is_dynamic => (),
|
|
// The module has an incorrect assertion type, diagnostic
|
|
Some(assert_type) => diagnostics.push(
|
|
DenoDiagnostic::InvalidAttributeType(assert_type.to_string()),
|
|
),
|
|
// The module is missing an attribute type, diagnostic
|
|
None => diagnostics.push(DenoDiagnostic::NoAttributeType),
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
match JsrPackageReqReference::from_specifier(specifier) {
|
|
Ok(pkg_ref) => {
|
|
let req = pkg_ref.into_inner().req;
|
|
diagnostics
|
|
.push(DenoDiagnostic::NotInstalledJsr(req, specifier.clone()));
|
|
}
|
|
_ => {
|
|
match NpmPackageReqReference::from_specifier(specifier) {
|
|
Ok(pkg_ref) => {
|
|
if let Some(npm_resolver) = managed_npm_resolver {
|
|
// show diagnostics for npm package references that aren't cached
|
|
let req = pkg_ref.req();
|
|
if !npm_resolver.is_pkg_req_folder_cached(req) {
|
|
diagnostics.push(DenoDiagnostic::NotInstalledNpm(
|
|
req.clone(),
|
|
specifier.clone(),
|
|
));
|
|
} else {
|
|
let resolution_kinds = [
|
|
NodeResolutionKind::Types,
|
|
NodeResolutionKind::Execution,
|
|
];
|
|
if resolution_kinds.into_iter().all(|k| {
|
|
scoped_resolver
|
|
.npm_to_file_url(
|
|
&pkg_ref,
|
|
&referrer_module.specifier,
|
|
k,
|
|
referrer_module.resolution_mode,
|
|
)
|
|
.is_none()
|
|
}) {
|
|
diagnostics
|
|
.push(DenoDiagnostic::NoExportNpm(pkg_ref.clone()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
if let Some(module_name) =
|
|
specifier.as_str().strip_prefix("node:")
|
|
{
|
|
if !deno_node::is_builtin_node_module(module_name) {
|
|
diagnostics.push(DenoDiagnostic::UnknownNodeSpecifier(
|
|
specifier.clone(),
|
|
));
|
|
} else if module_name == dependency_key {
|
|
let mut is_mapped = false;
|
|
if let Some(import_map) = import_map
|
|
&& let Resolution::Ok(resolved) = &resolution
|
|
&& import_map
|
|
.resolve(module_name, &resolved.specifier)
|
|
.is_ok()
|
|
{
|
|
is_mapped = true;
|
|
}
|
|
// show diagnostics for bare node specifiers that aren't mapped by import map
|
|
if !is_mapped {
|
|
diagnostics.push(DenoDiagnostic::BareNodeSpecifier(
|
|
module_name.to_string(),
|
|
));
|
|
}
|
|
} else if let Some(npm_resolver) = managed_npm_resolver {
|
|
// check that a @types/node package exists in the resolver
|
|
let types_node_req =
|
|
PackageReq::from_str("@types/node").unwrap();
|
|
if !npm_resolver.is_pkg_req_folder_cached(&types_node_req)
|
|
{
|
|
diagnostics.push(DenoDiagnostic::NotInstalledNpm(
|
|
types_node_req,
|
|
ModuleSpecifier::parse("npm:@types/node").unwrap(),
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
// When the document is not available, it means that it cannot be found
|
|
// in the cache or locally on the disk, so we want to issue a diagnostic
|
|
// about that.
|
|
// these may be invalid, however, if this is an ambient module with
|
|
// no real source (as in the case of a virtual module).
|
|
let deno_diagnostic = match specifier.scheme() {
|
|
"file" => DenoDiagnostic::NoLocal(specifier.clone()),
|
|
_ => DenoDiagnostic::NoCache(specifier.clone()),
|
|
};
|
|
deferred_diagnostics.push(deno_diagnostic);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// The specifier resolution resulted in an error, so we want to issue a
|
|
// diagnostic for that.
|
|
Resolution::Err(err) => {
|
|
if maybe_ambient_specifier_resolution_err(err).is_none() {
|
|
diagnostics.push(DenoDiagnostic::ResolutionError(*err.clone()))
|
|
} else {
|
|
deferred_diagnostics
|
|
.push(DenoDiagnostic::ResolutionError(*err.clone()));
|
|
}
|
|
}
|
|
_ => (),
|
|
}
|
|
(diagnostics, deferred_diagnostics)
|
|
}
|
|
|
|
/// Generate diagnostics related to a dependency. The dependency is analyzed to
|
|
/// determine if it can be remapped to the active import map as well as surface
|
|
/// any diagnostics related to the resolved code or type dependency.
|
|
fn diagnose_dependency(
|
|
diagnostics: &mut Vec<lsp::Diagnostic>,
|
|
deferred_diagnostics: &mut Vec<(String, lsp::Diagnostic)>,
|
|
snapshot: &language_server::StateSnapshot,
|
|
referrer_module: &DocumentModule,
|
|
dependency_key: &str,
|
|
dependency: &deno_graph::Dependency,
|
|
) {
|
|
if snapshot
|
|
.resolver
|
|
.in_node_modules(&referrer_module.specifier)
|
|
{
|
|
return; // ignore, surface typescript errors instead
|
|
}
|
|
|
|
let import_map = snapshot
|
|
.resolver
|
|
.get_scoped_resolver(referrer_module.scope.as_deref())
|
|
.as_workspace_resolver()
|
|
.maybe_import_map();
|
|
if let Some(import_map) = import_map {
|
|
let resolved = dependency
|
|
.maybe_code
|
|
.ok()
|
|
.or_else(|| dependency.maybe_type.ok());
|
|
if let Some(resolved) = resolved
|
|
&& let Some(to) = import_map_lookup(
|
|
import_map,
|
|
&resolved.specifier,
|
|
&referrer_module.specifier,
|
|
)
|
|
&& dependency_key != to
|
|
{
|
|
diagnostics.push(
|
|
DenoDiagnostic::ImportMapRemap {
|
|
from: dependency_key.to_string(),
|
|
to,
|
|
}
|
|
.to_lsp_diagnostic(&language_server::to_lsp_range(&resolved.range)),
|
|
);
|
|
}
|
|
}
|
|
|
|
let import_ranges: Vec<_> = dependency
|
|
.imports
|
|
.iter()
|
|
.map(|i| language_server::to_lsp_range(&i.specifier_range))
|
|
.collect();
|
|
// TODO(nayeemrmn): This is a crude way of detecting `@ts-types` which has
|
|
// a different specifier and therefore needs a separate call to
|
|
// `diagnose_resolution()`. It would be much cleaner if that were modelled as
|
|
// a separate dependency: https://github.com/denoland/deno_graph/issues/247.
|
|
let is_types_deno_types = !dependency.maybe_type.is_none()
|
|
&& !dependency.imports.iter().any(|i| {
|
|
dependency
|
|
.maybe_type
|
|
.includes(i.specifier_range.range.start)
|
|
.is_some()
|
|
});
|
|
let resolution = if dependency.maybe_code.is_none()
|
|
// If not @ts-types, diagnose the types if the code errored because
|
|
// it's likely resolving into the node_modules folder, which might be
|
|
// erroring correctly due to resolution only being for bundlers. Let this
|
|
// fail at runtime if necessary, but don't bother erroring in the editor
|
|
|| !is_types_deno_types && matches!(dependency.maybe_type, Resolution::Ok(_))
|
|
&& matches!(dependency.maybe_code, Resolution::Err(_))
|
|
{
|
|
&dependency.maybe_type
|
|
} else {
|
|
&dependency.maybe_code
|
|
};
|
|
let (resolution_diagnostics, deferred) = diagnose_resolution(
|
|
snapshot,
|
|
dependency_key,
|
|
resolution,
|
|
dependency.is_dynamic,
|
|
dependency.maybe_attribute_type.as_deref(),
|
|
referrer_module,
|
|
import_map,
|
|
);
|
|
diagnostics.extend(resolution_diagnostics.iter().flat_map(|diag| {
|
|
import_ranges
|
|
.iter()
|
|
.map(|range| diag.to_lsp_diagnostic(range))
|
|
}));
|
|
deferred_diagnostics.extend(
|
|
deferred
|
|
.iter()
|
|
.filter_map(|diag| {
|
|
maybe_ambient_import_specifier(diag).map(|spec| {
|
|
import_ranges
|
|
.iter()
|
|
.map(move |range| (spec.clone(), diag.to_lsp_diagnostic(range)))
|
|
})
|
|
})
|
|
.flatten(),
|
|
);
|
|
|
|
if is_types_deno_types {
|
|
let range = match &dependency.maybe_type {
|
|
Resolution::Ok(resolved) => {
|
|
language_server::to_lsp_range(&resolved.range)
|
|
}
|
|
Resolution::Err(error) => language_server::to_lsp_range(error.range()),
|
|
Resolution::None => unreachable!(),
|
|
};
|
|
let (resolution_diagnostics, deferred) = diagnose_resolution(
|
|
snapshot,
|
|
dependency_key,
|
|
&dependency.maybe_type,
|
|
dependency.is_dynamic,
|
|
dependency.maybe_attribute_type.as_deref(),
|
|
referrer_module,
|
|
import_map,
|
|
);
|
|
diagnostics.extend(
|
|
resolution_diagnostics
|
|
.iter()
|
|
.map(|diag| diag.to_lsp_diagnostic(&range)),
|
|
);
|
|
deferred_diagnostics.extend(Box::new(deferred.iter().filter_map(|diag| {
|
|
maybe_ambient_import_specifier(diag)
|
|
.map(|spec| (spec, diag.to_lsp_diagnostic(&range)))
|
|
})));
|
|
}
|
|
}
|
|
|
|
async fn publish_document_diagnostics(
|
|
document: &Arc<OpenDocument>,
|
|
diagnostics: Vec<lsp::Diagnostic>,
|
|
client: &Client,
|
|
state: &DiagnosticsState,
|
|
_token: &CancellationToken,
|
|
) {
|
|
state.update(&document.uri, document.version, &diagnostics);
|
|
client
|
|
.publish_diagnostics(
|
|
document.uri.as_ref().clone(),
|
|
diagnostics,
|
|
Some(document.version),
|
|
)
|
|
.await;
|
|
}
|
|
|
|
async fn generate_document_diagnostics(
|
|
document: &Arc<OpenDocument>,
|
|
snapshot: &Arc<StateSnapshot>,
|
|
ts_server: &TsServer,
|
|
ambient_modules_regex_cache: &OnceCellMap<
|
|
(CompilerOptionsKey, Option<Arc<Uri>>),
|
|
Option<regex::Regex>,
|
|
>,
|
|
token: &CancellationToken,
|
|
) -> Result<Vec<lsp::Diagnostic>, AnyError> {
|
|
if !document.is_diagnosable() {
|
|
return Ok(Vec::new());
|
|
}
|
|
let document_ = Document::Open(document.clone());
|
|
let module = match snapshot.document_modules.primary_module(&document_) {
|
|
Some(module) => module,
|
|
None => {
|
|
let url = uri_to_url(document_.uri());
|
|
if url.scheme() == "file"
|
|
&& !snapshot.resolver.in_node_modules(&url)
|
|
&& !snapshot.cache.in_cache_directory(&url)
|
|
{
|
|
return Ok(Vec::new());
|
|
}
|
|
// If this document represents a non-local module, the module may not be
|
|
// retrievable until its referrer is known through some other request.
|
|
// Wait and try one more time.
|
|
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
|
|
let Some(module) = snapshot.document_modules.primary_module(&document_)
|
|
else {
|
|
return Ok(Vec::new());
|
|
};
|
|
module
|
|
}
|
|
};
|
|
if !snapshot.config.specifier_enabled(&module.specifier) {
|
|
return Ok(Vec::new());
|
|
}
|
|
generate_module_diagnostics(
|
|
&module,
|
|
snapshot,
|
|
ts_server,
|
|
ambient_modules_regex_cache,
|
|
token,
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn generate_module_diagnostics(
|
|
module: &Arc<DocumentModule>,
|
|
snapshot: &Arc<StateSnapshot>,
|
|
ts_server: &TsServer,
|
|
ambient_modules_regex_cache: &OnceCellMap<
|
|
(CompilerOptionsKey, Option<Arc<Uri>>),
|
|
Option<regex::Regex>,
|
|
>,
|
|
token: &CancellationToken,
|
|
) -> Result<Vec<lsp::Diagnostic>, AnyError> {
|
|
let deps_handle = tokio::task::spawn_blocking({
|
|
let snapshot = snapshot.clone();
|
|
let module = module.clone();
|
|
let token = token.clone();
|
|
move || {
|
|
let mut diagnostics = Vec::new();
|
|
let mut deferred = Vec::new();
|
|
for (dependency_key, dependency) in module.dependencies.iter() {
|
|
if token.is_cancelled() {
|
|
return (Vec::new(), Vec::new());
|
|
}
|
|
diagnose_dependency(
|
|
&mut diagnostics,
|
|
&mut deferred,
|
|
&snapshot,
|
|
&module,
|
|
dependency_key,
|
|
dependency,
|
|
);
|
|
}
|
|
(diagnostics, deferred)
|
|
}
|
|
});
|
|
|
|
let lint_handle = tokio::task::spawn_blocking({
|
|
let snapshot = snapshot.clone();
|
|
let module = module.clone();
|
|
let token = token.clone();
|
|
move || {
|
|
// TODO(nayeemrmn): Support linting notebooks cells. Will require
|
|
// stitching cells from the same notebook into one module, linting it
|
|
// and then splitting/relocating the diagnostics to each cell.
|
|
if token.is_cancelled()
|
|
|| module.notebook_uri.is_some()
|
|
|| module.specifier.scheme() != "file"
|
|
|| snapshot.resolver.in_node_modules(&module.specifier)
|
|
{
|
|
return Vec::new();
|
|
}
|
|
let settings = snapshot
|
|
.config
|
|
.workspace_settings_for_specifier(&module.specifier);
|
|
if !settings.lint {
|
|
return Vec::new();
|
|
}
|
|
let linter = snapshot.linter_resolver.for_module(&module);
|
|
generate_document_lint_diagnostics(&module, &linter, token)
|
|
}
|
|
});
|
|
|
|
let mut ts_diagnostics = ts_server
|
|
.get_diagnostics(snapshot.clone(), module, token)
|
|
.await?;
|
|
let suggestion_actions_settings = snapshot
|
|
.config
|
|
.language_settings_for_specifier(&module.specifier)
|
|
.map(|s| s.suggestion_actions.clone())
|
|
.unwrap_or_default();
|
|
if !suggestion_actions_settings.enabled {
|
|
ts_diagnostics.retain(|d| {
|
|
d.category != DiagnosticCategory::Suggestion
|
|
// Still show deprecated and unused diagnostics.
|
|
// https://github.com/microsoft/vscode/blob/ce50bd4876af457f64d83cfd956bc916535285f4/extensions/typescript-language-features/src/languageFeatures/diagnostics.ts#L113-L114
|
|
|| d.reports_deprecated == Some(true)
|
|
|| d.reports_unnecessary == Some(true)
|
|
});
|
|
}
|
|
let mut diagnostics =
|
|
ts_json_to_diagnostics(ts_diagnostics, module, &snapshot.document_modules);
|
|
|
|
let (deps_diagnostics, deferred_deps_diagnostics) = deps_handle
|
|
.await
|
|
.inspect_err(|err| {
|
|
lsp_warn!("Deps diagnostics task join error: {err:#}");
|
|
})
|
|
.unwrap_or_default();
|
|
diagnostics.extend(deps_diagnostics);
|
|
let ambient_modules_regex_cell = ambient_modules_regex_cache
|
|
.entry((
|
|
module.compiler_options_key.clone(),
|
|
module.notebook_uri.clone(),
|
|
))
|
|
.or_default()
|
|
.clone();
|
|
let ambient_modules_regex = ambient_modules_regex_cell
|
|
.get_or_init(async || {
|
|
ts_server
|
|
.get_ambient_modules(
|
|
snapshot.clone(),
|
|
&module.compiler_options_key,
|
|
module.notebook_uri.as_ref(),
|
|
token,
|
|
)
|
|
.await
|
|
.inspect_err(|err| {
|
|
if !token.is_cancelled() {
|
|
lsp_warn!("Unable to get ambient modules: {:#}", err);
|
|
}
|
|
})
|
|
.ok()
|
|
.filter(|a| !a.is_empty())
|
|
.and_then(|ambient_modules| {
|
|
let regex_string = ambient_modules_to_regex_string(&ambient_modules);
|
|
regex::Regex::new(®ex_string).inspect_err(|err| {
|
|
lsp_warn!("Failed to compile ambient modules pattern: {err:#} (pattern is {regex_string:?})");
|
|
}).ok()
|
|
})
|
|
}).await;
|
|
if let Some(ambient_modules_regex) = ambient_modules_regex {
|
|
diagnostics.extend(deferred_deps_diagnostics.into_iter().filter_map(
|
|
|(import_url, diag)| {
|
|
if ambient_modules_regex.is_match(import_url.as_str()) {
|
|
return None;
|
|
}
|
|
Some(diag)
|
|
},
|
|
));
|
|
} else {
|
|
diagnostics.extend(deferred_deps_diagnostics.into_iter().map(|(_, d)| d));
|
|
}
|
|
|
|
let lint_diagnostics = lint_handle
|
|
.await
|
|
.inspect_err(|err| {
|
|
lsp_warn!("Lint task join error: {err:#}");
|
|
})
|
|
.unwrap_or_default();
|
|
diagnostics.extend(lint_diagnostics);
|
|
|
|
Ok(diagnostics)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::str::FromStr;
|
|
use std::sync::Arc;
|
|
|
|
use deno_config::deno_json::ConfigFile;
|
|
use pretty_assertions::assert_eq;
|
|
use test_util::TempDir;
|
|
|
|
use super::*;
|
|
use crate::lsp::cache::LspCache;
|
|
use crate::lsp::compiler_options::LspCompilerOptionsResolver;
|
|
use crate::lsp::config::Config;
|
|
use crate::lsp::config::WorkspaceSettings;
|
|
use crate::lsp::documents::DocumentModules;
|
|
use crate::lsp::documents::LanguageId;
|
|
use crate::lsp::language_server::StateSnapshot;
|
|
use crate::lsp::lint::LspLinterResolver;
|
|
use crate::lsp::resolver::LspResolver;
|
|
use crate::lsp::urls::url_to_uri;
|
|
|
|
async fn setup(
|
|
sources: &[(&str, &str, i32, LanguageId)],
|
|
maybe_import_map: Option<(&str, &str)>,
|
|
) -> (TempDir, StateSnapshot) {
|
|
let temp_dir = TempDir::new();
|
|
let root_url = temp_dir.url();
|
|
let cache = LspCache::new(Some(root_url.join(".deno_dir").unwrap()));
|
|
let mut config = Config::new_with_roots([root_url.clone()]);
|
|
let enabled_settings =
|
|
serde_json::from_str::<WorkspaceSettings>(r#"{ "enable": true }"#)
|
|
.unwrap();
|
|
config.set_workspace_settings(
|
|
enabled_settings.clone(),
|
|
vec![(Arc::new(root_url.clone()), enabled_settings)],
|
|
);
|
|
if let Some((relative_path, json_string)) = maybe_import_map {
|
|
let base_url = root_url.join(relative_path).unwrap();
|
|
let config_file = ConfigFile::new(json_string, base_url).unwrap();
|
|
config.tree.inject_config_file(config_file).await;
|
|
}
|
|
let resolver =
|
|
Arc::new(LspResolver::from_config(&config, &cache, None).await);
|
|
let compiler_options_resolver =
|
|
Arc::new(LspCompilerOptionsResolver::new(&config, &resolver));
|
|
resolver.set_compiler_options_resolver(&compiler_options_resolver.inner);
|
|
let linter_resolver = Arc::new(LspLinterResolver::new(
|
|
&config,
|
|
&compiler_options_resolver,
|
|
&resolver,
|
|
));
|
|
let mut document_modules = DocumentModules::default();
|
|
document_modules.update_config(
|
|
&config,
|
|
&compiler_options_resolver,
|
|
&resolver,
|
|
&cache,
|
|
&Default::default(),
|
|
);
|
|
for (relative_path, source, version, language_id) in sources {
|
|
let specifier = root_url.join(relative_path).unwrap();
|
|
document_modules.open_document(
|
|
url_to_uri(&specifier).unwrap(),
|
|
*version,
|
|
*language_id,
|
|
(*source).into(),
|
|
None,
|
|
);
|
|
}
|
|
(
|
|
temp_dir,
|
|
StateSnapshot {
|
|
project_version: 0,
|
|
document_modules,
|
|
config: Arc::new(config),
|
|
compiler_options_resolver,
|
|
linter_resolver,
|
|
resolver,
|
|
cache: Arc::new(cache),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn generate_all_deno_diagnostics(
|
|
snapshot: &StateSnapshot,
|
|
) -> Vec<(Uri, Vec<lsp::Diagnostic>)> {
|
|
snapshot
|
|
.document_modules
|
|
.documents
|
|
.open_docs()
|
|
.filter_map(|doc| {
|
|
if !doc.is_diagnosable() {
|
|
return None;
|
|
}
|
|
let module = snapshot
|
|
.document_modules
|
|
.primary_module(&Document::Open(doc.clone()))?;
|
|
if !snapshot.config.specifier_enabled(&module.specifier) {
|
|
return None;
|
|
}
|
|
let mut diagnostics = Vec::new();
|
|
let mut deferred = Vec::new();
|
|
for (dependency_key, dependency) in module.dependencies.iter() {
|
|
diagnose_dependency(
|
|
&mut diagnostics,
|
|
&mut deferred,
|
|
snapshot,
|
|
&module,
|
|
dependency_key,
|
|
dependency,
|
|
);
|
|
}
|
|
diagnostics.extend(deferred.into_iter().map(|(_, d)| d));
|
|
Some((doc.uri.as_ref().clone(), diagnostics))
|
|
})
|
|
.collect::<Vec<_>>()
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_deno_diagnostics_with_import_map() {
|
|
let (temp_dir, snapshot) = setup(
|
|
&[
|
|
(
|
|
"std/assert/mod.ts",
|
|
"export function assert() {}",
|
|
1,
|
|
LanguageId::TypeScript,
|
|
),
|
|
(
|
|
"a/file.ts",
|
|
"import { assert } from \"../std/assert/mod.ts\";\n\nassert();\nexport function a() {}",
|
|
1,
|
|
LanguageId::TypeScript,
|
|
),
|
|
(
|
|
"a/file2.ts",
|
|
"import { a } from './file.ts';\nconsole.log(a);\n",
|
|
1,
|
|
LanguageId::TypeScript,
|
|
),
|
|
],
|
|
Some((
|
|
"a/deno.json",
|
|
r#"{
|
|
"imports": {
|
|
"/~/std/": "../std/",
|
|
"$@/": "./",
|
|
"$a/": "../a/"
|
|
}
|
|
}"#,
|
|
)),
|
|
)
|
|
.await;
|
|
let actual = generate_all_deno_diagnostics(&snapshot);
|
|
assert_eq!(
|
|
json!(actual),
|
|
json!([
|
|
[
|
|
url_to_uri(&temp_dir.url().join("std/assert/mod.ts").unwrap()).unwrap(),
|
|
[],
|
|
],
|
|
[
|
|
url_to_uri(&temp_dir.url().join("a/file.ts").unwrap()).unwrap(),
|
|
[
|
|
{
|
|
"range": {
|
|
"start": { "line": 0, "character": 23 },
|
|
"end": { "line": 0, "character": 45 },
|
|
},
|
|
"severity": 4,
|
|
"code": "import-map-remap",
|
|
"source": "deno",
|
|
"message": "The import specifier can be remapped to \"/~/std/assert/mod.ts\" which will resolve it via the active import map.",
|
|
"data": {
|
|
"from": "../std/assert/mod.ts",
|
|
"to": "/~/std/assert/mod.ts",
|
|
},
|
|
},
|
|
],
|
|
],
|
|
[
|
|
url_to_uri(&temp_dir.url().join("a/file2.ts").unwrap()).unwrap(),
|
|
[],
|
|
],
|
|
]),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_code_action_import_map_remap() {
|
|
let uri = Uri::from_str("file:///a/file.ts").unwrap();
|
|
let specifier = ModuleSpecifier::parse("file:///a/file.ts").unwrap();
|
|
let result = DenoDiagnostic::get_code_action(&uri, &specifier, &lsp::Diagnostic {
|
|
range: lsp::Range {
|
|
start: lsp::Position { line: 0, character: 23 },
|
|
end: lsp::Position { line: 0, character: 50 },
|
|
},
|
|
severity: Some(lsp::DiagnosticSeverity::HINT),
|
|
code: Some(lsp::NumberOrString::String("import-map-remap".to_string())),
|
|
source: Some("deno".to_string()),
|
|
message: "The import specifier can be remapped to \"/~/std/assert/mod.ts\" which will resolve it via the active import map.".to_string(),
|
|
data: Some(json!({
|
|
"from": "../std/assert/mod.ts",
|
|
"to": "/~/std/assert/mod.ts"
|
|
})),
|
|
..Default::default()
|
|
});
|
|
assert!(result.is_ok());
|
|
let actual = result.unwrap();
|
|
assert_eq!(
|
|
json!(actual),
|
|
json!({
|
|
"title": "Update \"../std/assert/mod.ts\" to \"/~/std/assert/mod.ts\" to use import map.",
|
|
"kind": "quickfix",
|
|
"diagnostics": [
|
|
{
|
|
"range": {
|
|
"start": {
|
|
"line": 0,
|
|
"character": 23
|
|
},
|
|
"end": {
|
|
"line": 0,
|
|
"character": 50
|
|
}
|
|
},
|
|
"severity": 4,
|
|
"code": "import-map-remap",
|
|
"source": "deno",
|
|
"message": "The import specifier can be remapped to \"/~/std/assert/mod.ts\" which will resolve it via the active import map.",
|
|
"data": {
|
|
"from": "../std/assert/mod.ts",
|
|
"to": "/~/std/assert/mod.ts"
|
|
}
|
|
}
|
|
],
|
|
"edit": {
|
|
"changes": {
|
|
"file:///a/file.ts": [
|
|
{
|
|
"range": {
|
|
"start": {
|
|
"line": 0,
|
|
"character": 23
|
|
},
|
|
"end": {
|
|
"line": 0,
|
|
"character": 50
|
|
}
|
|
},
|
|
"newText": "\"/~/std/assert/mod.ts\""
|
|
}
|
|
]
|
|
}
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn duplicate_diagnostics_for_duplicate_imports() {
|
|
let (temp_dir, snapshot) = setup(
|
|
&[(
|
|
"a.ts",
|
|
r#"
|
|
// @ts-types="bad.d.ts"
|
|
import "bad.js";
|
|
import "bad.js";
|
|
"#,
|
|
1,
|
|
LanguageId::TypeScript,
|
|
)],
|
|
None,
|
|
)
|
|
.await;
|
|
let actual = generate_all_deno_diagnostics(&snapshot);
|
|
assert_eq!(
|
|
json!(actual),
|
|
json!([
|
|
[
|
|
url_to_uri(&temp_dir.url().join("a.ts").unwrap()).unwrap(),
|
|
[
|
|
{
|
|
"range": {
|
|
"start": { "line": 2, "character": 15 },
|
|
"end": { "line": 2, "character": 23 },
|
|
},
|
|
"severity": 1,
|
|
"code": "import-prefix-missing",
|
|
"source": "deno",
|
|
"message": "Relative import path \"bad.js\" not prefixed with / or ./ or ../",
|
|
},
|
|
{
|
|
"range": {
|
|
"start": { "line": 3, "character": 15 },
|
|
"end": { "line": 3, "character": 23 },
|
|
},
|
|
"severity": 1,
|
|
"code": "import-prefix-missing",
|
|
"source": "deno",
|
|
"message": "Relative import path \"bad.js\" not prefixed with / or ./ or ../",
|
|
},
|
|
{
|
|
"range": {
|
|
"start": { "line": 1, "character": 21 },
|
|
"end": { "line": 1, "character": 31 },
|
|
},
|
|
"severity": 1,
|
|
"code": "import-prefix-missing",
|
|
"source": "deno",
|
|
"message": "Relative import path \"bad.d.ts\" not prefixed with / or ./ or ../",
|
|
},
|
|
],
|
|
],
|
|
]),
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn unable_to_load_a_local_module() {
|
|
let (temp_dir, snapshot) = setup(
|
|
&[(
|
|
"a.ts",
|
|
r#"
|
|
import { 東京 } from "./🦕.ts";
|
|
"#,
|
|
1,
|
|
LanguageId::TypeScript,
|
|
)],
|
|
None,
|
|
)
|
|
.await;
|
|
let actual = generate_all_deno_diagnostics(&snapshot);
|
|
assert_eq!(
|
|
json!(actual),
|
|
json!([
|
|
[
|
|
url_to_uri(&temp_dir.url().join("a.ts").unwrap()).unwrap(),
|
|
[
|
|
{
|
|
"range": {
|
|
"start": { "line": 1, "character": 27 },
|
|
"end": { "line": 1, "character": 35 },
|
|
},
|
|
"severity": 1,
|
|
"code": "no-local",
|
|
"source": "deno",
|
|
"message": format!(
|
|
"Unable to load a local module: {}🦕.ts\nPlease check the file path.",
|
|
temp_dir.url(),
|
|
),
|
|
},
|
|
],
|
|
],
|
|
]),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_specifier_text_for_redirected() {
|
|
#[track_caller]
|
|
fn run_test(specifier: &str, referrer: &str, expected: &str) {
|
|
let result = specifier_text_for_redirected(
|
|
&ModuleSpecifier::parse(specifier).unwrap(),
|
|
&ModuleSpecifier::parse(referrer).unwrap(),
|
|
);
|
|
assert_eq!(result, expected);
|
|
}
|
|
|
|
run_test("file:///a/a.ts", "file:///a/mod.ts", "./a.ts");
|
|
run_test("file:///a/a.ts", "file:///a/sub_dir/mod.ts", "../a.ts");
|
|
run_test(
|
|
"file:///a/sub_dir/a.ts",
|
|
"file:///a/mod.ts",
|
|
"./sub_dir/a.ts",
|
|
);
|
|
run_test(
|
|
"https://deno.land/x/example/mod.ts",
|
|
"file:///a/sub_dir/a.ts",
|
|
"https://deno.land/x/example/mod.ts",
|
|
);
|
|
}
|
|
}
|