2024-01-01 19:58:21 +00:00
|
|
|
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2024-01-02 23:48:34 +00:00
|
|
|
use base64::Engine;
|
2021-10-28 23:56:01 +00:00
|
|
|
use deno_ast::MediaType;
|
2021-11-16 14:02:28 +00:00
|
|
|
use deno_core::anyhow::anyhow;
|
2020-12-21 13:44:26 +00:00
|
|
|
use deno_core::error::AnyError;
|
2021-02-17 18:47:18 +00:00
|
|
|
use deno_core::resolve_url;
|
2020-12-21 13:44:26 +00:00
|
|
|
use deno_core::serde_json;
|
|
|
|
use deno_core::serde_json::json;
|
|
|
|
use deno_core::serde_json::Value;
|
2023-08-23 23:03:05 +00:00
|
|
|
use deno_core::unsync::spawn;
|
2024-03-04 15:48:23 +00:00
|
|
|
use deno_core::url;
|
2020-12-21 13:44:26 +00:00
|
|
|
use deno_core::ModuleSpecifier;
|
2023-06-06 21:07:46 +00:00
|
|
|
use deno_graph::GraphKind;
|
2024-03-04 15:48:23 +00:00
|
|
|
use deno_graph::Resolution;
|
2023-05-17 21:38:50 +00:00
|
|
|
use deno_npm::NpmSystemInfo;
|
2023-05-05 16:44:24 +00:00
|
|
|
use deno_runtime::deno_fs;
|
2023-04-22 01:02:46 +00:00
|
|
|
use deno_runtime::deno_node::NodeResolver;
|
2023-05-01 20:42:05 +00:00
|
|
|
use deno_runtime::deno_tls::rustls::RootCertStore;
|
|
|
|
use deno_runtime::deno_tls::RootCertStoreProvider;
|
2024-03-04 15:48:23 +00:00
|
|
|
use deno_semver::jsr::JsrPackageReqReference;
|
2023-10-12 15:07:27 +00:00
|
|
|
use indexmap::IndexSet;
|
2021-03-26 16:34:25 +00:00
|
|
|
use log::error;
|
2024-02-29 03:54:16 +00:00
|
|
|
use serde::Deserialize;
|
2021-02-04 18:53:02 +00:00
|
|
|
use serde_json::from_value;
|
2024-03-21 04:29:52 +00:00
|
|
|
use std::collections::BTreeSet;
|
2022-10-20 17:23:21 +00:00
|
|
|
use std::collections::HashMap;
|
2023-02-23 15:58:10 +00:00
|
|
|
use std::collections::HashSet;
|
2024-03-21 04:29:52 +00:00
|
|
|
use std::collections::VecDeque;
|
2020-12-21 13:44:26 +00:00
|
|
|
use std::env;
|
2022-07-01 13:28:06 +00:00
|
|
|
use std::fmt::Write as _;
|
2024-01-18 20:57:30 +00:00
|
|
|
use std::path::Path;
|
2020-12-21 13:44:26 +00:00
|
|
|
use std::path::PathBuf;
|
|
|
|
use std::sync::Arc;
|
2024-01-02 23:48:34 +00:00
|
|
|
use tokio::sync::mpsc::unbounded_channel;
|
|
|
|
use tokio::sync::mpsc::UnboundedReceiver;
|
|
|
|
use tokio::sync::mpsc::UnboundedSender;
|
2023-11-22 04:08:48 +00:00
|
|
|
use tokio_util::sync::CancellationToken;
|
2022-04-03 04:17:30 +00:00
|
|
|
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::*;
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2021-05-29 11:21:11 +00:00
|
|
|
use super::analysis::fix_ts_import_changes;
|
2021-02-05 20:10:53 +00:00
|
|
|
use super::analysis::ts_changes_to_edit;
|
2021-02-04 18:53:02 +00:00
|
|
|
use super::analysis::CodeActionCollection;
|
2021-02-05 20:10:53 +00:00
|
|
|
use super::analysis::CodeActionData;
|
2023-07-02 01:07:57 +00:00
|
|
|
use super::analysis::TsResponseImportMapper;
|
2022-02-02 02:04:26 +00:00
|
|
|
use super::cache;
|
2020-12-21 13:44:26 +00:00
|
|
|
use super::capabilities;
|
2021-12-15 18:23:43 +00:00
|
|
|
use super::client::Client;
|
2021-06-04 21:31:44 +00:00
|
|
|
use super::code_lens;
|
2021-03-25 00:13:37 +00:00
|
|
|
use super::completions;
|
2020-12-21 13:44:26 +00:00
|
|
|
use super::config::Config;
|
2024-04-05 15:18:48 +00:00
|
|
|
use super::config::ConfigData;
|
2023-09-09 18:37:01 +00:00
|
|
|
use super::config::ConfigSnapshot;
|
2023-09-26 02:54:07 +00:00
|
|
|
use super::config::UpdateImportsOnFileMoveEnabled;
|
2023-09-21 05:46:39 +00:00
|
|
|
use super::config::WorkspaceSettings;
|
2021-05-10 01:16:04 +00:00
|
|
|
use super::config::SETTINGS_SECTION;
|
2020-12-21 13:44:26 +00:00
|
|
|
use super::diagnostics;
|
2023-09-24 22:33:52 +00:00
|
|
|
use super::diagnostics::DiagnosticDataSpecifier;
|
2023-05-26 06:10:18 +00:00
|
|
|
use super::diagnostics::DiagnosticServerUpdateMessage;
|
2022-01-17 22:09:43 +00:00
|
|
|
use super::diagnostics::DiagnosticsServer;
|
2023-09-24 22:33:52 +00:00
|
|
|
use super::diagnostics::DiagnosticsState;
|
2021-10-28 23:56:01 +00:00
|
|
|
use super::documents::to_lsp_range;
|
2021-11-12 16:42:04 +00:00
|
|
|
use super::documents::AssetOrDocument;
|
2022-02-02 23:02:59 +00:00
|
|
|
use super::documents::Document;
|
2021-10-28 23:56:01 +00:00
|
|
|
use super::documents::Documents;
|
2023-03-29 20:25:48 +00:00
|
|
|
use super::documents::DocumentsFilter;
|
2021-06-02 10:29:58 +00:00
|
|
|
use super::documents::LanguageId;
|
2024-02-29 03:54:16 +00:00
|
|
|
use super::jsr::CliJsrSearchApi;
|
2022-01-19 21:05:19 +00:00
|
|
|
use super::logging::lsp_log;
|
2023-03-30 14:43:16 +00:00
|
|
|
use super::logging::lsp_warn;
|
2021-06-01 11:53:08 +00:00
|
|
|
use super::lsp_custom;
|
2023-10-12 15:07:27 +00:00
|
|
|
use super::lsp_custom::TaskDefinition;
|
2023-08-29 15:22:05 +00:00
|
|
|
use super::npm::CliNpmSearchApi;
|
2021-06-23 01:48:01 +00:00
|
|
|
use super::parent_process_checker;
|
2021-01-27 00:32:49 +00:00
|
|
|
use super::performance::Performance;
|
2022-12-20 01:22:17 +00:00
|
|
|
use super::performance::PerformanceMark;
|
2021-08-06 01:46:32 +00:00
|
|
|
use super::refactor;
|
2022-01-24 00:27:52 +00:00
|
|
|
use super::registries::ModuleRegistry;
|
2022-03-29 22:59:27 +00:00
|
|
|
use super::testing;
|
2020-12-21 13:44:26 +00:00
|
|
|
use super::text;
|
|
|
|
use super::tsc;
|
2021-02-12 11:49:42 +00:00
|
|
|
use super::tsc::Assets;
|
2022-01-18 21:28:47 +00:00
|
|
|
use super::tsc::AssetsSnapshot;
|
2024-04-11 01:06:37 +00:00
|
|
|
use super::tsc::ChangeKind;
|
2023-08-17 14:46:11 +00:00
|
|
|
use super::tsc::GetCompletionDetailsArgs;
|
2020-12-21 13:44:26 +00:00
|
|
|
use super::tsc::TsServer;
|
2021-02-18 04:37:05 +00:00
|
|
|
use super::urls;
|
2022-11-28 22:28:54 +00:00
|
|
|
use crate::args::get_root_cert_store;
|
2023-01-18 00:18:24 +00:00
|
|
|
use crate::args::CaData;
|
2022-11-28 22:28:54 +00:00
|
|
|
use crate::args::CacheSetting;
|
2022-07-01 15:50:16 +00:00
|
|
|
use crate::args::CliOptions;
|
|
|
|
use crate::args::Flags;
|
2022-11-26 00:04:30 +00:00
|
|
|
use crate::cache::DenoDir;
|
2023-05-23 01:28:36 +00:00
|
|
|
use crate::cache::FastInsecureHasher;
|
2023-08-02 00:49:09 +00:00
|
|
|
use crate::cache::GlobalHttpCache;
|
2023-01-25 21:51:04 +00:00
|
|
|
use crate::cache::HttpCache;
|
2023-08-02 20:57:25 +00:00
|
|
|
use crate::cache::LocalLspHttpCache;
|
2023-05-01 18:35:23 +00:00
|
|
|
use crate::factory::CliFactory;
|
2023-01-25 21:51:04 +00:00
|
|
|
use crate::file_fetcher::FileFetcher;
|
2023-02-15 16:30:54 +00:00
|
|
|
use crate::graph_util;
|
2022-11-18 22:28:14 +00:00
|
|
|
use crate::http_util::HttpClient;
|
2024-03-26 15:52:20 +00:00
|
|
|
use crate::lsp::config::ConfigWatchedFileType;
|
2023-12-08 17:04:56 +00:00
|
|
|
use crate::lsp::logging::init_log_file;
|
2023-08-26 00:50:47 +00:00
|
|
|
use crate::lsp::tsc::file_text_changes_to_workspace_edit;
|
2023-03-15 14:34:23 +00:00
|
|
|
use crate::lsp::urls::LspUrlKind;
|
2023-10-02 21:53:55 +00:00
|
|
|
use crate::npm::create_cli_npm_resolver_for_lsp;
|
2023-04-22 01:02:46 +00:00
|
|
|
use crate::npm::CliNpmResolver;
|
2023-10-25 18:39:00 +00:00
|
|
|
use crate::npm::CliNpmResolverByonmCreateOptions;
|
2023-10-02 21:53:55 +00:00
|
|
|
use crate::npm::CliNpmResolverCreateOptions;
|
|
|
|
use crate::npm::CliNpmResolverManagedCreateOptions;
|
|
|
|
use crate::npm::CliNpmResolverManagedPackageJsonInstallerOption;
|
|
|
|
use crate::npm::CliNpmResolverManagedSnapshotOption;
|
2024-03-06 00:23:51 +00:00
|
|
|
use crate::resolver::CliNodeResolver;
|
2021-05-18 06:35:46 +00:00
|
|
|
use crate::tools::fmt::format_file;
|
2021-10-21 14:18:18 +00:00
|
|
|
use crate::tools::fmt::format_parsed_source;
|
2023-11-14 22:10:51 +00:00
|
|
|
use crate::tools::upgrade::check_for_upgrades_for_lsp;
|
|
|
|
use crate::tools::upgrade::upgrade_check_enabled;
|
2022-11-28 22:28:54 +00:00
|
|
|
use crate::util::fs::remove_dir_all_if_exists;
|
2023-09-24 16:59:42 +00:00
|
|
|
use crate::util::path::is_importable_ext;
|
2022-11-28 22:28:54 +00:00
|
|
|
use crate::util::path::specifier_to_file_path;
|
2024-03-27 15:58:18 +00:00
|
|
|
use crate::util::path::to_percent_decoded_str;
|
2022-11-28 22:28:54 +00:00
|
|
|
use crate::util::progress_bar::ProgressBar;
|
2022-12-13 01:52:10 +00:00
|
|
|
use crate::util::progress_bar::ProgressBarStyle;
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2023-05-01 20:42:05 +00:00
|
|
|
struct LspRootCertStoreProvider(RootCertStore);
|
|
|
|
|
|
|
|
impl RootCertStoreProvider for LspRootCertStoreProvider {
|
|
|
|
fn get_or_try_init(&self) -> Result<&RootCertStore, AnyError> {
|
|
|
|
Ok(&self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-23 01:28:36 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
struct LspNpmServices {
|
|
|
|
/// When this hash changes, the services need updating
|
|
|
|
config_hash: LspNpmConfigHash,
|
2023-08-29 15:22:05 +00:00
|
|
|
/// Npm's search api.
|
|
|
|
search_api: CliNpmSearchApi,
|
2023-10-25 18:39:00 +00:00
|
|
|
/// Node resolver.
|
2024-03-06 00:23:51 +00:00
|
|
|
node_resolver: Option<Arc<CliNodeResolver>>,
|
2023-05-23 01:28:36 +00:00
|
|
|
/// Resolver for npm packages.
|
2023-10-02 21:53:55 +00:00
|
|
|
resolver: Option<Arc<dyn CliNpmResolver>>,
|
2023-05-23 01:28:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
|
|
struct LspNpmConfigHash(u64);
|
|
|
|
|
|
|
|
impl LspNpmConfigHash {
|
|
|
|
pub fn from_inner(inner: &Inner) -> Self {
|
2024-03-26 15:52:20 +00:00
|
|
|
let config_data = inner.config.tree.root_data();
|
2024-04-05 15:18:48 +00:00
|
|
|
let node_modules_dir =
|
|
|
|
config_data.and_then(|d| d.node_modules_dir.as_ref());
|
|
|
|
let lockfile = config_data.and_then(|d| d.lockfile.as_ref());
|
2023-05-23 01:28:36 +00:00
|
|
|
let mut hasher = FastInsecureHasher::new();
|
2024-03-26 15:52:20 +00:00
|
|
|
hasher.write_hashable(node_modules_dir);
|
2023-08-02 00:49:09 +00:00
|
|
|
hasher.write_hashable(&inner.maybe_global_cache_path);
|
2024-03-26 15:52:20 +00:00
|
|
|
if let Some(lockfile) = lockfile {
|
2023-07-10 21:45:09 +00:00
|
|
|
hasher.write_hashable(&*lockfile.lock());
|
2023-05-23 01:28:36 +00:00
|
|
|
}
|
2023-07-10 21:45:09 +00:00
|
|
|
Self(hasher.finish())
|
2023-05-23 01:28:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-21 13:44:26 +00:00
|
|
|
#[derive(Debug, Clone)]
|
2023-11-22 04:08:48 +00:00
|
|
|
pub struct LanguageServer(Arc<tokio::sync::RwLock<Inner>>, CancellationToken);
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2024-01-11 17:07:44 +00:00
|
|
|
#[derive(Clone, Debug)]
|
2023-09-28 20:43:45 +00:00
|
|
|
pub struct StateNpmSnapshot {
|
2024-03-06 00:23:51 +00:00
|
|
|
pub node_resolver: Arc<CliNodeResolver>,
|
2023-09-29 13:26:25 +00:00
|
|
|
pub npm_resolver: Arc<dyn CliNpmResolver>,
|
2023-09-28 20:43:45 +00:00
|
|
|
}
|
|
|
|
|
2022-01-19 22:10:14 +00:00
|
|
|
/// Snapshot of the state used by TSC.
|
2024-01-11 17:07:44 +00:00
|
|
|
#[derive(Clone, Debug)]
|
2022-03-23 13:54:22 +00:00
|
|
|
pub struct StateSnapshot {
|
2024-04-15 00:07:04 +00:00
|
|
|
pub project_version: usize,
|
2022-01-18 21:28:47 +00:00
|
|
|
pub assets: AssetsSnapshot,
|
2022-02-02 02:04:26 +00:00
|
|
|
pub cache_metadata: cache::CacheMetadata,
|
2023-09-09 18:37:01 +00:00
|
|
|
pub config: Arc<ConfigSnapshot>,
|
2021-10-28 23:56:01 +00:00
|
|
|
pub documents: Documents,
|
2023-09-28 20:43:45 +00:00
|
|
|
pub npm: Option<StateNpmSnapshot>,
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2024-01-02 23:48:34 +00:00
|
|
|
type LanguageServerTaskFn = Box<dyn FnOnce(LanguageServer) + Send + Sync>;
|
|
|
|
|
|
|
|
/// Used to queue tasks from inside of the language server lock that must be
|
|
|
|
/// commenced from outside of it. For example, queue a request to cache a module
|
|
|
|
/// after having loaded a config file which references it.
|
|
|
|
#[derive(Debug)]
|
|
|
|
struct LanguageServerTaskQueue {
|
|
|
|
task_tx: UnboundedSender<LanguageServerTaskFn>,
|
|
|
|
/// This is moved out to its own task after initializing.
|
|
|
|
task_rx: Option<UnboundedReceiver<LanguageServerTaskFn>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for LanguageServerTaskQueue {
|
|
|
|
fn default() -> Self {
|
|
|
|
let (task_tx, task_rx) = unbounded_channel();
|
|
|
|
Self {
|
|
|
|
task_tx,
|
|
|
|
task_rx: Some(task_rx),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl LanguageServerTaskQueue {
|
|
|
|
fn queue_task(&self, task_fn: LanguageServerTaskFn) -> bool {
|
|
|
|
self.task_tx.send(task_fn).is_ok()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Panics if called more than once.
|
|
|
|
fn start(&mut self, ls: LanguageServer) {
|
|
|
|
let mut task_rx = self.task_rx.take().unwrap();
|
|
|
|
spawn(async move {
|
|
|
|
while let Some(task_fn) = task_rx.recv().await {
|
|
|
|
task_fn(ls.clone());
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
#[derive(Debug)]
|
2022-03-23 13:54:22 +00:00
|
|
|
pub struct Inner {
|
2021-02-04 18:53:02 +00:00
|
|
|
/// 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.
|
2021-02-12 11:49:42 +00:00
|
|
|
assets: Assets,
|
2022-02-02 02:04:26 +00:00
|
|
|
/// A representation of metadata associated with specifiers in the DENO_DIR
|
|
|
|
/// which is used by the language server
|
|
|
|
cache_metadata: cache::CacheMetadata,
|
2021-02-04 18:53:02 +00:00
|
|
|
/// The LSP client that this LSP server is connected to.
|
2022-03-23 13:54:22 +00:00
|
|
|
pub client: Client,
|
2021-02-04 18:53:02 +00:00
|
|
|
/// Configuration information.
|
2022-03-23 13:54:22 +00:00
|
|
|
pub config: Config,
|
2023-08-02 00:49:09 +00:00
|
|
|
deps_http_cache: Arc<dyn HttpCache>,
|
2023-09-24 22:33:52 +00:00
|
|
|
diagnostics_state: Arc<diagnostics::DiagnosticsState>,
|
2021-03-10 02:41:35 +00:00
|
|
|
diagnostics_server: diagnostics::DiagnosticsServer,
|
2021-10-28 23:56:01 +00:00
|
|
|
/// The collection of documents that the server is currently handling, either
|
|
|
|
/// on disk or "open" within the client.
|
2022-03-23 13:54:22 +00:00
|
|
|
pub documents: Documents,
|
2024-01-18 20:57:30 +00:00
|
|
|
initial_cwd: PathBuf,
|
2024-02-29 03:54:16 +00:00
|
|
|
jsr_search_api: CliJsrSearchApi,
|
2023-05-01 20:42:05 +00:00
|
|
|
http_client: Arc<HttpClient>,
|
2024-01-02 23:48:34 +00:00
|
|
|
task_queue: LanguageServerTaskQueue,
|
2021-04-09 01:27:27 +00:00
|
|
|
/// Handles module registries, which allow discovery of modules
|
2022-01-24 00:27:52 +00:00
|
|
|
module_registries: ModuleRegistry,
|
2021-04-09 01:27:27 +00:00
|
|
|
/// The path to the module registries cache
|
|
|
|
module_registries_location: PathBuf,
|
2021-07-27 21:25:09 +00:00
|
|
|
/// An optional path to the DENO_DIR which has been specified in the client
|
|
|
|
/// options.
|
2023-08-02 00:49:09 +00:00
|
|
|
maybe_global_cache_path: Option<PathBuf>,
|
2022-03-29 22:59:27 +00:00
|
|
|
/// A lazily create "server" for handling test run requests.
|
|
|
|
maybe_testing_server: Option<testing::TestServer>,
|
2023-05-23 01:28:36 +00:00
|
|
|
/// Services used for dealing with npm related functionality.
|
|
|
|
npm: LspNpmServices,
|
2024-04-15 00:07:04 +00:00
|
|
|
project_version: usize,
|
2021-02-04 18:53:02 +00:00
|
|
|
/// A collection of measurements which instrument that performance of the LSP.
|
2022-01-17 22:09:43 +00:00
|
|
|
performance: Arc<Performance>,
|
2021-02-04 18:53:02 +00:00
|
|
|
/// A memoized version of fixable diagnostic codes retrieved from TypeScript.
|
|
|
|
ts_fixable_diagnostics: Vec<String>,
|
|
|
|
/// An abstraction that handles interactions with TypeScript.
|
2022-03-23 13:54:22 +00:00
|
|
|
pub ts_server: Arc<TsServer>,
|
2021-02-18 04:37:05 +00:00
|
|
|
/// A map of specifiers and URLs used to translate over the LSP.
|
2023-08-02 20:57:25 +00:00
|
|
|
pub url_map: urls::LspUrlMap,
|
2024-03-21 04:29:52 +00:00
|
|
|
workspace_files: BTreeSet<ModuleSpecifier>,
|
|
|
|
/// Set to `self.config.settings.enable_settings_hash()` after
|
|
|
|
/// refreshing `self.workspace_files`.
|
|
|
|
workspace_files_hash: u64,
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl LanguageServer {
|
2023-11-22 04:08:48 +00:00
|
|
|
pub fn new(client: Client, token: CancellationToken) -> Self {
|
|
|
|
Self(
|
|
|
|
Arc::new(tokio::sync::RwLock::new(Inner::new(client))),
|
|
|
|
token,
|
|
|
|
)
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
2022-04-03 04:17:30 +00:00
|
|
|
|
2022-12-20 01:22:17 +00:00
|
|
|
/// Similar to `deno cache` on the command line, where modules will be cached
|
|
|
|
/// in the Deno cache, including any of their dependencies.
|
2024-02-29 03:54:16 +00:00
|
|
|
pub async fn cache(
|
2022-04-03 04:17:30 +00:00
|
|
|
&self,
|
2024-01-30 17:17:34 +00:00
|
|
|
specifiers: Vec<ModuleSpecifier>,
|
|
|
|
referrer: ModuleSpecifier,
|
2024-02-29 03:54:16 +00:00
|
|
|
force_global_cache: bool,
|
2022-04-03 04:17:30 +00:00
|
|
|
) -> LspResult<Option<Value>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
async fn create_graph_for_caching(
|
|
|
|
cli_options: CliOptions,
|
2023-01-24 13:23:19 +00:00
|
|
|
roots: Vec<ModuleSpecifier>,
|
2024-04-06 14:36:43 +00:00
|
|
|
open_docs: Vec<Arc<Document>>,
|
2022-12-20 01:22:17 +00:00
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
let open_docs = open_docs
|
|
|
|
.into_iter()
|
|
|
|
.map(|d| (d.specifier().clone(), d))
|
|
|
|
.collect::<HashMap<_, _>>();
|
2023-05-23 01:28:36 +00:00
|
|
|
let cli_options = Arc::new(cli_options);
|
|
|
|
let factory = CliFactory::from_cli_options(cli_options.clone());
|
2023-05-01 18:35:23 +00:00
|
|
|
let module_graph_builder = factory.module_graph_builder().await?;
|
2024-02-20 21:29:57 +00:00
|
|
|
let module_graph_creator = factory.module_graph_creator().await?;
|
2023-05-01 18:35:23 +00:00
|
|
|
let mut inner_loader = module_graph_builder.create_graph_loader();
|
2022-12-20 01:22:17 +00:00
|
|
|
let mut loader = crate::lsp::documents::OpenDocumentsGraphLoader {
|
|
|
|
inner_loader: &mut inner_loader,
|
|
|
|
open_docs: &open_docs,
|
2023-12-07 00:03:18 +00:00
|
|
|
unstable_sloppy_imports: cli_options.unstable_sloppy_imports(),
|
2022-12-20 01:22:17 +00:00
|
|
|
};
|
2024-02-20 21:29:57 +00:00
|
|
|
let graph = module_graph_creator
|
2023-06-06 21:07:46 +00:00
|
|
|
.create_graph_with_loader(GraphKind::All, roots.clone(), &mut loader)
|
2023-02-10 03:00:23 +00:00
|
|
|
.await?;
|
2023-02-15 16:30:54 +00:00
|
|
|
graph_util::graph_valid(
|
2023-02-10 03:00:23 +00:00
|
|
|
&graph,
|
2023-12-08 14:57:06 +00:00
|
|
|
factory.fs().as_ref(),
|
2023-02-10 03:00:23 +00:00
|
|
|
&roots,
|
2023-02-15 16:30:54 +00:00
|
|
|
graph_util::GraphValidOptions {
|
|
|
|
is_vendoring: false,
|
2023-02-10 03:00:23 +00:00
|
|
|
follow_type_only: true,
|
|
|
|
check_js: false,
|
|
|
|
},
|
|
|
|
)?;
|
2023-05-23 01:28:36 +00:00
|
|
|
|
|
|
|
// Update the lockfile on the file system with anything new
|
|
|
|
// found after caching
|
|
|
|
if let Some(lockfile) = cli_options.maybe_lockfile() {
|
|
|
|
let lockfile = lockfile.lock();
|
|
|
|
if let Err(err) = lockfile.write() {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error writing lockfile: {:#}", err);
|
2023-05-23 01:28:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-20 01:22:17 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2024-01-30 17:17:34 +00:00
|
|
|
// do as much as possible in a read, then do a write outside
|
|
|
|
let maybe_prepare_cache_result = {
|
|
|
|
let inner = self.0.read().await; // ensure dropped
|
2024-04-02 22:02:50 +00:00
|
|
|
match inner.prepare_cache(specifiers, referrer, force_global_cache) {
|
2024-01-30 17:17:34 +00:00
|
|
|
Ok(maybe_cache_result) => maybe_cache_result,
|
|
|
|
Err(err) => {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error preparing caching: {:#}", err);
|
2024-01-30 17:17:34 +00:00
|
|
|
self
|
|
|
|
.0
|
|
|
|
.read()
|
|
|
|
.await
|
|
|
|
.client
|
|
|
|
.show_message(MessageType::WARNING, err);
|
|
|
|
return Err(LspError::internal_error());
|
2022-12-20 01:22:17 +00:00
|
|
|
}
|
|
|
|
}
|
2024-01-30 17:17:34 +00:00
|
|
|
};
|
|
|
|
if let Some(result) = maybe_prepare_cache_result {
|
|
|
|
let cli_options = result.cli_options;
|
|
|
|
let roots = result.roots;
|
|
|
|
let open_docs = result.open_docs;
|
|
|
|
let handle = spawn(async move {
|
|
|
|
create_graph_for_caching(cli_options, roots, open_docs).await
|
|
|
|
});
|
|
|
|
if let Err(err) = handle.await.unwrap() {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error caching: {:#}", err);
|
2024-01-30 17:17:34 +00:00
|
|
|
self
|
|
|
|
.0
|
|
|
|
.read()
|
|
|
|
.await
|
|
|
|
.client
|
|
|
|
.show_message(MessageType::WARNING, err);
|
|
|
|
}
|
2024-02-14 22:48:39 +00:00
|
|
|
{
|
|
|
|
let mut inner = self.0.write().await;
|
2024-04-02 22:02:50 +00:00
|
|
|
let lockfile = inner.config.tree.root_lockfile().cloned();
|
2024-04-05 22:33:01 +00:00
|
|
|
inner.documents.refresh_lockfile(lockfile);
|
2024-02-14 22:48:39 +00:00
|
|
|
inner.refresh_npm_specifiers().await;
|
2024-02-12 22:12:49 +00:00
|
|
|
}
|
2024-01-30 17:17:34 +00:00
|
|
|
// now refresh the data in a read
|
|
|
|
self.0.read().await.post_cache(result.mark).await;
|
2022-04-03 04:17:30 +00:00
|
|
|
}
|
2024-01-30 17:17:34 +00:00
|
|
|
Ok(Some(json!(true)))
|
2022-04-03 04:17:30 +00:00
|
|
|
}
|
|
|
|
|
2023-05-26 06:10:18 +00:00
|
|
|
/// This request is only used by the lsp integration tests to
|
|
|
|
/// coordinate the tests receiving the latest diagnostics.
|
|
|
|
pub async fn latest_diagnostic_batch_index_request(
|
|
|
|
&self,
|
|
|
|
) -> LspResult<Option<Value>> {
|
|
|
|
Ok(
|
|
|
|
self
|
|
|
|
.0
|
|
|
|
.read()
|
|
|
|
.await
|
|
|
|
.diagnostics_server
|
|
|
|
.latest_batch_index()
|
|
|
|
.map(|v| v.into()),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2022-04-03 04:17:30 +00:00
|
|
|
pub async fn performance_request(&self) -> LspResult<Option<Value>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
Ok(Some(self.0.read().await.get_performance()))
|
2022-04-03 04:17:30 +00:00
|
|
|
}
|
|
|
|
|
2023-10-12 15:07:27 +00:00
|
|
|
pub async fn task_definitions(&self) -> LspResult<Vec<TaskDefinition>> {
|
|
|
|
self.0.read().await.task_definitions()
|
2022-04-03 04:17:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn test_run_request(
|
|
|
|
&self,
|
|
|
|
params: Option<Value>,
|
|
|
|
) -> LspResult<Option<Value>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
let inner = self.0.read().await;
|
2022-04-03 04:17:30 +00:00
|
|
|
if let Some(testing_server) = &inner.maybe_testing_server {
|
|
|
|
match params.map(serde_json::from_value) {
|
|
|
|
Some(Ok(params)) => testing_server
|
2023-05-11 21:17:14 +00:00
|
|
|
.run_request(params, inner.config.workspace_settings().clone()),
|
2022-04-03 04:17:30 +00:00
|
|
|
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<Value>,
|
|
|
|
) -> LspResult<Option<Value>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
if let Some(testing_server) = &self.0.read().await.maybe_testing_server {
|
2022-04-03 04:17:30 +00:00
|
|
|
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 virtual_text_document(
|
|
|
|
&self,
|
|
|
|
params: Option<Value>,
|
|
|
|
) -> LspResult<Option<Value>> {
|
|
|
|
match params.map(serde_json::from_value) {
|
|
|
|
Some(Ok(params)) => Ok(Some(
|
|
|
|
serde_json::to_value(
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.virtual_text_document(params)?,
|
2022-04-03 04:17:30 +00:00
|
|
|
)
|
|
|
|
.map_err(|err| {
|
|
|
|
error!(
|
2024-03-02 02:25:38 +00:00
|
|
|
"Failed to serialize virtual_text_document response: {:#}",
|
2022-04-03 04:17:30 +00:00
|
|
|
err
|
|
|
|
);
|
|
|
|
LspError::internal_error()
|
|
|
|
})?,
|
|
|
|
)),
|
|
|
|
Some(Err(err)) => Err(LspError::invalid_params(err.to_string())),
|
|
|
|
None => Err(LspError::invalid_params("Missing parameters")),
|
|
|
|
}
|
|
|
|
}
|
2023-03-15 14:34:23 +00:00
|
|
|
|
2023-10-24 20:27:27 +00:00
|
|
|
pub async fn refresh_configuration(&self) {
|
|
|
|
let (client, folders, capable) = {
|
2023-09-09 14:04:21 +00:00
|
|
|
let ls = self.0.read().await;
|
2023-10-24 20:27:27 +00:00
|
|
|
(
|
|
|
|
ls.client.clone(),
|
|
|
|
ls.config.workspace_folders.clone(),
|
|
|
|
ls.config.client_capabilities.workspace_configuration,
|
|
|
|
)
|
2023-09-09 14:04:21 +00:00
|
|
|
};
|
2023-10-24 20:27:27 +00:00
|
|
|
if capable {
|
|
|
|
let mut scopes = Vec::with_capacity(folders.len() + 1);
|
|
|
|
scopes.push(None);
|
|
|
|
for (_, folder) in &folders {
|
|
|
|
scopes.push(Some(folder.uri.clone()));
|
|
|
|
}
|
|
|
|
let configs = client
|
2023-03-15 14:34:23 +00:00
|
|
|
.when_outside_lsp_lock()
|
2023-10-24 20:27:27 +00:00
|
|
|
.workspace_configuration(scopes)
|
2023-03-15 14:34:23 +00:00
|
|
|
.await;
|
2023-10-24 20:27:27 +00:00
|
|
|
if let Ok(configs) = configs {
|
|
|
|
if configs.len() != folders.len() + 1 {
|
|
|
|
lsp_warn!("Incorrect number of configurations received.");
|
|
|
|
return;
|
2023-03-15 14:34:23 +00:00
|
|
|
}
|
2023-10-24 20:27:27 +00:00
|
|
|
let mut configs = configs.into_iter();
|
|
|
|
let unscoped = configs.next().unwrap();
|
2024-03-21 04:29:52 +00:00
|
|
|
let mut folder_settings = Vec::with_capacity(folders.len());
|
2023-10-24 20:27:27 +00:00
|
|
|
for (folder_uri, _) in &folders {
|
2024-03-21 04:29:52 +00:00
|
|
|
folder_settings.push((folder_uri.clone(), configs.next().unwrap()));
|
2023-10-24 20:27:27 +00:00
|
|
|
}
|
|
|
|
let mut ls = self.0.write().await;
|
2024-03-21 04:29:52 +00:00
|
|
|
ls.config.set_workspace_settings(unscoped, folder_settings);
|
2023-03-15 14:34:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Inner {
|
|
|
|
fn new(client: Client) -> Self {
|
2023-05-25 18:27:45 +00:00
|
|
|
let dir = DenoDir::new(None).expect("could not access DENO_DIR");
|
2022-11-26 00:04:30 +00:00
|
|
|
let module_registries_location = dir.registries_folder_path();
|
2023-05-01 20:42:05 +00:00
|
|
|
let http_client = Arc::new(HttpClient::new(None, None));
|
2023-06-10 15:09:45 +00:00
|
|
|
let module_registries = ModuleRegistry::new(
|
|
|
|
module_registries_location.clone(),
|
|
|
|
http_client.clone(),
|
|
|
|
);
|
2024-03-27 16:02:05 +00:00
|
|
|
let jsr_search_api =
|
|
|
|
CliJsrSearchApi::new(module_registries.file_fetcher.clone());
|
|
|
|
let npm_search_api =
|
|
|
|
CliNpmSearchApi::new(module_registries.file_fetcher.clone());
|
2023-08-08 14:23:02 +00:00
|
|
|
let deps_http_cache = Arc::new(GlobalHttpCache::new(
|
2024-03-27 16:02:05 +00:00
|
|
|
dir.deps_folder_path(),
|
2023-08-08 14:23:02 +00:00
|
|
|
crate::cache::RealDenoCacheEnv,
|
|
|
|
));
|
2023-07-08 20:06:45 +00:00
|
|
|
let documents = Documents::new(deps_http_cache.clone());
|
2023-01-25 21:51:04 +00:00
|
|
|
let cache_metadata = cache::CacheMetadata::new(deps_http_cache.clone());
|
2022-01-17 22:09:43 +00:00
|
|
|
let performance = Arc::new(Performance::default());
|
2024-03-26 15:52:20 +00:00
|
|
|
let config = Config::default();
|
2024-04-02 22:02:50 +00:00
|
|
|
let ts_server =
|
|
|
|
Arc::new(TsServer::new(performance.clone(), deps_http_cache.clone()));
|
2023-09-24 22:33:52 +00:00
|
|
|
let diagnostics_state = Arc::new(DiagnosticsState::default());
|
2022-01-17 22:09:43 +00:00
|
|
|
let diagnostics_server = DiagnosticsServer::new(
|
|
|
|
client.clone(),
|
|
|
|
performance.clone(),
|
|
|
|
ts_server.clone(),
|
2023-09-24 22:33:52 +00:00
|
|
|
diagnostics_state.clone(),
|
2022-01-17 22:09:43 +00:00
|
|
|
);
|
2022-01-18 21:28:47 +00:00
|
|
|
let assets = Assets::new(ts_server.clone());
|
2024-01-18 20:57:30 +00:00
|
|
|
let initial_cwd = std::env::current_dir().unwrap_or_else(|_| {
|
|
|
|
panic!("Could not resolve current working directory")
|
|
|
|
});
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
Self {
|
2022-01-18 21:28:47 +00:00
|
|
|
assets,
|
2022-02-02 02:04:26 +00:00
|
|
|
cache_metadata,
|
2020-12-21 13:44:26 +00:00
|
|
|
client,
|
2021-05-20 09:56:48 +00:00
|
|
|
config,
|
2023-01-25 21:51:04 +00:00
|
|
|
deps_http_cache,
|
2023-09-24 22:33:52 +00:00
|
|
|
diagnostics_state,
|
2022-01-17 22:09:43 +00:00
|
|
|
diagnostics_server,
|
2021-10-28 23:56:01 +00:00
|
|
|
documents,
|
2023-01-25 21:51:04 +00:00
|
|
|
http_client,
|
2024-01-18 20:57:30 +00:00
|
|
|
initial_cwd: initial_cwd.clone(),
|
2024-02-29 03:54:16 +00:00
|
|
|
jsr_search_api,
|
2023-08-02 00:49:09 +00:00
|
|
|
maybe_global_cache_path: None,
|
2024-04-15 00:07:04 +00:00
|
|
|
project_version: 0,
|
2024-01-02 23:48:34 +00:00
|
|
|
task_queue: Default::default(),
|
2022-03-29 22:59:27 +00:00
|
|
|
maybe_testing_server: None,
|
2021-04-09 01:27:27 +00:00
|
|
|
module_registries,
|
|
|
|
module_registries_location,
|
2023-05-23 01:28:36 +00:00
|
|
|
npm: LspNpmServices {
|
|
|
|
config_hash: LspNpmConfigHash(0), // this will be updated in initialize
|
2023-08-29 15:22:05 +00:00
|
|
|
search_api: npm_search_api,
|
2023-10-25 18:39:00 +00:00
|
|
|
node_resolver: None,
|
2023-10-02 21:53:55 +00:00
|
|
|
resolver: None,
|
2023-05-23 01:28:36 +00:00
|
|
|
},
|
2022-01-17 22:09:43 +00:00
|
|
|
performance,
|
2021-02-04 18:53:02 +00:00
|
|
|
ts_fixable_diagnostics: Default::default(),
|
2021-03-10 02:41:35 +00:00
|
|
|
ts_server,
|
2021-02-18 04:37:05 +00:00
|
|
|
url_map: Default::default(),
|
2024-03-21 04:29:52 +00:00
|
|
|
workspace_files: Default::default(),
|
|
|
|
workspace_files_hash: 0,
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-25 15:23:24 +00:00
|
|
|
/// Searches assets and documents for the provided
|
|
|
|
/// specifier erroring if it doesn't exist.
|
|
|
|
pub fn get_asset_or_document(
|
2022-01-18 21:28:47 +00:00
|
|
|
&self,
|
2021-11-12 16:42:04 +00:00
|
|
|
specifier: &ModuleSpecifier,
|
|
|
|
) -> LspResult<AssetOrDocument> {
|
2023-03-15 21:46:36 +00:00
|
|
|
self
|
|
|
|
.get_maybe_asset_or_document(specifier)
|
|
|
|
.map(Ok)
|
|
|
|
.unwrap_or_else(|| {
|
2022-04-25 15:23:24 +00:00
|
|
|
Err(LspError::invalid_params(format!(
|
2023-01-27 15:43:16 +00:00
|
|
|
"Unable to find asset or document for: {specifier}"
|
2022-04-25 15:23:24 +00:00
|
|
|
)))
|
2023-03-15 21:46:36 +00:00
|
|
|
})
|
2021-11-12 16:42:04 +00:00
|
|
|
}
|
|
|
|
|
2022-04-25 15:23:24 +00:00
|
|
|
/// Searches assets and documents for the provided specifier.
|
|
|
|
pub fn get_maybe_asset_or_document(
|
2021-11-12 16:42:04 +00:00
|
|
|
&self,
|
|
|
|
specifier: &ModuleSpecifier,
|
|
|
|
) -> Option<AssetOrDocument> {
|
2021-04-02 06:21:07 +00:00
|
|
|
if specifier.scheme() == "asset" {
|
2022-04-25 15:23:24 +00:00
|
|
|
self.assets.get(specifier).map(AssetOrDocument::Asset)
|
2021-04-02 06:21:07 +00:00
|
|
|
} else {
|
2021-11-12 16:42:04 +00:00
|
|
|
self.documents.get(specifier).map(AssetOrDocument::Document)
|
2021-04-02 06:21:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-23 13:54:22 +00:00
|
|
|
pub async fn get_navigation_tree(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-02-01 03:30:41 +00:00
|
|
|
specifier: &ModuleSpecifier,
|
2021-10-28 23:56:01 +00:00
|
|
|
) -> Result<Arc<tsc::NavigationTree>, AnyError> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args(
|
|
|
|
"lsp.get_navigation_tree",
|
|
|
|
json!({ "specifier": specifier }),
|
2021-05-11 04:54:10 +00:00
|
|
|
);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let navigation_tree =
|
|
|
|
if let Some(navigation_tree) = asset_or_doc.maybe_navigation_tree() {
|
|
|
|
navigation_tree
|
2021-06-04 21:31:44 +00:00
|
|
|
} else {
|
2021-11-12 16:42:04 +00:00
|
|
|
let navigation_tree: tsc::NavigationTree = self
|
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_navigation_tree(self.snapshot(), specifier.clone())
|
2021-11-12 16:42:04 +00:00
|
|
|
.await?;
|
|
|
|
let navigation_tree = Arc::new(navigation_tree);
|
2021-11-18 18:50:24 +00:00
|
|
|
match asset_or_doc {
|
|
|
|
AssetOrDocument::Asset(_) => self
|
2021-11-12 16:42:04 +00:00
|
|
|
.assets
|
2021-11-18 18:50:24 +00:00
|
|
|
.cache_navigation_tree(specifier, navigation_tree.clone())?,
|
|
|
|
AssetOrDocument::Document(doc) => {
|
|
|
|
self.documents.try_cache_navigation_tree(
|
|
|
|
specifier,
|
|
|
|
&doc.script_version(),
|
|
|
|
navigation_tree.clone(),
|
|
|
|
)?
|
|
|
|
}
|
2021-11-12 16:42:04 +00:00
|
|
|
}
|
|
|
|
navigation_tree
|
|
|
|
};
|
2021-06-04 21:31:44 +00:00
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(navigation_tree)
|
2021-02-01 03:30:41 +00:00
|
|
|
}
|
|
|
|
|
2021-10-28 23:56:01 +00:00
|
|
|
fn is_diagnosable(&self, specifier: &ModuleSpecifier) -> bool {
|
|
|
|
if specifier.scheme() == "asset" {
|
|
|
|
matches!(
|
2023-03-21 15:46:40 +00:00
|
|
|
MediaType::from_specifier(specifier),
|
2021-10-28 23:56:01 +00:00
|
|
|
MediaType::JavaScript
|
|
|
|
| MediaType::Jsx
|
2021-12-09 22:12:21 +00:00
|
|
|
| MediaType::Mjs
|
|
|
|
| MediaType::Cjs
|
2021-10-28 23:56:01 +00:00
|
|
|
| MediaType::TypeScript
|
|
|
|
| MediaType::Tsx
|
2021-12-09 22:12:21 +00:00
|
|
|
| MediaType::Mts
|
|
|
|
| MediaType::Cts
|
2021-10-28 23:56:01 +00:00
|
|
|
| MediaType::Dts
|
2021-12-09 22:12:21 +00:00
|
|
|
| MediaType::Dmts
|
|
|
|
| MediaType::Dcts
|
2021-10-28 23:56:01 +00:00
|
|
|
)
|
|
|
|
} else {
|
2021-11-12 16:42:04 +00:00
|
|
|
self
|
|
|
|
.documents
|
|
|
|
.get(specifier)
|
|
|
|
.map(|d| d.is_diagnosable())
|
|
|
|
.unwrap_or(false)
|
2021-10-28 23:56:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-23 13:54:22 +00:00
|
|
|
pub fn snapshot(&self) -> Arc<StateSnapshot> {
|
2023-10-02 21:53:55 +00:00
|
|
|
let maybe_state_npm_snapshot = self
|
|
|
|
.npm
|
|
|
|
.resolver
|
|
|
|
.as_ref()
|
|
|
|
.map(|resolver| resolver.clone_snapshotted())
|
|
|
|
.map(|resolver| {
|
|
|
|
let fs = Arc::new(deno_fs::RealFs);
|
2024-03-06 00:23:51 +00:00
|
|
|
let node_resolver = Arc::new(NodeResolver::new(
|
|
|
|
fs.clone(),
|
|
|
|
resolver.clone().into_npm_resolver(),
|
|
|
|
));
|
|
|
|
let cli_node_resolver = Arc::new(CliNodeResolver::new(
|
|
|
|
None,
|
|
|
|
fs,
|
2023-10-02 21:53:55 +00:00
|
|
|
node_resolver,
|
2024-03-06 00:23:51 +00:00
|
|
|
resolver.clone(),
|
|
|
|
));
|
|
|
|
StateNpmSnapshot {
|
|
|
|
node_resolver: cli_node_resolver,
|
2023-10-02 21:53:55 +00:00
|
|
|
npm_resolver: resolver,
|
|
|
|
}
|
|
|
|
});
|
2022-01-19 22:10:14 +00:00
|
|
|
Arc::new(StateSnapshot {
|
2024-04-15 00:07:04 +00:00
|
|
|
project_version: self.project_version,
|
2022-01-18 21:28:47 +00:00
|
|
|
assets: self.assets.snapshot(),
|
2022-02-02 02:04:26 +00:00
|
|
|
cache_metadata: self.cache_metadata.clone(),
|
2023-09-09 18:37:01 +00:00
|
|
|
config: self.config.snapshot(),
|
2021-01-26 09:55:04 +00:00
|
|
|
documents: self.documents.clone(),
|
2023-10-02 21:53:55 +00:00
|
|
|
npm: maybe_state_npm_snapshot,
|
2022-01-19 22:10:14 +00:00
|
|
|
})
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2024-03-12 03:48:00 +00:00
|
|
|
pub fn update_cache(&mut self) -> Result<(), AnyError> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark("lsp.update_cache");
|
2021-07-27 21:25:09 +00:00
|
|
|
self.performance.measure(mark);
|
2023-05-11 21:17:14 +00:00
|
|
|
let maybe_cache = &self.config.workspace_settings().cache;
|
2023-08-02 00:49:09 +00:00
|
|
|
let maybe_global_cache_path = if let Some(cache_str) = maybe_cache {
|
|
|
|
lsp_log!("Setting global cache path from: \"{}\"", cache_str);
|
2021-07-27 21:25:09 +00:00
|
|
|
let cache_url = if let Ok(url) = Url::from_file_path(cache_str) {
|
|
|
|
Ok(url)
|
2023-09-09 14:04:21 +00:00
|
|
|
} else if let Some(root_uri) = self.config.root_uri() {
|
2022-11-28 22:28:54 +00:00
|
|
|
let root_path = specifier_to_file_path(root_uri)?;
|
2021-07-27 21:25:09 +00:00
|
|
|
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
|
|
|
|
))
|
|
|
|
}?;
|
2022-11-28 22:28:54 +00:00
|
|
|
let cache_path = specifier_to_file_path(&cache_url)?;
|
2021-12-15 18:23:43 +00:00
|
|
|
lsp_log!(
|
2023-08-02 00:49:09 +00:00
|
|
|
" Resolved global cache path: \"{}\"",
|
2021-07-27 21:25:09 +00:00
|
|
|
cache_path.to_string_lossy()
|
|
|
|
);
|
|
|
|
Some(cache_path)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
2023-08-02 00:49:09 +00:00
|
|
|
if self.maybe_global_cache_path != maybe_global_cache_path {
|
2024-03-12 03:48:00 +00:00
|
|
|
self.set_new_global_cache_path(maybe_global_cache_path)?;
|
2021-07-27 21:25:09 +00:00
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2024-03-12 03:48:00 +00:00
|
|
|
fn recreate_http_client_and_dependents(&mut self) -> Result<(), AnyError> {
|
|
|
|
self.set_new_global_cache_path(self.maybe_global_cache_path.clone())
|
2023-08-02 00:49:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Recreates the http client and all dependent structs.
|
2024-03-12 03:48:00 +00:00
|
|
|
fn set_new_global_cache_path(
|
2023-08-02 00:49:09 +00:00
|
|
|
&mut self,
|
2022-11-18 22:28:14 +00:00
|
|
|
new_cache_path: Option<PathBuf>,
|
|
|
|
) -> Result<(), AnyError> {
|
2023-05-25 18:27:45 +00:00
|
|
|
let dir = DenoDir::new(new_cache_path.clone())?;
|
2023-05-11 21:17:14 +00:00
|
|
|
let workspace_settings = self.config.workspace_settings();
|
2022-11-18 22:28:14 +00:00
|
|
|
let maybe_root_path = self
|
|
|
|
.config
|
2023-09-09 14:04:21 +00:00
|
|
|
.root_uri()
|
2022-11-28 22:28:54 +00:00
|
|
|
.and_then(|uri| specifier_to_file_path(uri).ok());
|
2023-05-01 20:42:05 +00:00
|
|
|
let root_cert_store = get_root_cert_store(
|
2022-11-18 22:28:14 +00:00
|
|
|
maybe_root_path,
|
2023-05-11 21:17:14 +00:00
|
|
|
workspace_settings.certificate_stores.clone(),
|
|
|
|
workspace_settings.tls_certificate.clone().map(CaData::File),
|
2023-05-01 20:42:05 +00:00
|
|
|
)?;
|
|
|
|
let root_cert_store_provider =
|
|
|
|
Arc::new(LspRootCertStoreProvider(root_cert_store));
|
|
|
|
self.http_client = Arc::new(HttpClient::new(
|
|
|
|
Some(root_cert_store_provider),
|
2023-05-11 21:17:14 +00:00
|
|
|
workspace_settings
|
|
|
|
.unsafely_ignore_certificate_errors
|
|
|
|
.clone(),
|
2023-05-01 20:42:05 +00:00
|
|
|
));
|
2024-03-27 16:02:05 +00:00
|
|
|
self.module_registries_location = dir.registries_folder_path();
|
2023-01-25 21:51:04 +00:00
|
|
|
self.module_registries = ModuleRegistry::new(
|
2024-03-27 16:02:05 +00:00
|
|
|
self.module_registries_location.clone(),
|
2023-01-25 21:51:04 +00:00
|
|
|
self.http_client.clone(),
|
2023-05-01 20:42:05 +00:00
|
|
|
);
|
2024-03-27 16:02:05 +00:00
|
|
|
self.jsr_search_api =
|
|
|
|
CliJsrSearchApi::new(self.module_registries.file_fetcher.clone());
|
|
|
|
self.npm.search_api =
|
|
|
|
CliNpmSearchApi::new(self.module_registries.file_fetcher.clone());
|
2022-11-18 22:28:14 +00:00
|
|
|
// update the cache path
|
2023-08-08 14:23:02 +00:00
|
|
|
let global_cache = Arc::new(GlobalHttpCache::new(
|
|
|
|
dir.deps_folder_path(),
|
|
|
|
crate::cache::RealDenoCacheEnv,
|
|
|
|
));
|
2023-08-02 20:57:25 +00:00
|
|
|
let maybe_local_cache =
|
2024-03-26 15:52:20 +00:00
|
|
|
self.config.tree.root_vendor_dir().map(|local_path| {
|
2024-04-02 22:02:50 +00:00
|
|
|
Arc::new(LocalLspHttpCache::new(
|
|
|
|
local_path.clone(),
|
|
|
|
global_cache.clone(),
|
|
|
|
))
|
2023-08-02 20:57:25 +00:00
|
|
|
});
|
|
|
|
let cache: Arc<dyn HttpCache> = maybe_local_cache
|
|
|
|
.clone()
|
|
|
|
.map(|c| c as Arc<dyn HttpCache>)
|
|
|
|
.unwrap_or(global_cache);
|
2023-08-02 00:49:09 +00:00
|
|
|
self.deps_http_cache = cache.clone();
|
|
|
|
self.documents.set_cache(cache.clone());
|
|
|
|
self.cache_metadata.set_cache(cache);
|
2023-08-02 20:57:25 +00:00
|
|
|
self.url_map.set_cache(maybe_local_cache);
|
2023-08-02 00:49:09 +00:00
|
|
|
self.maybe_global_cache_path = new_cache_path;
|
2022-11-18 22:28:14 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2023-05-23 01:28:36 +00:00
|
|
|
async fn recreate_npm_services_if_necessary(&mut self) {
|
2023-08-02 00:49:09 +00:00
|
|
|
let deno_dir = match DenoDir::new(self.maybe_global_cache_path.clone()) {
|
2023-05-23 01:28:36 +00:00
|
|
|
Ok(deno_dir) => deno_dir,
|
|
|
|
Err(err) => {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error getting deno dir: {:#}", err);
|
2023-05-23 01:28:36 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
let config_hash = LspNpmConfigHash::from_inner(self);
|
|
|
|
if config_hash == self.npm.config_hash {
|
|
|
|
return; // no need to do anything
|
|
|
|
}
|
2024-03-26 15:52:20 +00:00
|
|
|
let config_data = self.config.tree.root_data();
|
2023-10-25 18:39:00 +00:00
|
|
|
let npm_resolver = create_npm_resolver(
|
|
|
|
&deno_dir,
|
2024-01-18 20:57:30 +00:00
|
|
|
&self.initial_cwd,
|
2023-10-25 18:39:00 +00:00
|
|
|
&self.http_client,
|
2024-04-05 15:18:48 +00:00
|
|
|
config_data,
|
2023-10-25 18:39:00 +00:00
|
|
|
)
|
|
|
|
.await;
|
2024-03-06 00:23:51 +00:00
|
|
|
let node_resolver = Arc::new(NodeResolver::new(
|
2023-10-25 18:39:00 +00:00
|
|
|
Arc::new(deno_fs::RealFs),
|
|
|
|
npm_resolver.clone().into_npm_resolver(),
|
2024-03-06 00:23:51 +00:00
|
|
|
));
|
|
|
|
self.npm.node_resolver = Some(Arc::new(CliNodeResolver::new(
|
|
|
|
None,
|
|
|
|
Arc::new(deno_fs::RealFs),
|
|
|
|
node_resolver,
|
|
|
|
npm_resolver.clone(),
|
2023-10-25 18:39:00 +00:00
|
|
|
)));
|
|
|
|
self.npm.resolver = Some(npm_resolver);
|
2023-05-23 01:28:36 +00:00
|
|
|
|
|
|
|
// update the hash
|
|
|
|
self.npm.config_hash = config_hash;
|
|
|
|
}
|
|
|
|
|
2023-01-25 21:51:04 +00:00
|
|
|
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(),
|
2023-07-01 22:52:30 +00:00
|
|
|
Default::default(),
|
2023-01-25 21:51:04 +00:00
|
|
|
None,
|
|
|
|
);
|
|
|
|
file_fetcher.set_download_log_level(super::logging::lsp_log_level());
|
|
|
|
file_fetcher
|
|
|
|
}
|
|
|
|
|
2021-12-15 18:23:43 +00:00
|
|
|
pub fn update_debug_flag(&self) {
|
2023-05-11 21:17:14 +00:00
|
|
|
let internal_debug = self.config.workspace_settings().internal_debug;
|
2021-12-15 18:23:43 +00:00
|
|
|
super::logging::set_lsp_debug_flag(internal_debug)
|
2021-05-11 04:54:10 +00:00
|
|
|
}
|
|
|
|
|
2021-04-09 01:27:27 +00:00
|
|
|
async fn update_registries(&mut self) -> Result<(), AnyError> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark("lsp.update_registries");
|
2024-03-12 03:48:00 +00:00
|
|
|
self.recreate_http_client_and_dependents()?;
|
2023-05-11 21:17:14 +00:00
|
|
|
let workspace_settings = self.config.workspace_settings();
|
2022-01-24 00:27:52 +00:00
|
|
|
for (registry, enabled) in workspace_settings.suggest.imports.hosts.iter() {
|
2021-04-09 01:27:27 +00:00
|
|
|
if *enabled {
|
2021-12-15 18:23:43 +00:00
|
|
|
lsp_log!("Enabling import suggestions for: {}", registry);
|
2021-04-09 01:27:27 +00:00
|
|
|
self.module_registries.enable(registry).await?;
|
|
|
|
} else {
|
2024-03-12 03:48:00 +00:00
|
|
|
self.module_registries.disable(registry)?;
|
2021-04-09 01:27:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(())
|
|
|
|
}
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2023-10-02 21:53:55 +00:00
|
|
|
async fn create_npm_resolver(
|
|
|
|
deno_dir: &DenoDir,
|
2024-01-18 20:57:30 +00:00
|
|
|
initial_cwd: &Path,
|
2023-10-02 21:53:55 +00:00
|
|
|
http_client: &Arc<HttpClient>,
|
2024-04-05 15:18:48 +00:00
|
|
|
config_data: Option<&ConfigData>,
|
2023-10-02 21:53:55 +00:00
|
|
|
) -> Arc<dyn CliNpmResolver> {
|
2024-04-05 15:18:48 +00:00
|
|
|
let byonm = config_data.map(|d| d.byonm).unwrap_or(false);
|
|
|
|
create_cli_npm_resolver_for_lsp(if byonm {
|
2023-10-25 18:39:00 +00:00
|
|
|
CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions {
|
|
|
|
fs: Arc::new(deno_fs::RealFs),
|
2024-01-18 20:57:30 +00:00
|
|
|
root_node_modules_dir: initial_cwd.join("node_modules"),
|
2023-10-25 18:39:00 +00:00
|
|
|
})
|
|
|
|
} else {
|
|
|
|
CliNpmResolverCreateOptions::Managed(CliNpmResolverManagedCreateOptions {
|
2023-10-02 21:53:55 +00:00
|
|
|
http_client: http_client.clone(),
|
2024-04-05 15:18:48 +00:00
|
|
|
snapshot: match config_data.and_then(|d| d.lockfile.as_ref()) {
|
2023-10-02 21:53:55 +00:00
|
|
|
Some(lockfile) => {
|
|
|
|
CliNpmResolverManagedSnapshotOption::ResolveFromLockfile(
|
|
|
|
lockfile.clone(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
None => CliNpmResolverManagedSnapshotOption::Specified(None),
|
|
|
|
},
|
|
|
|
// Don't provide the lockfile. We don't want these resolvers
|
|
|
|
// updating it. Only the cache request should update the lockfile.
|
|
|
|
maybe_lockfile: None,
|
|
|
|
fs: Arc::new(deno_fs::RealFs),
|
|
|
|
npm_global_cache_dir: deno_dir.npm_folder_path(),
|
|
|
|
// 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.
|
|
|
|
cache_setting: CacheSetting::Only,
|
|
|
|
text_only_progress_bar: ProgressBar::new(ProgressBarStyle::TextOnly),
|
2024-04-05 15:18:48 +00:00
|
|
|
maybe_node_modules_path: config_data
|
|
|
|
.and_then(|d| d.node_modules_dir.clone()),
|
2023-10-02 21:53:55 +00:00
|
|
|
// do not install while resolving in the lsp—leave that to the cache command
|
|
|
|
package_json_installer:
|
|
|
|
CliNpmResolverManagedPackageJsonInstallerOption::NoInstall,
|
2024-03-06 13:24:15 +00:00
|
|
|
npm_registry_url: crate::args::npm_registry_url().to_owned(),
|
2023-10-02 21:53:55 +00:00
|
|
|
npm_system_info: NpmSystemInfo::default(),
|
2023-10-25 18:39:00 +00:00
|
|
|
})
|
|
|
|
})
|
2023-10-02 21:53:55 +00:00
|
|
|
.await
|
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
// lspower::LanguageServer methods. This file's LanguageServer delegates to us.
|
|
|
|
impl Inner {
|
2020-12-21 13:44:26 +00:00
|
|
|
async fn initialize(
|
2021-01-26 09:55:04 +00:00
|
|
|
&mut self,
|
2020-12-21 13:44:26 +00:00
|
|
|
params: InitializeParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<InitializeResult> {
|
2021-12-15 18:23:43 +00:00
|
|
|
lsp_log!("Starting Deno language server...");
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.initialize", ¶ms);
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2021-06-23 01:48:01 +00:00
|
|
|
// exit this process when the parent is lost
|
|
|
|
if let Some(parent_pid) = params.process_id {
|
|
|
|
parent_process_checker::start(parent_pid)
|
|
|
|
}
|
|
|
|
|
2024-01-28 21:56:45 +00:00
|
|
|
let capabilities = capabilities::server_capabilities(¶ms.capabilities);
|
2020-12-21 13:44:26 +00:00
|
|
|
|
|
|
|
let version = format!(
|
|
|
|
"{} ({}, {})",
|
|
|
|
crate::version::deno(),
|
|
|
|
env!("PROFILE"),
|
|
|
|
env!("TARGET")
|
|
|
|
);
|
2021-12-15 18:23:43 +00:00
|
|
|
lsp_log!(" version: {}", version);
|
2021-06-09 00:00:26 +00:00
|
|
|
if let Ok(path) = std::env::current_exe() {
|
2021-12-15 18:23:43 +00:00
|
|
|
lsp_log!(" executable: {}", path.to_string_lossy());
|
2021-06-09 00:00:26 +00:00
|
|
|
}
|
2020-12-21 13:44:26 +00:00
|
|
|
|
|
|
|
let server_info = ServerInfo {
|
|
|
|
name: "deno-language-server".to_string(),
|
|
|
|
version: Some(version),
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(client_info) = params.client_info {
|
2021-12-15 18:23:43 +00:00
|
|
|
lsp_log!(
|
2020-12-21 13:44:26 +00:00
|
|
|
"Connected to \"{}\" {}",
|
|
|
|
client_info.name,
|
|
|
|
client_info.version.unwrap_or_default(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2023-09-21 05:46:39 +00:00
|
|
|
if let Some(options) = params.initialization_options {
|
|
|
|
self.config.set_workspace_settings(
|
|
|
|
WorkspaceSettings::from_initialization_options(options),
|
2024-03-21 04:29:52 +00:00
|
|
|
vec![],
|
2023-09-21 05:46:39 +00:00
|
|
|
);
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
2024-03-21 04:29:52 +00:00
|
|
|
let mut workspace_folders = vec![];
|
2023-09-09 14:04:21 +00:00
|
|
|
if let Some(folders) = params.workspace_folders {
|
2024-03-21 04:29:52 +00:00
|
|
|
workspace_folders = folders
|
2022-03-21 01:33:37 +00:00
|
|
|
.into_iter()
|
2023-03-15 14:34:23 +00:00
|
|
|
.map(|folder| {
|
|
|
|
(
|
|
|
|
self.url_map.normalize_url(&folder.uri, LspUrlKind::Folder),
|
|
|
|
folder,
|
|
|
|
)
|
|
|
|
})
|
2023-09-09 14:04:21 +00:00
|
|
|
.collect();
|
|
|
|
}
|
|
|
|
// rootUri is deprecated by the LSP spec. If it's specified, merge it into
|
|
|
|
// workspace_folders.
|
|
|
|
if let Some(root_uri) = params.root_uri {
|
2024-03-21 04:29:52 +00:00
|
|
|
if !workspace_folders.iter().any(|(_, f)| f.uri == root_uri) {
|
2023-09-09 14:04:21 +00:00
|
|
|
let name = root_uri.path_segments().and_then(|s| s.last());
|
|
|
|
let name = name.unwrap_or_default().to_string();
|
2024-03-21 04:29:52 +00:00
|
|
|
workspace_folders.insert(
|
2023-09-09 14:04:21 +00:00
|
|
|
0,
|
|
|
|
(
|
|
|
|
self.url_map.normalize_url(&root_uri, LspUrlKind::Folder),
|
|
|
|
WorkspaceFolder {
|
|
|
|
uri: root_uri,
|
|
|
|
name,
|
|
|
|
},
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2024-03-21 04:29:52 +00:00
|
|
|
self.config.set_workspace_folders(workspace_folders);
|
2022-01-19 22:10:14 +00:00
|
|
|
self.config.update_capabilities(¶ms.capabilities);
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2024-04-11 23:17:10 +00:00
|
|
|
if let Err(e) = self
|
2023-12-22 01:04:02 +00:00
|
|
|
.ts_server
|
2024-04-11 23:17:10 +00:00
|
|
|
.start(self.config.internal_inspect().to_address())
|
|
|
|
{
|
|
|
|
lsp_warn!("{}", e);
|
|
|
|
self.client.show_message(MessageType::ERROR, e);
|
|
|
|
return Err(tower_lsp::jsonrpc::Error::internal_error());
|
|
|
|
};
|
2023-12-22 01:04:02 +00:00
|
|
|
|
2021-05-11 04:54:10 +00:00
|
|
|
self.update_debug_flag();
|
2024-03-26 15:52:20 +00:00
|
|
|
self.refresh_workspace_files();
|
|
|
|
self.refresh_config_tree().await;
|
2024-03-12 03:48:00 +00:00
|
|
|
if let Err(err) = self.update_cache() {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error updating cache: {:#}", err);
|
2023-03-15 14:34:23 +00:00
|
|
|
self.client.show_message(MessageType::WARNING, err);
|
2021-07-27 21:25:09 +00:00
|
|
|
}
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2021-02-04 18:53:02 +00:00
|
|
|
if capabilities.code_action_provider.is_some() {
|
2023-05-12 23:07:40 +00:00
|
|
|
let fixable_diagnostics = self
|
2021-02-04 18:53:02 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_supported_code_fixes(self.snapshot())
|
|
|
|
.await?;
|
2021-02-04 18:53:02 +00:00
|
|
|
self.ts_fixable_diagnostics = fixable_diagnostics;
|
|
|
|
}
|
|
|
|
|
2021-04-09 01:27:27 +00:00
|
|
|
// Check to see if we need to setup any module registries
|
|
|
|
if let Err(err) = self.update_registries().await {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error updating registries: {:#}", err);
|
2023-03-15 14:34:23 +00:00
|
|
|
self.client.show_message(MessageType::WARNING, err);
|
2021-04-09 01:27:27 +00:00
|
|
|
}
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2023-05-23 01:28:36 +00:00
|
|
|
self.recreate_npm_services_if_necessary().await;
|
2023-06-26 13:10:27 +00:00
|
|
|
self.assets.initialize(self.snapshot()).await;
|
2022-04-25 15:23:24 +00:00
|
|
|
|
2021-07-27 21:25:09 +00:00
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(InitializeResult {
|
|
|
|
capabilities,
|
|
|
|
server_info: Some(server_info),
|
2022-10-14 12:04:38 +00:00
|
|
|
offset_encoding: None,
|
2021-07-27 21:25:09 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2024-03-21 04:29:52 +00:00
|
|
|
fn walk_workspace(config: &Config) -> (BTreeSet<ModuleSpecifier>, bool) {
|
|
|
|
let mut workspace_files = Default::default();
|
2024-03-31 20:39:23 +00:00
|
|
|
let entry_limit = 1000;
|
2024-03-21 04:29:52 +00:00
|
|
|
let mut pending = VecDeque::new();
|
|
|
|
let mut entry_count = 0;
|
|
|
|
let mut roots = config
|
|
|
|
.workspace_folders
|
|
|
|
.iter()
|
|
|
|
.filter_map(|p| specifier_to_file_path(&p.0).ok())
|
|
|
|
.collect::<Vec<_>>();
|
|
|
|
roots.sort();
|
|
|
|
for i in 0..roots.len() {
|
|
|
|
if i == 0 || !roots[i].starts_with(&roots[i - 1]) {
|
|
|
|
if let Ok(read_dir) = std::fs::read_dir(&roots[i]) {
|
|
|
|
pending.push_back((roots[i].clone(), read_dir));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while let Some((parent_path, read_dir)) = pending.pop_front() {
|
|
|
|
for entry in read_dir {
|
|
|
|
let Ok(entry) = entry else {
|
|
|
|
continue;
|
|
|
|
};
|
2024-03-31 20:39:23 +00:00
|
|
|
if entry_count >= entry_limit {
|
2024-03-21 04:29:52 +00:00
|
|
|
return (workspace_files, true);
|
|
|
|
}
|
|
|
|
entry_count += 1;
|
|
|
|
let path = parent_path.join(entry.path());
|
|
|
|
let Ok(specifier) = ModuleSpecifier::from_file_path(&path) else {
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
// TODO(nayeemrmn): Don't walk folders that are `None` here and aren't
|
|
|
|
// in a `deno.json` scope.
|
|
|
|
if config.settings.specifier_enabled(&specifier) == Some(false) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
let Ok(file_type) = entry.file_type() else {
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
let Some(file_name) = path.file_name() else {
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
if file_type.is_dir() {
|
|
|
|
let dir_name = file_name.to_string_lossy().to_lowercase();
|
|
|
|
// We ignore these directories by default because there is a
|
|
|
|
// high likelihood they aren't relevant. Someone can opt-into
|
|
|
|
// them by specifying one of them as an enabled path.
|
|
|
|
if matches!(dir_name.as_str(), "node_modules" | ".git") {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// ignore cargo target directories for anyone using Deno with Rust
|
|
|
|
if dir_name == "target"
|
|
|
|
&& path
|
|
|
|
.parent()
|
|
|
|
.map(|p| p.join("Cargo.toml").exists())
|
|
|
|
.unwrap_or(false)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if let Ok(read_dir) = std::fs::read_dir(&path) {
|
|
|
|
pending.push_back((path, read_dir));
|
|
|
|
}
|
|
|
|
} else if file_type.is_file()
|
|
|
|
|| file_type.is_symlink()
|
|
|
|
&& std::fs::metadata(&path)
|
|
|
|
.ok()
|
|
|
|
.map(|m| m.is_file())
|
|
|
|
.unwrap_or(false)
|
|
|
|
{
|
|
|
|
if file_name.to_string_lossy().contains(".min.") {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
let media_type = MediaType::from_specifier(&specifier);
|
|
|
|
match media_type {
|
|
|
|
MediaType::JavaScript
|
|
|
|
| MediaType::Jsx
|
|
|
|
| MediaType::Mjs
|
|
|
|
| MediaType::Cjs
|
|
|
|
| MediaType::TypeScript
|
|
|
|
| MediaType::Mts
|
|
|
|
| MediaType::Cts
|
|
|
|
| MediaType::Dts
|
|
|
|
| MediaType::Dmts
|
|
|
|
| MediaType::Dcts
|
|
|
|
| MediaType::Json
|
|
|
|
| MediaType::Tsx => {}
|
|
|
|
MediaType::Wasm
|
|
|
|
| MediaType::SourceMap
|
|
|
|
| MediaType::TsBuildInfo
|
|
|
|
| MediaType::Unknown => {
|
|
|
|
if path.extension().and_then(|s| s.to_str()) != Some("jsonc") {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
workspace_files.insert(specifier);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
(workspace_files, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn refresh_workspace_files(&mut self) {
|
|
|
|
let enable_settings_hash = self.config.settings.enable_settings_hash();
|
|
|
|
if self.workspace_files_hash == enable_settings_hash {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
let (workspace_files, hit_limit) = Self::walk_workspace(&self.config);
|
|
|
|
if hit_limit {
|
|
|
|
let document_preload_limit =
|
|
|
|
self.config.workspace_settings().document_preload_limit;
|
|
|
|
if document_preload_limit == 0 {
|
|
|
|
log::debug!("Skipped document preload.");
|
|
|
|
} else {
|
|
|
|
lsp_warn!(
|
|
|
|
concat!(
|
|
|
|
"Hit the language server document preload limit of {} file system entries. ",
|
|
|
|
"You may want to use the \"deno.enablePaths\" configuration setting to only have Deno ",
|
|
|
|
"partially enable a workspace or increase the limit via \"deno.documentPreloadLimit\". ",
|
|
|
|
"In cases where Deno ends up using too much memory, you may want to lower the limit."
|
|
|
|
),
|
|
|
|
document_preload_limit,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.workspace_files = workspace_files;
|
|
|
|
self.workspace_files_hash = enable_settings_hash;
|
|
|
|
}
|
|
|
|
|
2024-03-26 15:52:20 +00:00
|
|
|
async fn refresh_config_tree(&mut self) {
|
|
|
|
let file_fetcher = self.create_file_fetcher(CacheSetting::RespectHeaders);
|
2024-04-02 22:02:50 +00:00
|
|
|
self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.refresh(&self.config.settings, &self.workspace_files, &file_fetcher)
|
|
|
|
.await;
|
|
|
|
for config_file in self.config.tree.config_files() {
|
|
|
|
if let Ok((compiler_options, _)) = config_file.to_compiler_options() {
|
|
|
|
if let Some(compiler_options_obj) = compiler_options.as_object() {
|
|
|
|
if let Some(jsx_import_source) =
|
|
|
|
compiler_options_obj.get("jsxImportSource")
|
|
|
|
{
|
|
|
|
if let Some(jsx_import_source) = jsx_import_source.as_str() {
|
|
|
|
let specifiers = vec![Url::parse(&format!(
|
|
|
|
"data:application/typescript;base64,{}",
|
|
|
|
base64::engine::general_purpose::STANDARD
|
|
|
|
.encode(format!("import '{jsx_import_source}/jsx-runtime';"))
|
|
|
|
))
|
|
|
|
.unwrap()];
|
|
|
|
let referrer = config_file.specifier.clone();
|
|
|
|
self.task_queue.queue_task(Box::new(|ls: LanguageServer| {
|
|
|
|
spawn(async move {
|
|
|
|
if let Err(err) = ls.cache(specifiers, referrer, false).await
|
|
|
|
{
|
|
|
|
lsp_warn!("{:#}", err);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}));
|
2024-03-26 15:52:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-26 22:52:31 +00:00
|
|
|
async fn refresh_documents_config(&mut self) {
|
2024-03-26 15:52:20 +00:00
|
|
|
self.documents.update_config(
|
|
|
|
&self.config,
|
|
|
|
self.npm.node_resolver.clone(),
|
|
|
|
self.npm.resolver.clone(),
|
|
|
|
&self.workspace_files,
|
|
|
|
);
|
2023-07-26 22:52:31 +00:00
|
|
|
|
|
|
|
// refresh the npm specifiers because it might have discovered
|
|
|
|
// a @types/node package and now's a good time to do that anyway
|
|
|
|
self.refresh_npm_specifiers().await;
|
2024-04-11 01:06:37 +00:00
|
|
|
|
2024-04-15 00:07:04 +00:00
|
|
|
self.project_changed(&[], true).await;
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2024-03-12 03:48:00 +00:00
|
|
|
fn shutdown(&self) -> LspResult<()> {
|
2020-12-21 13:44:26 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2024-04-11 01:06:37 +00:00
|
|
|
async fn did_open(
|
2022-01-25 15:30:38 +00:00
|
|
|
&mut self,
|
|
|
|
specifier: &ModuleSpecifier,
|
|
|
|
params: DidOpenTextDocumentParams,
|
2024-04-06 14:36:43 +00:00
|
|
|
) -> Arc<Document> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.did_open", ¶ms);
|
2021-08-19 03:19:12 +00:00
|
|
|
let language_id =
|
|
|
|
params
|
|
|
|
.text_document
|
|
|
|
.language_id
|
|
|
|
.parse()
|
|
|
|
.unwrap_or_else(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("{:#}", err);
|
2021-08-19 03:19:12 +00:00
|
|
|
LanguageId::Unknown
|
|
|
|
});
|
|
|
|
if language_id == LanguageId::Unknown {
|
2023-03-30 14:43:16 +00:00
|
|
|
lsp_warn!(
|
2021-08-19 03:19:12 +00:00
|
|
|
"Unsupported language id \"{}\" received for document \"{}\".",
|
2023-03-30 14:43:16 +00:00
|
|
|
params.text_document.language_id,
|
|
|
|
params.text_document.uri
|
2021-08-19 03:19:12 +00:00
|
|
|
);
|
|
|
|
}
|
2021-11-12 16:42:04 +00:00
|
|
|
let document = self.documents.open(
|
2021-01-22 10:03:16 +00:00
|
|
|
specifier.clone(),
|
|
|
|
params.text_document.version,
|
2021-10-28 23:56:01 +00:00
|
|
|
params.text_document.language_id.parse().unwrap(),
|
2022-05-20 20:40:55 +00:00
|
|
|
params.text_document.text.into(),
|
2021-01-22 10:03:16 +00:00
|
|
|
);
|
2024-04-11 01:06:37 +00:00
|
|
|
self
|
2024-04-15 00:07:04 +00:00
|
|
|
.project_changed(&[(document.specifier(), ChangeKind::Opened)], false)
|
2024-04-11 01:06:37 +00:00
|
|
|
.await;
|
2021-02-09 22:46:12 +00:00
|
|
|
|
2021-06-02 10:29:58 +00:00
|
|
|
self.performance.measure(mark);
|
2022-02-02 23:02:59 +00:00
|
|
|
document
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn did_change(&mut self, params: DidChangeTextDocumentParams) {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.did_change", ¶ms);
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-02-09 22:46:12 +00:00
|
|
|
match self.documents.change(
|
2021-01-22 10:03:16 +00:00
|
|
|
&specifier,
|
|
|
|
params.text_document.version,
|
|
|
|
params.content_changes,
|
|
|
|
) {
|
2021-11-12 16:42:04 +00:00
|
|
|
Ok(document) => {
|
|
|
|
if document.is_diagnosable() {
|
2024-04-11 01:06:37 +00:00
|
|
|
self
|
|
|
|
.project_changed(
|
|
|
|
&[(document.specifier(), ChangeKind::Modified)],
|
|
|
|
false,
|
|
|
|
)
|
|
|
|
.await;
|
2022-10-21 15:20:18 +00:00
|
|
|
self.refresh_npm_specifiers().await;
|
2024-04-10 18:58:49 +00:00
|
|
|
self.diagnostics_server.invalidate(&[specifier]);
|
2022-02-02 23:02:59 +00:00
|
|
|
self.send_diagnostics_update();
|
2022-03-29 22:59:27 +00:00
|
|
|
self.send_testing_update();
|
2021-06-02 10:29:58 +00:00
|
|
|
}
|
|
|
|
}
|
2024-03-02 02:25:38 +00:00
|
|
|
Err(err) => error!("{:#}", err),
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2022-10-21 15:20:18 +00:00
|
|
|
async fn refresh_npm_specifiers(&mut self) {
|
|
|
|
let package_reqs = self.documents.npm_package_reqs();
|
2023-05-23 01:28:36 +00:00
|
|
|
let npm_resolver = self.npm.resolver.clone();
|
2023-05-17 21:38:50 +00:00
|
|
|
// spawn to avoid the LSP's Send requirements
|
2023-09-29 13:26:25 +00:00
|
|
|
let handle = spawn(async move {
|
2023-10-02 21:53:55 +00:00
|
|
|
if let Some(npm_resolver) =
|
|
|
|
npm_resolver.as_ref().and_then(|r| r.as_managed())
|
|
|
|
{
|
2023-09-29 13:26:25 +00:00
|
|
|
npm_resolver.set_package_reqs(&package_reqs).await
|
|
|
|
} else {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
});
|
2023-05-17 21:38:50 +00:00
|
|
|
if let Err(err) = handle.await.unwrap() {
|
2023-03-30 14:43:16 +00:00
|
|
|
lsp_warn!("Could not set npm package requirements. {:#}", err);
|
2022-10-21 15:20:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn did_close(&mut self, params: DidCloseTextDocumentParams) {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.did_close", ¶ms);
|
2023-09-24 22:33:52 +00:00
|
|
|
self.diagnostics_state.clear(¶ms.text_document.uri);
|
2023-02-06 21:49:49 +00:00
|
|
|
if params.text_document.uri.scheme() == "deno" {
|
2021-07-26 21:40:12 +00:00
|
|
|
// we can ignore virtual text documents closing, as they don't need to
|
2020-12-21 13:44:26 +00:00
|
|
|
// be tracked in memory, as they are static assets that won't change
|
|
|
|
// already managed by the language service
|
|
|
|
return;
|
|
|
|
}
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if self.is_diagnosable(&specifier) {
|
2022-10-21 15:20:18 +00:00
|
|
|
self.refresh_npm_specifiers().await;
|
2024-04-10 18:58:49 +00:00
|
|
|
self.diagnostics_server.invalidate(&[specifier.clone()]);
|
2022-02-02 23:02:59 +00:00
|
|
|
self.send_diagnostics_update();
|
2022-03-29 22:59:27 +00:00
|
|
|
self.send_testing_update();
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
2023-10-12 14:37:56 +00:00
|
|
|
if let Err(err) = self.documents.close(&specifier) {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("{:#}", err);
|
2023-10-12 14:37:56 +00:00
|
|
|
}
|
2024-04-11 01:06:37 +00:00
|
|
|
self
|
2024-04-15 00:07:04 +00:00
|
|
|
.project_changed(&[(&specifier, ChangeKind::Closed)], false)
|
2024-04-11 01:06:37 +00:00
|
|
|
.await;
|
2021-06-02 10:29:58 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn did_change_configuration(
|
2021-01-26 09:55:04 +00:00
|
|
|
&mut self,
|
2021-01-04 21:52:20 +00:00
|
|
|
params: DidChangeConfigurationParams,
|
2020-12-21 13:44:26 +00:00
|
|
|
) {
|
2023-10-24 20:27:27 +00:00
|
|
|
if !self.config.client_capabilities.workspace_configuration {
|
|
|
|
let config = params.settings.as_object().map(|settings| {
|
|
|
|
let deno =
|
|
|
|
serde_json::to_value(settings.get(SETTINGS_SECTION)).unwrap();
|
|
|
|
let javascript =
|
|
|
|
serde_json::to_value(settings.get("javascript")).unwrap();
|
|
|
|
let typescript =
|
|
|
|
serde_json::to_value(settings.get("typescript")).unwrap();
|
|
|
|
WorkspaceSettings::from_raw_settings(deno, javascript, typescript)
|
|
|
|
});
|
|
|
|
if let Some(settings) = config {
|
2024-03-21 04:29:52 +00:00
|
|
|
self.config.set_workspace_settings(settings, vec![]);
|
2023-10-24 20:27:27 +00:00
|
|
|
}
|
|
|
|
};
|
2021-05-10 01:16:04 +00:00
|
|
|
|
2021-05-11 04:54:10 +00:00
|
|
|
self.update_debug_flag();
|
2024-03-26 15:52:20 +00:00
|
|
|
self.refresh_workspace_files();
|
|
|
|
self.refresh_config_tree().await;
|
2024-03-12 03:48:00 +00:00
|
|
|
if let Err(err) = self.update_cache() {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error updating cache: {:#}", err);
|
2023-03-15 14:34:23 +00:00
|
|
|
self.client.show_message(MessageType::WARNING, err);
|
2021-07-27 21:25:09 +00:00
|
|
|
}
|
2021-05-10 01:16:04 +00:00
|
|
|
if let Err(err) = self.update_registries().await {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Error updating registries: {:#}", err);
|
2023-03-15 14:34:23 +00:00
|
|
|
self.client.show_message(MessageType::WARNING, err);
|
2021-05-10 01:16:04 +00:00
|
|
|
}
|
2023-05-23 01:28:36 +00:00
|
|
|
self.recreate_npm_services_if_necessary().await;
|
2023-07-26 22:52:31 +00:00
|
|
|
self.refresh_documents_config().await;
|
2023-05-23 01:28:36 +00:00
|
|
|
self.diagnostics_server.invalidate_all();
|
2022-02-02 23:02:59 +00:00
|
|
|
self.send_diagnostics_update();
|
2022-03-29 22:59:27 +00:00
|
|
|
self.send_testing_update();
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn did_change_watched_files(
|
2021-01-26 09:55:04 +00:00
|
|
|
&mut self,
|
2020-12-21 13:44:26 +00:00
|
|
|
params: DidChangeWatchedFilesParams,
|
|
|
|
) {
|
2021-05-11 04:54:10 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
2023-12-01 02:54:59 +00:00
|
|
|
.mark_with_args("lsp.did_change_watched_files", ¶ms);
|
2021-11-23 17:32:40 +00:00
|
|
|
|
2024-03-26 15:52:20 +00:00
|
|
|
let changes = params
|
|
|
|
.changes
|
|
|
|
.into_iter()
|
|
|
|
.map(|e| (self.url_map.normalize_url(&e.uri, LspUrlKind::File), e))
|
|
|
|
.collect::<Vec<_>>();
|
|
|
|
if changes
|
2023-10-12 15:07:27 +00:00
|
|
|
.iter()
|
2024-03-26 15:52:20 +00:00
|
|
|
.any(|(s, _)| self.config.tree.is_watched_file(s))
|
|
|
|
{
|
|
|
|
let mut deno_config_changes = IndexSet::with_capacity(changes.len());
|
|
|
|
deno_config_changes.extend(changes.iter().filter_map(|(s, e)| {
|
|
|
|
self.config.tree.watched_file_type(s).and_then(|t| {
|
|
|
|
let configuration_type = match t.1 {
|
|
|
|
ConfigWatchedFileType::DenoJson => {
|
|
|
|
lsp_custom::DenoConfigurationType::DenoJson
|
|
|
|
}
|
|
|
|
ConfigWatchedFileType::PackageJson => {
|
|
|
|
lsp_custom::DenoConfigurationType::PackageJson
|
|
|
|
}
|
|
|
|
_ => return None,
|
|
|
|
};
|
|
|
|
Some(lsp_custom::DenoConfigurationChangeEvent {
|
2024-04-02 22:02:50 +00:00
|
|
|
scope_uri: t.0.clone(),
|
2024-03-26 15:52:20 +00:00
|
|
|
file_uri: e.uri.clone(),
|
|
|
|
typ: lsp_custom::DenoConfigurationChangeType::from_file_change_type(
|
|
|
|
e.typ,
|
|
|
|
),
|
|
|
|
configuration_type,
|
|
|
|
})
|
|
|
|
})
|
|
|
|
}));
|
|
|
|
self.workspace_files_hash = 0;
|
|
|
|
self.refresh_workspace_files();
|
|
|
|
self.refresh_config_tree().await;
|
|
|
|
deno_config_changes.extend(changes.iter().filter_map(|(s, e)| {
|
|
|
|
self.config.tree.watched_file_type(s).and_then(|t| {
|
|
|
|
let configuration_type = match t.1 {
|
|
|
|
ConfigWatchedFileType::DenoJson => {
|
|
|
|
lsp_custom::DenoConfigurationType::DenoJson
|
|
|
|
}
|
|
|
|
ConfigWatchedFileType::PackageJson => {
|
|
|
|
lsp_custom::DenoConfigurationType::PackageJson
|
|
|
|
}
|
|
|
|
_ => return None,
|
|
|
|
};
|
|
|
|
Some(lsp_custom::DenoConfigurationChangeEvent {
|
2024-04-02 22:02:50 +00:00
|
|
|
scope_uri: t.0.clone(),
|
2024-03-26 15:52:20 +00:00
|
|
|
file_uri: e.uri.clone(),
|
|
|
|
typ: lsp_custom::DenoConfigurationChangeType::from_file_change_type(
|
|
|
|
e.typ,
|
|
|
|
),
|
|
|
|
configuration_type,
|
|
|
|
})
|
|
|
|
})
|
|
|
|
}));
|
|
|
|
if !deno_config_changes.is_empty() {
|
|
|
|
self.client.send_did_change_deno_configuration_notification(
|
|
|
|
lsp_custom::DidChangeDenoConfigurationNotificationParams {
|
|
|
|
changes: deno_config_changes.into_iter().collect(),
|
|
|
|
},
|
2024-01-23 06:12:41 +00:00
|
|
|
);
|
|
|
|
}
|
2023-05-23 01:28:36 +00:00
|
|
|
self.recreate_npm_services_if_necessary().await;
|
2023-07-26 22:52:31 +00:00
|
|
|
self.refresh_documents_config().await;
|
2022-02-02 23:02:59 +00:00
|
|
|
self.diagnostics_server.invalidate_all();
|
2023-05-12 23:07:40 +00:00
|
|
|
self.ts_server.restart(self.snapshot()).await;
|
2022-02-02 23:02:59 +00:00
|
|
|
self.send_diagnostics_update();
|
2022-03-29 22:59:27 +00:00
|
|
|
self.send_testing_update();
|
2020-12-31 03:33:44 +00:00
|
|
|
}
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2023-03-15 14:34:23 +00:00
|
|
|
fn did_change_workspace_folders(
|
2022-03-21 01:33:37 +00:00
|
|
|
&mut self,
|
|
|
|
params: DidChangeWorkspaceFoldersParams,
|
|
|
|
) {
|
|
|
|
let mut workspace_folders = params
|
|
|
|
.event
|
|
|
|
.added
|
|
|
|
.into_iter()
|
2023-03-15 14:34:23 +00:00
|
|
|
.map(|folder| {
|
|
|
|
(
|
|
|
|
self.url_map.normalize_url(&folder.uri, LspUrlKind::Folder),
|
|
|
|
folder,
|
|
|
|
)
|
|
|
|
})
|
2022-03-21 01:33:37 +00:00
|
|
|
.collect::<Vec<(ModuleSpecifier, WorkspaceFolder)>>();
|
2023-09-09 14:04:21 +00:00
|
|
|
for (specifier, folder) in &self.config.workspace_folders {
|
|
|
|
if !params.event.removed.is_empty()
|
|
|
|
&& params.event.removed.iter().any(|f| f.uri == folder.uri)
|
|
|
|
{
|
|
|
|
continue;
|
2022-03-21 01:33:37 +00:00
|
|
|
}
|
2023-09-09 14:04:21 +00:00
|
|
|
workspace_folders.push((specifier.clone(), folder.clone()));
|
2022-03-21 01:33:37 +00:00
|
|
|
}
|
2024-03-21 04:29:52 +00:00
|
|
|
self.config.set_workspace_folders(workspace_folders);
|
2022-03-21 01:33:37 +00:00
|
|
|
}
|
|
|
|
|
2021-04-20 01:29:27 +00:00
|
|
|
async fn document_symbol(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-04-20 01:29:27 +00:00
|
|
|
params: DocumentSymbolParams,
|
|
|
|
) -> LspResult<Option<DocumentSymbolResponse>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-18 06:35:46 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.document_symbol", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_document = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_document.line_index();
|
2021-04-20 01:29:27 +00:00
|
|
|
|
2021-11-16 22:23:25 +00:00
|
|
|
let navigation_tree =
|
|
|
|
self.get_navigation_tree(&specifier).await.map_err(|err| {
|
|
|
|
error!(
|
2024-03-02 02:25:38 +00:00
|
|
|
"Error getting document symbols for \"{}\": {:#}",
|
2021-11-16 22:23:25 +00:00
|
|
|
specifier, err
|
|
|
|
);
|
|
|
|
LspError::internal_error()
|
2021-04-20 01:29:27 +00:00
|
|
|
})?;
|
|
|
|
|
2021-11-16 22:23:25 +00:00
|
|
|
let response = if let Some(child_items) = &navigation_tree.child_items {
|
2021-04-20 01:29:27 +00:00
|
|
|
let mut document_symbols = Vec::<DocumentSymbol>::new();
|
|
|
|
for item in child_items {
|
2021-10-28 23:56:01 +00:00
|
|
|
item
|
|
|
|
.collect_document_symbols(line_index.clone(), &mut document_symbols);
|
2021-04-20 01:29:27 +00:00
|
|
|
}
|
|
|
|
Some(DocumentSymbolResponse::Nested(document_symbols))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2020-12-21 13:44:26 +00:00
|
|
|
async fn formatting(
|
|
|
|
&self,
|
|
|
|
params: DocumentFormattingParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<Vec<TextEdit>>> {
|
2023-10-09 22:43:32 +00:00
|
|
|
let mut specifier = self
|
2023-03-15 14:34:23 +00:00
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2023-10-09 22:43:32 +00:00
|
|
|
// skip formatting any files ignored by the config file
|
2024-03-26 15:52:20 +00:00
|
|
|
if !self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&specifier)
|
|
|
|
.files
|
|
|
|
.matches_specifier(&specifier)
|
|
|
|
{
|
2023-10-09 22:43:32 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-11-12 16:42:04 +00:00
|
|
|
let document = match self.documents.get(&specifier) {
|
|
|
|
Some(doc) if doc.is_open() => doc,
|
|
|
|
_ => return Ok(None),
|
|
|
|
};
|
2023-10-09 22:43:32 +00:00
|
|
|
// Detect vendored paths. Vendor file URLs will normalize to their remote
|
|
|
|
// counterparts, but for formatting we want to favour the file URL.
|
|
|
|
// TODO(nayeemrmn): Implement `Document::file_resource_path()` or similar.
|
|
|
|
if specifier.scheme() != "file"
|
|
|
|
&& params.text_document.uri.scheme() == "file"
|
|
|
|
{
|
|
|
|
specifier = params.text_document.uri.clone();
|
|
|
|
}
|
2022-11-28 22:28:54 +00:00
|
|
|
let file_path = specifier_to_file_path(&specifier).map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("{:#}", err);
|
2022-11-28 22:28:54 +00:00
|
|
|
LspError::invalid_request()
|
|
|
|
})?;
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.formatting", ¶ms);
|
2021-09-13 18:19:10 +00:00
|
|
|
|
2023-07-20 13:28:40 +00:00
|
|
|
// spawn a blocking task to allow doing other work while this is occurring
|
2023-10-09 03:39:52 +00:00
|
|
|
let text_edits = deno_core::unsync::spawn_blocking({
|
2024-03-26 15:52:20 +00:00
|
|
|
let fmt_options = self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&specifier)
|
|
|
|
.options
|
|
|
|
.clone();
|
2023-07-20 13:28:40 +00:00
|
|
|
let document = document.clone();
|
|
|
|
move || {
|
2023-10-09 03:39:52 +00:00
|
|
|
let format_result = match document.maybe_parsed_source() {
|
2023-07-20 13:28:40 +00:00
|
|
|
Some(Ok(parsed_source)) => {
|
|
|
|
format_parsed_source(&parsed_source, &fmt_options)
|
|
|
|
}
|
2024-03-02 02:25:38 +00:00
|
|
|
Some(Err(err)) => Err(anyhow!("{:#}", err)),
|
2023-07-20 13:28:40 +00:00
|
|
|
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(), &fmt_options)
|
|
|
|
}
|
2023-10-09 03:39:52 +00:00
|
|
|
};
|
|
|
|
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) => {
|
|
|
|
lsp_warn!("Format error: {:#}", err);
|
|
|
|
None
|
|
|
|
}
|
2023-07-20 13:28:40 +00:00
|
|
|
}
|
2022-12-20 01:22:17 +00:00
|
|
|
}
|
2023-07-20 13:28:40 +00:00
|
|
|
})
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2021-09-07 14:39:32 +00:00
|
|
|
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
if let Some(text_edits) = text_edits {
|
|
|
|
if text_edits.is_empty() {
|
|
|
|
Ok(None)
|
|
|
|
} else {
|
|
|
|
Ok(Some(text_edits))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-18 21:28:47 +00:00
|
|
|
async fn hover(&self, params: HoverParams) -> LspResult<Option<Hover>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.hover", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
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()
|
2022-02-25 01:03:12 +00:00
|
|
|
.and_then(|s| self.documents.get(s))
|
2022-01-31 22:33:57 +00:00
|
|
|
.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!(
|
2021-10-28 23:56:01 +00:00
|
|
|
"**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n",
|
2024-03-04 15:48:23 +00:00
|
|
|
self.resolution_to_hover_text(&dep.maybe_code),
|
|
|
|
self.resolution_to_hover_text(&dep.maybe_type),
|
2021-10-28 23:56:01 +00:00
|
|
|
),
|
2022-01-31 22:33:57 +00:00
|
|
|
(false, false, Some(types_dep)) if !types_dep.is_none() => format!(
|
2021-11-08 00:50:48 +00:00
|
|
|
"**Resolved Dependency**\n\n**Code**: {}\n**Types**: {}\n**Import Types**: {}\n",
|
2024-03-04 15:48:23 +00:00
|
|
|
self.resolution_to_hover_text(&dep.maybe_code),
|
|
|
|
self.resolution_to_hover_text(&dep.maybe_type),
|
|
|
|
self.resolution_to_hover_text(types_dep),
|
2021-11-08 00:50:48 +00:00
|
|
|
),
|
2022-01-31 22:33:57 +00:00
|
|
|
(false, false, Some(_)) => format!(
|
|
|
|
"**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n",
|
2024-03-04 15:48:23 +00:00
|
|
|
self.resolution_to_hover_text(&dep.maybe_code),
|
|
|
|
self.resolution_to_hover_text(&dep.maybe_type),
|
2021-10-28 23:56:01 +00:00
|
|
|
),
|
2022-01-31 22:33:57 +00:00
|
|
|
(false, true, Some(types_dep)) if !types_dep.is_none() => format!(
|
2021-11-08 00:50:48 +00:00
|
|
|
"**Resolved Dependency**\n\n**Code**: {}\n\n**Types**: {}\n",
|
2024-03-04 15:48:23 +00:00
|
|
|
self.resolution_to_hover_text(&dep.maybe_code),
|
|
|
|
self.resolution_to_hover_text(types_dep),
|
2021-11-08 00:50:48 +00:00
|
|
|
),
|
2022-01-31 22:33:57 +00:00
|
|
|
(false, true, _) => format!(
|
|
|
|
"**Resolved Dependency**\n\n**Code**: {}\n",
|
2024-03-04 15:48:23 +00:00
|
|
|
self.resolution_to_hover_text(&dep.maybe_code),
|
2022-01-31 22:33:57 +00:00
|
|
|
),
|
|
|
|
(true, false, _) => format!(
|
2021-10-28 23:56:01 +00:00
|
|
|
"**Resolved Dependency**\n\n**Types**: {}\n",
|
2024-03-04 15:48:23 +00:00
|
|
|
self.resolution_to_hover_text(&dep.maybe_type),
|
2021-10-28 23:56:01 +00:00
|
|
|
),
|
2022-01-31 22:33:57 +00:00
|
|
|
(true, true, _) => unreachable!("{}", json!(params)),
|
2021-10-28 23:56:01 +00:00
|
|
|
};
|
2022-01-07 00:27:13 +00:00
|
|
|
let value =
|
|
|
|
if let Some(docs) = self.module_registries.get_hover(&dep).await {
|
2023-01-27 15:43:16 +00:00
|
|
|
format!("{value}\n\n---\n\n{docs}")
|
2022-01-07 00:27:13 +00:00
|
|
|
} else {
|
|
|
|
value
|
|
|
|
};
|
2021-10-28 23:56:01 +00:00
|
|
|
Some(Hover {
|
|
|
|
contents: HoverContents::Markup(MarkupContent {
|
|
|
|
kind: MarkupKind::Markdown,
|
|
|
|
value,
|
|
|
|
}),
|
|
|
|
range: Some(to_lsp_range(&range)),
|
|
|
|
})
|
2020-12-21 13:44:26 +00:00
|
|
|
} else {
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2023-05-12 23:07:40 +00:00
|
|
|
let position =
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?;
|
|
|
|
let maybe_quick_info = self
|
2021-06-24 23:06:51 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_quick_info(self.snapshot(), specifier.clone(), position)
|
|
|
|
.await?;
|
2022-02-09 23:08:53 +00:00
|
|
|
maybe_quick_info.map(|qi| qi.to_hover(line_index, self))
|
2021-06-24 23:06:51 +00:00
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(hover)
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2024-03-04 15:48:23 +00:00
|
|
|
fn resolution_to_hover_text(&self, resolution: &Resolution) -> String {
|
|
|
|
match resolution {
|
|
|
|
Resolution::Ok(resolved) => {
|
|
|
|
let specifier = &resolved.specifier;
|
2024-03-27 15:58:18 +00:00
|
|
|
let format = |scheme: &str, rest: &str| -> String {
|
|
|
|
format!("{}​{}", scheme, rest).replace('@', "​@")
|
|
|
|
};
|
2024-03-04 15:48:23 +00:00
|
|
|
match specifier.scheme() {
|
|
|
|
"data" => "_(a data url)_".to_string(),
|
|
|
|
"blob" => "_(a blob url)_".to_string(),
|
2024-03-27 15:58:18 +00:00
|
|
|
"file" => format(
|
|
|
|
&specifier[..url::Position::AfterScheme],
|
|
|
|
&to_percent_decoded_str(&specifier[url::Position::AfterScheme..]),
|
|
|
|
),
|
2024-03-04 15:48:23 +00:00
|
|
|
_ => {
|
2024-03-27 15:58:18 +00:00
|
|
|
let mut result = format(
|
2024-03-04 15:48:23 +00:00
|
|
|
&specifier[..url::Position::AfterScheme],
|
|
|
|
&specifier[url::Position::AfterScheme..],
|
2024-03-27 15:58:18 +00:00
|
|
|
);
|
2024-03-04 15:48:23 +00:00
|
|
|
if let Ok(jsr_req_ref) =
|
|
|
|
JsrPackageReqReference::from_specifier(specifier)
|
|
|
|
{
|
|
|
|
if let Some(url) = self
|
|
|
|
.documents
|
|
|
|
.get_jsr_resolver()
|
|
|
|
.jsr_to_registry_url(&jsr_req_ref)
|
|
|
|
{
|
|
|
|
result = format!("{result} (<{url}>)");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Resolution::Err(_) => "_[errored]_".to_string(),
|
|
|
|
Resolution::None => "_[missing]_".to_string(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-04 18:53:02 +00:00
|
|
|
async fn code_action(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-02-04 18:53:02 +00:00
|
|
|
params: CodeActionParams,
|
|
|
|
) -> LspResult<Option<CodeActionResponse>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-02-04 18:53:02 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.code_action", ¶ms);
|
2021-08-06 01:46:32 +00:00
|
|
|
let mut all_actions = CodeActionResponse::new();
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-08-06 01:46:32 +00:00
|
|
|
|
|
|
|
// QuickFix
|
2021-02-04 18:53:02 +00:00
|
|
|
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,
|
|
|
|
},
|
2023-08-27 04:04:12 +00:00
|
|
|
"deno-lint" => d.code.is_some(),
|
2023-01-24 20:14:49 +00:00
|
|
|
"deno" => diagnostics::DenoDiagnostic::is_fixable(d),
|
2021-02-04 18:53:02 +00:00
|
|
|
_ => false,
|
|
|
|
},
|
|
|
|
None => false,
|
|
|
|
})
|
|
|
|
.collect();
|
2021-08-06 01:46:32 +00:00
|
|
|
if !fixable_diagnostics.is_empty() {
|
|
|
|
let mut code_actions = CodeActionCollection::default();
|
|
|
|
let file_diagnostics = self
|
|
|
|
.diagnostics_server
|
2022-02-02 23:02:59 +00:00
|
|
|
.get_ts_diagnostics(&specifier, asset_or_doc.document_lsp_version());
|
2023-09-24 22:33:52 +00:00
|
|
|
let mut includes_no_cache = false;
|
2021-08-06 01:46:32 +00:00
|
|
|
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(),
|
2021-04-07 09:47:31 +00:00
|
|
|
};
|
2021-08-06 01:46:32 +00:00
|
|
|
let codes = vec![code];
|
2023-05-12 23:07:40 +00:00
|
|
|
let actions = self
|
|
|
|
.ts_server
|
|
|
|
.get_code_fixes(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier.clone(),
|
|
|
|
line_index.offset_tsc(diagnostic.range.start)?
|
|
|
|
..line_index.offset_tsc(diagnostic.range.end)?,
|
|
|
|
codes,
|
2024-03-26 15:52:20 +00:00
|
|
|
(&self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&specifier)
|
|
|
|
.options)
|
|
|
|
.into(),
|
2023-09-26 02:54:07 +00:00
|
|
|
tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
&specifier,
|
|
|
|
),
|
2023-05-12 23:07:40 +00:00
|
|
|
)
|
|
|
|
.await;
|
2021-08-06 01:46:32 +00:00
|
|
|
for action in actions {
|
2021-02-12 04:17:48 +00:00
|
|
|
code_actions
|
2021-08-06 01:46:32 +00:00
|
|
|
.add_ts_fix_action(&specifier, &action, diagnostic, self)
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to convert fix: {:#}", err);
|
2021-08-06 01:46:32 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?;
|
|
|
|
if code_actions.is_fix_all_action(
|
|
|
|
&action,
|
|
|
|
diagnostic,
|
|
|
|
&file_diagnostics,
|
|
|
|
) {
|
|
|
|
code_actions
|
|
|
|
.add_ts_fix_all_action(&action, &specifier, diagnostic);
|
|
|
|
}
|
2021-02-12 04:17:48 +00:00
|
|
|
}
|
|
|
|
}
|
2023-09-24 22:33:52 +00:00
|
|
|
Some("deno") => {
|
|
|
|
if diagnostic.code
|
|
|
|
== Some(NumberOrString::String("no-cache".to_string()))
|
2024-02-12 22:12:49 +00:00
|
|
|
|| diagnostic.code
|
|
|
|
== Some(NumberOrString::String("no-cache-jsr".to_string()))
|
2023-09-24 22:33:52 +00:00
|
|
|
|| diagnostic.code
|
|
|
|
== Some(NumberOrString::String("no-cache-npm".to_string()))
|
|
|
|
{
|
|
|
|
includes_no_cache = true;
|
|
|
|
}
|
|
|
|
code_actions
|
|
|
|
.add_deno_fix_action(&specifier, diagnostic)
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("{:#}", err);
|
2023-09-24 22:33:52 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?
|
|
|
|
}
|
2021-08-06 01:46:32 +00:00
|
|
|
Some("deno-lint") => code_actions
|
2024-03-21 21:18:59 +00:00
|
|
|
.add_deno_lint_actions(
|
2021-08-06 01:46:32 +00:00
|
|
|
&specifier,
|
|
|
|
diagnostic,
|
2021-11-12 16:42:04 +00:00
|
|
|
asset_or_doc.document().map(|d| d.text_info()),
|
2022-02-25 01:03:12 +00:00
|
|
|
asset_or_doc.maybe_parsed_source().and_then(|r| r.ok()),
|
2021-08-06 01:46:32 +00:00
|
|
|
)
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to fix lint error: {:#}", err);
|
2021-08-06 01:46:32 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?,
|
|
|
|
_ => (),
|
2021-02-12 04:17:48 +00:00
|
|
|
}
|
2021-02-04 18:53:02 +00:00
|
|
|
}
|
2023-09-24 22:33:52 +00:00
|
|
|
if includes_no_cache {
|
|
|
|
let no_cache_diagnostics =
|
|
|
|
self.diagnostics_state.no_cache_diagnostics(&specifier);
|
|
|
|
let uncached_deps = no_cache_diagnostics
|
|
|
|
.iter()
|
|
|
|
.filter_map(|d| {
|
|
|
|
let data = serde_json::from_value::<DiagnosticDataSpecifier>(
|
|
|
|
d.data.clone().into(),
|
|
|
|
)
|
|
|
|
.ok()?;
|
|
|
|
Some(data.specifier)
|
|
|
|
})
|
|
|
|
.collect::<HashSet<_>>();
|
|
|
|
if uncached_deps.len() > 1 {
|
|
|
|
code_actions
|
|
|
|
.add_cache_all_action(&specifier, no_cache_diagnostics.to_owned());
|
|
|
|
}
|
|
|
|
}
|
2021-08-06 01:46:32 +00:00
|
|
|
code_actions.set_preferred_fixes();
|
|
|
|
all_actions.extend(code_actions.get_response());
|
2021-02-04 18:53:02 +00:00
|
|
|
}
|
2021-08-06 01:46:32 +00:00
|
|
|
|
|
|
|
// Refactor
|
2023-03-15 21:46:36 +00:00
|
|
|
let only = params
|
|
|
|
.context
|
|
|
|
.only
|
|
|
|
.as_ref()
|
|
|
|
.and_then(|values| values.first().map(|v| v.as_str().to_owned()))
|
|
|
|
.unwrap_or_default();
|
2023-05-12 23:07:40 +00:00
|
|
|
let refactor_infos = self
|
2021-08-06 01:46:32 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_applicable_refactors(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier.clone(),
|
|
|
|
line_index.offset_tsc(params.range.start)?
|
|
|
|
..line_index.offset_tsc(params.range.end)?,
|
2023-09-26 02:54:07 +00:00
|
|
|
Some(tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
&specifier,
|
|
|
|
)),
|
2023-05-12 23:07:40 +00:00
|
|
|
only,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-08-06 01:46:32 +00:00
|
|
|
let mut refactor_actions = Vec::<CodeAction>::new();
|
|
|
|
for refactor_info in refactor_infos.iter() {
|
|
|
|
refactor_actions
|
|
|
|
.extend(refactor_info.to_code_actions(&specifier, ¶ms.range));
|
|
|
|
}
|
|
|
|
all_actions.extend(
|
2023-01-26 22:24:03 +00:00
|
|
|
refactor::prune_invalid_actions(refactor_actions, 5)
|
2021-08-06 01:46:32 +00:00
|
|
|
.into_iter()
|
|
|
|
.map(CodeActionOrCommand::CodeAction),
|
|
|
|
);
|
|
|
|
|
2021-08-09 23:56:34 +00:00
|
|
|
let code_action_disabled_support =
|
|
|
|
self.config.client_capabilities.code_action_disabled_support;
|
|
|
|
let actions: Vec<CodeActionOrCommand> = 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() {
|
2021-08-06 01:46:32 +00:00
|
|
|
None
|
2021-08-09 23:56:34 +00:00
|
|
|
} else {
|
|
|
|
Some(actions)
|
2021-08-06 01:46:32 +00:00
|
|
|
};
|
2021-08-09 23:56:34 +00:00
|
|
|
|
2021-02-04 18:53:02 +00:00
|
|
|
self.performance.measure(mark);
|
2021-08-06 01:46:32 +00:00
|
|
|
Ok(response)
|
2021-02-04 18:53:02 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 20:10:53 +00:00
|
|
|
async fn code_action_resolve(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-02-05 20:10:53 +00:00
|
|
|
params: CodeAction,
|
|
|
|
) -> LspResult<CodeAction> {
|
2021-08-06 01:46:32 +00:00
|
|
|
if params.kind.is_none() || params.data.is_none() {
|
|
|
|
return Ok(params);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.code_action_resolve", ¶ms);
|
2021-08-06 01:46:32 +00:00
|
|
|
let kind = params.kind.clone().unwrap();
|
|
|
|
let data = params.data.clone().unwrap();
|
|
|
|
|
|
|
|
let result = if kind.as_str().starts_with(CodeActionKind::QUICKFIX.as_str())
|
|
|
|
{
|
2021-02-25 03:15:55 +00:00
|
|
|
let code_action_data: CodeActionData =
|
|
|
|
from_value(data).map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to decode code action data: {:#}", err);
|
2021-02-25 03:15:55 +00:00
|
|
|
LspError::invalid_params("The CodeAction's data is invalid.")
|
|
|
|
})?;
|
2023-05-12 23:07:40 +00:00
|
|
|
let combined_code_actions = self
|
2021-02-25 03:15:55 +00:00
|
|
|
.ts_server
|
2023-08-17 14:46:11 +00:00
|
|
|
.get_combined_code_fix(
|
|
|
|
self.snapshot(),
|
|
|
|
&code_action_data,
|
2024-03-26 15:52:20 +00:00
|
|
|
(&self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&code_action_data.specifier)
|
|
|
|
.options)
|
|
|
|
.into(),
|
2023-09-26 02:54:07 +00:00
|
|
|
tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
&code_action_data.specifier,
|
|
|
|
),
|
2023-08-17 14:46:11 +00:00
|
|
|
)
|
2023-05-12 23:07:40 +00:00
|
|
|
.await?;
|
2021-02-25 03:15:55 +00:00
|
|
|
if combined_code_actions.commands.is_some() {
|
|
|
|
error!("Deno does not support code actions with commands.");
|
2021-08-06 01:46:32 +00:00
|
|
|
return Err(LspError::invalid_request());
|
2021-02-25 03:15:55 +00:00
|
|
|
}
|
2021-08-06 01:46:32 +00:00
|
|
|
|
|
|
|
let changes = if code_action_data.fix_id == "fixMissingImport" {
|
|
|
|
fix_ts_import_changes(
|
|
|
|
&code_action_data.specifier,
|
|
|
|
&combined_code_actions.changes,
|
2024-03-26 15:52:20 +00:00
|
|
|
&self.get_ts_response_import_mapper(&code_action_data.specifier),
|
2021-08-06 01:46:32 +00:00
|
|
|
)
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to remap changes: {:#}", err);
|
2021-08-06 01:46:32 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?
|
|
|
|
} else {
|
2022-04-25 15:23:24 +00:00
|
|
|
combined_code_actions.changes
|
2021-08-06 01:46:32 +00:00
|
|
|
};
|
2023-01-03 10:41:50 +00:00
|
|
|
let mut code_action = params;
|
2022-04-25 15:23:24 +00:00
|
|
|
code_action.edit = ts_changes_to_edit(&changes, self).map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to convert changes to edits: {:#}", err);
|
2022-04-25 15:23:24 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?;
|
2021-08-06 01:46:32 +00:00
|
|
|
code_action
|
|
|
|
} else if kind.as_str().starts_with(CodeActionKind::REFACTOR.as_str()) {
|
2023-01-03 10:41:50 +00:00
|
|
|
let mut code_action = params;
|
2021-08-06 01:46:32 +00:00
|
|
|
let action_data: refactor::RefactorCodeActionData = from_value(data)
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to decode code action data: {:#}", err);
|
2021-08-06 01:46:32 +00:00
|
|
|
LspError::invalid_params("The CodeAction's data is invalid.")
|
|
|
|
})?;
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&action_data.specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2023-05-12 23:07:40 +00:00
|
|
|
let refactor_edit_info = self
|
|
|
|
.ts_server
|
|
|
|
.get_edits_for_refactor(
|
|
|
|
self.snapshot(),
|
2023-09-21 05:46:39 +00:00
|
|
|
action_data.specifier.clone(),
|
2024-03-26 15:52:20 +00:00
|
|
|
(&self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&action_data.specifier)
|
|
|
|
.options)
|
|
|
|
.into(),
|
2023-05-12 23:07:40 +00:00
|
|
|
line_index.offset_tsc(action_data.range.start)?
|
|
|
|
..line_index.offset_tsc(action_data.range.end)?,
|
|
|
|
action_data.refactor_name,
|
|
|
|
action_data.action_name,
|
2023-09-26 02:54:07 +00:00
|
|
|
Some(tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
&action_data.specifier,
|
|
|
|
)),
|
2023-05-12 23:07:40 +00:00
|
|
|
)
|
|
|
|
.await?;
|
2024-03-12 03:48:00 +00:00
|
|
|
code_action.edit = refactor_edit_info.to_workspace_edit(self)?;
|
2021-08-06 01:46:32 +00:00
|
|
|
code_action
|
2021-02-25 03:15:55 +00:00
|
|
|
} else {
|
|
|
|
// The code action doesn't need to be resolved
|
2021-08-06 01:46:32 +00:00
|
|
|
params
|
2021-02-25 03:15:55 +00:00
|
|
|
};
|
2021-08-06 01:46:32 +00:00
|
|
|
|
2021-02-05 20:10:53 +00:00
|
|
|
self.performance.measure(mark);
|
2021-08-06 01:46:32 +00:00
|
|
|
Ok(result)
|
2021-02-05 20:10:53 +00:00
|
|
|
}
|
|
|
|
|
2024-03-26 15:52:20 +00:00
|
|
|
pub fn get_ts_response_import_mapper(
|
|
|
|
&self,
|
2024-04-02 22:02:50 +00:00
|
|
|
_referrer: &ModuleSpecifier,
|
2024-03-26 15:52:20 +00:00
|
|
|
) -> TsResponseImportMapper {
|
2023-07-02 01:07:57 +00:00
|
|
|
TsResponseImportMapper::new(
|
|
|
|
&self.documents,
|
2024-04-02 22:02:50 +00:00
|
|
|
self.config.tree.root_import_map().map(|i| i.as_ref()),
|
2023-11-04 16:41:51 +00:00
|
|
|
self.npm.node_resolver.as_deref(),
|
2023-10-02 21:53:55 +00:00
|
|
|
self.npm.resolver.as_deref(),
|
2023-07-02 01:07:57 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-02-01 03:30:41 +00:00
|
|
|
async fn code_lens(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-02-01 03:30:41 +00:00
|
|
|
params: CodeLensParams,
|
|
|
|
) -> LspResult<Option<Vec<CodeLens>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
2021-05-10 01:16:04 +00:00
|
|
|
{
|
2021-02-01 03:30:41 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.code_lens", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2023-11-30 16:23:47 +00:00
|
|
|
let settings = self.config.workspace_settings_for_specifier(&specifier);
|
|
|
|
let mut code_lenses = Vec::new();
|
|
|
|
if settings.code_lens.test
|
|
|
|
&& self.config.specifier_enabled_for_test(&specifier)
|
|
|
|
{
|
|
|
|
if let Some(Ok(parsed_source)) = asset_or_doc.maybe_parsed_source() {
|
|
|
|
code_lenses.extend(
|
|
|
|
code_lens::collect_test(&specifier, parsed_source).map_err(
|
|
|
|
|err| {
|
|
|
|
error!(
|
2024-03-02 02:25:38 +00:00
|
|
|
"Error getting test code lenses for \"{}\": {:#}",
|
2023-11-30 16:23:47 +00:00
|
|
|
&specifier, err
|
|
|
|
);
|
|
|
|
LspError::internal_error()
|
|
|
|
},
|
|
|
|
)?,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if settings.code_lens.implementations || settings.code_lens.references {
|
|
|
|
let navigation_tree =
|
|
|
|
self.get_navigation_tree(&specifier).await.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Error getting code lenses for \"{}\": {:#}", specifier, err);
|
2023-11-30 16:23:47 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?;
|
|
|
|
let line_index = asset_or_doc.line_index();
|
|
|
|
code_lenses.extend(
|
|
|
|
code_lens::collect_tsc(
|
|
|
|
&specifier,
|
|
|
|
&settings.code_lens,
|
|
|
|
line_index,
|
|
|
|
&navigation_tree,
|
|
|
|
)
|
|
|
|
.map_err(|err| {
|
|
|
|
error!(
|
2024-03-02 02:25:38 +00:00
|
|
|
"Error getting ts code lenses for \"{:#}\": {:#}",
|
2023-11-30 16:23:47 +00:00
|
|
|
&specifier, err
|
|
|
|
);
|
|
|
|
LspError::internal_error()
|
|
|
|
})?,
|
|
|
|
);
|
|
|
|
}
|
2021-02-01 03:30:41 +00:00
|
|
|
self.performance.measure(mark);
|
2021-06-04 21:31:44 +00:00
|
|
|
|
2023-11-30 16:23:47 +00:00
|
|
|
if code_lenses.is_empty() {
|
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-04 21:31:44 +00:00
|
|
|
Ok(Some(code_lenses))
|
2021-02-01 03:30:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn code_lens_resolve(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-06-04 21:31:44 +00:00
|
|
|
code_lens: CodeLens,
|
2021-02-01 03:30:41 +00:00
|
|
|
) -> LspResult<CodeLens> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.code_lens_resolve", &code_lens);
|
2021-06-04 21:31:44 +00:00
|
|
|
let result = if code_lens.data.is_some() {
|
|
|
|
code_lens::resolve_code_lens(code_lens, self)
|
|
|
|
.await
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Error resolving code lens: {:#}", err);
|
2021-06-04 21:31:44 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})
|
2021-02-01 03:30:41 +00:00
|
|
|
} else {
|
|
|
|
Err(LspError::invalid_params(
|
|
|
|
"Code lens is missing the \"data\" property.",
|
|
|
|
))
|
2021-06-04 21:31:44 +00:00
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
result
|
2021-02-01 03:30:41 +00:00
|
|
|
}
|
|
|
|
|
2020-12-21 13:44:26 +00:00
|
|
|
async fn document_highlight(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2020-12-21 13:44:26 +00:00
|
|
|
params: DocumentHighlightParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<Vec<DocumentHighlight>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.document_highlight", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2020-12-21 13:44:26 +00:00
|
|
|
let files_to_search = vec![specifier.clone()];
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_document_highlights = self
|
2021-02-25 03:15:55 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_document_highlights(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?,
|
|
|
|
files_to_search,
|
|
|
|
)
|
|
|
|
.await?;
|
2020-12-21 13:44:26 +00:00
|
|
|
|
|
|
|
if let Some(document_highlights) = maybe_document_highlights {
|
2021-01-27 00:32:49 +00:00
|
|
|
let result = document_highlights
|
|
|
|
.into_iter()
|
2022-02-25 01:03:12 +00:00
|
|
|
.flat_map(|dh| dh.to_highlight(line_index.clone()))
|
2021-01-27 00:32:49 +00:00
|
|
|
.collect();
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(Some(result))
|
2020-12-21 13:44:26 +00:00
|
|
|
} else {
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn references(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2020-12-21 13:44:26 +00:00
|
|
|
params: ReferenceParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<Vec<Location>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.references", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2023-03-30 16:15:21 +00:00
|
|
|
let maybe_referenced_symbols = self
|
2021-02-25 03:15:55 +00:00
|
|
|
.ts_server
|
2023-03-30 16:15:21 +00:00
|
|
|
.find_references(
|
|
|
|
self.snapshot(),
|
2023-05-12 23:07:40 +00:00
|
|
|
specifier.clone(),
|
2023-03-30 16:15:21 +00:00
|
|
|
line_index.offset_tsc(params.text_document_position.position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2023-03-30 16:15:21 +00:00
|
|
|
if let Some(symbols) = maybe_referenced_symbols {
|
2020-12-21 13:44:26 +00:00
|
|
|
let mut results = Vec::new();
|
2023-03-30 16:15:21 +00:00
|
|
|
for reference in symbols.iter().flat_map(|s| &s.references) {
|
2020-12-21 13:44:26 +00:00
|
|
|
if !params.context.include_declaration && reference.is_definition {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
let reference_specifier =
|
2023-03-30 16:15:21 +00:00
|
|
|
resolve_url(&reference.entry.document_span.file_name).unwrap();
|
2021-11-16 22:23:25 +00:00
|
|
|
let reference_line_index = if reference_specifier == specifier {
|
|
|
|
line_index.clone()
|
|
|
|
} else {
|
|
|
|
let asset_or_doc =
|
2022-04-25 15:23:24 +00:00
|
|
|
self.get_asset_or_document(&reference_specifier)?;
|
2021-11-16 22:23:25 +00:00
|
|
|
asset_or_doc.line_index()
|
|
|
|
};
|
2023-03-30 16:15:21 +00:00
|
|
|
results.push(
|
|
|
|
reference
|
|
|
|
.entry
|
|
|
|
.to_location(reference_line_index, &self.url_map),
|
|
|
|
);
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
Ok(Some(results))
|
|
|
|
} else {
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn goto_definition(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2020-12-21 13:44:26 +00:00
|
|
|
params: GotoDefinitionParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<GotoDefinitionResponse>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.goto_definition", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_definition = self
|
2021-02-25 03:15:55 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_definition(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2020-12-21 13:44:26 +00:00
|
|
|
|
|
|
|
if let Some(definition) = maybe_definition {
|
2024-03-12 03:48:00 +00:00
|
|
|
let results = definition.to_definition(line_index, self);
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(results)
|
2020-12-21 13:44:26 +00:00
|
|
|
} else {
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-23 00:09:19 +00:00
|
|
|
async fn goto_type_definition(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-11-23 00:09:19 +00:00
|
|
|
params: GotoTypeDefinitionParams,
|
|
|
|
) -> LspResult<Option<GotoTypeDefinitionResponse>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-11-23 00:09:19 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.goto_definition", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-23 00:09:19 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_definition_info = self
|
2021-11-23 00:09:19 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_type_definition(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-11-23 00:09:19 +00:00
|
|
|
|
|
|
|
let response = if let Some(definition_info) = maybe_definition_info {
|
|
|
|
let mut location_links = Vec::new();
|
|
|
|
for info in definition_info {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(link) = info.document_span.to_link(line_index.clone(), self)
|
2021-11-23 00:09:19 +00:00
|
|
|
{
|
|
|
|
location_links.push(link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Some(GotoTypeDefinitionResponse::Link(location_links))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2020-12-21 13:44:26 +00:00
|
|
|
async fn completion(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2020-12-21 13:44:26 +00:00
|
|
|
params: CompletionParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<CompletionResponse>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2023-10-24 20:27:27 +00:00
|
|
|
let language_settings =
|
|
|
|
self.config.language_settings_for_specifier(&specifier);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
2023-09-26 02:54:07 +00:00
|
|
|
|| !language_settings.map(|s| s.suggest.enabled).unwrap_or(true)
|
2021-06-02 10:29:58 +00:00
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.completion", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-03-25 00:13:37 +00:00
|
|
|
// 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.
|
2023-09-26 02:54:07 +00:00
|
|
|
let mut response = None;
|
|
|
|
if language_settings
|
|
|
|
.map(|s| s.suggest.include_completions_for_import_statements)
|
|
|
|
.unwrap_or(true)
|
2021-04-09 01:27:27 +00:00
|
|
|
{
|
2023-09-26 02:54:07 +00:00
|
|
|
response = completions::get_import_completions(
|
|
|
|
&specifier,
|
|
|
|
¶ms.text_document_position.position,
|
|
|
|
&self.config.snapshot(),
|
|
|
|
&self.client,
|
|
|
|
&self.module_registries,
|
2024-02-29 03:54:16 +00:00
|
|
|
&self.jsr_search_api,
|
2023-09-26 02:54:07 +00:00
|
|
|
&self.npm.search_api,
|
|
|
|
&self.documents,
|
2024-04-02 22:02:50 +00:00
|
|
|
self.config.tree.root_import_map().map(|i| i.as_ref()),
|
2023-09-26 02:54:07 +00:00
|
|
|
)
|
|
|
|
.await;
|
|
|
|
}
|
|
|
|
if response.is_none() {
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2022-07-11 23:35:18 +00:00
|
|
|
let (trigger_character, trigger_kind) =
|
|
|
|
if let Some(context) = ¶ms.context {
|
|
|
|
(
|
|
|
|
context.trigger_character.clone(),
|
|
|
|
Some(context.trigger_kind.into()),
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
(None, None)
|
|
|
|
};
|
2021-03-25 00:13:37 +00:00
|
|
|
let position =
|
|
|
|
line_index.offset_tsc(params.text_document_position.position)?;
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_completion_info = self
|
|
|
|
.ts_server
|
|
|
|
.get_completions(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier.clone(),
|
|
|
|
position,
|
|
|
|
tsc::GetCompletionsAtPositionOptions {
|
2023-09-26 02:54:07 +00:00
|
|
|
user_preferences: tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
&specifier,
|
|
|
|
),
|
2023-05-12 23:07:40 +00:00
|
|
|
trigger_character,
|
|
|
|
trigger_kind,
|
2021-03-25 00:13:37 +00:00
|
|
|
},
|
2024-03-26 15:52:20 +00:00
|
|
|
(&self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&specifier)
|
|
|
|
.options)
|
|
|
|
.into(),
|
2023-05-12 23:07:40 +00:00
|
|
|
)
|
|
|
|
.await;
|
2020-12-21 13:44:26 +00:00
|
|
|
|
2021-03-25 00:13:37 +00:00
|
|
|
if let Some(completions) = maybe_completion_info {
|
2023-09-26 02:54:07 +00:00
|
|
|
response = Some(
|
|
|
|
completions.as_completion_response(
|
|
|
|
line_index,
|
|
|
|
&self
|
|
|
|
.config
|
|
|
|
.language_settings_for_specifier(&specifier)
|
|
|
|
.cloned()
|
|
|
|
.unwrap_or_default()
|
|
|
|
.suggest,
|
|
|
|
&specifier,
|
|
|
|
position,
|
|
|
|
self,
|
|
|
|
),
|
2021-03-25 00:13:37 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(response)
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2021-03-15 22:01:41 +00:00
|
|
|
async fn completion_resolve(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-03-15 22:01:41 +00:00
|
|
|
params: CompletionItem,
|
|
|
|
) -> LspResult<CompletionItem> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.completion_resolve", ¶ms);
|
2021-03-25 00:13:37 +00:00
|
|
|
let completion_item = if let Some(data) = ¶ms.data {
|
|
|
|
let data: completions::CompletionItemData =
|
|
|
|
serde_json::from_value(data.clone()).map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("{:#}", err);
|
2021-03-15 22:01:41 +00:00
|
|
|
LspError::invalid_params(
|
|
|
|
"Could not decode data field of completion item.",
|
|
|
|
)
|
|
|
|
})?;
|
2022-07-11 23:35:18 +00:00
|
|
|
if let Some(data) = &data.tsc {
|
2023-01-03 10:41:50 +00:00
|
|
|
let specifier = &data.specifier;
|
2023-05-12 23:07:40 +00:00
|
|
|
let result = self
|
|
|
|
.ts_server
|
2023-09-26 02:54:07 +00:00
|
|
|
.get_completion_details(
|
|
|
|
self.snapshot(),
|
|
|
|
GetCompletionDetailsArgs {
|
2024-03-26 15:52:20 +00:00
|
|
|
format_code_settings: Some(
|
|
|
|
(&self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(specifier)
|
|
|
|
.options)
|
|
|
|
.into(),
|
|
|
|
),
|
2023-09-26 02:54:07 +00:00
|
|
|
preferences: Some(
|
|
|
|
tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
specifier,
|
|
|
|
),
|
|
|
|
),
|
|
|
|
..data.into()
|
|
|
|
},
|
|
|
|
)
|
2023-05-12 23:07:40 +00:00
|
|
|
.await;
|
2023-01-03 17:13:21 +00:00
|
|
|
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!(
|
2024-03-02 02:25:38 +00:00
|
|
|
"Failed to serialize virtual_text_document response: {:#}",
|
2023-01-03 17:13:21 +00:00
|
|
|
err
|
|
|
|
);
|
|
|
|
LspError::internal_error()
|
|
|
|
})?
|
|
|
|
} else {
|
2022-07-11 23:35:18 +00:00
|
|
|
error!(
|
2023-01-03 17:13:21 +00:00
|
|
|
"Received an undefined response from tsc for completion details."
|
2022-07-11 23:35:18 +00:00
|
|
|
);
|
2023-01-03 17:13:21 +00:00
|
|
|
params
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(err) => {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to get completion info from TypeScript: {:#}", err);
|
2023-01-03 17:13:21 +00:00
|
|
|
return Ok(params);
|
|
|
|
}
|
2021-03-25 00:13:37 +00:00
|
|
|
}
|
2021-12-13 19:24:11 +00:00
|
|
|
} else if let Some(url) = data.documentation {
|
|
|
|
CompletionItem {
|
|
|
|
documentation: self.module_registries.get_documentation(&url).await,
|
|
|
|
data: None,
|
|
|
|
..params
|
|
|
|
}
|
2021-03-15 22:01:41 +00:00
|
|
|
} else {
|
2021-03-25 00:13:37 +00:00
|
|
|
params
|
2021-03-15 22:01:41 +00:00
|
|
|
}
|
|
|
|
} else {
|
2021-03-25 00:13:37 +00:00
|
|
|
params
|
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(completion_item)
|
2021-03-15 22:01:41 +00:00
|
|
|
}
|
|
|
|
|
2021-01-12 21:53:27 +00:00
|
|
|
async fn goto_implementation(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-01-12 21:53:27 +00:00
|
|
|
params: GotoImplementationParams,
|
|
|
|
) -> LspResult<Option<GotoImplementationResponse>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.goto_implementation", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-01-12 21:53:27 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_implementations = self
|
2021-02-25 03:15:55 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_implementations(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-01-12 21:53:27 +00:00
|
|
|
|
2021-02-18 03:15:13 +00:00
|
|
|
let result = if let Some(implementations) = maybe_implementations {
|
|
|
|
let mut links = Vec::new();
|
|
|
|
for implementation in implementations {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(link) = implementation.to_link(line_index.clone(), self) {
|
2021-02-18 03:15:13 +00:00
|
|
|
links.push(link)
|
2021-01-12 21:53:27 +00:00
|
|
|
}
|
|
|
|
}
|
2021-02-18 03:15:13 +00:00
|
|
|
Some(GotoDefinitionResponse::Link(links))
|
2021-01-12 21:53:27 +00:00
|
|
|
} else {
|
2021-02-18 03:15:13 +00:00
|
|
|
None
|
|
|
|
};
|
|
|
|
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(result)
|
2021-01-12 21:53:27 +00:00
|
|
|
}
|
|
|
|
|
2021-04-02 06:21:07 +00:00
|
|
|
async fn folding_range(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-04-02 06:21:07 +00:00
|
|
|
params: FoldingRangeParams,
|
|
|
|
) -> LspResult<Option<Vec<FoldingRange>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-04-02 06:21:07 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.folding_range", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-04-02 06:21:07 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let outlining_spans = self
|
2021-04-02 06:21:07 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_outlining_spans(self.snapshot(), specifier)
|
|
|
|
.await?;
|
2021-04-02 06:21:07 +00:00
|
|
|
|
|
|
|
let response = if !outlining_spans.is_empty() {
|
|
|
|
Some(
|
|
|
|
outlining_spans
|
|
|
|
.iter()
|
|
|
|
.map(|span| {
|
|
|
|
span.to_folding_range(
|
2021-11-12 16:42:04 +00:00
|
|
|
asset_or_doc.line_index(),
|
2022-05-20 20:40:55 +00:00
|
|
|
asset_or_doc.text().as_bytes(),
|
2021-04-02 06:21:07 +00:00
|
|
|
self.config.client_capabilities.line_folding_only,
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.collect::<Vec<FoldingRange>>(),
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2021-04-19 05:11:26 +00:00
|
|
|
async fn incoming_calls(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-04-19 05:11:26 +00:00
|
|
|
params: CallHierarchyIncomingCallsParams,
|
|
|
|
) -> LspResult<Option<Vec<CallHierarchyIncomingCall>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.item.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-04-19 05:11:26 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.incoming_calls", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-04-19 05:11:26 +00:00
|
|
|
|
|
|
|
let incoming_calls: Vec<tsc::CallHierarchyIncomingCall> = self
|
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.provide_call_hierarchy_incoming_calls(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.item.selection_range.start)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-04-19 05:11:26 +00:00
|
|
|
|
|
|
|
let maybe_root_path_owned = self
|
2022-03-21 01:33:37 +00:00
|
|
|
.config
|
2023-09-09 14:04:21 +00:00
|
|
|
.root_uri()
|
2022-11-28 22:28:54 +00:00
|
|
|
.and_then(|uri| specifier_to_file_path(uri).ok());
|
2021-04-19 05:11:26 +00:00
|
|
|
let mut resolved_items = Vec::<CallHierarchyIncomingCall>::new();
|
|
|
|
for item in incoming_calls.iter() {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(resolved) = item.try_resolve_call_hierarchy_incoming_call(
|
|
|
|
self,
|
|
|
|
maybe_root_path_owned.as_deref(),
|
|
|
|
) {
|
2021-04-19 05:11:26 +00:00
|
|
|
resolved_items.push(resolved);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(Some(resolved_items))
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn outgoing_calls(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-04-19 05:11:26 +00:00
|
|
|
params: CallHierarchyOutgoingCallsParams,
|
|
|
|
) -> LspResult<Option<Vec<CallHierarchyOutgoingCall>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.item.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-04-19 05:11:26 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.outgoing_calls", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-04-19 05:11:26 +00:00
|
|
|
|
|
|
|
let outgoing_calls: Vec<tsc::CallHierarchyOutgoingCall> = self
|
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.provide_call_hierarchy_outgoing_calls(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.item.selection_range.start)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-04-19 05:11:26 +00:00
|
|
|
|
|
|
|
let maybe_root_path_owned = self
|
2022-03-21 01:33:37 +00:00
|
|
|
.config
|
2023-09-09 14:04:21 +00:00
|
|
|
.root_uri()
|
2022-11-28 22:28:54 +00:00
|
|
|
.and_then(|uri| specifier_to_file_path(uri).ok());
|
2021-04-19 05:11:26 +00:00
|
|
|
let mut resolved_items = Vec::<CallHierarchyOutgoingCall>::new();
|
|
|
|
for item in outgoing_calls.iter() {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(resolved) = item.try_resolve_call_hierarchy_outgoing_call(
|
|
|
|
line_index.clone(),
|
|
|
|
self,
|
|
|
|
maybe_root_path_owned.as_deref(),
|
|
|
|
) {
|
2021-04-19 05:11:26 +00:00
|
|
|
resolved_items.push(resolved);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(Some(resolved_items))
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn prepare_call_hierarchy(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2021-04-19 05:11:26 +00:00
|
|
|
params: CallHierarchyPrepareParams,
|
|
|
|
) -> LspResult<Option<Vec<CallHierarchyItem>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2021-05-11 04:54:10 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
2023-12-01 02:54:59 +00:00
|
|
|
.mark_with_args("lsp.prepare_call_hierarchy", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-04-19 05:11:26 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_one_or_many = self
|
|
|
|
.ts_server
|
|
|
|
.prepare_call_hierarchy(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-04-19 05:11:26 +00:00
|
|
|
|
|
|
|
let response = if let Some(one_or_many) = maybe_one_or_many {
|
|
|
|
let maybe_root_path_owned = self
|
2022-03-21 01:33:37 +00:00
|
|
|
.config
|
2023-09-09 14:04:21 +00:00
|
|
|
.root_uri()
|
2022-11-28 22:28:54 +00:00
|
|
|
.and_then(|uri| specifier_to_file_path(uri).ok());
|
2021-04-19 05:11:26 +00:00
|
|
|
let mut resolved_items = Vec::<CallHierarchyItem>::new();
|
|
|
|
match one_or_many {
|
|
|
|
tsc::OneOrMany::One(item) => {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(resolved) = item.try_resolve_call_hierarchy_item(
|
|
|
|
self,
|
|
|
|
maybe_root_path_owned.as_deref(),
|
|
|
|
) {
|
2021-04-19 05:11:26 +00:00
|
|
|
resolved_items.push(resolved)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tsc::OneOrMany::Many(items) => {
|
|
|
|
for item in items.iter() {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(resolved) = item.try_resolve_call_hierarchy_item(
|
|
|
|
self,
|
|
|
|
maybe_root_path_owned.as_deref(),
|
|
|
|
) {
|
2021-04-19 05:11:26 +00:00
|
|
|
resolved_items.push(resolved);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Some(resolved_items)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2020-12-30 00:58:20 +00:00
|
|
|
async fn rename(
|
2022-01-19 16:38:40 +00:00
|
|
|
&self,
|
2020-12-30 00:58:20 +00:00
|
|
|
params: RenameParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<WorkspaceEdit>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2020-12-30 00:58:20 +00:00
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.rename", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2020-12-30 00:58:20 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let maybe_locations = self
|
2021-02-25 03:15:55 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.find_rename_locations(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position.position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2020-12-30 00:58:20 +00:00
|
|
|
|
2021-01-22 10:03:16 +00:00
|
|
|
if let Some(locations) = maybe_locations {
|
|
|
|
let rename_locations = tsc::RenameLocations { locations };
|
|
|
|
let workspace_edits = rename_locations
|
2021-02-06 12:39:01 +00:00
|
|
|
.into_workspace_edit(¶ms.new_name, self)
|
2021-01-22 10:03:16 +00:00
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Failed to get workspace edits: {:#}", err);
|
2021-01-22 10:03:16 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?;
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2021-01-22 10:03:16 +00:00
|
|
|
Ok(Some(workspace_edits))
|
|
|
|
} else {
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2021-01-22 10:03:16 +00:00
|
|
|
Ok(None)
|
2020-12-30 00:58:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-23 23:33:25 +00:00
|
|
|
async fn selection_range(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-03-23 23:33:25 +00:00
|
|
|
params: SelectionRangeParams,
|
|
|
|
) -> LspResult<Option<Vec<SelectionRange>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-03-23 23:33:25 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.selection_range", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-03-23 23:33:25 +00:00
|
|
|
|
|
|
|
let mut selection_ranges = Vec::<SelectionRange>::new();
|
|
|
|
for position in params.positions {
|
|
|
|
let selection_range: tsc::SelectionRange = self
|
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_smart_selection_range(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier.clone(),
|
|
|
|
line_index.offset_tsc(position)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-03-23 23:33:25 +00:00
|
|
|
|
2021-10-28 23:56:01 +00:00
|
|
|
selection_ranges
|
|
|
|
.push(selection_range.to_selection_range(line_index.clone()));
|
2021-03-23 23:33:25 +00:00
|
|
|
}
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(Some(selection_ranges))
|
|
|
|
}
|
|
|
|
|
2021-04-20 01:26:36 +00:00
|
|
|
async fn semantic_tokens_full(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-04-20 01:26:36 +00:00
|
|
|
params: SemanticTokensParams,
|
|
|
|
) -> LspResult<Option<SemanticTokensResult>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2023-09-10 19:09:45 +00:00
|
|
|
if !self.is_diagnosable(&specifier) {
|
2021-04-20 01:26:36 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.semantic_tokens_full", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-04-20 01:26:36 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let semantic_classification = self
|
2021-04-20 01:26:36 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_encoded_semantic_classifications(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
0..line_index.text_content_length_utf16().into(),
|
|
|
|
)
|
|
|
|
.await?;
|
2021-04-20 01:26:36 +00:00
|
|
|
|
2021-11-16 22:23:25 +00:00
|
|
|
let semantic_tokens =
|
2022-03-02 21:06:38 +00:00
|
|
|
semantic_classification.to_semantic_tokens(&asset_or_doc, line_index)?;
|
2021-04-20 01:26:36 +00:00
|
|
|
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(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-04-20 01:26:36 +00:00
|
|
|
params: SemanticTokensRangeParams,
|
|
|
|
) -> LspResult<Option<SemanticTokensRangeResult>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2023-09-10 19:09:45 +00:00
|
|
|
if !self.is_diagnosable(&specifier) {
|
2021-04-20 01:26:36 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2021-05-11 04:54:10 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
2023-12-01 02:54:59 +00:00
|
|
|
.mark_with_args("lsp.semantic_tokens_range", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-04-20 01:26:36 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let semantic_classification = self
|
2021-04-20 01:26:36 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_encoded_semantic_classifications(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.range.start)?
|
|
|
|
..line_index.offset_tsc(params.range.end)?,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-04-20 01:26:36 +00:00
|
|
|
|
2021-11-16 22:23:25 +00:00
|
|
|
let semantic_tokens =
|
2022-03-02 21:06:38 +00:00
|
|
|
semantic_classification.to_semantic_tokens(&asset_or_doc, line_index)?;
|
2021-04-20 01:26:36 +00:00
|
|
|
let response = if !semantic_tokens.data.is_empty() {
|
|
|
|
Some(SemanticTokensRangeResult::Tokens(semantic_tokens))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2021-02-16 02:34:09 +00:00
|
|
|
async fn signature_help(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-02-16 02:34:09 +00:00
|
|
|
params: SignatureHelpParams,
|
|
|
|
) -> LspResult<Option<SignatureHelp>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self.url_map.normalize_url(
|
|
|
|
¶ms.text_document_position_params.text_document.uri,
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
2021-10-28 23:56:01 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
2021-06-02 10:29:58 +00:00
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
|
|
|
{
|
2021-05-10 01:16:04 +00:00
|
|
|
return Ok(None);
|
|
|
|
}
|
2021-06-02 10:29:58 +00:00
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.signature_help", ¶ms);
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
2021-11-12 16:42:04 +00:00
|
|
|
let line_index = asset_or_doc.line_index();
|
2021-02-16 02:34:09 +00:00
|
|
|
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,
|
|
|
|
}
|
|
|
|
};
|
2021-02-25 03:15:55 +00:00
|
|
|
let maybe_signature_help_items: Option<tsc::SignatureHelpItems> = self
|
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_signature_help_items(
|
|
|
|
self.snapshot(),
|
|
|
|
specifier,
|
|
|
|
line_index.offset_tsc(params.text_document_position_params.position)?,
|
|
|
|
options,
|
|
|
|
)
|
|
|
|
.await?;
|
2021-02-16 02:34:09 +00:00
|
|
|
|
|
|
|
if let Some(signature_help_items) = maybe_signature_help_items {
|
2022-02-09 23:08:53 +00:00
|
|
|
let signature_help = signature_help_items.into_signature_help(self);
|
2021-02-16 02:34:09 +00:00
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(Some(signature_help))
|
|
|
|
} else {
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
}
|
2021-11-23 00:08:56 +00:00
|
|
|
|
2023-08-26 00:50:47 +00:00
|
|
|
async fn will_rename_files(
|
|
|
|
&self,
|
|
|
|
params: RenameFilesParams,
|
|
|
|
) -> LspResult<Option<WorkspaceEdit>> {
|
|
|
|
let mut changes = vec![];
|
|
|
|
for rename in params.files {
|
2023-09-26 02:54:07 +00:00
|
|
|
let old_specifier = self.url_map.normalize_url(
|
|
|
|
&resolve_url(&rename.old_uri).unwrap(),
|
|
|
|
LspUrlKind::File,
|
|
|
|
);
|
|
|
|
let options = self
|
|
|
|
.config
|
|
|
|
.language_settings_for_specifier(&old_specifier)
|
|
|
|
.map(|s| s.update_imports_on_file_move.clone())
|
|
|
|
.unwrap_or_default();
|
|
|
|
// Note that `Always` and `Prompt` are treated the same in the server, the
|
|
|
|
// client will worry about that after receiving the edits.
|
|
|
|
if options.enabled == UpdateImportsOnFileMoveEnabled::Never {
|
|
|
|
continue;
|
|
|
|
}
|
2024-03-26 15:52:20 +00:00
|
|
|
let format_code_settings = (&self
|
|
|
|
.config
|
|
|
|
.tree
|
|
|
|
.fmt_options_for_specifier(&old_specifier)
|
|
|
|
.options)
|
|
|
|
.into();
|
2023-08-26 00:50:47 +00:00
|
|
|
changes.extend(
|
|
|
|
self
|
|
|
|
.ts_server
|
|
|
|
.get_edits_for_file_rename(
|
|
|
|
self.snapshot(),
|
2023-09-26 02:54:07 +00:00
|
|
|
old_specifier,
|
2023-08-26 00:50:47 +00:00
|
|
|
self.url_map.normalize_url(
|
|
|
|
&resolve_url(&rename.new_uri).unwrap(),
|
|
|
|
LspUrlKind::File,
|
|
|
|
),
|
2024-03-26 15:52:20 +00:00
|
|
|
format_code_settings,
|
2023-08-26 00:50:47 +00:00
|
|
|
tsc::UserPreferences {
|
|
|
|
allow_text_changes_in_new_files: Some(true),
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.await?,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
file_text_changes_to_workspace_edit(&changes, self)
|
|
|
|
}
|
|
|
|
|
2021-11-23 00:08:56 +00:00
|
|
|
async fn symbol(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-11-23 00:08:56 +00:00
|
|
|
params: WorkspaceSymbolParams,
|
|
|
|
) -> LspResult<Option<Vec<SymbolInformation>>> {
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.symbol", ¶ms);
|
2021-11-23 00:08:56 +00:00
|
|
|
|
2023-05-12 23:07:40 +00:00
|
|
|
let navigate_to_items = self
|
2021-11-23 00:08:56 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.get_navigate_to_items(
|
|
|
|
self.snapshot(),
|
|
|
|
tsc::GetNavigateToItemsArgs {
|
|
|
|
search: params.query,
|
|
|
|
// this matches vscode's hard coded result count
|
|
|
|
max_result_count: Some(256),
|
|
|
|
file: None,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.await?;
|
2021-11-23 00:08:56 +00:00
|
|
|
|
|
|
|
let maybe_symbol_information = if navigate_to_items.is_empty() {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
let mut symbol_information = Vec::new();
|
|
|
|
for item in navigate_to_items {
|
2022-04-25 15:23:24 +00:00
|
|
|
if let Some(info) = item.to_symbol_information(self) {
|
2021-11-23 00:08:56 +00:00
|
|
|
symbol_information.push(info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Some(symbol_information)
|
|
|
|
};
|
|
|
|
|
|
|
|
self.performance.measure(mark);
|
|
|
|
Ok(maybe_symbol_information)
|
|
|
|
}
|
2022-02-02 23:02:59 +00:00
|
|
|
|
2024-04-15 00:07:04 +00:00
|
|
|
async fn project_changed(
|
|
|
|
&mut self,
|
|
|
|
modified_scripts: &[(&ModuleSpecifier, ChangeKind)],
|
|
|
|
config_changed: bool,
|
|
|
|
) {
|
|
|
|
self.project_version += 1; // increment before getting the snapshot
|
|
|
|
self
|
|
|
|
.ts_server
|
|
|
|
.project_changed(self.snapshot(), modified_scripts, config_changed)
|
|
|
|
.await;
|
|
|
|
}
|
|
|
|
|
2022-02-02 23:02:59 +00:00
|
|
|
fn send_diagnostics_update(&self) {
|
2023-05-26 06:10:18 +00:00
|
|
|
let snapshot = DiagnosticServerUpdateMessage {
|
|
|
|
snapshot: self.snapshot(),
|
|
|
|
config: self.config.snapshot(),
|
2023-08-02 20:57:25 +00:00
|
|
|
url_map: self.url_map.clone(),
|
2023-05-26 06:10:18 +00:00
|
|
|
};
|
2022-02-02 23:02:59 +00:00
|
|
|
if let Err(err) = self.diagnostics_server.update(snapshot) {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Cannot update diagnostics: {:#}", err);
|
2022-02-02 23:02:59 +00:00
|
|
|
}
|
|
|
|
}
|
2022-03-29 22:59:27 +00:00
|
|
|
|
|
|
|
/// 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()) {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Cannot update testing server: {:#}", err);
|
2022-03-29 22:59:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
|
2022-04-03 04:17:30 +00:00
|
|
|
#[tower_lsp::async_trait]
|
|
|
|
impl tower_lsp::LanguageServer for LanguageServer {
|
2023-09-05 15:36:35 +00:00
|
|
|
async fn execute_command(
|
|
|
|
&self,
|
|
|
|
params: ExecuteCommandParams,
|
|
|
|
) -> LspResult<Option<Value>> {
|
|
|
|
if params.command == "deno.cache" {
|
2024-02-29 03:54:16 +00:00
|
|
|
#[derive(Default, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
struct Options {
|
|
|
|
#[serde(default)]
|
|
|
|
force_global_cache: bool,
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct Arguments(Vec<Url>, Url, #[serde(default)] Options);
|
|
|
|
let Arguments(specifiers, referrer, options) =
|
|
|
|
serde_json::from_value(json!(params.arguments))
|
|
|
|
.map_err(|err| LspError::invalid_params(err.to_string()))?;
|
|
|
|
self
|
|
|
|
.cache(specifiers, referrer, options.force_global_cache)
|
|
|
|
.await
|
2023-10-10 04:53:41 +00:00
|
|
|
} else if params.command == "deno.reloadImportRegistries" {
|
|
|
|
self.0.write().await.reload_import_registries().await
|
|
|
|
} else {
|
|
|
|
Ok(None)
|
2023-09-05 15:36:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn initialize(
|
|
|
|
&self,
|
|
|
|
params: InitializeParams,
|
|
|
|
) -> LspResult<InitializeResult> {
|
2022-12-20 01:22:17 +00:00
|
|
|
let mut language_server = self.0.write().await;
|
2022-02-02 23:02:59 +00:00
|
|
|
language_server.diagnostics_server.start();
|
2021-03-10 02:41:35 +00:00
|
|
|
language_server.initialize(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2023-03-15 14:34:23 +00:00
|
|
|
async fn initialized(&self, _: InitializedParams) {
|
2023-08-26 00:50:47 +00:00
|
|
|
let mut registrations = Vec::with_capacity(2);
|
2023-11-17 21:40:12 +00:00
|
|
|
let (client, http_client) = {
|
2023-03-15 14:34:23 +00:00
|
|
|
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.
|
2023-08-26 00:50:47 +00:00
|
|
|
let options = DidChangeWatchedFilesRegistrationOptions {
|
|
|
|
watchers: vec![FileSystemWatcher {
|
2023-09-26 20:57:14 +00:00
|
|
|
glob_pattern: GlobPattern::String(
|
|
|
|
"**/*.{json,jsonc,lock}".to_string(),
|
|
|
|
),
|
2023-09-01 20:13:13 +00:00
|
|
|
kind: None,
|
2023-08-26 00:50:47 +00:00
|
|
|
}],
|
|
|
|
};
|
|
|
|
registrations.push(Registration {
|
2023-03-15 14:34:23 +00:00
|
|
|
id: "workspace/didChangeWatchedFiles".to_string(),
|
|
|
|
method: "workspace/didChangeWatchedFiles".to_string(),
|
2023-08-26 00:50:47 +00:00
|
|
|
register_options: Some(serde_json::to_value(options).unwrap()),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
if ls.config.client_capabilities.workspace_will_rename_files {
|
|
|
|
let options = FileOperationRegistrationOptions {
|
|
|
|
filters: vec![FileOperationFilter {
|
|
|
|
scheme: Some("file".to_string()),
|
|
|
|
pattern: FileOperationPattern {
|
|
|
|
glob: "**/*".to_string(),
|
|
|
|
matches: None,
|
|
|
|
options: None,
|
|
|
|
},
|
|
|
|
}],
|
|
|
|
};
|
|
|
|
registrations.push(Registration {
|
|
|
|
id: "workspace/willRenameFiles".to_string(),
|
|
|
|
method: "workspace/willRenameFiles".to_string(),
|
|
|
|
register_options: Some(serde_json::to_value(options).unwrap()),
|
2023-03-15 14:34:23 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
if ls.config.client_capabilities.testing_api {
|
|
|
|
let test_server = testing::TestServer::new(
|
|
|
|
ls.client.clone(),
|
|
|
|
ls.performance.clone(),
|
2023-09-09 14:04:21 +00:00
|
|
|
ls.config.root_uri().cloned(),
|
2023-03-15 14:34:23 +00:00
|
|
|
);
|
|
|
|
ls.maybe_testing_server = Some(test_server);
|
|
|
|
}
|
2024-01-17 20:22:28 +00:00
|
|
|
|
2024-03-26 15:52:20 +00:00
|
|
|
let mut config_events = vec![];
|
2024-04-02 22:02:50 +00:00
|
|
|
for (scope_uri, config_data) in ls.config.tree.data_by_scope().iter() {
|
2024-03-26 15:52:20 +00:00
|
|
|
if let Some(config_file) = &config_data.config_file {
|
2024-01-23 06:12:41 +00:00
|
|
|
config_events.push(lsp_custom::DenoConfigurationChangeEvent {
|
2024-03-26 15:52:20 +00:00
|
|
|
scope_uri: scope_uri.clone(),
|
2024-01-23 06:12:41 +00:00
|
|
|
file_uri: config_file.specifier.clone(),
|
|
|
|
typ: lsp_custom::DenoConfigurationChangeType::Added,
|
|
|
|
configuration_type: lsp_custom::DenoConfigurationType::DenoJson,
|
|
|
|
});
|
|
|
|
}
|
2024-03-26 15:52:20 +00:00
|
|
|
if let Some(package_json) = &config_data.package_json {
|
2024-01-23 06:12:41 +00:00
|
|
|
config_events.push(lsp_custom::DenoConfigurationChangeEvent {
|
2024-03-26 15:52:20 +00:00
|
|
|
scope_uri: scope_uri.clone(),
|
2024-01-23 06:12:41 +00:00
|
|
|
file_uri: package_json.specifier(),
|
|
|
|
typ: lsp_custom::DenoConfigurationChangeType::Added,
|
|
|
|
configuration_type: lsp_custom::DenoConfigurationType::PackageJson,
|
|
|
|
});
|
|
|
|
}
|
2024-03-26 15:52:20 +00:00
|
|
|
}
|
|
|
|
if !config_events.is_empty() {
|
|
|
|
ls.client.send_did_change_deno_configuration_notification(
|
|
|
|
lsp_custom::DidChangeDenoConfigurationNotificationParams {
|
|
|
|
changes: config_events,
|
|
|
|
},
|
|
|
|
);
|
2024-01-17 20:22:28 +00:00
|
|
|
}
|
|
|
|
|
2023-11-17 21:40:12 +00:00
|
|
|
(ls.client.clone(), ls.http_client.clone())
|
2023-03-15 14:34:23 +00:00
|
|
|
};
|
|
|
|
|
2023-08-26 00:50:47 +00:00
|
|
|
for registration in registrations {
|
2023-03-15 14:34:23 +00:00
|
|
|
if let Err(err) = client
|
|
|
|
.when_outside_lsp_lock()
|
|
|
|
.register_capability(vec![registration])
|
|
|
|
.await
|
|
|
|
{
|
2023-03-30 14:43:16 +00:00
|
|
|
lsp_warn!("Client errored on capabilities.\n{:#}", err);
|
2023-03-15 14:34:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-10-24 20:27:27 +00:00
|
|
|
self.refresh_configuration().await;
|
2023-05-23 01:28:36 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
let mut ls = self.0.write().await;
|
2023-12-08 17:04:56 +00:00
|
|
|
init_log_file(ls.config.log_file());
|
2023-07-26 22:52:31 +00:00
|
|
|
ls.refresh_documents_config().await;
|
2023-05-23 01:28:36 +00:00
|
|
|
ls.diagnostics_server.invalidate_all();
|
|
|
|
ls.send_diagnostics_update();
|
2024-01-02 23:48:34 +00:00
|
|
|
ls.task_queue.start(self.clone());
|
|
|
|
};
|
2023-11-14 22:10:51 +00:00
|
|
|
|
|
|
|
if upgrade_check_enabled() {
|
2023-11-17 21:40:12 +00:00
|
|
|
// spawn to avoid lsp send/sync requirement, but also just
|
|
|
|
// to ensure this initialized method returns quickly
|
|
|
|
spawn(async move {
|
|
|
|
match check_for_upgrades_for_lsp(http_client).await {
|
|
|
|
Ok(version_info) => {
|
|
|
|
client.send_did_upgrade_check_notification(
|
|
|
|
lsp_custom::DidUpgradeCheckNotificationParams {
|
|
|
|
upgrade_available: version_info.map(|info| {
|
|
|
|
lsp_custom::UpgradeAvailable {
|
|
|
|
latest_version: info.latest_version,
|
|
|
|
is_canary: info.is_canary,
|
|
|
|
}
|
|
|
|
}),
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Err(err) => lsp_warn!("Failed to check for upgrades: {err}"),
|
2023-11-14 22:10:51 +00:00
|
|
|
}
|
2023-11-17 21:40:12 +00:00
|
|
|
});
|
2023-11-14 22:10:51 +00:00
|
|
|
}
|
2024-01-02 23:48:34 +00:00
|
|
|
|
|
|
|
lsp_log!("Server ready.");
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn shutdown(&self) -> LspResult<()> {
|
2023-11-22 04:08:48 +00:00
|
|
|
self.1.cancel();
|
2024-03-12 03:48:00 +00:00
|
|
|
self.0.write().await.shutdown()
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn did_open(&self, params: DidOpenTextDocumentParams) {
|
2023-02-06 21:49:49 +00:00
|
|
|
if params.text_document.uri.scheme() == "deno" {
|
2022-02-02 23:02:59 +00:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2023-10-24 20:27:27 +00:00
|
|
|
let mut inner = self.0.write().await;
|
|
|
|
let specifier = inner
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2024-04-11 01:06:37 +00:00
|
|
|
let document = inner.did_open(&specifier, params).await;
|
2023-10-24 20:27:27 +00:00
|
|
|
if document.is_diagnosable() {
|
|
|
|
inner.refresh_npm_specifiers().await;
|
2024-04-10 18:58:49 +00:00
|
|
|
inner.diagnostics_server.invalidate(&[specifier]);
|
2023-10-24 20:27:27 +00:00
|
|
|
inner.send_diagnostics_update();
|
|
|
|
inner.send_testing_update();
|
2022-01-25 15:30:38 +00:00
|
|
|
}
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn did_change(&self, params: DidChangeTextDocumentParams) {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.write().await.did_change(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2023-09-24 16:59:42 +00:00
|
|
|
async fn did_save(&self, params: DidSaveTextDocumentParams) {
|
|
|
|
let uri = ¶ms.text_document.uri;
|
2024-01-30 17:17:34 +00:00
|
|
|
let specifier = {
|
2023-10-12 14:37:56 +00:00
|
|
|
let mut inner = self.0.write().await;
|
2023-09-26 02:54:07 +00:00
|
|
|
let specifier = inner.url_map.normalize_url(uri, LspUrlKind::File);
|
2023-10-12 14:37:56 +00:00
|
|
|
inner.documents.save(&specifier);
|
2023-10-24 20:27:27 +00:00
|
|
|
if !inner
|
|
|
|
.config
|
|
|
|
.workspace_settings_for_specifier(&specifier)
|
|
|
|
.cache_on_save
|
2023-09-26 02:54:07 +00:00
|
|
|
|| !inner.config.specifier_enabled(&specifier)
|
|
|
|
|| !inner.diagnostics_state.has_no_cache_diagnostics(&specifier)
|
2023-09-24 16:59:42 +00:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2023-09-26 02:54:07 +00:00
|
|
|
match specifier_to_file_path(&specifier) {
|
|
|
|
Ok(path) if is_importable_ext(&path) => {}
|
|
|
|
_ => return,
|
|
|
|
}
|
2024-01-30 17:17:34 +00:00
|
|
|
specifier
|
|
|
|
};
|
2024-02-29 03:54:16 +00:00
|
|
|
if let Err(err) = self.cache(vec![], specifier.clone(), false).await {
|
2024-03-02 02:25:38 +00:00
|
|
|
lsp_warn!("Failed to cache \"{}\" on save: {:#}", &specifier, err);
|
2023-09-24 16:59:42 +00:00
|
|
|
}
|
2021-02-09 22:46:12 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn did_close(&self, params: DidCloseTextDocumentParams) {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.write().await.did_close(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn did_change_configuration(
|
|
|
|
&self,
|
|
|
|
params: DidChangeConfigurationParams,
|
|
|
|
) {
|
2023-10-24 20:27:27 +00:00
|
|
|
let mark = {
|
2023-03-15 14:34:23 +00:00
|
|
|
let inner = self.0.read().await;
|
2023-10-24 20:27:27 +00:00
|
|
|
inner
|
|
|
|
.performance
|
2023-12-01 02:54:59 +00:00
|
|
|
.mark_with_args("lsp.did_change_configuration", ¶ms)
|
2022-01-25 15:30:38 +00:00
|
|
|
};
|
|
|
|
|
2023-10-24 20:27:27 +00:00
|
|
|
self.refresh_configuration().await;
|
2022-01-25 15:30:38 +00:00
|
|
|
|
2022-12-20 01:22:17 +00:00
|
|
|
let mut inner = self.0.write().await;
|
2023-10-24 20:27:27 +00:00
|
|
|
inner.did_change_configuration(params).await;
|
2022-01-25 15:30:38 +00:00
|
|
|
inner.performance.measure(mark);
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn did_change_watched_files(
|
|
|
|
&self,
|
|
|
|
params: DidChangeWatchedFilesParams,
|
|
|
|
) {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.write().await.did_change_watched_files(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2022-03-21 01:33:37 +00:00
|
|
|
async fn did_change_workspace_folders(
|
|
|
|
&self,
|
|
|
|
params: DidChangeWorkspaceFoldersParams,
|
|
|
|
) {
|
2023-03-15 14:34:23 +00:00
|
|
|
let (performance, mark) = {
|
|
|
|
let mut ls = self.0.write().await;
|
|
|
|
let mark = ls
|
|
|
|
.performance
|
2023-12-01 02:54:59 +00:00
|
|
|
.mark_with_args("lsp.did_change_workspace_folders", ¶ms);
|
2023-03-15 14:34:23 +00:00
|
|
|
ls.did_change_workspace_folders(params);
|
|
|
|
(ls.performance.clone(), mark)
|
2022-03-21 01:33:37 +00:00
|
|
|
};
|
2023-03-15 14:34:23 +00:00
|
|
|
|
2023-10-24 20:27:27 +00:00
|
|
|
self.refresh_configuration().await;
|
|
|
|
{
|
2023-05-23 01:28:36 +00:00
|
|
|
let mut ls = self.0.write().await;
|
2024-03-21 04:29:52 +00:00
|
|
|
ls.refresh_workspace_files();
|
2024-03-26 15:52:20 +00:00
|
|
|
ls.refresh_config_tree().await;
|
2023-07-26 22:52:31 +00:00
|
|
|
ls.refresh_documents_config().await;
|
2023-05-23 01:28:36 +00:00
|
|
|
ls.diagnostics_server.invalidate_all();
|
|
|
|
ls.send_diagnostics_update();
|
|
|
|
}
|
2023-03-15 14:34:23 +00:00
|
|
|
performance.measure(mark);
|
2022-03-21 01:33:37 +00:00
|
|
|
}
|
|
|
|
|
2021-04-20 01:29:27 +00:00
|
|
|
async fn document_symbol(
|
|
|
|
&self,
|
|
|
|
params: DocumentSymbolParams,
|
|
|
|
) -> LspResult<Option<DocumentSymbolResponse>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.document_symbol(params).await
|
2021-04-20 01:29:27 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn formatting(
|
|
|
|
&self,
|
|
|
|
params: DocumentFormattingParams,
|
|
|
|
) -> LspResult<Option<Vec<TextEdit>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.formatting(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn hover(&self, params: HoverParams) -> LspResult<Option<Hover>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.hover(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2023-09-26 20:57:14 +00:00
|
|
|
async fn inlay_hint(
|
|
|
|
&self,
|
|
|
|
params: InlayHintParams,
|
|
|
|
) -> LspResult<Option<Vec<InlayHint>>> {
|
|
|
|
self.0.read().await.inlay_hint(params).await
|
|
|
|
}
|
|
|
|
|
2021-02-04 18:53:02 +00:00
|
|
|
async fn code_action(
|
|
|
|
&self,
|
|
|
|
params: CodeActionParams,
|
|
|
|
) -> LspResult<Option<CodeActionResponse>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.code_action(params).await
|
2021-02-04 18:53:02 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 20:10:53 +00:00
|
|
|
async fn code_action_resolve(
|
|
|
|
&self,
|
|
|
|
params: CodeAction,
|
|
|
|
) -> LspResult<CodeAction> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.code_action_resolve(params).await
|
2021-02-05 20:10:53 +00:00
|
|
|
}
|
|
|
|
|
2021-02-01 03:30:41 +00:00
|
|
|
async fn code_lens(
|
|
|
|
&self,
|
|
|
|
params: CodeLensParams,
|
|
|
|
) -> LspResult<Option<Vec<CodeLens>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.code_lens(params).await
|
2021-02-01 03:30:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn code_lens_resolve(&self, params: CodeLens) -> LspResult<CodeLens> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.code_lens_resolve(params).await
|
2021-02-01 03:30:41 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn document_highlight(
|
|
|
|
&self,
|
|
|
|
params: DocumentHighlightParams,
|
|
|
|
) -> LspResult<Option<Vec<DocumentHighlight>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.document_highlight(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn references(
|
|
|
|
&self,
|
|
|
|
params: ReferenceParams,
|
|
|
|
) -> LspResult<Option<Vec<Location>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.references(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn goto_definition(
|
|
|
|
&self,
|
|
|
|
params: GotoDefinitionParams,
|
|
|
|
) -> LspResult<Option<GotoDefinitionResponse>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.goto_definition(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2021-11-23 00:09:19 +00:00
|
|
|
async fn goto_type_definition(
|
|
|
|
&self,
|
|
|
|
params: GotoTypeDefinitionParams,
|
|
|
|
) -> LspResult<Option<GotoTypeDefinitionResponse>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.goto_type_definition(params).await
|
2021-11-23 00:09:19 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn completion(
|
|
|
|
&self,
|
|
|
|
params: CompletionParams,
|
|
|
|
) -> LspResult<Option<CompletionResponse>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.completion(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2021-03-15 22:01:41 +00:00
|
|
|
async fn completion_resolve(
|
|
|
|
&self,
|
|
|
|
params: CompletionItem,
|
|
|
|
) -> LspResult<CompletionItem> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.completion_resolve(params).await
|
2021-03-15 22:01:41 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn goto_implementation(
|
|
|
|
&self,
|
|
|
|
params: GotoImplementationParams,
|
|
|
|
) -> LspResult<Option<GotoImplementationResponse>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.goto_implementation(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2021-04-02 06:21:07 +00:00
|
|
|
async fn folding_range(
|
|
|
|
&self,
|
|
|
|
params: FoldingRangeParams,
|
|
|
|
) -> LspResult<Option<Vec<FoldingRange>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.folding_range(params).await
|
2021-04-02 06:21:07 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 05:11:26 +00:00
|
|
|
async fn incoming_calls(
|
|
|
|
&self,
|
|
|
|
params: CallHierarchyIncomingCallsParams,
|
|
|
|
) -> LspResult<Option<Vec<CallHierarchyIncomingCall>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.incoming_calls(params).await
|
2021-04-19 05:11:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn outgoing_calls(
|
|
|
|
&self,
|
|
|
|
params: CallHierarchyOutgoingCallsParams,
|
|
|
|
) -> LspResult<Option<Vec<CallHierarchyOutgoingCall>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.outgoing_calls(params).await
|
2021-04-19 05:11:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn prepare_call_hierarchy(
|
|
|
|
&self,
|
|
|
|
params: CallHierarchyPrepareParams,
|
|
|
|
) -> LspResult<Option<Vec<CallHierarchyItem>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.prepare_call_hierarchy(params).await
|
2021-04-19 05:11:26 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 09:55:04 +00:00
|
|
|
async fn rename(
|
|
|
|
&self,
|
|
|
|
params: RenameParams,
|
|
|
|
) -> LspResult<Option<WorkspaceEdit>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.rename(params).await
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2021-03-23 23:33:25 +00:00
|
|
|
async fn selection_range(
|
|
|
|
&self,
|
|
|
|
params: SelectionRangeParams,
|
|
|
|
) -> LspResult<Option<Vec<SelectionRange>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.selection_range(params).await
|
2021-03-23 23:33:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-20 01:26:36 +00:00
|
|
|
async fn semantic_tokens_full(
|
|
|
|
&self,
|
|
|
|
params: SemanticTokensParams,
|
|
|
|
) -> LspResult<Option<SemanticTokensResult>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.semantic_tokens_full(params).await
|
2021-04-20 01:26:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn semantic_tokens_range(
|
|
|
|
&self,
|
|
|
|
params: SemanticTokensRangeParams,
|
|
|
|
) -> LspResult<Option<SemanticTokensRangeResult>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.semantic_tokens_range(params).await
|
2021-04-20 01:26:36 +00:00
|
|
|
}
|
|
|
|
|
2021-02-16 02:34:09 +00:00
|
|
|
async fn signature_help(
|
|
|
|
&self,
|
|
|
|
params: SignatureHelpParams,
|
|
|
|
) -> LspResult<Option<SignatureHelp>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.signature_help(params).await
|
2021-02-16 02:34:09 +00:00
|
|
|
}
|
2021-11-23 00:08:56 +00:00
|
|
|
|
2023-08-26 00:50:47 +00:00
|
|
|
async fn will_rename_files(
|
|
|
|
&self,
|
|
|
|
params: RenameFilesParams,
|
|
|
|
) -> LspResult<Option<WorkspaceEdit>> {
|
|
|
|
self.0.read().await.will_rename_files(params).await
|
|
|
|
}
|
|
|
|
|
2021-11-23 00:08:56 +00:00
|
|
|
async fn symbol(
|
|
|
|
&self,
|
|
|
|
params: WorkspaceSymbolParams,
|
|
|
|
) -> LspResult<Option<Vec<SymbolInformation>>> {
|
2022-12-20 01:22:17 +00:00
|
|
|
self.0.read().await.symbol(params).await
|
2021-11-23 00:08:56 +00:00
|
|
|
}
|
2021-01-26 09:55:04 +00:00
|
|
|
}
|
|
|
|
|
2022-12-20 01:22:17 +00:00
|
|
|
struct PrepareCacheResult {
|
|
|
|
cli_options: CliOptions,
|
2023-01-24 13:23:19 +00:00
|
|
|
roots: Vec<ModuleSpecifier>,
|
2024-04-06 14:36:43 +00:00
|
|
|
open_docs: Vec<Arc<Document>>,
|
2022-12-20 01:22:17 +00:00
|
|
|
mark: PerformanceMark,
|
|
|
|
}
|
|
|
|
|
2021-02-04 18:53:02 +00:00
|
|
|
// These are implementations of custom commands supported by the LSP
|
2021-01-26 09:55:04 +00:00
|
|
|
impl Inner {
|
2022-12-20 01:22:17 +00:00
|
|
|
fn prepare_cache(
|
|
|
|
&self,
|
2024-01-30 17:17:34 +00:00
|
|
|
specifiers: Vec<ModuleSpecifier>,
|
|
|
|
referrer: ModuleSpecifier,
|
2024-02-29 03:54:16 +00:00
|
|
|
force_global_cache: bool,
|
2023-02-23 01:16:16 +00:00
|
|
|
) -> Result<Option<PrepareCacheResult>, AnyError> {
|
2024-01-30 17:17:34 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
|
|
|
.mark_with_args("lsp.cache", (&specifiers, &referrer));
|
2024-04-02 22:02:50 +00:00
|
|
|
let config_data = self.config.tree.root_data();
|
2024-01-30 17:17:34 +00:00
|
|
|
let roots = if !specifiers.is_empty() {
|
|
|
|
specifiers
|
2021-06-21 21:18:32 +00:00
|
|
|
} else {
|
2024-03-26 15:52:20 +00:00
|
|
|
vec![referrer.clone()]
|
2021-10-10 21:26:22 +00:00
|
|
|
};
|
2023-05-23 01:28:36 +00:00
|
|
|
let workspace_settings = self.config.workspace_settings();
|
2024-03-31 20:39:23 +00:00
|
|
|
let cli_options = CliOptions::new(
|
2022-07-01 15:50:16 +00:00
|
|
|
Flags {
|
2023-08-02 00:49:09 +00:00
|
|
|
cache_path: self.maybe_global_cache_path.clone(),
|
2023-05-23 01:28:36 +00:00
|
|
|
ca_stores: workspace_settings.certificate_stores.clone(),
|
|
|
|
ca_data: workspace_settings.tls_certificate.clone().map(CaData::File),
|
|
|
|
unsafely_ignore_certificate_errors: workspace_settings
|
|
|
|
.unsafely_ignore_certificate_errors
|
|
|
|
.clone(),
|
2024-04-02 22:02:50 +00:00
|
|
|
import_map_path: config_data.and_then(|d| {
|
2024-03-31 20:39:23 +00:00
|
|
|
if d.import_map_from_settings {
|
|
|
|
return Some(d.import_map.as_ref()?.base_url().to_string());
|
|
|
|
}
|
|
|
|
None
|
|
|
|
}),
|
2023-07-10 21:45:09 +00:00
|
|
|
node_modules_dir: Some(
|
2024-03-26 15:52:20 +00:00
|
|
|
config_data
|
|
|
|
.and_then(|d| d.node_modules_dir.as_ref())
|
|
|
|
.is_some(),
|
2023-07-10 21:45:09 +00:00
|
|
|
),
|
2023-05-23 01:28:36 +00:00
|
|
|
// bit of a hack to force the lsp to cache the @types/node package
|
|
|
|
type_check_mode: crate::args::TypeCheckMode::Local,
|
2022-07-01 15:50:16 +00:00
|
|
|
..Default::default()
|
|
|
|
},
|
2024-01-18 20:57:30 +00:00
|
|
|
self.initial_cwd.clone(),
|
2024-04-02 22:02:50 +00:00
|
|
|
config_data.and_then(|d| d.config_file.as_deref().cloned()),
|
|
|
|
config_data.and_then(|d| d.lockfile.clone()),
|
|
|
|
config_data.and_then(|d| d.package_json.as_deref().cloned()),
|
2024-02-29 03:54:16 +00:00
|
|
|
force_global_cache,
|
2023-02-23 01:16:16 +00:00
|
|
|
)?;
|
2022-07-01 15:50:16 +00:00
|
|
|
|
2023-03-29 20:25:48 +00:00
|
|
|
let open_docs = self.documents.documents(DocumentsFilter::OpenDiagnosable);
|
2022-12-20 01:22:17 +00:00
|
|
|
Ok(Some(PrepareCacheResult {
|
|
|
|
cli_options,
|
|
|
|
open_docs,
|
|
|
|
roots,
|
|
|
|
mark,
|
|
|
|
}))
|
|
|
|
}
|
2021-10-10 21:26:22 +00:00
|
|
|
|
2022-12-20 01:22:17 +00:00
|
|
|
async fn post_cache(&self, mark: PerformanceMark) {
|
2022-06-27 17:43:43 +00:00
|
|
|
// 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();
|
2023-05-12 23:07:40 +00:00
|
|
|
self.ts_server.restart(self.snapshot()).await;
|
2023-01-28 15:18:32 +00:00
|
|
|
self.send_diagnostics_update();
|
|
|
|
self.send_testing_update();
|
|
|
|
|
|
|
|
self.performance.measure(mark);
|
|
|
|
}
|
|
|
|
|
2021-02-12 10:08:36 +00:00
|
|
|
fn get_performance(&self) -> Value {
|
2021-01-27 00:32:49 +00:00
|
|
|
let averages = self.performance.averages();
|
2021-02-12 10:08:36 +00:00
|
|
|
json!({ "averages": averages })
|
2021-01-27 00:32:49 +00:00
|
|
|
}
|
|
|
|
|
2023-10-12 15:07:27 +00:00
|
|
|
fn task_definitions(&self) -> LspResult<Vec<TaskDefinition>> {
|
|
|
|
let mut result = vec![];
|
2024-03-26 15:52:20 +00:00
|
|
|
for config_file in self.config.tree.config_files() {
|
2023-10-12 15:07:27 +00:00
|
|
|
if let Some(tasks) = json!(&config_file.json.tasks).as_object() {
|
|
|
|
for (name, value) in tasks {
|
|
|
|
let Some(command) = value.as_str() else {
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
result.push(TaskDefinition {
|
|
|
|
name: name.clone(),
|
|
|
|
command: command.to_string(),
|
|
|
|
source_uri: config_file.specifier.clone(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2024-03-26 15:52:20 +00:00
|
|
|
for package_json in self.config.tree.package_jsons() {
|
2023-10-12 15:07:27 +00:00
|
|
|
if let Some(scripts) = &package_json.scripts {
|
|
|
|
for (name, command) in scripts {
|
|
|
|
result.push(TaskDefinition {
|
|
|
|
name: name.clone(),
|
|
|
|
command: command.clone(),
|
|
|
|
source_uri: package_json.specifier(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result.sort_by_key(|d| d.name.clone());
|
|
|
|
Ok(result)
|
2022-03-29 00:27:43 +00:00
|
|
|
}
|
|
|
|
|
2022-10-16 02:39:43 +00:00
|
|
|
async fn inlay_hint(
|
|
|
|
&self,
|
|
|
|
params: InlayHintParams,
|
|
|
|
) -> LspResult<Option<Vec<InlayHint>>> {
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2022-10-16 02:39:43 +00:00
|
|
|
if !self.is_diagnosable(&specifier)
|
|
|
|
|| !self.config.specifier_enabled(&specifier)
|
2023-10-24 20:27:27 +00:00
|
|
|
|| !self.config.enabled_inlay_hints_for_specifier(&specifier)
|
2022-10-16 02:39:43 +00:00
|
|
|
{
|
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:54:59 +00:00
|
|
|
let mark = self.performance.mark_with_args("lsp.inlay_hint", ¶ms);
|
2022-10-16 02:39:43 +00:00
|
|
|
let asset_or_doc = self.get_asset_or_document(&specifier)?;
|
|
|
|
let line_index = asset_or_doc.line_index();
|
2023-05-12 23:07:40 +00:00
|
|
|
let text_span =
|
|
|
|
tsc::TextSpan::from_range(¶ms.range, line_index.clone()).map_err(
|
|
|
|
|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Failed to convert range to text_span: {:#}", err);
|
2023-05-12 23:07:40 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
},
|
|
|
|
)?;
|
|
|
|
let maybe_inlay_hints = self
|
2022-10-16 02:39:43 +00:00
|
|
|
.ts_server
|
2023-05-12 23:07:40 +00:00
|
|
|
.provide_inlay_hints(
|
|
|
|
self.snapshot(),
|
2023-09-21 05:46:39 +00:00
|
|
|
specifier.clone(),
|
2023-05-12 23:07:40 +00:00
|
|
|
text_span,
|
2023-09-26 02:54:07 +00:00
|
|
|
tsc::UserPreferences::from_config_for_specifier(
|
|
|
|
&self.config,
|
|
|
|
&specifier,
|
|
|
|
),
|
2023-05-12 23:07:40 +00:00
|
|
|
)
|
|
|
|
.await?;
|
2022-10-16 02:39:43 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2021-04-09 01:27:27 +00:00
|
|
|
async fn reload_import_registries(&mut self) -> LspResult<Option<Value>> {
|
2022-11-28 22:28:54 +00:00
|
|
|
remove_dir_all_if_exists(&self.module_registries_location)
|
2021-04-09 01:27:27 +00:00
|
|
|
.await
|
|
|
|
.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to remove registries cache: {:#}", err);
|
2021-04-09 01:27:27 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?;
|
|
|
|
self.update_registries().await.map_err(|err| {
|
2024-03-02 02:25:38 +00:00
|
|
|
error!("Unable to update registries: {:#}", err);
|
2021-04-09 01:27:27 +00:00
|
|
|
LspError::internal_error()
|
|
|
|
})?;
|
|
|
|
Ok(Some(json!(true)))
|
|
|
|
}
|
|
|
|
|
2022-04-25 15:23:24 +00:00
|
|
|
fn virtual_text_document(
|
2022-12-20 01:22:17 +00:00
|
|
|
&self,
|
2021-06-01 11:53:08 +00:00
|
|
|
params: lsp_custom::VirtualTextDocumentParams,
|
2020-12-30 04:17:17 +00:00
|
|
|
) -> LspResult<Option<String>> {
|
2021-05-11 04:54:10 +00:00
|
|
|
let mark = self
|
|
|
|
.performance
|
2023-12-01 02:54:59 +00:00
|
|
|
.mark_with_args("lsp.virtual_text_document", ¶ms);
|
2023-03-15 14:34:23 +00:00
|
|
|
let specifier = self
|
|
|
|
.url_map
|
|
|
|
.normalize_url(¶ms.text_document.uri, LspUrlKind::File);
|
2023-09-27 00:48:34 +00:00
|
|
|
let contents = if specifier.scheme() == "deno"
|
|
|
|
&& specifier.path() == "/status.md"
|
|
|
|
{
|
2021-01-27 00:32:49 +00:00
|
|
|
let mut contents = String::new();
|
2021-11-12 16:42:04 +00:00
|
|
|
let mut documents_specifiers = self
|
|
|
|
.documents
|
2023-03-29 20:25:48 +00:00
|
|
|
.documents(DocumentsFilter::All)
|
2021-11-12 16:42:04 +00:00
|
|
|
.into_iter()
|
|
|
|
.map(|d| d.specifier().clone())
|
|
|
|
.collect::<Vec<_>>();
|
2021-04-19 21:10:43 +00:00
|
|
|
documents_specifiers.sort();
|
|
|
|
let measures = self.performance.to_vec();
|
2023-05-11 21:17:14 +00:00
|
|
|
let workspace_settings = self.config.workspace_settings();
|
2021-01-27 00:32:49 +00:00
|
|
|
|
2022-07-01 13:28:06 +00:00
|
|
|
write!(
|
|
|
|
contents,
|
2020-12-21 13:44:26 +00:00
|
|
|
r#"# Deno Language Server Status
|
2021-01-04 21:52:20 +00:00
|
|
|
|
2021-07-21 01:50:43 +00:00
|
|
|
## Workspace Settings
|
|
|
|
|
|
|
|
```json
|
|
|
|
{}
|
|
|
|
```
|
|
|
|
|
|
|
|
## Workspace Details
|
|
|
|
|
2021-04-19 21:10:43 +00:00
|
|
|
- <details><summary>Documents in memory: {}</summary>
|
|
|
|
|
|
|
|
- {}
|
|
|
|
|
|
|
|
</details>
|
|
|
|
|
|
|
|
- <details><summary>Performance measures: {}</summary>
|
|
|
|
|
|
|
|
- {}
|
|
|
|
|
|
|
|
</details>
|
2021-01-27 00:32:49 +00:00
|
|
|
"#,
|
2021-07-21 01:50:43 +00:00
|
|
|
serde_json::to_string_pretty(&workspace_settings).unwrap(),
|
2021-10-28 23:56:01 +00:00
|
|
|
documents_specifiers.len(),
|
2021-04-19 21:10:43 +00:00
|
|
|
documents_specifiers
|
|
|
|
.into_iter()
|
|
|
|
.map(|s| s.to_string())
|
|
|
|
.collect::<Vec<String>>()
|
|
|
|
.join("\n - "),
|
|
|
|
measures.len(),
|
|
|
|
measures
|
|
|
|
.iter()
|
|
|
|
.map(|m| m.to_string())
|
|
|
|
.collect::<Vec<String>>()
|
|
|
|
.join("\n - ")
|
2022-07-01 13:28:06 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2023-12-12 07:18:10 +00:00
|
|
|
|
2021-04-19 21:10:43 +00:00
|
|
|
contents
|
2023-12-12 07:18:10 +00:00
|
|
|
.push_str("\n## Performance (last 3 000 entries)\n\n|Name|Count|Duration|\n|---|---|---|\n");
|
2023-12-11 16:33:56 +00:00
|
|
|
let mut averages = self.performance.averages_as_f64();
|
|
|
|
averages.sort_by(|a, b| a.0.cmp(&b.0));
|
|
|
|
for (name, count, average_duration) in averages {
|
2023-12-12 07:18:10 +00:00
|
|
|
writeln!(contents, "|{}|{}|{}ms|", name, count, average_duration)
|
2023-12-11 16:33:56 +00:00
|
|
|
.unwrap();
|
2021-01-27 00:32:49 +00:00
|
|
|
}
|
2023-12-12 07:18:10 +00:00
|
|
|
|
|
|
|
contents.push_str(
|
|
|
|
"\n## Performance (total)\n\n|Name|Count|Duration|\n|---|---|---|\n",
|
|
|
|
);
|
|
|
|
let mut measurements_by_type = self.performance.measurements_by_type();
|
|
|
|
measurements_by_type.sort_by(|a, b| a.0.cmp(&b.0));
|
|
|
|
for (name, total_count, total_duration) in measurements_by_type {
|
|
|
|
writeln!(
|
|
|
|
contents,
|
|
|
|
"|{}|{}|{:.3}ms|",
|
|
|
|
name, total_count, total_duration
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
}
|
|
|
|
|
2021-01-27 00:32:49 +00:00
|
|
|
Some(contents)
|
2020-12-21 13:44:26 +00:00
|
|
|
} else {
|
2022-04-25 15:23:24 +00:00
|
|
|
let asset_or_doc = self.get_maybe_asset_or_document(&specifier);
|
2021-11-12 16:42:04 +00:00
|
|
|
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
|
2020-12-21 13:44:26 +00:00
|
|
|
}
|
|
|
|
};
|
2021-01-27 00:32:49 +00:00
|
|
|
self.performance.measure(mark);
|
2020-12-21 13:44:26 +00:00
|
|
|
Ok(contents)
|
|
|
|
}
|
|
|
|
}
|
2024-03-21 04:29:52 +00:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use pretty_assertions::assert_eq;
|
|
|
|
use test_util::TempDir;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_walk_workspace() {
|
|
|
|
let temp_dir = TempDir::new();
|
|
|
|
temp_dir.create_dir_all("root1/node_modules/");
|
|
|
|
temp_dir.write("root1/node_modules/mod.ts", ""); // no, node_modules
|
|
|
|
|
|
|
|
temp_dir.create_dir_all("root1/sub_dir");
|
|
|
|
temp_dir.create_dir_all("root1/target");
|
|
|
|
temp_dir.create_dir_all("root1/node_modules");
|
|
|
|
temp_dir.create_dir_all("root1/.git");
|
|
|
|
temp_dir.create_dir_all("root1/file.ts"); // no, directory
|
|
|
|
temp_dir.write("root1/mod0.ts", ""); // yes
|
|
|
|
temp_dir.write("root1/mod1.js", ""); // yes
|
|
|
|
temp_dir.write("root1/mod2.tsx", ""); // yes
|
|
|
|
temp_dir.write("root1/mod3.d.ts", ""); // yes
|
|
|
|
temp_dir.write("root1/mod4.jsx", ""); // yes
|
|
|
|
temp_dir.write("root1/mod5.mjs", ""); // yes
|
|
|
|
temp_dir.write("root1/mod6.mts", ""); // yes
|
|
|
|
temp_dir.write("root1/mod7.d.mts", ""); // yes
|
|
|
|
temp_dir.write("root1/mod8.json", ""); // yes
|
|
|
|
temp_dir.write("root1/mod9.jsonc", ""); // yes
|
|
|
|
temp_dir.write("root1/other.txt", ""); // no, text file
|
|
|
|
temp_dir.write("root1/other.wasm", ""); // no, don't load wasm
|
|
|
|
temp_dir.write("root1/Cargo.toml", ""); // no
|
|
|
|
temp_dir.write("root1/sub_dir/mod.ts", ""); // yes
|
|
|
|
temp_dir.write("root1/sub_dir/data.min.ts", ""); // no, minified file
|
|
|
|
temp_dir.write("root1/.git/main.ts", ""); // no, .git folder
|
|
|
|
temp_dir.write("root1/node_modules/main.ts", ""); // no, because it's in a node_modules folder
|
|
|
|
temp_dir.write("root1/target/main.ts", ""); // no, because there is a Cargo.toml in the root directory
|
|
|
|
|
|
|
|
temp_dir.create_dir_all("root2/folder");
|
|
|
|
temp_dir.create_dir_all("root2/sub_folder");
|
|
|
|
temp_dir.write("root2/file1.ts", ""); // yes, enabled
|
|
|
|
temp_dir.write("root2/file2.ts", ""); // no, not enabled
|
|
|
|
temp_dir.write("root2/folder/main.ts", ""); // yes, enabled
|
|
|
|
temp_dir.write("root2/folder/other.ts", ""); // no, disabled
|
|
|
|
temp_dir.write("root2/sub_folder/a.js", ""); // no, not enabled
|
|
|
|
temp_dir.write("root2/sub_folder/b.ts", ""); // no, not enabled
|
|
|
|
temp_dir.write("root2/sub_folder/c.js", ""); // no, not enabled
|
|
|
|
|
|
|
|
temp_dir.create_dir_all("root3/");
|
|
|
|
temp_dir.write("root3/mod.ts", ""); // no, not enabled
|
|
|
|
|
|
|
|
let mut config = Config::new_with_roots(vec![
|
|
|
|
temp_dir.uri().join("root1/").unwrap(),
|
|
|
|
temp_dir.uri().join("root2/").unwrap(),
|
|
|
|
temp_dir.uri().join("root3/").unwrap(),
|
|
|
|
]);
|
|
|
|
config.set_workspace_settings(
|
|
|
|
Default::default(),
|
|
|
|
vec![
|
|
|
|
(
|
|
|
|
temp_dir.uri().join("root1/").unwrap(),
|
|
|
|
WorkspaceSettings {
|
|
|
|
enable: Some(true),
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
),
|
|
|
|
(
|
|
|
|
temp_dir.uri().join("root2/").unwrap(),
|
|
|
|
WorkspaceSettings {
|
|
|
|
enable: Some(true),
|
|
|
|
enable_paths: Some(vec![
|
|
|
|
"file1.ts".to_string(),
|
|
|
|
"folder".to_string(),
|
|
|
|
]),
|
|
|
|
disable_paths: vec!["folder/other.ts".to_string()],
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
),
|
|
|
|
(
|
|
|
|
temp_dir.uri().join("root3/").unwrap(),
|
|
|
|
WorkspaceSettings {
|
|
|
|
enable: Some(false),
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
),
|
|
|
|
],
|
|
|
|
);
|
|
|
|
|
|
|
|
let (workspace_files, hit_limit) = Inner::walk_workspace(&config);
|
|
|
|
assert!(!hit_limit);
|
|
|
|
assert_eq!(
|
|
|
|
json!(workspace_files),
|
|
|
|
json!([
|
|
|
|
temp_dir.uri().join("root1/mod0.ts").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod1.js").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod2.tsx").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod3.d.ts").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod4.jsx").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod5.mjs").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod6.mts").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod7.d.mts").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod8.json").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/mod9.jsonc").unwrap(),
|
|
|
|
temp_dir.uri().join("root1/sub_dir/mod.ts").unwrap(),
|
|
|
|
temp_dir.uri().join("root2/file1.ts").unwrap(),
|
|
|
|
temp_dir.uri().join("root2/folder/main.ts").unwrap(),
|
|
|
|
])
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|