// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use deno_ast::MediaType; use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::AnyError; use deno_core::resolve_url; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; use deno_core::ModuleSpecifier; use deno_runtime::deno_node::PackageJson; use deno_runtime::deno_web::BlobStore; use import_map::ImportMap; use log::error; use serde_json::from_value; use std::collections::HashMap; use std::collections::HashSet; use std::env; use std::fmt::Write as _; use std::path::PathBuf; use std::sync::Arc; use tower_lsp::jsonrpc::Error as LspError; use tower_lsp::jsonrpc::Result as LspResult; use tower_lsp::lsp_types::request::*; use tower_lsp::lsp_types::*; use super::analysis::fix_ts_import_changes; use super::analysis::ts_changes_to_edit; use super::analysis::CodeActionCollection; use super::analysis::CodeActionData; use super::cache; use super::capabilities; use super::client::Client; use super::code_lens; use super::completions; use super::config::Config; use super::config::SETTINGS_SECTION; use super::diagnostics; use super::diagnostics::DiagnosticsServer; use super::documents::to_hover_text; use super::documents::to_lsp_range; use super::documents::AssetOrDocument; use super::documents::Document; use super::documents::Documents; use super::documents::DocumentsFilter; use super::documents::LanguageId; use super::logging::lsp_log; use super::logging::lsp_warn; use super::lsp_custom; use super::parent_process_checker; use super::performance::Performance; use super::performance::PerformanceMark; use super::refactor; use super::registries::ModuleRegistry; use super::testing; use super::text; use super::tsc; use super::tsc::Assets; use super::tsc::AssetsSnapshot; use super::tsc::TsServer; use super::urls; use super::urls::LspClientUrl; use crate::args::get_root_cert_store; use crate::args::package_json; use crate::args::resolve_import_map_from_specifier; use crate::args::CaData; use crate::args::CacheSetting; use crate::args::CliOptions; use crate::args::ConfigFile; use crate::args::Flags; use crate::args::FmtOptions; use crate::args::LintOptions; use crate::args::TsConfig; use crate::cache::DenoDir; use crate::cache::HttpCache; use crate::file_fetcher::FileFetcher; use crate::graph_util; use crate::http_util::HttpClient; use crate::lsp::urls::LspUrlKind; use crate::npm::create_npm_fs_resolver; use crate::npm::NpmCache; use crate::npm::NpmPackageResolver; use crate::npm::NpmRegistryApi; use crate::npm::NpmResolution; use crate::proc_state::ProcState; use crate::tools::fmt::format_file; use crate::tools::fmt::format_parsed_source; use crate::util::fs::remove_dir_all_if_exists; use crate::util::path::specifier_to_file_path; use crate::util::progress_bar::ProgressBar; use crate::util::progress_bar::ProgressBarStyle; #[derive(Debug, Clone)] pub struct LanguageServer(Arc>); /// Snapshot of the state used by TSC. #[derive(Debug, Default)] pub struct StateSnapshot { pub assets: AssetsSnapshot, pub cache_metadata: cache::CacheMetadata, pub documents: Documents, pub maybe_import_map: Option>, pub maybe_npm_resolver: Option, } #[derive(Debug)] pub struct Inner { /// Cached versions of "fixed" assets that can either be inlined in Rust or /// are part of the TypeScript snapshot and have to be fetched out. assets: Assets, /// A representation of metadata associated with specifiers in the DENO_DIR /// which is used by the language server cache_metadata: cache::CacheMetadata, /// The LSP client that this LSP server is connected to. pub client: Client, /// Configuration information. pub config: Config, deps_http_cache: HttpCache, diagnostics_server: diagnostics::DiagnosticsServer, /// The collection of documents that the server is currently handling, either /// on disk or "open" within the client. pub documents: Documents, http_client: HttpClient, /// Handles module registries, which allow discovery of modules module_registries: ModuleRegistry, /// The path to the module registries cache module_registries_location: PathBuf, /// An optional path to the DENO_DIR which has been specified in the client /// options. maybe_cache_path: Option, /// An optional configuration file which has been specified in the client /// options. maybe_config_file: Option, /// An optional import map which is used to resolve modules. maybe_import_map: Option>, /// The URL for the import map which is used to determine relative imports. maybe_import_map_uri: Option, /// An optional package.json configuration file. maybe_package_json: Option, /// Configuration for formatter which has been taken from specified config file. fmt_options: FmtOptions, /// An optional configuration for linter which has been taken from specified config file. lint_options: LintOptions, /// A lazily create "server" for handling test run requests. maybe_testing_server: Option, /// Npm's registry api. npm_api: NpmRegistryApi, /// Npm cache npm_cache: NpmCache, /// Npm resolution that is stored in memory. npm_resolution: NpmResolution, /// Resolver for npm packages. npm_resolver: NpmPackageResolver, /// A collection of measurements which instrument that performance of the LSP. performance: Arc, /// A memoized version of fixable diagnostic codes retrieved from TypeScript. ts_fixable_diagnostics: Vec, /// An abstraction that handles interactions with TypeScript. pub ts_server: Arc, /// A map of specifiers and URLs used to translate over the LSP. pub url_map: urls::LspUrlMap, } impl LanguageServer { pub fn new(client: Client) -> Self { Self(Arc::new(tokio::sync::RwLock::new(Inner::new(client)))) } /// Similar to `deno cache` on the command line, where modules will be cached /// in the Deno cache, including any of their dependencies. pub async fn cache_request( &self, params: Option, ) -> LspResult> { async fn create_graph_for_caching( cli_options: CliOptions, roots: Vec, open_docs: Vec, ) -> Result<(), AnyError> { let open_docs = open_docs .into_iter() .map(|d| (d.specifier().clone(), d)) .collect::>(); let ps = ProcState::from_options(Arc::new(cli_options)).await?; let mut inner_loader = ps.create_graph_loader(); let mut loader = crate::lsp::documents::OpenDocumentsGraphLoader { inner_loader: &mut inner_loader, open_docs: &open_docs, }; let graph = ps .create_graph_with_loader(roots.clone(), &mut loader) .await?; graph_util::graph_valid( &graph, &roots, graph_util::GraphValidOptions { is_vendoring: false, follow_type_only: true, check_js: false, }, )?; Ok(()) } match params.map(serde_json::from_value) { Some(Ok(params)) => { // do as much as possible in a read, then do a write outside let maybe_cache_result = { let inner = self.0.read().await; // ensure dropped match inner.prepare_cache(params) { Ok(maybe_cache_result) => maybe_cache_result, Err(err) => { self .0 .read() .await .client .show_message(MessageType::WARNING, err); return Err(LspError::internal_error()); } } }; if let Some(result) = maybe_cache_result { let cli_options = result.cli_options; let roots = result.roots; let open_docs = result.open_docs; let handle = tokio::task::spawn_local(async move { create_graph_for_caching(cli_options, roots, open_docs).await }); if let Err(err) = handle.await.unwrap() { self .0 .read() .await .client .show_message(MessageType::WARNING, err); } // do npm resolution in a write—we should have everything // cached by this point anyway self.0.write().await.refresh_npm_specifiers().await; // now refresh the data in a read self.0.read().await.post_cache(result.mark).await; } Ok(Some(json!(true))) } Some(Err(err)) => Err(LspError::invalid_params(err.to_string())), None => Err(LspError::invalid_params("Missing parameters")), } } pub async fn performance_request(&self) -> LspResult> { Ok(Some(self.0.read().await.get_performance())) } pub async fn reload_import_registries_request( &self, ) -> LspResult> { self.0.write().await.reload_import_registries().await } pub async fn task_request(&self) -> LspResult> { self.0.read().await.get_tasks() } pub async fn test_run_request( &self, params: Option, ) -> LspResult> { let inner = self.0.read().await; if let Some(testing_server) = &inner.maybe_testing_server { match params.map(serde_json::from_value) { Some(Ok(params)) => testing_server .run_request(params, inner.config.get_workspace_settings()), Some(Err(err)) => Err(LspError::invalid_params(err.to_string())), None => Err(LspError::invalid_params("Missing parameters")), } } else { Err(LspError::invalid_request()) } } pub async fn test_run_cancel_request( &self, params: Option, ) -> LspResult> { if let Some(testing_server) = &self.0.read().await.maybe_testing_server { match params.map(serde_json::from_value) { Some(Ok(params)) => testing_server.run_cancel_request(params), Some(Err(err)) => Err(LspError::invalid_params(err.to_string())), None => Err(LspError::invalid_params("Missing parameters")), } } else { Err(LspError::invalid_request()) } } pub async fn inlay_hint( &self, params: InlayHintParams, ) -> LspResult>> { self.0.read().await.inlay_hint(params).await } pub async fn virtual_text_document( &self, params: Option, ) -> LspResult> { match params.map(serde_json::from_value) { Some(Ok(params)) => Ok(Some( serde_json::to_value( self.0.read().await.virtual_text_document(params)?, ) .map_err(|err| { error!( "Failed to serialize virtual_text_document response: {}", err ); LspError::internal_error() })?, )), Some(Err(err)) => Err(LspError::invalid_params(err.to_string())), None => Err(LspError::invalid_params("Missing parameters")), } } pub async fn refresh_specifiers_from_client(&self) -> bool { let (client, specifiers) = { let ls = self.0.read().await; let specifiers = if ls.config.client_capabilities.workspace_configuration { let root_capacity = match &ls.config.workspace_folders { Some(folder) => folder.len(), None => 1, }; let config_specifiers = ls.config.get_specifiers(); let mut specifiers = HashMap::with_capacity(root_capacity + config_specifiers.len()); match &ls.config.workspace_folders { Some(entry) => { for (specifier, folder) in entry { specifiers.insert( specifier.clone(), LspClientUrl::new(folder.uri.clone()), ); } } None => { if let Some(root_uri) = &ls.config.root_uri { specifiers.insert( root_uri.clone(), ls.url_map.normalize_specifier(root_uri).unwrap(), ); } } } specifiers.extend(ls.config.get_specifiers().iter().map(|s| { (s.clone(), ls.url_map.normalize_specifier(s).unwrap()) })); Some(specifiers.into_iter().collect::>()) } else { None }; (ls.client.clone(), specifiers) }; let mut touched = false; if let Some(specifiers) = specifiers { let configs_result = client .when_outside_lsp_lock() .specifier_configurations( specifiers .iter() .map(|(_, client_uri)| client_uri.clone()) .collect(), ) .await; let mut ls = self.0.write().await; if let Ok(configs) = configs_result { for (value, internal_uri) in configs.into_iter().zip(specifiers.into_iter().map(|s| s.0)) { match value { Ok(specifier_settings) => { if ls .config .set_specifier_settings(internal_uri, specifier_settings) { touched = true; } } Err(err) => { error!("{}", err); } } } } if ls.config.update_enabled_paths() { touched = true; } if touched { ls.refresh_documents_config(); ls.diagnostics_server.invalidate_all(); ls.send_diagnostics_update(); } } touched } } fn create_lsp_structs( dir: &DenoDir, http_client: HttpClient, ) -> (NpmRegistryApi, NpmCache, NpmPackageResolver, NpmResolution) { let registry_url = NpmRegistryApi::default_url(); let progress_bar = ProgressBar::new(ProgressBarStyle::TextOnly); let npm_cache = NpmCache::from_deno_dir( dir, // Use an "only" cache setting in order to make the // user do an explicit "cache" command and prevent // the cache from being filled with lots of packages while // the user is typing. CacheSetting::Only, http_client.clone(), progress_bar.clone(), ); let api = NpmRegistryApi::new( registry_url.clone(), npm_cache.clone(), http_client, progress_bar.clone(), ); let resolution = NpmResolution::new(api.clone(), None, None); let fs_resolver = create_npm_fs_resolver( npm_cache.clone(), &progress_bar, registry_url.clone(), resolution.clone(), None, ); ( api, npm_cache, NpmPackageResolver::new(resolution.clone(), fs_resolver, None), resolution, ) } impl Inner { fn new(client: Client) -> Self { let maybe_custom_root = env::var("DENO_DIR").map(String::into).ok(); let dir = DenoDir::new(maybe_custom_root).expect("could not access DENO_DIR"); let module_registries_location = dir.registries_folder_path(); let http_client = HttpClient::new(None, None).unwrap(); let module_registries = ModuleRegistry::new(&module_registries_location, http_client.clone()) .unwrap(); let location = dir.deps_folder_path(); let documents = Documents::new(&location); let deps_http_cache = HttpCache::new(&location); let cache_metadata = cache::CacheMetadata::new(deps_http_cache.clone()); let performance = Arc::new(Performance::default()); let ts_server = Arc::new(TsServer::new(performance.clone())); let config = Config::new(); let diagnostics_server = DiagnosticsServer::new( client.clone(), performance.clone(), ts_server.clone(), ); let assets = Assets::new(ts_server.clone()); let (npm_api, npm_cache, npm_resolver, npm_resolution) = create_lsp_structs(&dir, http_client.clone()); Self { assets, cache_metadata, client, config, deps_http_cache, diagnostics_server, documents, http_client, maybe_cache_path: None, maybe_config_file: None, maybe_import_map: None, maybe_import_map_uri: None, maybe_package_json: None, fmt_options: Default::default(), lint_options: Default::default(), maybe_testing_server: None, module_registries, module_registries_location, npm_api, npm_cache, npm_resolution, npm_resolver, performance, ts_fixable_diagnostics: Default::default(), ts_server, url_map: Default::default(), } } /// Searches assets and documents for the provided /// specifier erroring if it doesn't exist. pub fn get_asset_or_document( &self, specifier: &ModuleSpecifier, ) -> LspResult { self .get_maybe_asset_or_document(specifier) .map(Ok) .unwrap_or_else(|| { Err(LspError::invalid_params(format!( "Unable to find asset or document for: {specifier}" ))) }) } /// Searches assets and documents for the provided specifier. pub fn get_maybe_asset_or_document( &self, specifier: &ModuleSpecifier, ) -> Option { if specifier.scheme() == "asset" { self.assets.get(specifier).map(AssetOrDocument::Asset) } else { self.documents.get(specifier).map(AssetOrDocument::Document) } } pub async fn get_navigation_tree( &self, specifier: &ModuleSpecifier, ) -> Result, AnyError> { let mark = self.performance.mark( "get_navigation_tree", Some(json!({ "specifier": specifier })), ); let asset_or_doc = self.get_asset_or_document(specifier)?; let navigation_tree = if let Some(navigation_tree) = asset_or_doc.maybe_navigation_tree() { navigation_tree } else { let navigation_tree: tsc::NavigationTree = self .ts_server .request( self.snapshot(), tsc::RequestMethod::GetNavigationTree(specifier.clone()), ) .await?; let navigation_tree = Arc::new(navigation_tree); match asset_or_doc { AssetOrDocument::Asset(_) => self .assets .cache_navigation_tree(specifier, navigation_tree.clone())?, AssetOrDocument::Document(doc) => { self.documents.try_cache_navigation_tree( specifier, &doc.script_version(), navigation_tree.clone(), )? } } navigation_tree }; self.performance.measure(mark); Ok(navigation_tree) } fn get_config_file(&self) -> Result, AnyError> { let workspace_settings = self.config.get_workspace_settings(); let maybe_config = workspace_settings.config; if let Some(config_str) = &maybe_config { if !config_str.is_empty() { lsp_log!("Setting Deno configuration from: \"{}\"", config_str); let config_url = if let Ok(url) = Url::from_file_path(config_str) { Ok(url) } else if let Some(root_uri) = &self.config.root_uri { root_uri.join(config_str).map_err(|_| { anyhow!("Bad file path for configuration file: \"{}\"", config_str) }) } else { Err(anyhow!( "The path to the configuration file (\"{}\") is not resolvable.", config_str )) }?; lsp_log!(" Resolved configuration file: \"{}\"", config_url); let config_file = ConfigFile::from_specifier(&config_url)?; return Ok(Some(config_file)); } } // Auto-discover config // It is possible that root_uri is not set, for example when having a single // file open and not a workspace. In those situations we can't // automatically discover the configuration if let Some(root_uri) = &self.config.root_uri { let root_path = specifier_to_file_path(root_uri)?; let mut checked = std::collections::HashSet::new(); let maybe_config = ConfigFile::discover_from(&root_path, &mut checked)?; Ok(maybe_config.map(|c| { lsp_log!(" Auto-resolved configuration file: \"{}\"", c.specifier); c })) } else { Ok(None) } } fn get_package_json( &self, maybe_config_file: Option<&ConfigFile>, ) -> Result, AnyError> { // It is possible that root_uri is not set, for example when having a single // file open and not a workspace. In those situations we can't // automatically discover the configuration if let Some(root_uri) = &self.config.root_uri { let root_path = specifier_to_file_path(root_uri)?; let maybe_package_json = package_json::discover_from( &root_path, maybe_config_file.and_then(|f| f.specifier.to_file_path().ok()), )?; Ok(maybe_package_json.map(|c| { lsp_log!(" Auto-resolved package.json: \"{}\"", c.specifier()); c })) } else { Ok(None) } } fn is_diagnosable(&self, specifier: &ModuleSpecifier) -> bool { if specifier.scheme() == "asset" { matches!( MediaType::from_specifier(specifier), MediaType::JavaScript | MediaType::Jsx | MediaType::Mjs | MediaType::Cjs | MediaType::TypeScript | MediaType::Tsx | MediaType::Mts | MediaType::Cts | MediaType::Dts | MediaType::Dmts | MediaType::Dcts ) } else { self .documents .get(specifier) .map(|d| d.is_diagnosable()) .unwrap_or(false) } } fn merge_user_tsconfig( &self, tsconfig: &mut TsConfig, ) -> Result<(), AnyError> { if let Some(config_file) = self.maybe_config_file.as_ref() { let (value, maybe_ignored_options) = config_file.to_compiler_options()?; tsconfig.merge(&value); if let Some(ignored_options) = maybe_ignored_options { // TODO(@kitsonk) turn these into diagnostics that can be sent to the // client lsp_warn!("{}", ignored_options); } } Ok(()) } pub fn snapshot(&self) -> Arc { Arc::new(StateSnapshot { assets: self.assets.snapshot(), cache_metadata: self.cache_metadata.clone(), documents: self.documents.clone(), maybe_import_map: self.maybe_import_map.clone(), maybe_npm_resolver: Some({ // create a new snapshotted npm resolution and resolver let resolution = NpmResolution::new( self.npm_api.clone(), Some(self.npm_resolution.snapshot()), None, ); NpmPackageResolver::new( resolution.clone(), create_npm_fs_resolver( self.npm_cache.clone(), &ProgressBar::new(ProgressBarStyle::TextOnly), self.npm_api.base_url().clone(), resolution, None, ), None, ) }), }) } pub fn update_cache(&mut self) -> Result<(), AnyError> { let mark = self.performance.mark("update_cache", None::<()>); self.performance.measure(mark); let maybe_cache = self.config.get_workspace_settings().cache; let maybe_cache_path = if let Some(cache_str) = &maybe_cache { lsp_log!("Setting cache path from: \"{}\"", cache_str); let cache_url = if let Ok(url) = Url::from_file_path(cache_str) { Ok(url) } else if let Some(root_uri) = &self.config.root_uri { let root_path = specifier_to_file_path(root_uri)?; let cache_path = root_path.join(cache_str); Url::from_file_path(cache_path).map_err(|_| { anyhow!("Bad file path for import path: {:?}", cache_str) }) } else { Err(anyhow!( "The path to the cache path (\"{}\") is not resolvable.", cache_str )) }?; let cache_path = specifier_to_file_path(&cache_url)?; lsp_log!( " Resolved cache path: \"{}\"", cache_path.to_string_lossy() ); Some(cache_path) } else { None }; if self.maybe_cache_path != maybe_cache_path { self.recreate_http_client_and_dependents(maybe_cache_path)?; } Ok(()) } /// Recreates the http client and all dependent structs. fn recreate_http_client_and_dependents( &mut self, new_cache_path: Option, ) -> Result<(), AnyError> { let maybe_custom_root = new_cache_path .clone() .or_else(|| env::var("DENO_DIR").map(String::into).ok()); let dir = DenoDir::new(maybe_custom_root)?; let workspace_settings = self.config.get_workspace_settings(); let maybe_root_path = self .config .root_uri .as_ref() .and_then(|uri| specifier_to_file_path(uri).ok()); let root_cert_store = Some(get_root_cert_store( maybe_root_path, workspace_settings.certificate_stores, workspace_settings.tls_certificate.map(CaData::File), )?); let module_registries_location = dir.registries_folder_path(); self.http_client = HttpClient::new( root_cert_store, workspace_settings.unsafely_ignore_certificate_errors, )?; self.module_registries = ModuleRegistry::new( &module_registries_location, self.http_client.clone(), )?; self.module_registries_location = module_registries_location; ( self.npm_api, self.npm_cache, self.npm_resolver, self.npm_resolution, ) = create_lsp_structs(&dir, self.http_client.clone()); // update the cache path let location = dir.deps_folder_path(); self.documents.set_location(&location); self.cache_metadata.set_location(&location); self.maybe_cache_path = new_cache_path; Ok(()) } pub async fn update_import_map(&mut self) -> Result<(), AnyError> { let mark = self.performance.mark("update_import_map", None::<()>); let maybe_import_map_url = self.resolve_import_map_specifier()?; if let Some(import_map_url) = maybe_import_map_url { if import_map_url.scheme() != "data" { lsp_log!(" Resolved import map: \"{}\"", import_map_url); } let import_map = self .fetch_import_map(&import_map_url, CacheSetting::RespectHeaders) .await?; self.maybe_import_map_uri = Some(import_map_url); self.maybe_import_map = Some(Arc::new(import_map)); } else { self.maybe_import_map_uri = None; self.maybe_import_map = None; } self.performance.measure(mark); Ok(()) } async fn fetch_import_map( &self, import_map_url: &ModuleSpecifier, cache_setting: CacheSetting, ) -> Result { resolve_import_map_from_specifier( import_map_url, self.maybe_config_file.as_ref(), &self.create_file_fetcher(cache_setting), ) .await .map_err(|err| { anyhow!( "Failed to load the import map at: {}. {:#}", import_map_url, err ) }) } fn create_file_fetcher(&self, cache_setting: CacheSetting) -> FileFetcher { let mut file_fetcher = FileFetcher::new( self.deps_http_cache.clone(), cache_setting, true, self.http_client.clone(), BlobStore::default(), None, ); file_fetcher.set_download_log_level(super::logging::lsp_log_level()); file_fetcher } fn resolve_import_map_specifier( &self, ) -> Result, AnyError> { Ok( if let Some(import_map_str) = self .config .get_workspace_settings() .import_map .and_then(|s| if s.is_empty() { None } else { Some(s) }) { lsp_log!( "Setting import map from workspace settings: \"{}\"", import_map_str ); if let Some(config_file) = &self.maybe_config_file { if let Some(import_map_path) = config_file.to_import_map_path() { lsp_log!("Warning: Import map \"{}\" configured in \"{}\" being ignored due to an import map being explicitly configured in workspace settings.", import_map_path, config_file.specifier); } } if let Ok(url) = Url::from_file_path(&import_map_str) { Some(url) } else if import_map_str.starts_with("data:") { let import_map_url = Url::parse(&import_map_str).map_err(|_| { anyhow!("Bad data url for import map: {}", import_map_str) })?; Some(import_map_url) } else if let Some(root_uri) = &self.config.root_uri { let root_path = specifier_to_file_path(root_uri)?; let import_map_path = root_path.join(&import_map_str); let import_map_url = Url::from_file_path(import_map_path).map_err(|_| { anyhow!("Bad file path for import map: {}", import_map_str) })?; Some(import_map_url) } else { return Err(anyhow!( "The path to the import map (\"{}\") is not resolvable.", import_map_str )); } } else if let Some(config_file) = &self.maybe_config_file { if config_file.is_an_import_map() { lsp_log!( "Setting import map defined in configuration file: \"{}\"", config_file.specifier ); let import_map_url = config_file.specifier.clone(); Some(import_map_url) } else if let Some(import_map_path) = config_file.to_import_map_path() { lsp_log!( "Setting import map from configuration file: \"{}\"", import_map_path ); let specifier = if let Ok(config_file_path) = config_file.specifier.to_file_path() { let import_map_file_path = config_file_path .parent() .ok_or_else(|| { anyhow!("Bad config file specifier: {}", config_file.specifier) })? .join(&import_map_path); ModuleSpecifier::from_file_path(import_map_file_path).unwrap() } else { deno_core::resolve_import( &import_map_path, config_file.specifier.as_str(), )? }; Some(specifier) } else { None } } else { None }, ) } pub fn update_debug_flag(&self) { let internal_debug = self.config.get_workspace_settings().internal_debug; super::logging::set_lsp_debug_flag(internal_debug) } async fn update_registries(&mut self) -> Result<(), AnyError> { let mark = self.performance.mark("update_registries", None::<()>); self.recreate_http_client_and_dependents(self.maybe_cache_path.clone())?; let workspace_settings = self.config.get_workspace_settings(); for (registry, enabled) in workspace_settings.suggest.imports.hosts.iter() { if *enabled { lsp_log!("Enabling import suggestions for: {}", registry); self.module_registries.enable(registry).await?; } else { self.module_registries.disable(registry).await?; } } self.performance.measure(mark); Ok(()) } fn update_config_file(&mut self) -> Result<(), AnyError> { self.maybe_config_file = None; self.fmt_options = Default::default(); self.lint_options = Default::default(); if let Some(config_file) = self.get_config_file()? { let lint_options = config_file .to_lint_config() .and_then(|maybe_lint_config| { LintOptions::resolve(maybe_lint_config, None) }) .map_err(|err| { anyhow!("Unable to update lint configuration: {:?}", err) })?; let fmt_options = config_file .to_fmt_config() .and_then(|maybe_fmt_config| { FmtOptions::resolve(maybe_fmt_config, None) }) .map_err(|err| { anyhow!("Unable to update formatter configuration: {:?}", err) })?; self.maybe_config_file = Some(config_file); self.lint_options = lint_options; self.fmt_options = fmt_options; } Ok(()) } /// Updates the package.json. Always ensure this is done after updating /// the configuration file as the resolution of this depends on that. fn update_package_json(&mut self) -> Result<(), AnyError> { self.maybe_package_json = None; self.maybe_package_json = self.get_package_json(self.maybe_config_file.as_ref())?; Ok(()) } async fn update_tsconfig(&mut self) -> Result<(), AnyError> { let mark = self.performance.mark("update_tsconfig", None::<()>); let mut tsconfig = TsConfig::new(json!({ "allowJs": true, "esModuleInterop": true, "experimentalDecorators": true, "isolatedModules": true, "jsx": "react", "lib": ["deno.ns", "deno.window"], "module": "esnext", "moduleDetection": "force", "noEmit": true, "resolveJsonModule": true, "strict": true, "target": "esnext", "useDefineForClassFields": true, // TODO(@kitsonk) remove for Deno 1.15 "useUnknownInCatchVariables": false, })); let config = &self.config; let workspace_settings = config.get_workspace_settings(); if workspace_settings.unstable { let unstable_libs = json!({ "lib": ["deno.ns", "deno.window", "deno.unstable"] }); tsconfig.merge(&unstable_libs); } if let Err(err) = self.merge_user_tsconfig(&mut tsconfig) { self.client.show_message(MessageType::WARNING, err); } let _ok: bool = self .ts_server .request(self.snapshot(), tsc::RequestMethod::Configure(tsconfig)) .await?; self.performance.measure(mark); Ok(()) } } // lspower::LanguageServer methods. This file's LanguageServer delegates to us. impl Inner { async fn initialize( &mut self, params: InitializeParams, ) -> LspResult { lsp_log!("Starting Deno language server..."); let mark = self.performance.mark("initialize", Some(¶ms)); // exit this process when the parent is lost if let Some(parent_pid) = params.process_id { parent_process_checker::start(parent_pid) } let capabilities = capabilities::server_capabilities(¶ms.capabilities); let version = format!( "{} ({}, {})", crate::version::deno(), env!("PROFILE"), env!("TARGET") ); lsp_log!(" version: {}", version); if let Ok(path) = std::env::current_exe() { lsp_log!(" executable: {}", path.to_string_lossy()); } let server_info = ServerInfo { name: "deno-language-server".to_string(), version: Some(version), }; if let Some(client_info) = params.client_info { lsp_log!( "Connected to \"{}\" {}", client_info.name, client_info.version.unwrap_or_default(), ); } { // sometimes this root uri may not have a trailing slash, so force it to self.config.root_uri = params .root_uri .map(|s| self.url_map.normalize_url(&s, LspUrlKind::Folder)); if let Some(value) = params.initialization_options { self.config.set_workspace_settings(value).map_err(|err| { error!("Cannot set workspace settings: {}", err); LspError::internal_error() })?; } self.config.workspace_folders = params.workspace_folders.map(|folders| { folders .into_iter() .map(|folder| { ( self.url_map.normalize_url(&folder.uri, LspUrlKind::Folder), folder, ) }) .collect() }); self.config.update_capabilities(¶ms.capabilities); } self.update_debug_flag(); // Check to see if we need to change the cache path if let Err(err) = self.update_cache() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_config_file() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_package_json() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_tsconfig().await { self.client.show_message(MessageType::WARNING, err); } if capabilities.code_action_provider.is_some() { let fixable_diagnostics: Vec = self .ts_server .request(self.snapshot(), tsc::RequestMethod::GetSupportedCodeFixes) .await .map_err(|err| { error!("Unable to get fixable diagnostics: {}", err); LspError::internal_error() })?; self.ts_fixable_diagnostics = fixable_diagnostics; } // Check to see if we need to setup the import map if let Err(err) = self.update_import_map().await { self.client.show_message(MessageType::WARNING, err); } // Check to see if we need to setup any module registries if let Err(err) = self.update_registries().await { self.client.show_message(MessageType::WARNING, err); } // self.refresh_documents_config(); // todo(THIS PR): REMOVE self.assets.intitialize(self.snapshot()).await; self.performance.measure(mark); Ok(InitializeResult { capabilities, server_info: Some(server_info), offset_encoding: None, }) } fn refresh_documents_config(&mut self) { self.documents.update_config( self.maybe_import_map.clone(), self.maybe_config_file.as_ref(), self.maybe_package_json.as_ref(), self.npm_api.clone(), self.npm_resolution.clone(), ); } async fn shutdown(&self) -> LspResult<()> { Ok(()) } async fn did_open( &mut self, specifier: &ModuleSpecifier, params: DidOpenTextDocumentParams, ) -> Document { let mark = self.performance.mark("did_open", Some(¶ms)); let language_id = params .text_document .language_id .parse() .unwrap_or_else(|err| { error!("{}", err); LanguageId::Unknown }); if language_id == LanguageId::Unknown { lsp_warn!( "Unsupported language id \"{}\" received for document \"{}\".", params.text_document.language_id, params.text_document.uri ); } let document = self.documents.open( specifier.clone(), params.text_document.version, params.text_document.language_id.parse().unwrap(), params.text_document.text.into(), ); self.performance.measure(mark); document } async fn did_change(&mut self, params: DidChangeTextDocumentParams) { let mark = self.performance.mark("did_change", Some(¶ms)); let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); match self.documents.change( &specifier, params.text_document.version, params.content_changes, ) { Ok(document) => { if document.is_diagnosable() { self.refresh_npm_specifiers().await; self .diagnostics_server .invalidate(&self.documents.dependents(&specifier)); self.send_diagnostics_update(); self.send_testing_update(); } } Err(err) => error!("{}", err), } self.performance.measure(mark); } async fn refresh_npm_specifiers(&mut self) { let package_reqs = self.documents.npm_package_reqs(); if let Err(err) = self .npm_resolver .set_package_reqs((*package_reqs).clone()) .await { lsp_warn!("Could not set npm package requirements. {:#}", err); } } async fn did_close(&mut self, params: DidCloseTextDocumentParams) { let mark = self.performance.mark("did_close", Some(¶ms)); if params.text_document.uri.scheme() == "deno" { // we can ignore virtual text documents closing, as they don't need to // be tracked in memory, as they are static assets that won't change // already managed by the language service return; } let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if let Err(err) = self.documents.close(&specifier) { error!("{}", err); } if self.is_diagnosable(&specifier) { self.refresh_npm_specifiers().await; let mut specifiers = self.documents.dependents(&specifier); specifiers.push(specifier); self.diagnostics_server.invalidate(&specifiers); self.send_diagnostics_update(); self.send_testing_update(); } self.performance.measure(mark); } async fn did_change_configuration( &mut self, client_workspace_config: Option, params: DidChangeConfigurationParams, ) { let maybe_config = if self.config.client_capabilities.workspace_configuration { client_workspace_config } else { params .settings .as_object() .and_then(|settings| settings.get(SETTINGS_SECTION)) .cloned() }; if let Some(value) = maybe_config { if let Err(err) = self.config.set_workspace_settings(value) { error!("failed to update settings: {}", err); } } self.update_debug_flag(); if let Err(err) = self.update_cache() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_registries().await { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_config_file() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_package_json() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_import_map().await { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_tsconfig().await { self.client.show_message(MessageType::WARNING, err); } self.refresh_documents_config(); self.send_diagnostics_update(); self.send_testing_update(); } async fn did_change_watched_files( &mut self, params: DidChangeWatchedFilesParams, ) { let mark = self .performance .mark("did_change_watched_files", Some(¶ms)); let mut touched = false; let changes: HashSet = params .changes .iter() .map(|f| self.url_map.normalize_url(&f.uri, LspUrlKind::File)) .collect(); // if the current deno.json has changed, we need to reload it if let Some(config_file) = &self.maybe_config_file { if changes.contains(&config_file.specifier) { if let Err(err) = self.update_config_file() { self.client.show_message(MessageType::WARNING, err); } if let Err(err) = self.update_tsconfig().await { self.client.show_message(MessageType::WARNING, err); } touched = true; } } if let Some(package_json) = &self.maybe_package_json { // always update the package json if the deno config changes if touched || changes.contains(&package_json.specifier()) { if let Err(err) = self.update_package_json() { self.client.show_message(MessageType::WARNING, err); } touched = true; } } // if the current import map, or config file has changed, we need to // reload the import map if let Some(import_map_uri) = &self.maybe_import_map_uri { if touched || changes.contains(import_map_uri) { if let Err(err) = self.update_import_map().await { self.client.show_message(MessageType::WARNING, err); } touched = true; } } if touched { self.refresh_documents_config(); self.refresh_npm_specifiers().await; self.diagnostics_server.invalidate_all(); self.restart_ts_server().await; self.send_diagnostics_update(); self.send_testing_update(); } self.performance.measure(mark); } fn did_change_workspace_folders( &mut self, params: DidChangeWorkspaceFoldersParams, ) { let mut workspace_folders = params .event .added .into_iter() .map(|folder| { ( self.url_map.normalize_url(&folder.uri, LspUrlKind::Folder), folder, ) }) .collect::>(); if let Some(current_folders) = &self.config.workspace_folders { for (specifier, folder) in current_folders { if !params.event.removed.is_empty() && params.event.removed.iter().any(|f| f.uri == folder.uri) { continue; } workspace_folders.push((specifier.clone(), folder.clone())); } } self.config.workspace_folders = Some(workspace_folders); } async fn document_symbol( &self, params: DocumentSymbolParams, ) -> LspResult> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("document_symbol", Some(¶ms)); let asset_or_document = self.get_asset_or_document(&specifier)?; let line_index = asset_or_document.line_index(); let navigation_tree = self.get_navigation_tree(&specifier).await.map_err(|err| { error!( "Error getting document symbols for \"{}\": {}", specifier, err ); LspError::internal_error() })?; let response = if let Some(child_items) = &navigation_tree.child_items { let mut document_symbols = Vec::::new(); for item in child_items { item .collect_document_symbols(line_index.clone(), &mut document_symbols); } Some(DocumentSymbolResponse::Nested(document_symbols)) } else { None }; self.performance.measure(mark); Ok(response) } async fn formatting( &self, params: DocumentFormattingParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); let document = match self.documents.get(&specifier) { Some(doc) if doc.is_open() => doc, _ => return Ok(None), }; let mark = self.performance.mark("formatting", Some(¶ms)); let file_path = specifier_to_file_path(&specifier).map_err(|err| { error!("{}", err); LspError::invalid_request() })?; // skip formatting any files ignored by the config file if !self.fmt_options.files.matches_specifier(&specifier) { return Ok(None); } let format_result = match document.maybe_parsed_source() { Some(Ok(parsed_source)) => { format_parsed_source(&parsed_source, &self.fmt_options.options) } Some(Err(err)) => Err(anyhow!("{}", err)), None => { // the file path is only used to determine what formatter should // be used to format the file, so give the filepath an extension // that matches what the user selected as the language let file_path = document .maybe_language_id() .and_then(|id| id.as_extension()) .map(|ext| file_path.with_extension(ext)) .unwrap_or(file_path); // it's not a js/ts file, so attempt to format its contents format_file(&file_path, &document.content(), &self.fmt_options.options) } }; let text_edits = match format_result { Ok(Some(new_text)) => Some(text::get_edits( &document.content(), &new_text, document.line_index().as_ref(), )), Ok(None) => Some(Vec::new()), Err(err) => { // TODO(lucacasonato): handle error properly lsp_warn!("Format error: {:#}", err); None } }; self.performance.measure(mark); if let Some(text_edits) = text_edits { if text_edits.is_empty() { Ok(None) } else { Ok(Some(text_edits)) } } else { self.client.show_message(MessageType::WARNING, format!("Unable to format \"{specifier}\". Likely due to unrecoverable syntax errors in the file.")); Ok(None) } } async fn hover(&self, params: HoverParams) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("hover", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let hover = if let Some((_, dep, range)) = asset_or_doc .get_maybe_dependency(¶ms.text_document_position_params.position) { let dep_maybe_types_dependency = dep .get_code() .and_then(|s| self.documents.get(s)) .map(|d| d.maybe_types_dependency()); let value = match (dep.maybe_code.is_none(), dep.maybe_type.is_none(), &dep_maybe_types_dependency) { (false, false, None) => format!( "**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n", to_hover_text(&dep.maybe_code), to_hover_text(&dep.maybe_type) ), (false, false, Some(types_dep)) if !types_dep.is_none() => format!( "**Resolved Dependency**\n\n**Code**: {}\n**Types**: {}\n**Import Types**: {}\n", to_hover_text(&dep.maybe_code), to_hover_text(&dep.maybe_type), to_hover_text(types_dep) ), (false, false, Some(_)) => format!( "**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n", to_hover_text(&dep.maybe_code), to_hover_text(&dep.maybe_type) ), (false, true, Some(types_dep)) if !types_dep.is_none() => format!( "**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n", to_hover_text(&dep.maybe_code), to_hover_text(types_dep) ), (false, true, _) => format!( "**Resolved Dependency**\n\n**Code**: {}\n", to_hover_text(&dep.maybe_code) ), (true, false, _) => format!( "**Resolved Dependency**\n\n**Types**: {}\n", to_hover_text(&dep.maybe_type) ), (true, true, _) => unreachable!("{}", json!(params)), }; let value = if let Some(docs) = self.module_registries.get_hover(&dep).await { format!("{value}\n\n---\n\n{docs}") } else { value }; Some(Hover { contents: HoverContents::Markup(MarkupContent { kind: MarkupKind::Markdown, value, }), range: Some(to_lsp_range(&range)), }) } else { let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::GetQuickInfo(( specifier, line_index.offset_tsc(params.text_document_position_params.position)?, )); let maybe_quick_info: Option = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Unable to get quick info: {}", err); LspError::internal_error() })?; maybe_quick_info.map(|qi| qi.to_hover(line_index, self)) }; self.performance.measure(mark); Ok(hover) } async fn code_action( &self, params: CodeActionParams, ) -> LspResult> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("code_action", Some(¶ms)); let mut all_actions = CodeActionResponse::new(); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); // QuickFix let fixable_diagnostics: Vec<&Diagnostic> = params .context .diagnostics .iter() .filter(|d| match &d.source { Some(source) => match source.as_str() { "deno-ts" => match &d.code { Some(NumberOrString::String(code)) => { self.ts_fixable_diagnostics.contains(code) } Some(NumberOrString::Number(code)) => { self.ts_fixable_diagnostics.contains(&code.to_string()) } _ => false, }, "deno-lint" => matches!(&d.code, Some(_)), "deno" => diagnostics::DenoDiagnostic::is_fixable(d), _ => false, }, None => false, }) .collect(); if !fixable_diagnostics.is_empty() { let mut code_actions = CodeActionCollection::default(); let file_diagnostics = self .diagnostics_server .get_ts_diagnostics(&specifier, asset_or_doc.document_lsp_version()); for diagnostic in &fixable_diagnostics { match diagnostic.source.as_deref() { Some("deno-ts") => { let code = match diagnostic.code.as_ref().unwrap() { NumberOrString::String(code) => code.to_string(), NumberOrString::Number(code) => code.to_string(), }; let codes = vec![code]; let req = tsc::RequestMethod::GetCodeFixes(( specifier.clone(), line_index.offset_tsc(diagnostic.range.start)?, line_index.offset_tsc(diagnostic.range.end)?, codes, )); let actions: Vec = match self.ts_server.request(self.snapshot(), req).await { Ok(items) => items, Err(err) => { // sometimes tsc reports errors when retrieving code actions // because they don't reflect the current state of the document // so we will log them to the output, but we won't send an error // message back to the client. error!("Error getting actions from TypeScript: {}", err); Vec::new() } }; for action in actions { code_actions .add_ts_fix_action(&specifier, &action, diagnostic, self) .map_err(|err| { error!("Unable to convert fix: {}", err); LspError::internal_error() })?; if code_actions.is_fix_all_action( &action, diagnostic, &file_diagnostics, ) { code_actions .add_ts_fix_all_action(&action, &specifier, diagnostic); } } } Some("deno") => code_actions .add_deno_fix_action(&specifier, diagnostic) .map_err(|err| { error!("{}", err); LspError::internal_error() })?, Some("deno-lint") => code_actions .add_deno_lint_ignore_action( &specifier, diagnostic, asset_or_doc.document().map(|d| d.text_info()), asset_or_doc.maybe_parsed_source().and_then(|r| r.ok()), ) .map_err(|err| { error!("Unable to fix lint error: {}", err); LspError::internal_error() })?, _ => (), } } code_actions.set_preferred_fixes(); all_actions.extend(code_actions.get_response()); } // Refactor let start = line_index.offset_tsc(params.range.start)?; let length = line_index.offset_tsc(params.range.end)? - start; let only = params .context .only .as_ref() .and_then(|values| values.first().map(|v| v.as_str().to_owned())) .unwrap_or_default(); let req = tsc::RequestMethod::GetApplicableRefactors(( specifier.clone(), tsc::TextSpan { start, length }, only, )); let refactor_infos: Vec = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let mut refactor_actions = Vec::::new(); for refactor_info in refactor_infos.iter() { refactor_actions .extend(refactor_info.to_code_actions(&specifier, ¶ms.range)); } all_actions.extend( refactor::prune_invalid_actions(refactor_actions, 5) .into_iter() .map(CodeActionOrCommand::CodeAction), ); let code_action_disabled_support = self.config.client_capabilities.code_action_disabled_support; let actions: Vec = all_actions.into_iter().filter(|ca| { code_action_disabled_support || matches!(ca, CodeActionOrCommand::CodeAction(ca) if ca.disabled.is_none()) }).collect(); let response = if actions.is_empty() { None } else { Some(actions) }; self.performance.measure(mark); Ok(response) } async fn code_action_resolve( &self, params: CodeAction, ) -> LspResult { if params.kind.is_none() || params.data.is_none() { return Ok(params); } let mark = self.performance.mark("code_action_resolve", Some(¶ms)); let kind = params.kind.clone().unwrap(); let data = params.data.clone().unwrap(); let result = if kind.as_str().starts_with(CodeActionKind::QUICKFIX.as_str()) { let snapshot = self.snapshot(); let code_action_data: CodeActionData = from_value(data).map_err(|err| { error!("Unable to decode code action data: {}", err); LspError::invalid_params("The CodeAction's data is invalid.") })?; let req = tsc::RequestMethod::GetCombinedCodeFix(( code_action_data.specifier.clone(), json!(code_action_data.fix_id.clone()), )); let combined_code_actions: tsc::CombinedCodeActions = self .ts_server .request(snapshot.clone(), req) .await .map_err(|err| { error!("Unable to get combined fix from TypeScript: {}", err); LspError::internal_error() })?; if combined_code_actions.commands.is_some() { error!("Deno does not support code actions with commands."); return Err(LspError::invalid_request()); } let changes = if code_action_data.fix_id == "fixMissingImport" { fix_ts_import_changes( &code_action_data.specifier, &combined_code_actions.changes, &self.documents, ) .map_err(|err| { error!("Unable to remap changes: {}", err); LspError::internal_error() })? } else { combined_code_actions.changes }; let mut code_action = params; code_action.edit = ts_changes_to_edit(&changes, self).map_err(|err| { error!("Unable to convert changes to edits: {}", err); LspError::internal_error() })?; code_action } else if kind.as_str().starts_with(CodeActionKind::REFACTOR.as_str()) { let snapshot = self.snapshot(); let mut code_action = params; let action_data: refactor::RefactorCodeActionData = from_value(data) .map_err(|err| { error!("Unable to decode code action data: {}", err); LspError::invalid_params("The CodeAction's data is invalid.") })?; let asset_or_doc = self.get_asset_or_document(&action_data.specifier)?; let line_index = asset_or_doc.line_index(); let start = line_index.offset_tsc(action_data.range.start)?; let length = line_index.offset_tsc(action_data.range.end)? - start; let req = tsc::RequestMethod::GetEditsForRefactor(( action_data.specifier, tsc::TextSpan { start, length }, action_data.refactor_name, action_data.action_name, )); let refactor_edit_info: tsc::RefactorEditInfo = self.ts_server.request(snapshot, req).await.map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; code_action.edit = refactor_edit_info .to_workspace_edit(self) .await .map_err(|err| { error!("Unable to convert changes to edits: {}", err); LspError::internal_error() })?; code_action } else { // The code action doesn't need to be resolved params }; self.performance.measure(mark); Ok(result) } async fn code_lens( &self, params: CodeLensParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) || !(self.config.get_workspace_settings().enabled_code_lens() || self.config.specifier_code_lens_test(&specifier)) { return Ok(None); } let mark = self.performance.mark("code_lens", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let navigation_tree = self.get_navigation_tree(&specifier).await.map_err(|err| { error!("Error getting code lenses for \"{}\": {}", specifier, err); LspError::internal_error() })?; let parsed_source = asset_or_doc.maybe_parsed_source().and_then(|r| r.ok()); let line_index = asset_or_doc.line_index(); let code_lenses = code_lens::collect( &specifier, parsed_source, &self.config, line_index, &navigation_tree, ) .await .map_err(|err| { error!("Error getting code lenses for \"{}\": {}", specifier, err); LspError::internal_error() })?; self.performance.measure(mark); Ok(Some(code_lenses)) } async fn code_lens_resolve( &self, code_lens: CodeLens, ) -> LspResult { let mark = self.performance.mark("code_lens_resolve", Some(&code_lens)); let result = if code_lens.data.is_some() { code_lens::resolve_code_lens(code_lens, self) .await .map_err(|err| { error!("Error resolving code lens: {}", err); LspError::internal_error() }) } else { Err(LspError::invalid_params( "Code lens is missing the \"data\" property.", )) }; self.performance.measure(mark); result } async fn document_highlight( &self, params: DocumentHighlightParams, ) -> LspResult>> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("document_highlight", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let files_to_search = vec![specifier.clone()]; let req = tsc::RequestMethod::GetDocumentHighlights(( specifier, line_index.offset_tsc(params.text_document_position_params.position)?, files_to_search, )); let maybe_document_highlights: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Unable to get document highlights from TypeScript: {}", err); LspError::internal_error() })?; if let Some(document_highlights) = maybe_document_highlights { let result = document_highlights .into_iter() .flat_map(|dh| dh.to_highlight(line_index.clone())) .collect(); self.performance.measure(mark); Ok(Some(result)) } else { self.performance.measure(mark); Ok(None) } } async fn references( &self, params: ReferenceParams, ) -> LspResult>> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("references", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::GetReferences(( specifier.clone(), line_index.offset_tsc(params.text_document_position.position)?, )); let maybe_references: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Unable to get references from TypeScript: {}", err); LspError::internal_error() })?; if let Some(references) = maybe_references { let mut results = Vec::new(); for reference in references { if !params.context.include_declaration && reference.is_definition { continue; } let reference_specifier = resolve_url(&reference.document_span.file_name).unwrap(); let reference_line_index = if reference_specifier == specifier { line_index.clone() } else { let asset_or_doc = self.get_asset_or_document(&reference_specifier)?; asset_or_doc.line_index() }; results .push(reference.to_location(reference_line_index, &self.url_map)); } self.performance.measure(mark); Ok(Some(results)) } else { self.performance.measure(mark); Ok(None) } } async fn goto_definition( &self, params: GotoDefinitionParams, ) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("goto_definition", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::GetDefinition(( specifier, line_index.offset_tsc(params.text_document_position_params.position)?, )); let maybe_definition: Option = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Unable to get definition from TypeScript: {}", err); LspError::internal_error() })?; if let Some(definition) = maybe_definition { let results = definition.to_definition(line_index, self).await; self.performance.measure(mark); Ok(results) } else { self.performance.measure(mark); Ok(None) } } async fn goto_type_definition( &self, params: GotoTypeDefinitionParams, ) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("goto_definition", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::GetTypeDefinition { specifier, position: line_index .offset_tsc(params.text_document_position_params.position)?, }; let maybe_definition_info: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Unable to get type definition from TypeScript: {}", err); LspError::internal_error() })?; let response = if let Some(definition_info) = maybe_definition_info { let mut location_links = Vec::new(); for info in definition_info { if let Some(link) = info.document_span.to_link(line_index.clone(), self) { location_links.push(link); } } Some(GotoTypeDefinitionResponse::Link(location_links)) } else { None }; self.performance.measure(mark); Ok(response) } async fn completion( &self, params: CompletionParams, ) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("completion", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; // Import specifiers are something wholly internal to Deno, so for // completions, we will use internal logic and if there are completions // for imports, we will return those and not send a message into tsc, where // other completions come from. let response = if let Some(response) = completions::get_import_completions( &specifier, ¶ms.text_document_position.position, &self.config.snapshot(), &self.client, &self.module_registries, &self.documents, self.maybe_import_map.clone(), ) .await { Some(response) } else { let line_index = asset_or_doc.line_index(); let (trigger_character, trigger_kind) = if let Some(context) = ¶ms.context { ( context.trigger_character.clone(), Some(context.trigger_kind.into()), ) } else { (None, None) }; let position = line_index.offset_tsc(params.text_document_position.position)?; let use_snippets = self.config.client_capabilities.snippet_support; let req = tsc::RequestMethod::GetCompletions(( specifier.clone(), position, tsc::GetCompletionsAtPositionOptions { user_preferences: tsc::UserPreferences { allow_incomplete_completions: Some(true), allow_text_changes_in_new_files: Some(specifier.scheme() == "file"), import_module_specifier_ending: Some( tsc::ImportModuleSpecifierEnding::Index, ), include_automatic_optional_chain_completions: Some(true), include_completions_for_import_statements: Some( self.config.get_workspace_settings().suggest.auto_imports, ), include_completions_for_module_exports: Some(true), include_completions_with_object_literal_method_snippets: Some( use_snippets, ), include_completions_with_class_member_snippets: Some(use_snippets), include_completions_with_insert_text: Some(true), include_completions_with_snippet_text: Some(use_snippets), jsx_attribute_completion_style: Some( tsc::JsxAttributeCompletionStyle::Auto, ), provide_prefix_and_suffix_text_for_rename: Some(true), provide_refactor_not_applicable_reason: Some(true), use_label_details_in_completion_entries: Some(true), ..Default::default() }, trigger_character, trigger_kind, }, )); let snapshot = self.snapshot(); let maybe_completion_info: Option = self.ts_server.request(snapshot, req).await.map_err(|err| { error!("Unable to get completion info from TypeScript: {}", err); LspError::internal_error() })?; if let Some(completions) = maybe_completion_info { let results = completions.as_completion_response( line_index, &self.config.get_workspace_settings().suggest, &specifier, position, ); Some(results) } else { None } }; self.performance.measure(mark); Ok(response) } async fn completion_resolve( &self, params: CompletionItem, ) -> LspResult { let mark = self.performance.mark("completion_resolve", Some(¶ms)); let completion_item = if let Some(data) = ¶ms.data { let data: completions::CompletionItemData = serde_json::from_value(data.clone()).map_err(|err| { error!("{}", err); LspError::invalid_params( "Could not decode data field of completion item.", ) })?; if let Some(data) = &data.tsc { let specifier = &data.specifier; let req = tsc::RequestMethod::GetCompletionDetails(data.into()); let result: Result, _> = self.ts_server.request(self.snapshot(), req).await; match result { Ok(maybe_completion_info) => { if let Some(completion_info) = maybe_completion_info { completion_info .as_completion_item(¶ms, data, specifier, self) .map_err(|err| { error!( "Failed to serialize virtual_text_document response: {}", err ); LspError::internal_error() })? } else { error!( "Received an undefined response from tsc for completion details." ); params } } Err(err) => { error!("Unable to get completion info from TypeScript: {}", err); return Ok(params); } } } else if let Some(url) = data.documentation { CompletionItem { documentation: self.module_registries.get_documentation(&url).await, data: None, ..params } } else { params } } else { params }; self.performance.measure(mark); Ok(completion_item) } async fn goto_implementation( &self, params: GotoImplementationParams, ) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("goto_implementation", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::GetImplementation(( specifier, line_index.offset_tsc(params.text_document_position_params.position)?, )); let maybe_implementations: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let result = if let Some(implementations) = maybe_implementations { let mut links = Vec::new(); for implementation in implementations { if let Some(link) = implementation.to_link(line_index.clone(), self) { links.push(link) } } Some(GotoDefinitionResponse::Link(links)) } else { None }; self.performance.measure(mark); Ok(result) } async fn folding_range( &self, params: FoldingRangeParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("folding_range", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let req = tsc::RequestMethod::GetOutliningSpans(specifier); let outlining_spans: Vec = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let response = if !outlining_spans.is_empty() { Some( outlining_spans .iter() .map(|span| { span.to_folding_range( asset_or_doc.line_index(), asset_or_doc.text().as_bytes(), self.config.client_capabilities.line_folding_only, ) }) .collect::>(), ) } else { None }; self.performance.measure(mark); Ok(response) } async fn incoming_calls( &self, params: CallHierarchyIncomingCallsParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.item.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("incoming_calls", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::ProvideCallHierarchyIncomingCalls(( specifier, line_index.offset_tsc(params.item.selection_range.start)?, )); let incoming_calls: Vec = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let maybe_root_path_owned = self .config .root_uri .as_ref() .and_then(|uri| specifier_to_file_path(uri).ok()); let mut resolved_items = Vec::::new(); for item in incoming_calls.iter() { if let Some(resolved) = item.try_resolve_call_hierarchy_incoming_call( self, maybe_root_path_owned.as_deref(), ) { resolved_items.push(resolved); } } self.performance.measure(mark); Ok(Some(resolved_items)) } async fn outgoing_calls( &self, params: CallHierarchyOutgoingCallsParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.item.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("outgoing_calls", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::ProvideCallHierarchyOutgoingCalls(( specifier, line_index.offset_tsc(params.item.selection_range.start)?, )); let outgoing_calls: Vec = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let maybe_root_path_owned = self .config .root_uri .as_ref() .and_then(|uri| specifier_to_file_path(uri).ok()); let mut resolved_items = Vec::::new(); for item in outgoing_calls.iter() { if let Some(resolved) = item.try_resolve_call_hierarchy_outgoing_call( line_index.clone(), self, maybe_root_path_owned.as_deref(), ) { resolved_items.push(resolved); } } self.performance.measure(mark); Ok(Some(resolved_items)) } async fn prepare_call_hierarchy( &self, params: CallHierarchyPrepareParams, ) -> LspResult>> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self .performance .mark("prepare_call_hierarchy", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::PrepareCallHierarchy(( specifier, line_index.offset_tsc(params.text_document_position_params.position)?, )); let maybe_one_or_many: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let response = if let Some(one_or_many) = maybe_one_or_many { let maybe_root_path_owned = self .config .root_uri .as_ref() .and_then(|uri| specifier_to_file_path(uri).ok()); let mut resolved_items = Vec::::new(); match one_or_many { tsc::OneOrMany::One(item) => { if let Some(resolved) = item.try_resolve_call_hierarchy_item( self, maybe_root_path_owned.as_deref(), ) { resolved_items.push(resolved) } } tsc::OneOrMany::Many(items) => { for item in items.iter() { if let Some(resolved) = item.try_resolve_call_hierarchy_item( self, maybe_root_path_owned.as_deref(), ) { resolved_items.push(resolved); } } } } Some(resolved_items) } else { None }; self.performance.measure(mark); Ok(response) } async fn rename( &self, params: RenameParams, ) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("rename", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::FindRenameLocations { specifier, position: line_index .offset_tsc(params.text_document_position.position)?, find_in_strings: false, find_in_comments: false, provide_prefix_and_suffix_text_for_rename: false, }; let maybe_locations: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; if let Some(locations) = maybe_locations { let rename_locations = tsc::RenameLocations { locations }; let workspace_edits = rename_locations .into_workspace_edit(¶ms.new_name, self) .await .map_err(|err| { error!("Failed to get workspace edits: {}", err); LspError::internal_error() })?; self.performance.measure(mark); Ok(Some(workspace_edits)) } else { self.performance.measure(mark); Ok(None) } } async fn selection_range( &self, params: SelectionRangeParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("selection_range", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let mut selection_ranges = Vec::::new(); for position in params.positions { let req = tsc::RequestMethod::GetSmartSelectionRange(( specifier.clone(), line_index.offset_tsc(position)?, )); let selection_range: tsc::SelectionRange = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; selection_ranges .push(selection_range.to_selection_range(line_index.clone())); } self.performance.measure(mark); Ok(Some(selection_ranges)) } async fn semantic_tokens_full( &self, params: SemanticTokensParams, ) -> LspResult> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("semantic_tokens_full", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let req = tsc::RequestMethod::GetEncodedSemanticClassifications(( specifier, tsc::TextSpan { start: 0, length: line_index.text_content_length_utf16().into(), }, )); let semantic_classification: tsc::Classifications = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let semantic_tokens = semantic_classification.to_semantic_tokens(&asset_or_doc, line_index)?; let response = if !semantic_tokens.data.is_empty() { Some(SemanticTokensResult::Tokens(semantic_tokens)) } else { None }; self.performance.measure(mark); Ok(response) } async fn semantic_tokens_range( &self, params: SemanticTokensRangeParams, ) -> LspResult> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self .performance .mark("semantic_tokens_range", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let start = line_index.offset_tsc(params.range.start)?; let length = line_index.offset_tsc(params.range.end)? - start; let req = tsc::RequestMethod::GetEncodedSemanticClassifications(( specifier, tsc::TextSpan { start, length }, )); let semantic_classification: tsc::Classifications = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver {}", err); LspError::invalid_request() })?; let semantic_tokens = semantic_classification.to_semantic_tokens(&asset_or_doc, line_index)?; let response = if !semantic_tokens.data.is_empty() { Some(SemanticTokensRangeResult::Tokens(semantic_tokens)) } else { None }; self.performance.measure(mark); Ok(response) } async fn signature_help( &self, params: SignatureHelpParams, ) -> LspResult> { let specifier = self.url_map.normalize_url( ¶ms.text_document_position_params.text_document.uri, LspUrlKind::File, ); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) { return Ok(None); } let mark = self.performance.mark("signature_help", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let options = if let Some(context) = params.context { tsc::SignatureHelpItemsOptions { trigger_reason: Some(tsc::SignatureHelpTriggerReason { kind: context.trigger_kind.into(), trigger_character: context.trigger_character, }), } } else { tsc::SignatureHelpItemsOptions { trigger_reason: None, } }; let req = tsc::RequestMethod::GetSignatureHelpItems(( specifier, line_index.offset_tsc(params.text_document_position_params.position)?, options, )); let maybe_signature_help_items: Option = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed to request to tsserver: {}", err); LspError::invalid_request() })?; if let Some(signature_help_items) = maybe_signature_help_items { let signature_help = signature_help_items.into_signature_help(self); self.performance.measure(mark); Ok(Some(signature_help)) } else { self.performance.measure(mark); Ok(None) } } async fn symbol( &self, params: WorkspaceSymbolParams, ) -> LspResult>> { let mark = self.performance.mark("symbol", Some(¶ms)); let req = tsc::RequestMethod::GetNavigateToItems { search: params.query, // this matches vscode's hard coded result count max_result_count: Some(256), file: None, }; let navigate_to_items: Vec = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Failed request to tsserver: {}", err); LspError::invalid_request() })?; let maybe_symbol_information = if navigate_to_items.is_empty() { None } else { let mut symbol_information = Vec::new(); for item in navigate_to_items { if let Some(info) = item.to_symbol_information(self) { symbol_information.push(info); } } Some(symbol_information) }; self.performance.measure(mark); Ok(maybe_symbol_information) } fn send_diagnostics_update(&self) { let snapshot = ( self.snapshot(), self.config.snapshot(), self.lint_options.clone(), ); if let Err(err) = self.diagnostics_server.update(snapshot) { error!("Cannot update diagnostics: {}", err); } } /// Send a message to the testing server to look for any changes in tests and /// update the client. fn send_testing_update(&self) { if let Some(testing_server) = &self.maybe_testing_server { if let Err(err) = testing_server.update(self.snapshot()) { error!("Cannot update testing server: {}", err); } } } } #[tower_lsp::async_trait] impl tower_lsp::LanguageServer for LanguageServer { async fn initialize( &self, params: InitializeParams, ) -> LspResult { let mut language_server = self.0.write().await; language_server.diagnostics_server.start(); language_server.initialize(params).await } async fn initialized(&self, _: InitializedParams) { let mut maybe_registration = None; let client = { let mut ls = self.0.write().await; if ls .config .client_capabilities .workspace_did_change_watched_files { // we are going to watch all the JSON files in the workspace, and the // notification handler will pick up any of the changes of those files we // are interested in. let watch_registration_options = DidChangeWatchedFilesRegistrationOptions { watchers: vec![FileSystemWatcher { glob_pattern: "**/*.{json,jsonc}".to_string(), kind: Some(WatchKind::Change), }], }; maybe_registration = Some(Registration { id: "workspace/didChangeWatchedFiles".to_string(), method: "workspace/didChangeWatchedFiles".to_string(), register_options: Some( serde_json::to_value(watch_registration_options).unwrap(), ), }); } if ls.config.client_capabilities.testing_api { let test_server = testing::TestServer::new( ls.client.clone(), ls.performance.clone(), ls.config.root_uri.clone(), ); ls.maybe_testing_server = Some(test_server); } ls.client.clone() }; if let Some(registration) = maybe_registration { if let Err(err) = client .when_outside_lsp_lock() .register_capability(vec![registration]) .await { lsp_warn!("Client errored on capabilities.\n{:#}", err); } } if !self.refresh_specifiers_from_client().await { // force update config self.0.write().await.refresh_documents_config(); } lsp_log!("Server ready."); } async fn shutdown(&self) -> LspResult<()> { self.0.write().await.shutdown().await } async fn did_open(&self, params: DidOpenTextDocumentParams) { if params.text_document.uri.scheme() == "deno" { // we can ignore virtual text documents opening, as they don't need to // be tracked in memory, as they are static assets that won't change // already managed by the language service return; } let (client, client_uri, specifier, had_specifier_settings) = { let mut inner = self.0.write().await; let client = inner.client.clone(); let client_uri = LspClientUrl::new(params.text_document.uri.clone()); let specifier = inner .url_map .normalize_url(client_uri.as_url(), LspUrlKind::File); let document = inner.did_open(&specifier, params).await; let has_specifier_settings = inner.config.has_specifier_settings(&specifier); if document.is_diagnosable() { inner.refresh_npm_specifiers().await; let specifiers = inner.documents.dependents(&specifier); inner.diagnostics_server.invalidate(&specifiers); // don't send diagnostics yet if we don't have the specifier settings if has_specifier_settings { inner.send_diagnostics_update(); inner.send_testing_update(); } } (client, client_uri, specifier, has_specifier_settings) }; // retrieve the specifier settings outside the lock if // they haven't been asked for yet if !had_specifier_settings { let response = client .when_outside_lsp_lock() .specifier_configuration(&client_uri) .await; let mut ls = self.0.write().await; match response { Ok(specifier_settings) => { ls.config .set_specifier_settings(specifier.clone(), specifier_settings); ls.config.update_enabled_paths(); } Err(err) => { error!("{}", err); } } if ls .documents .get(&specifier) .map(|d| d.is_diagnosable()) .unwrap_or(false) { ls.refresh_documents_config(); ls.send_diagnostics_update(); ls.send_testing_update(); } } } async fn did_change(&self, params: DidChangeTextDocumentParams) { self.0.write().await.did_change(params).await } async fn did_save(&self, _params: DidSaveTextDocumentParams) { // We don't need to do anything on save at the moment, but if this isn't // implemented, lspower complains about it not being implemented. } async fn did_close(&self, params: DidCloseTextDocumentParams) { self.0.write().await.did_close(params).await } async fn did_change_configuration( &self, params: DidChangeConfigurationParams, ) { let (mark, has_workspace_capability, client) = { let inner = self.0.read().await; ( inner .performance .mark("did_change_configuration", Some(¶ms)), inner.config.client_capabilities.workspace_configuration, inner.client.clone(), ) }; self.refresh_specifiers_from_client().await; // Get the configuration from the client outside of the lock // in order to prevent potential deadlocking scenarios where // the server holds a lock and calls into the client, which // calls into the server which deadlocks acquiring the lock. // There is a gap here between when the configuration is // received and acquiring the lock, but most likely there // won't be any racing here. let client_workspace_config = if has_workspace_capability { let config_response = client .when_outside_lsp_lock() .workspace_configuration() .await; match config_response { Ok(value) => Some(value), Err(err) => { error!("{}", err); None } } } else { None }; // now update the inner state let mut inner = self.0.write().await; inner .did_change_configuration(client_workspace_config, params) .await; inner.performance.measure(mark); } async fn did_change_watched_files( &self, params: DidChangeWatchedFilesParams, ) { self.0.write().await.did_change_watched_files(params).await } async fn did_change_workspace_folders( &self, params: DidChangeWorkspaceFoldersParams, ) { let (performance, mark) = { let mut ls = self.0.write().await; let mark = ls .performance .mark("did_change_workspace_folders", Some(¶ms)); ls.did_change_workspace_folders(params); (ls.performance.clone(), mark) }; self.refresh_specifiers_from_client().await; performance.measure(mark); } async fn document_symbol( &self, params: DocumentSymbolParams, ) -> LspResult> { self.0.read().await.document_symbol(params).await } async fn formatting( &self, params: DocumentFormattingParams, ) -> LspResult>> { self.0.read().await.formatting(params).await } async fn hover(&self, params: HoverParams) -> LspResult> { self.0.read().await.hover(params).await } async fn code_action( &self, params: CodeActionParams, ) -> LspResult> { self.0.read().await.code_action(params).await } async fn code_action_resolve( &self, params: CodeAction, ) -> LspResult { self.0.read().await.code_action_resolve(params).await } async fn code_lens( &self, params: CodeLensParams, ) -> LspResult>> { self.0.read().await.code_lens(params).await } async fn code_lens_resolve(&self, params: CodeLens) -> LspResult { self.0.read().await.code_lens_resolve(params).await } async fn document_highlight( &self, params: DocumentHighlightParams, ) -> LspResult>> { self.0.read().await.document_highlight(params).await } async fn references( &self, params: ReferenceParams, ) -> LspResult>> { self.0.read().await.references(params).await } async fn goto_definition( &self, params: GotoDefinitionParams, ) -> LspResult> { self.0.read().await.goto_definition(params).await } async fn goto_type_definition( &self, params: GotoTypeDefinitionParams, ) -> LspResult> { self.0.read().await.goto_type_definition(params).await } async fn completion( &self, params: CompletionParams, ) -> LspResult> { self.0.read().await.completion(params).await } async fn completion_resolve( &self, params: CompletionItem, ) -> LspResult { self.0.read().await.completion_resolve(params).await } async fn goto_implementation( &self, params: GotoImplementationParams, ) -> LspResult> { self.0.read().await.goto_implementation(params).await } async fn folding_range( &self, params: FoldingRangeParams, ) -> LspResult>> { self.0.read().await.folding_range(params).await } async fn incoming_calls( &self, params: CallHierarchyIncomingCallsParams, ) -> LspResult>> { self.0.read().await.incoming_calls(params).await } async fn outgoing_calls( &self, params: CallHierarchyOutgoingCallsParams, ) -> LspResult>> { self.0.read().await.outgoing_calls(params).await } async fn prepare_call_hierarchy( &self, params: CallHierarchyPrepareParams, ) -> LspResult>> { self.0.read().await.prepare_call_hierarchy(params).await } async fn rename( &self, params: RenameParams, ) -> LspResult> { self.0.read().await.rename(params).await } async fn selection_range( &self, params: SelectionRangeParams, ) -> LspResult>> { self.0.read().await.selection_range(params).await } async fn semantic_tokens_full( &self, params: SemanticTokensParams, ) -> LspResult> { self.0.read().await.semantic_tokens_full(params).await } async fn semantic_tokens_range( &self, params: SemanticTokensRangeParams, ) -> LspResult> { self.0.read().await.semantic_tokens_range(params).await } async fn signature_help( &self, params: SignatureHelpParams, ) -> LspResult> { self.0.read().await.signature_help(params).await } async fn symbol( &self, params: WorkspaceSymbolParams, ) -> LspResult>> { self.0.read().await.symbol(params).await } } struct PrepareCacheResult { cli_options: CliOptions, roots: Vec, open_docs: Vec, mark: PerformanceMark, } // These are implementations of custom commands supported by the LSP impl Inner { fn prepare_cache( &self, params: lsp_custom::CacheParams, ) -> Result, AnyError> { let referrer = self .url_map .normalize_url(¶ms.referrer.uri, LspUrlKind::File); if !self.is_diagnosable(&referrer) { return Ok(None); } let mark = self.performance.mark("cache", Some(¶ms)); let roots = if !params.uris.is_empty() { params .uris .iter() .map(|t| self.url_map.normalize_url(&t.uri, LspUrlKind::File)) .collect() } else { vec![referrer] }; let mut cli_options = CliOptions::new( Flags { cache_path: self.maybe_cache_path.clone(), ca_stores: None, ca_data: None, unsafely_ignore_certificate_errors: None, // this is to allow loading npm specifiers, so we can remove this // once stabilizing them unstable: true, ..Default::default() }, std::env::current_dir().with_context(|| "Failed getting cwd.")?, self.maybe_config_file.clone(), // TODO(#16510): add support for lockfile None, // TODO(bartlomieju): handle package.json dependencies here None, )?; cli_options.set_import_map_specifier(self.maybe_import_map_uri.clone()); let open_docs = self.documents.documents(DocumentsFilter::OpenDiagnosable); Ok(Some(PrepareCacheResult { cli_options, open_docs, roots, mark, })) } async fn post_cache(&self, mark: PerformanceMark) { // Now that we have dependencies loaded, we need to re-analyze all the files. // For that we're invalidating all the existing diagnostics and restarting // the language server for TypeScript (as it might hold to some stale // documents). self.diagnostics_server.invalidate_all(); self.restart_ts_server().await; self.send_diagnostics_update(); self.send_testing_update(); self.performance.measure(mark); } async fn restart_ts_server(&self) { let _: bool = self .ts_server .request(self.snapshot(), tsc::RequestMethod::Restart) .await .unwrap(); } fn get_performance(&self) -> Value { let averages = self.performance.averages(); json!({ "averages": averages }) } fn get_tasks(&self) -> LspResult> { Ok( self .maybe_config_file .as_ref() .and_then(|cf| cf.to_lsp_tasks()), ) } async fn inlay_hint( &self, params: InlayHintParams, ) -> LspResult>> { let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); let workspace_settings = self.config.get_workspace_settings(); if !self.is_diagnosable(&specifier) || !self.config.specifier_enabled(&specifier) || !workspace_settings.enabled_inlay_hints() { return Ok(None); } let mark = self.performance.mark("inlay_hint", Some(¶ms)); let asset_or_doc = self.get_asset_or_document(&specifier)?; let line_index = asset_or_doc.line_index(); let range = tsc::TextSpan::from_range(¶ms.range, line_index.clone()) .map_err(|err| { error!("Failed to convert range to text_span: {}", err); LspError::internal_error() })?; let req = tsc::RequestMethod::ProvideInlayHints(( specifier, range, (&workspace_settings).into(), )); let maybe_inlay_hints: Option> = self .ts_server .request(self.snapshot(), req) .await .map_err(|err| { error!("Unable to get inlay hints: {}", err); LspError::internal_error() })?; let maybe_inlay_hints = maybe_inlay_hints.map(|hints| { hints .iter() .map(|hint| hint.to_lsp(line_index.clone())) .collect() }); self.performance.measure(mark); Ok(maybe_inlay_hints) } async fn reload_import_registries(&mut self) -> LspResult> { remove_dir_all_if_exists(&self.module_registries_location) .await .map_err(|err| { error!("Unable to remove registries cache: {}", err); LspError::internal_error() })?; self.update_registries().await.map_err(|err| { error!("Unable to update registries: {}", err); LspError::internal_error() })?; Ok(Some(json!(true))) } fn virtual_text_document( &self, params: lsp_custom::VirtualTextDocumentParams, ) -> LspResult> { let mark = self .performance .mark("virtual_text_document", Some(¶ms)); let specifier = self .url_map .normalize_url(¶ms.text_document.uri, LspUrlKind::File); let contents = if specifier.as_str() == "deno:/status.md" { let mut contents = String::new(); let mut documents_specifiers = self .documents .documents(DocumentsFilter::All) .into_iter() .map(|d| d.specifier().clone()) .collect::>(); documents_specifiers.sort(); let measures = self.performance.to_vec(); let workspace_settings = self.config.get_workspace_settings(); write!( contents, r#"# Deno Language Server Status ## Workspace Settings ```json {} ``` ## Workspace Details -
Documents in memory: {} - {}
-
Performance measures: {} - {}
"#, serde_json::to_string_pretty(&workspace_settings).unwrap(), documents_specifiers.len(), documents_specifiers .into_iter() .map(|s| s.to_string()) .collect::>() .join("\n - "), measures.len(), measures .iter() .map(|m| m.to_string()) .collect::>() .join("\n - ") ) .unwrap(); contents .push_str("\n## Performance\n\n|Name|Duration|Count|\n|---|---|---|\n"); let mut averages = self.performance.averages(); averages.sort(); for average in averages { writeln!( contents, "|{}|{}ms|{}|", average.name, average.average_duration, average.count ) .unwrap(); } Some(contents) } else { let asset_or_doc = self.get_maybe_asset_or_document(&specifier); if let Some(asset_or_doc) = asset_or_doc { Some(asset_or_doc.text().to_string()) } else { error!("The source was not found: {}", specifier); None } }; self.performance.measure(mark); Ok(contents) } }