diff options
Diffstat (limited to 'cli/lsp')
| -rw-r--r-- | cli/lsp/analysis.rs | 79 | ||||
| -rw-r--r-- | cli/lsp/diagnostics.rs | 123 |
2 files changed, 146 insertions, 56 deletions
diff --git a/cli/lsp/analysis.rs b/cli/lsp/analysis.rs index 19ee60d4c..831ad9b29 100644 --- a/cli/lsp/analysis.rs +++ b/cli/lsp/analysis.rs @@ -140,6 +140,7 @@ pub struct Dependency { pub maybe_code: Option<ResolvedDependency>, pub maybe_code_specifier_range: Option<Range>, pub maybe_type: Option<ResolvedDependency>, + pub maybe_type_specifier_range: Option<Range>, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -259,13 +260,24 @@ pub fn analyze_dependencies( // Parse leading comments for supported triple slash references. for comment in parsed_module.get_leading_comments().iter() { - if let Some(ts_reference) = parse_ts_reference(&comment.text) { + if let Some((ts_reference, span)) = parse_ts_reference(&comment) { + let loc = parsed_module.source_map.lookup_char_pos(span.lo); match ts_reference { TypeScriptReference::Path(import) => { let dep = dependencies.entry(import.clone()).or_default(); let resolved_import = resolve_import(&import, specifier, maybe_import_map); dep.maybe_code = Some(resolved_import); + dep.maybe_code_specifier_range = Some(Range { + start: Position { + line: (loc.line - 1) as u32, + character: loc.col_display as u32, + }, + end: Position { + line: (loc.line - 1) as u32, + character: (loc.col_display + import.chars().count() + 2) as u32, + }, + }); } TypeScriptReference::Types(import) => { let resolved_import = @@ -273,11 +285,20 @@ pub fn analyze_dependencies( if media_type == &MediaType::JavaScript || media_type == &MediaType::Jsx { - maybe_type = Some(resolved_import) - } else { - let dep = dependencies.entry(import).or_default(); - dep.maybe_type = Some(resolved_import); + maybe_type = Some(resolved_import.clone()); } + let dep = dependencies.entry(import.clone()).or_default(); + dep.maybe_type = Some(resolved_import); + dep.maybe_type_specifier_range = Some(Range { + start: Position { + line: (loc.line - 1) as u32, + character: loc.col_display as u32, + }, + end: Position { + line: (loc.line - 1) as u32, + character: (loc.col_display + import.chars().count() + 2) as u32, + }, + }); } } } @@ -294,7 +315,13 @@ pub fn analyze_dependencies( let maybe_resolved_type_dependency = // Check for `@deno-types` pragmas that affect the import if let Some(comment) = desc.leading_comments.last() { - parse_deno_types(&comment.text).as_ref().map(|deno_types| resolve_import(deno_types, specifier, maybe_import_map)) + parse_deno_types(&comment).as_ref().map(|(deno_types, span)| { + ( + resolve_import(deno_types, specifier, maybe_import_map), + deno_types.clone(), + parsed_module.source_map.lookup_char_pos(span.lo) + ) + }) } else { None }; @@ -304,6 +331,17 @@ pub fn analyze_dependencies( match desc.kind { swc_ecmascript::dep_graph::DependencyKind::ExportType | swc_ecmascript::dep_graph::DependencyKind::ImportType => { + dep.maybe_type_specifier_range = Some(Range { + start: Position { + line: (desc.specifier_line - 1) as u32, + character: desc.specifier_col as u32, + }, + end: Position { + line: (desc.specifier_line - 1) as u32, + character: (desc.specifier_col + desc.specifier.chars().count() + 2) + as u32, + }, + }); dep.maybe_type = Some(resolved_import) } _ => { @@ -321,8 +359,22 @@ pub fn analyze_dependencies( dep.maybe_code = Some(resolved_import); } } - if maybe_resolved_type_dependency.is_some() && dep.maybe_type.is_none() { - dep.maybe_type = maybe_resolved_type_dependency; + if dep.maybe_type.is_none() { + if let Some((resolved_dependency, specifier, loc)) = + maybe_resolved_type_dependency + { + dep.maybe_type_specifier_range = Some(Range { + start: Position { + line: (loc.line - 1) as u32, + character: (loc.col_display + 1) as u32, + }, + end: Position { + line: (loc.line - 1) as u32, + character: (loc.col_display + 1 + specifier.chars().count()) as u32, + }, + }); + dep.maybe_type = Some(resolved_dependency); + } } } @@ -723,6 +775,16 @@ mod tests { character: 58, } }), + maybe_type_specifier_range: Some(Range { + start: Position { + line: 7, + character: 20, + }, + end: Position { + line: 7, + character: 62, + } + }) }) ); assert_eq!( @@ -743,6 +805,7 @@ mod tests { character: 50, } }), + maybe_type_specifier_range: None, }) ); } diff --git a/cli/lsp/diagnostics.rs b/cli/lsp/diagnostics.rs index ea781abde..9b9035ac5 100644 --- a/cli/lsp/diagnostics.rs +++ b/cli/lsp/diagnostics.rs @@ -1,13 +1,16 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. use super::analysis; +use super::documents::DocumentCache; use super::language_server; +use super::sources::Sources; use super::tsc; use crate::diagnostics; use crate::media_type::MediaType; use crate::tokio_util::create_basic_runtime; +use analysis::ResolvedDependency; use deno_core::error::anyhow; use deno_core::error::AnyError; use deno_core::resolve_url; @@ -392,6 +395,64 @@ async fn generate_ts_diagnostics( Ok(diagnostics_vec) } +fn diagnose_dependency( + diagnostics: &mut Vec<lsp::Diagnostic>, + documents: &DocumentCache, + sources: &Sources, + maybe_dependency: &Option<ResolvedDependency>, + maybe_range: &Option<lsp::Range>, +) { + if let (Some(dep), Some(range)) = (maybe_dependency, *maybe_range) { + match dep { + analysis::ResolvedDependency::Err(err) => { + diagnostics.push(lsp::Diagnostic { + range, + severity: Some(lsp::DiagnosticSeverity::Error), + code: Some(err.as_code()), + code_description: None, + source: Some("deno".to_string()), + message: err.to_string(), + related_information: None, + tags: None, + data: None, + }) + } + analysis::ResolvedDependency::Resolved(specifier) => { + if !(documents.contains_key(&specifier) + || sources.contains_key(&specifier)) + { + let (code, message) = match specifier.scheme() { + "file" => (Some(lsp::NumberOrString::String("no-local".to_string())), format!("Unable to load a local module: \"{}\".\n Please check the file path.", specifier)), + "data" => (Some(lsp::NumberOrString::String("no-cache-data".to_string())), "Uncached data URL.".to_string()), + "blob" => (Some(lsp::NumberOrString::String("no-cache-blob".to_string())), "Uncached blob URL.".to_string()), + _ => (Some(lsp::NumberOrString::String("no-cache".to_string())), format!("Uncached or missing remote URL: \"{}\".", specifier)), + }; + diagnostics.push(lsp::Diagnostic { + range, + severity: Some(lsp::DiagnosticSeverity::Error), + code, + source: Some("deno".to_string()), + message, + data: Some(json!({ "specifier": specifier })), + ..Default::default() + }); + } else if sources.contains_key(&specifier) { + if let Some(message) = sources.get_maybe_warning(&specifier) { + diagnostics.push(lsp::Diagnostic { + range, + severity: Some(lsp::DiagnosticSeverity::Warning), + code: Some(lsp::NumberOrString::String("deno-warn".to_string())), + source: Some("deno".to_string()), + message, + ..Default::default() + }) + } + } + } + } + } +} + /// Generate diagnostics for dependencies of a module, attempting to resolve /// dependencies on the local file system or in the DENO_DIR cache. async fn generate_deps_diagnostics( @@ -417,54 +478,20 @@ async fn generate_deps_diagnostics( let mut diagnostics = Vec::new(); if let Some(dependencies) = documents.dependencies(specifier) { for (_, dependency) in dependencies { - // TODO(@kitsonk) add diagnostics for maybe_type dependencies - if let (Some(code), Some(range)) = - (dependency.maybe_code, dependency.maybe_code_specifier_range) - { - match code { - analysis::ResolvedDependency::Err(err) => diagnostics.push(lsp::Diagnostic { - range, - severity: Some(lsp::DiagnosticSeverity::Error), - code: Some(err.as_code()), - code_description: None, - source: Some("deno".to_string()), - message: err.to_string(), - related_information: None, - tags: None, - data: None, - }), - analysis::ResolvedDependency::Resolved(specifier) => { - if !(documents.contains_key(&specifier) || sources.contains_key(&specifier)) { - let (code, message) = match specifier.scheme() { - "file" => (Some(lsp::NumberOrString::String("no-local".to_string())), format!("Unable to load a local module: \"{}\".\n Please check the file path.", specifier)), - "data" => (Some(lsp::NumberOrString::String("no-cache-data".to_string())), "Uncached data URL.".to_string()), - "blob" => (Some(lsp::NumberOrString::String("no-cache-blob".to_string())), "Uncached blob URL.".to_string()), - _ => (Some(lsp::NumberOrString::String("no-cache".to_string())), format!("Uncached or missing remote URL: \"{}\".", specifier)), - }; - diagnostics.push(lsp::Diagnostic { - range, - severity: Some(lsp::DiagnosticSeverity::Error), - code, - source: Some("deno".to_string()), - message, - data: Some(json!({ "specifier": specifier })), - ..Default::default() - }); - } else if sources.contains_key(&specifier) { - if let Some(message) = sources.get_maybe_warning(&specifier) { - diagnostics.push(lsp::Diagnostic { - range, - severity: Some(lsp::DiagnosticSeverity::Warning), - code: Some(lsp::NumberOrString::String("deno-warn".to_string())), - source: Some("deno".to_string()), - message, - ..Default::default() - }) - } - } - }, - } - } + diagnose_dependency( + &mut diagnostics, + &documents, + &sources, + &dependency.maybe_code, + &dependency.maybe_code_specifier_range, + ); + diagnose_dependency( + &mut diagnostics, + &documents, + &sources, + &dependency.maybe_type, + &dependency.maybe_type_specifier_range, + ); } } diagnostics_vec.push((specifier.clone(), version, diagnostics)); |