2021-01-11 12:13:41 -05:00
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
2020-12-21 08:44:26 -05:00
use deno_core ::error ::anyhow ;
use deno_core ::error ::AnyError ;
2021-02-17 13:47:18 -05:00
use deno_core ::resolve_url ;
2020-12-21 08:44:26 -05:00
use deno_core ::serde_json ;
use deno_core ::serde_json ::json ;
use deno_core ::serde_json ::Value ;
use deno_core ::ModuleSpecifier ;
2021-03-26 12:34:25 -04:00
use log ::error ;
use log ::info ;
use log ::warn ;
2020-12-29 23:17:17 -05:00
use lspower ::jsonrpc ::Error as LspError ;
use lspower ::jsonrpc ::Result as LspResult ;
2021-01-29 14:34:33 -05:00
use lspower ::lsp ::request ::* ;
use lspower ::lsp ::* ;
2020-12-21 08:44:26 -05:00
use lspower ::Client ;
2021-02-04 13:53:02 -05:00
use serde_json ::from_value ;
2020-12-21 08:44:26 -05:00
use std ::env ;
use std ::path ::PathBuf ;
2021-05-11 00:54:10 -04:00
use std ::sync ::atomic ::Ordering ;
2020-12-21 08:44:26 -05:00
use std ::sync ::Arc ;
use tokio ::fs ;
2021-02-09 17:46:12 -05:00
use super ::analysis ;
2021-05-29 07:21:11 -04:00
use super ::analysis ::fix_ts_import_changes ;
2021-02-05 15:10:53 -05:00
use super ::analysis ::ts_changes_to_edit ;
2021-02-04 13:53:02 -05:00
use super ::analysis ::CodeActionCollection ;
2021-02-05 15:10:53 -05:00
use super ::analysis ::CodeActionData ;
2021-02-09 17:46:12 -05:00
use super ::analysis ::ResolvedDependency ;
2020-12-21 08:44:26 -05:00
use super ::capabilities ;
2021-06-04 17:31:44 -04:00
use super ::code_lens ;
2021-03-24 20:13:37 -04:00
use super ::completions ;
2020-12-21 08:44:26 -05:00
use super ::config ::Config ;
2021-05-20 05:56:48 -04:00
use super ::config ::ConfigSnapshot ;
2021-05-09 21:16:04 -04:00
use super ::config ::SETTINGS_SECTION ;
2020-12-21 08:44:26 -05:00
use super ::diagnostics ;
use super ::diagnostics ::DiagnosticSource ;
2021-01-22 05:03:16 -05:00
use super ::documents ::DocumentCache ;
2021-06-02 06:29:58 -04:00
use super ::documents ::LanguageId ;
2021-06-01 07:53:08 -04:00
use super ::lsp_custom ;
2021-01-26 19:32:49 -05:00
use super ::performance ::Performance ;
2021-04-08 21:27:27 -04:00
use super ::registries ;
2020-12-29 23:17:17 -05:00
use super ::sources ;
2020-12-21 08:44:26 -05:00
use super ::sources ::Sources ;
use super ::text ;
2021-01-22 05:03:16 -05:00
use super ::text ::LineIndex ;
2020-12-21 08:44:26 -05:00
use super ::tsc ;
2021-01-22 05:03:16 -05:00
use super ::tsc ::AssetDocument ;
2021-02-12 06:49:42 -05:00
use super ::tsc ::Assets ;
2020-12-21 08:44:26 -05:00
use super ::tsc ::TsServer ;
2021-02-17 23:37:05 -05:00
use super ::urls ;
2021-05-18 02:35:46 -04:00
use crate ::config_file ::ConfigFile ;
use crate ::config_file ::TsConfig ;
use crate ::deno_dir ;
use crate ::import_map ::ImportMap ;
use crate ::logger ;
use crate ::media_type ::MediaType ;
use crate ::tools ::fmt ::format_file ;
use crate ::tools ::fmt ::get_typescript_config ;
2020-12-21 08:44:26 -05:00
2021-04-08 21:27:27 -04:00
pub const REGISTRIES_PATH : & str = " registries " ;
const SOURCES_PATH : & str = " deps " ;
2020-12-21 08:44:26 -05:00
#[ derive(Debug, Clone) ]
2021-01-26 04:55:04 -05:00
pub struct LanguageServer ( Arc < tokio ::sync ::Mutex < Inner > > ) ;
2020-12-21 08:44:26 -05:00
#[ derive(Debug, Clone, Default) ]
pub struct StateSnapshot {
2021-02-12 06:49:42 -05:00
pub assets : Assets ,
2021-05-20 05:56:48 -04:00
pub config : ConfigSnapshot ,
2021-01-25 18:47:12 -05:00
pub documents : DocumentCache ,
2021-04-08 21:27:27 -04:00
pub module_registries : registries ::ModuleRegistry ,
2021-02-11 23:17:48 -05:00
pub performance : Performance ,
2021-01-26 04:55:04 -05:00
pub sources : Sources ,
2021-05-09 21:16:04 -04:00
pub url_map : urls ::LspUrlMap ,
2021-01-26 04:55:04 -05:00
}
#[ derive(Debug) ]
2021-02-06 07:39:01 -05:00
pub ( crate ) struct Inner {
2021-02-04 13:53:02 -05: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 06:49:42 -05:00
assets : Assets ,
2021-02-04 13:53:02 -05:00
/// The LSP client that this LSP server is connected to.
2021-05-11 10:43:00 -04:00
pub ( crate ) client : Client ,
2021-02-04 13:53:02 -05:00
/// Configuration information.
2021-06-04 17:31:44 -04:00
pub ( crate ) config : Config ,
2021-03-09 21:41:35 -05:00
diagnostics_server : diagnostics ::DiagnosticsServer ,
2021-02-04 13:53:02 -05:00
/// The "in-memory" documents in the editor which can be updated and changed.
2021-01-26 19:32:49 -05:00
documents : DocumentCache ,
2021-04-08 21:27:27 -04:00
/// Handles module registries, which allow discovery of modules
module_registries : registries ::ModuleRegistry ,
/// The path to the module registries cache
module_registries_location : PathBuf ,
2021-02-04 13:53:02 -05:00
/// An optional URL which provides the location of a TypeScript configuration
/// file which will be used by the Deno LSP.
2021-01-26 04:55:04 -05:00
maybe_config_uri : Option < Url > ,
2021-02-04 13:53:02 -05:00
/// An optional import map which is used to resolve modules.
2021-02-12 06:49:42 -05:00
pub ( crate ) maybe_import_map : Option < ImportMap > ,
2021-02-04 13:53:02 -05:00
/// The URL for the import map which is used to determine relative imports.
2021-01-26 04:55:04 -05:00
maybe_import_map_uri : Option < Url > ,
2021-02-04 13:53:02 -05:00
/// A collection of measurements which instrument that performance of the LSP.
2021-01-26 19:32:49 -05:00
performance : Performance ,
2021-02-04 13:53:02 -05:00
/// Cached sources that are read-only.
2021-01-26 19:32:49 -05:00
sources : Sources ,
2021-02-04 13:53:02 -05:00
/// A memoized version of fixable diagnostic codes retrieved from TypeScript.
ts_fixable_diagnostics : Vec < String > ,
/// An abstraction that handles interactions with TypeScript.
2021-05-11 10:43:00 -04:00
pub ( crate ) ts_server : Arc < TsServer > ,
2021-02-17 23:37:05 -05:00
/// A map of specifiers and URLs used to translate over the LSP.
2021-05-11 10:43:00 -04:00
pub ( crate ) url_map : urls ::LspUrlMap ,
2020-12-21 08:44:26 -05:00
}
impl LanguageServer {
pub fn new ( client : Client ) -> Self {
2021-01-26 04:55:04 -05:00
Self ( Arc ::new ( tokio ::sync ::Mutex ::new ( Inner ::new ( client ) ) ) )
}
}
impl Inner {
fn new ( client : Client ) -> Self {
2020-12-21 08:44:26 -05:00
let maybe_custom_root = env ::var ( " DENO_DIR " ) . map ( String ::into ) . ok ( ) ;
let dir = deno_dir ::DenoDir ::new ( maybe_custom_root )
. expect ( " could not access DENO_DIR " ) ;
2021-04-08 21:27:27 -04:00
let module_registries_location = dir . root . join ( REGISTRIES_PATH ) ;
let module_registries =
registries ::ModuleRegistry ::new ( & module_registries_location ) ;
let sources_location = dir . root . join ( SOURCES_PATH ) ;
let sources = Sources ::new ( & sources_location ) ;
2021-03-09 21:41:35 -05:00
let ts_server = Arc ::new ( TsServer ::new ( ) ) ;
let performance = Performance ::default ( ) ;
let diagnostics_server = diagnostics ::DiagnosticsServer ::new ( ) ;
2021-05-20 05:56:48 -04:00
let config = Config ::new ( client . clone ( ) ) ;
2020-12-21 08:44:26 -05:00
2021-01-26 04:55:04 -05:00
Self {
2020-12-21 08:44:26 -05:00
assets : Default ::default ( ) ,
client ,
2021-05-20 05:56:48 -04:00
config ,
2021-03-09 21:41:35 -05:00
diagnostics_server ,
2021-01-26 19:32:49 -05:00
documents : Default ::default ( ) ,
2020-12-30 22:33:44 -05:00
maybe_config_uri : Default ::default ( ) ,
2020-12-21 08:44:26 -05:00
maybe_import_map : Default ::default ( ) ,
maybe_import_map_uri : Default ::default ( ) ,
2021-04-08 21:27:27 -04:00
module_registries ,
module_registries_location ,
2021-03-09 21:41:35 -05:00
performance ,
2021-01-26 19:32:49 -05:00
sources ,
2021-02-04 13:53:02 -05:00
ts_fixable_diagnostics : Default ::default ( ) ,
2021-03-09 21:41:35 -05:00
ts_server ,
2021-02-17 23:37:05 -05:00
url_map : Default ::default ( ) ,
2020-12-21 08:44:26 -05:00
}
}
2021-02-09 17:46:12 -05:00
/// Analyzes dependencies of a document that has been opened in the editor and
/// sets the dependencies property on the document.
fn analyze_dependencies (
& mut self ,
specifier : & ModuleSpecifier ,
source : & str ,
) {
2021-03-24 20:13:37 -04:00
let media_type = MediaType ::from ( specifier ) ;
if let Ok ( parsed_module ) =
analysis ::parse_module ( specifier , source , & media_type )
{
let ( mut deps , _ ) = analysis ::analyze_dependencies (
specifier ,
& media_type ,
& parsed_module ,
& self . maybe_import_map ,
) ;
2021-02-09 17:46:12 -05:00
for ( _ , dep ) in deps . iter_mut ( ) {
if dep . maybe_type . is_none ( ) {
if let Some ( ResolvedDependency ::Resolved ( resolved ) ) = & dep . maybe_code
{
dep . maybe_type = self . sources . get_maybe_types ( resolved ) ;
}
}
}
if let Err ( err ) = self . documents . set_dependencies ( specifier , Some ( deps ) ) {
error! ( " {} " , err ) ;
}
}
}
2021-01-22 05:03:16 -05:00
/// Searches assets, open documents and external sources for a line_index,
/// which might be performed asynchronously, hydrating in memory caches for
/// subsequent requests.
2021-02-06 07:39:01 -05:00
pub ( crate ) async fn get_line_index (
& mut self ,
2020-12-22 05:21:18 -05:00
specifier : ModuleSpecifier ,
2021-01-22 05:03:16 -05:00
) -> Result < LineIndex , AnyError > {
2021-05-11 00:54:10 -04:00
let mark = self
. performance
. mark ( " get_line_index " , Some ( json! ( { " specifier " : specifier } ) ) ) ;
2021-02-17 13:47:18 -05:00
let result = if specifier . scheme ( ) = = " asset " {
2021-02-06 07:39:01 -05:00
if let Some ( asset ) = self . get_asset ( & specifier ) . await ? {
Ok ( asset . line_index )
2020-12-21 08:44:26 -05:00
} else {
2021-02-06 07:39:01 -05:00
Err ( anyhow! ( " asset is missing: {} " , specifier ) )
2020-12-22 05:21:18 -05:00
}
2021-01-26 04:55:04 -05:00
} else if let Some ( line_index ) = self . documents . line_index ( & specifier ) {
2021-01-22 05:03:16 -05:00
Ok ( line_index )
2021-01-26 04:55:04 -05:00
} else if let Some ( line_index ) = self . sources . get_line_index ( & specifier ) {
2021-01-22 05:03:16 -05:00
Ok ( line_index )
2020-12-21 08:44:26 -05:00
} else {
2021-01-22 05:03:16 -05:00
Err ( anyhow! ( " Unable to find line index for: {} " , specifier ) )
2021-01-26 19:32:49 -05:00
} ;
self . performance . measure ( mark ) ;
result
2021-01-22 05:03:16 -05:00
}
/// Only searches already cached assets and documents for a line index. If
/// the line index cannot be found, `None` is returned.
2021-06-04 17:31:44 -04:00
pub fn get_line_index_sync (
2021-02-11 23:17:48 -05:00
& self ,
2021-01-22 05:03:16 -05:00
specifier : & ModuleSpecifier ,
) -> Option < LineIndex > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark (
" get_line_index_sync " ,
Some ( json! ( { " specifier " : specifier } ) ) ,
) ;
2021-02-17 13:47:18 -05:00
let maybe_line_index = if specifier . scheme ( ) = = " asset " {
2021-01-26 04:55:04 -05:00
if let Some ( Some ( asset ) ) = self . assets . get ( specifier ) {
2021-01-22 05:03:16 -05:00
Some ( asset . line_index . clone ( ) )
2020-12-22 05:21:18 -05:00
} else {
2021-01-22 05:03:16 -05:00
None
2020-12-22 05:21:18 -05:00
}
2021-01-22 05:03:16 -05:00
} else {
2021-01-26 04:55:04 -05:00
let documents = & self . documents ;
2021-02-12 06:49:42 -05:00
if documents . contains_key ( specifier ) {
2021-01-22 05:03:16 -05:00
documents . line_index ( specifier )
} else {
2021-01-26 04:55:04 -05:00
self . sources . get_line_index ( specifier )
2021-01-22 05:03:16 -05:00
}
2021-01-26 19:32:49 -05:00
} ;
self . performance . measure ( mark ) ;
maybe_line_index
2020-12-21 08:44:26 -05:00
}
2021-04-02 02:21:07 -04:00
// TODO(@kitsonk) we really should find a better way to just return the
// content as a `&str`, or be able to get the byte at a particular offset
// which is all that this API that is consuming it is trying to do at the
// moment
/// Searches already cached assets and documents and returns its text
/// content. If not found, `None` is returned.
2021-06-07 07:38:07 -04:00
pub ( crate ) fn get_text_content (
& self ,
specifier : & ModuleSpecifier ,
) -> Option < String > {
2021-04-02 02:21:07 -04:00
if specifier . scheme ( ) = = " asset " {
self
. assets
. get ( specifier )
. map ( | o | o . clone ( ) . map ( | a | a . text ) ) ?
} else if self . documents . contains_key ( specifier ) {
self . documents . content ( specifier ) . unwrap ( )
} else {
self . sources . get_source ( specifier )
}
}
2021-06-07 07:38:07 -04:00
pub ( crate ) fn get_media_type (
& self ,
specifier : & ModuleSpecifier ,
) -> Option < MediaType > {
if specifier . scheme ( ) = = " asset " | | self . documents . contains_key ( specifier ) {
Some ( MediaType ::from ( specifier ) )
} else {
self . sources . get_media_type ( specifier )
}
}
2021-06-04 17:31:44 -04:00
pub ( crate ) async fn get_navigation_tree (
2021-01-31 22:30:41 -05:00
& mut self ,
specifier : & ModuleSpecifier ,
) -> Result < tsc ::NavigationTree , AnyError > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark (
" get_navigation_tree " ,
Some ( json! ( { " specifier " : specifier } ) ) ,
) ;
2021-06-04 17:31:44 -04:00
let maybe_navigation_tree = if specifier . scheme ( ) = = " asset " {
self
. assets
. get ( specifier )
. map ( | o | o . clone ( ) . map ( | a | a . maybe_navigation_tree ) . flatten ( ) )
. flatten ( )
} else if self . documents . contains_key ( specifier ) {
self . documents . get_navigation_tree ( specifier )
} else {
self . sources . get_navigation_tree ( specifier )
} ;
let navigation_tree = if let Some ( navigation_tree ) = maybe_navigation_tree {
navigation_tree
2021-01-31 22:30:41 -05:00
} else {
2021-02-24 22:15:55 -05:00
let navigation_tree : tsc ::NavigationTree = self
2021-02-09 04:48:53 -05:00
. ts_server
. request (
2021-05-20 05:56:48 -04:00
self . snapshot ( ) ? ,
2021-02-09 04:48:53 -05:00
tsc ::RequestMethod ::GetNavigationTree ( specifier . clone ( ) ) ,
)
. await ? ;
2021-06-04 17:31:44 -04:00
if specifier . scheme ( ) = = " asset " {
self
. assets
. set_navigation_tree ( specifier , navigation_tree . clone ( ) ) ? ;
} else if self . documents . contains_key ( specifier ) {
self
. documents
. set_navigation_tree ( specifier , navigation_tree . clone ( ) ) ? ;
} else {
self
. sources
. set_navigation_tree ( specifier , navigation_tree . clone ( ) ) ? ;
}
navigation_tree
} ;
self . performance . measure ( mark ) ;
Ok ( navigation_tree )
2021-01-31 22:30:41 -05:00
}
2021-05-20 05:56:48 -04:00
pub ( crate ) fn snapshot ( & self ) -> LspResult < StateSnapshot > {
Ok ( StateSnapshot {
2020-12-21 08:44:26 -05:00
assets : self . assets . clone ( ) ,
2021-05-20 05:56:48 -04:00
config : self . config . snapshot ( ) . map_err ( | err | {
error! ( " {} " , err ) ;
LspError ::internal_error ( )
} ) ? ,
2021-01-26 04:55:04 -05:00
documents : self . documents . clone ( ) ,
2021-04-08 21:27:27 -04:00
module_registries : self . module_registries . clone ( ) ,
2021-02-11 23:17:48 -05:00
performance : self . performance . clone ( ) ,
2020-12-21 08:44:26 -05:00
sources : self . sources . clone ( ) ,
2021-05-09 21:16:04 -04:00
url_map : self . url_map . clone ( ) ,
2021-05-20 05:56:48 -04:00
} )
2020-12-21 08:44:26 -05:00
}
2021-01-26 19:32:49 -05:00
pub async fn update_import_map ( & mut self ) -> Result < ( ) , AnyError > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " update_import_map " , None ::< ( ) > ) ;
2020-12-22 05:21:18 -05:00
let ( maybe_import_map , maybe_root_uri ) = {
2021-01-26 04:55:04 -05:00
let config = & self . config ;
2021-05-09 21:16:04 -04:00
(
2021-05-20 05:56:48 -04:00
config . get_workspace_settings ( ) . import_map ,
2021-05-09 21:16:04 -04:00
config . root_uri . clone ( ) ,
)
2020-12-22 05:21:18 -05:00
} ;
if let Some ( import_map_str ) = & maybe_import_map {
2020-12-30 22:33:44 -05:00
info! ( " Updating import map from: \" {} \" " , import_map_str ) ;
2020-12-22 05:21:18 -05:00
let import_map_url = if let Ok ( url ) = Url ::from_file_path ( import_map_str )
2020-12-21 08:44:26 -05:00
{
2020-12-22 05:21:18 -05:00
Ok ( url )
} else if let Some ( root_uri ) = & maybe_root_uri {
let root_path = root_uri
. to_file_path ( )
. map_err ( | _ | anyhow! ( " Bad root_uri: {} " , root_uri ) ) ? ;
let import_map_path = root_path . join ( import_map_str ) ;
Url ::from_file_path ( import_map_path ) . map_err ( | _ | {
anyhow! ( " Bad file path for import map: {:?} " , import_map_str )
} )
2020-12-21 08:44:26 -05:00
} else {
2020-12-22 05:21:18 -05:00
Err ( anyhow! (
" The path to the import map ( \" {} \" ) is not resolvable. " ,
import_map_str
) )
} ? ;
2021-06-08 20:00:26 -04:00
let import_map_path = import_map_url . to_file_path ( ) . map_err ( | _ | {
anyhow! ( " Cannot convert \" {} \" into a file path. " , import_map_url )
} ) ? ;
info! (
" Resolved import map: \" {} \" " ,
import_map_path . to_string_lossy ( )
) ;
2020-12-22 05:21:18 -05:00
let import_map_json =
fs ::read_to_string ( import_map_path ) . await . map_err ( | err | {
anyhow! (
" Failed to load the import map at: {}. [{}] " ,
import_map_url ,
err
)
} ) ? ;
let import_map =
ImportMap ::from_json ( & import_map_url . to_string ( ) , & import_map_json ) ? ;
2021-01-26 04:55:04 -05:00
self . maybe_import_map_uri = Some ( import_map_url ) ;
self . maybe_import_map = Some ( import_map ) ;
2020-12-21 08:44:26 -05:00
} else {
2021-01-26 04:55:04 -05:00
self . maybe_import_map = None ;
2020-12-22 05:21:18 -05:00
}
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-22 05:21:18 -05:00
Ok ( ( ) )
}
2021-05-11 00:54:10 -04:00
pub fn update_debug_flag ( & self ) -> bool {
2021-05-20 05:56:48 -04:00
let internal_debug = self . config . get_workspace_settings ( ) . internal_debug ;
2021-05-11 00:54:10 -04:00
logger ::LSP_DEBUG_FLAG
. compare_exchange (
2021-05-20 05:56:48 -04:00
! internal_debug ,
internal_debug ,
2021-05-11 00:54:10 -04:00
Ordering ::Acquire ,
Ordering ::Relaxed ,
)
. is_ok ( )
}
2021-04-08 21:27:27 -04:00
async fn update_registries ( & mut self ) -> Result < ( ) , AnyError > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " update_registries " , None ::< ( ) > ) ;
2021-05-20 05:56:48 -04:00
for ( registry , enabled ) in self
. config
. get_workspace_settings ( )
. suggest
. imports
. hosts
. iter ( )
2021-04-08 21:27:27 -04:00
{
if * enabled {
2021-06-01 07:53:08 -04:00
info! ( " Enabling import suggestions for: {} " , registry ) ;
2021-04-08 21:27:27 -04:00
self . module_registries . enable ( registry ) . await ? ;
} else {
self . module_registries . disable ( registry ) . await ? ;
}
}
self . performance . measure ( mark ) ;
Ok ( ( ) )
}
2021-01-26 04:55:04 -05:00
async fn update_tsconfig ( & mut self ) -> Result < ( ) , AnyError > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " update_tsconfig " , None ::< ( ) > ) ;
2020-12-22 05:21:18 -05:00
let mut tsconfig = TsConfig ::new ( json! ( {
" allowJs " : true ,
2021-02-05 06:01:48 -05:00
" esModuleInterop " : true ,
2020-12-22 05:21:18 -05:00
" experimentalDecorators " : true ,
" isolatedModules " : true ,
2021-02-05 06:01:48 -05:00
" jsx " : " react " ,
2020-12-22 05:21:18 -05:00
" lib " : [ " deno.ns " , " deno.window " ] ,
" module " : " esnext " ,
" noEmit " : true ,
" strict " : true ,
" target " : " esnext " ,
2021-04-10 17:56:40 -04:00
" useDefineForClassFields " : true ,
2020-12-22 05:21:18 -05:00
} ) ) ;
2020-12-30 22:33:44 -05:00
let ( maybe_config , maybe_root_uri ) = {
2021-01-26 04:55:04 -05:00
let config = & self . config ;
2021-05-20 05:56:48 -04:00
let workspace_settings = config . get_workspace_settings ( ) ;
if workspace_settings . unstable {
2020-12-22 05:21:18 -05:00
let unstable_libs = json! ( {
" lib " : [ " deno.ns " , " deno.window " , " deno.unstable " ]
} ) ;
tsconfig . merge ( & unstable_libs ) ;
2020-12-21 08:44:26 -05:00
}
2021-05-20 05:56:48 -04:00
( workspace_settings . config , config . root_uri . clone ( ) )
2020-12-30 22:33:44 -05:00
} ;
if let Some ( config_str ) = & maybe_config {
info! ( " Updating TypeScript configuration from: \" {} \" " , config_str ) ;
let config_url = if let Ok ( url ) = Url ::from_file_path ( config_str ) {
Ok ( url )
} else if let Some ( root_uri ) = & maybe_root_uri {
let root_path = root_uri
. to_file_path ( )
. map_err ( | _ | anyhow! ( " Bad root_uri: {} " , root_uri ) ) ? ;
let config_path = root_path . join ( config_str ) ;
Url ::from_file_path ( config_path ) . map_err ( | _ | {
anyhow! ( " Bad file path for configuration file: \" {} \" " , config_str )
} )
} else {
Err ( anyhow! (
" The path to the configuration file ( \" {} \" ) is not resolvable. " ,
config_str
) )
} ? ;
2021-06-08 20:00:26 -04:00
info! ( " Resolved configuration file: \" {} \" " , config_url ) ;
2021-05-10 12:16:39 -04:00
2021-06-06 01:00:17 -04:00
let config_file = {
let buffer = config_url
. to_file_path ( )
. map_err ( | _ | anyhow! ( " Bad uri: \" {} \" " , config_url ) ) ? ;
let path = buffer
. to_str ( )
. ok_or_else ( | | anyhow! ( " Bad uri: \" {} \" " , config_url ) ) ? ;
ConfigFile ::read ( path ) ?
} ;
2021-05-10 12:16:39 -04:00
let ( value , maybe_ignored_options ) = config_file . as_compiler_options ( ) ? ;
2020-12-30 22:33:44 -05:00
tsconfig . merge ( & value ) ;
2021-01-26 04:55:04 -05:00
self . maybe_config_uri = Some ( config_url ) ;
2020-12-30 22:33:44 -05:00
if let Some ( ignored_options ) = maybe_ignored_options {
// TODO(@kitsonk) turn these into diagnostics that can be sent to the
// client
warn! ( " {} " , ignored_options ) ;
}
2020-12-22 05:21:18 -05:00
}
2021-02-24 22:15:55 -05:00
let _ok : bool = self
2020-12-22 05:21:18 -05:00
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , tsc ::RequestMethod ::Configure ( tsconfig ) )
2020-12-22 05:21:18 -05:00
. await ? ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-22 05:21:18 -05:00
Ok ( ( ) )
2020-12-21 08:44:26 -05:00
}
2021-02-06 07:39:01 -05:00
pub ( crate ) fn document_version (
2021-02-11 23:17:48 -05:00
& self ,
2021-02-06 07:39:01 -05:00
specifier : ModuleSpecifier ,
) -> Option < i32 > {
self . documents . version ( & specifier )
}
2021-02-06 07:39:01 -05:00
async fn get_asset (
& mut self ,
specifier : & ModuleSpecifier ,
) -> Result < Option < AssetDocument > , AnyError > {
2021-02-06 07:39:01 -05:00
if let Some ( maybe_asset ) = self . assets . get ( specifier ) {
return Ok ( maybe_asset . clone ( ) ) ;
} else {
let maybe_asset =
2021-05-20 05:56:48 -04:00
tsc ::get_asset ( & specifier , & self . ts_server , self . snapshot ( ) ? ) . await ? ;
2021-02-06 07:39:01 -05:00
self . assets . insert ( specifier . clone ( ) , maybe_asset . clone ( ) ) ;
Ok ( maybe_asset )
}
2021-02-06 07:39:01 -05:00
}
2020-12-21 08:44:26 -05:00
}
2021-01-26 04:55:04 -05:00
// lspower::LanguageServer methods. This file's LanguageServer delegates to us.
impl Inner {
2020-12-21 08:44:26 -05:00
async fn initialize (
2021-01-26 04:55:04 -05:00
& mut self ,
2020-12-21 08:44:26 -05:00
params : InitializeParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < InitializeResult > {
2020-12-21 08:44:26 -05:00
info! ( " Starting Deno language server... " ) ;
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " initialize " , Some ( & params ) ) ;
2020-12-21 08:44:26 -05:00
let capabilities = capabilities ::server_capabilities ( & params . capabilities ) ;
let version = format! (
" {} ({}, {}) " ,
crate ::version ::deno ( ) ,
env! ( " PROFILE " ) ,
env! ( " TARGET " )
) ;
info! ( " version: {} " , version ) ;
2021-06-08 20:00:26 -04:00
if let Ok ( path ) = std ::env ::current_exe ( ) {
info! ( " executable: {} " , path . to_string_lossy ( ) ) ;
}
2020-12-21 08:44:26 -05:00
let server_info = ServerInfo {
name : " deno-language-server " . to_string ( ) ,
version : Some ( version ) ,
} ;
if let Some ( client_info ) = params . client_info {
info! (
" Connected to \" {} \" {} " ,
client_info . name ,
client_info . version . unwrap_or_default ( ) ,
) ;
}
{
2021-01-26 04:55:04 -05:00
let config = & mut self . config ;
2020-12-21 08:44:26 -05:00
config . root_uri = params . root_uri ;
if let Some ( value ) = params . initialization_options {
2021-05-20 05:56:48 -04:00
config . set_workspace_settings ( value ) . map_err ( | err | {
error! ( " Cannot set workspace settings: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-21 08:44:26 -05:00
}
config . update_capabilities ( & params . capabilities ) ;
}
2021-05-11 00:54:10 -04:00
self . update_debug_flag ( ) ;
2020-12-22 05:21:18 -05:00
if let Err ( err ) = self . update_tsconfig ( ) . await {
warn! ( " Updating tsconfig has errored: {} " , err ) ;
}
2020-12-21 08:44:26 -05:00
2021-02-04 13:53:02 -05:00
if capabilities . code_action_provider . is_some ( ) {
2021-02-24 22:15:55 -05:00
let fixable_diagnostics : Vec < String > = self
2021-02-04 13:53:02 -05:00
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , tsc ::RequestMethod ::GetSupportedCodeFixes )
2021-02-04 13:53:02 -05:00
. await
. map_err ( | err | {
error! ( " Unable to get fixable diagnostics: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
self . ts_fixable_diagnostics = fixable_diagnostics ;
}
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( InitializeResult {
capabilities ,
server_info : Some ( server_info ) ,
} )
}
2021-01-26 04:55:04 -05:00
async fn initialized ( & mut self , _ : InitializedParams ) {
2020-12-21 08:44:26 -05:00
// Check to see if we need to setup the import map
if let Err ( err ) = self . update_import_map ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2020-12-21 08:44:26 -05:00
}
2021-04-08 21:27:27 -04:00
// Check to see if we need to setup any module registries
if let Err ( err ) = self . update_registries ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2021-04-08 21:27:27 -04:00
}
2020-12-21 08:44:26 -05:00
2021-01-04 16:52:20 -05:00
if self
. config
. client_capabilities
. workspace_did_change_watched_files
2020-12-21 08:44:26 -05:00
{
2021-01-04 16:52:20 -05:00
// we are going to watch all the JSON files in the workspace, and the
// notification handler will pick up any of the changes of those files we
// are interested in.
let watch_registration_options =
DidChangeWatchedFilesRegistrationOptions {
watchers : vec ! [ FileSystemWatcher {
glob_pattern : " **/*.json " . to_string ( ) ,
kind : Some ( WatchKind ::Change ) ,
} ] ,
} ;
let registration = Registration {
id : " workspace/didChangeWatchedFiles " . to_string ( ) ,
method : " workspace/didChangeWatchedFiles " . to_string ( ) ,
register_options : Some (
serde_json ::to_value ( watch_registration_options ) . unwrap ( ) ,
) ,
} ;
if let Err ( err ) =
self . client . register_capability ( vec! [ registration ] ) . await
{
warn! ( " Client errored on capabilities. \n {} " , err ) ;
}
2020-12-21 08:44:26 -05:00
}
info! ( " Server ready. " ) ;
}
2020-12-29 23:17:17 -05:00
async fn shutdown ( & self ) -> LspResult < ( ) > {
2020-12-21 08:44:26 -05:00
Ok ( ( ) )
}
2021-01-26 04:55:04 -05:00
async fn did_open ( & mut self , params : DidOpenTextDocumentParams ) {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " did_open " , Some ( & params ) ) ;
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-05-20 05:56:48 -04:00
if let Err ( err ) = self
. config
. update_specifier_settings ( & specifier , & params . text_document . uri )
. await
{
error! ( " Error updating specifier settings: {} " , err ) ;
}
2021-05-09 21:16:04 -04:00
2020-12-21 08:44:26 -05:00
if params . text_document . uri . scheme ( ) = = " deno " {
// we can ignore virtual text documents opening, as they don't need to
// be tracked in memory, as they are static assets that won't change
// already managed by the language service
return ;
}
2021-06-02 06:29:58 -04:00
let language_id = match params . text_document . language_id . parse ( ) {
Ok ( language_id ) = > language_id ,
Err ( err ) = > {
error! ( " {} " , err ) ;
LanguageId ::TypeScript
}
} ;
2021-01-26 04:55:04 -05:00
self . documents . open (
2021-01-22 05:03:16 -05:00
specifier . clone ( ) ,
params . text_document . version ,
2021-06-02 06:29:58 -04:00
language_id ,
2021-02-09 17:46:12 -05:00
& params . text_document . text ,
2021-01-22 05:03:16 -05:00
) ;
2021-02-09 17:46:12 -05:00
2021-06-02 06:29:58 -04:00
if self . documents . is_diagnosable ( & specifier ) {
self . analyze_dependencies ( & specifier , & params . text_document . text ) ;
2021-06-03 07:13:53 -04:00
self
. diagnostics_server
. invalidate ( self . documents . dependents ( & specifier ) )
. await ;
2021-06-02 06:29:58 -04:00
if let Err ( err ) = self . diagnostics_server . update ( ) {
error! ( " {} " , err ) ;
}
2021-01-22 05:03:16 -05:00
}
2021-06-02 06:29:58 -04:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
}
2021-01-26 04:55:04 -05:00
async fn did_change ( & mut self , params : DidChangeTextDocumentParams ) {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " did_change " , Some ( & params ) ) ;
2021-02-17 23:37:05 -05:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-02-09 17:46:12 -05:00
match self . documents . change (
2021-01-22 05:03:16 -05:00
& specifier ,
params . text_document . version ,
params . content_changes ,
) {
2021-06-02 06:29:58 -04:00
Ok ( Some ( source ) ) = > {
if self . documents . is_diagnosable ( & specifier ) {
self . analyze_dependencies ( & specifier , & source ) ;
2021-06-03 07:13:53 -04:00
self
. diagnostics_server
. invalidate ( self . documents . dependents ( & specifier ) )
. await ;
2021-06-02 06:29:58 -04:00
if let Err ( err ) = self . diagnostics_server . update ( ) {
error! ( " {} " , err ) ;
}
}
}
2021-02-09 17:46:12 -05:00
Ok ( _ ) = > error! ( " No content returned from change. " ) ,
Err ( err ) = > error! ( " {} " , err ) ,
2020-12-21 08:44:26 -05:00
}
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
}
2021-01-26 04:55:04 -05:00
async fn did_close ( & mut self , params : DidCloseTextDocumentParams ) {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " did_close " , Some ( & params ) ) ;
2020-12-21 08:44:26 -05:00
if params . text_document . uri . scheme ( ) = = " deno " {
// we can ignore virtual text documents opening, as they don't need to
// be tracked in memory, as they are static assets that won't change
// already managed by the language service
return ;
}
2021-02-17 23:37:05 -05:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-01-26 04:55:04 -05:00
self . documents . close ( & specifier ) ;
2021-01-22 05:03:16 -05:00
2021-06-02 06:29:58 -04:00
if self . documents . is_diagnosable ( & specifier ) {
if let Err ( err ) = self . diagnostics_server . update ( ) {
error! ( " {} " , err ) ;
}
2020-12-21 08:44:26 -05:00
}
2021-06-02 06:29:58 -04:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
}
async fn did_change_configuration (
2021-01-26 04:55:04 -05:00
& mut self ,
2021-01-04 16:52:20 -05:00
params : DidChangeConfigurationParams ,
2020-12-21 08:44:26 -05:00
) {
2021-05-11 00:54:10 -04:00
let mark = self
. performance
. mark ( " did_change_configuration " , Some ( & params ) ) ;
2020-12-21 08:44:26 -05:00
2021-06-01 05:24:36 -04:00
let maybe_config =
if self . config . client_capabilities . workspace_configuration {
let config_response = self
. client
. configuration ( vec! [ ConfigurationItem {
scope_uri : None ,
section : Some ( SETTINGS_SECTION . to_string ( ) ) ,
} ] )
. await ;
if let Err ( err ) = self . config . update_all_settings ( ) . await {
error! ( " Cannot request updating all settings: {} " , err ) ;
}
match config_response {
Ok ( value_vec ) = > value_vec . get ( 0 ) . cloned ( ) ,
Err ( err ) = > {
error! ( " Error getting workspace configuration: {} " , err ) ;
None
}
}
} else {
params
. settings
. as_object ( )
. map ( | settings | settings . get ( SETTINGS_SECTION ) )
. flatten ( )
. cloned ( )
} ;
if let Some ( value ) = maybe_config {
if let Err ( err ) = self . config . set_workspace_settings ( value ) {
2021-05-09 21:16:04 -04:00
error! ( " failed to update settings: {} " , err ) ;
2021-02-08 05:45:46 -05:00
}
2020-12-21 08:44:26 -05:00
}
2021-05-09 21:16:04 -04:00
2021-05-11 00:54:10 -04:00
self . update_debug_flag ( ) ;
2021-05-09 21:16:04 -04:00
if let Err ( err ) = self . update_import_map ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2021-05-09 21:16:04 -04:00
}
if let Err ( err ) = self . update_registries ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2021-05-09 21:16:04 -04:00
}
if let Err ( err ) = self . update_tsconfig ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2021-05-09 21:16:04 -04:00
}
if let Err ( err ) = self . diagnostics_server . update ( ) {
error! ( " {} " , err ) ;
}
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
}
async fn did_change_watched_files (
2021-01-26 04:55:04 -05:00
& mut self ,
2020-12-21 08:44:26 -05:00
params : DidChangeWatchedFilesParams ,
) {
2021-05-11 00:54:10 -04:00
let mark = self
. performance
. mark ( " did_change_watched_files " , Some ( & params ) ) ;
2020-12-21 08:44:26 -05:00
// if the current import map has changed, we need to reload it
2021-01-26 04:55:04 -05:00
if let Some ( import_map_uri ) = & self . maybe_import_map_uri {
if params . changes . iter ( ) . any ( | fe | * import_map_uri = = fe . uri ) {
2020-12-21 08:44:26 -05:00
if let Err ( err ) = self . update_import_map ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2020-12-21 08:44:26 -05:00
}
}
}
2020-12-30 22:33:44 -05:00
// if the current tsconfig has changed, we need to reload it
2021-01-26 04:55:04 -05:00
if let Some ( config_uri ) = & self . maybe_config_uri {
if params . changes . iter ( ) . any ( | fe | * config_uri = = fe . uri ) {
2020-12-30 22:33:44 -05:00
if let Err ( err ) = self . update_tsconfig ( ) . await {
2021-06-01 07:53:08 -04:00
self . client . show_message ( MessageType ::Warning , err ) . await ;
2020-12-30 22:33:44 -05:00
}
}
}
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
}
2021-04-19 21:29:27 -04:00
async fn document_symbol (
2021-05-09 21:16:04 -04:00
& mut self ,
2021-04-19 21:29:27 -04:00
params : DocumentSymbolParams ,
) -> LspResult < Option < DocumentSymbolResponse > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-18 02:35:46 -04:00
return Ok ( None ) ;
}
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " document_symbol " , Some ( & params ) ) ;
2021-04-19 21:29:27 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let req = tsc ::RequestMethod ::GetNavigationTree ( specifier ) ;
let navigation_tree : tsc ::NavigationTree = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-19 21:29:27 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let response = if let Some ( child_items ) = navigation_tree . child_items {
let mut document_symbols = Vec ::< DocumentSymbol > ::new ( ) ;
for item in child_items {
item . collect_document_symbols ( & line_index , & mut document_symbols ) ;
}
Some ( DocumentSymbolResponse ::Nested ( document_symbols ) )
} else {
None
} ;
self . performance . measure ( mark ) ;
Ok ( response )
}
2020-12-21 08:44:26 -05:00
async fn formatting (
& self ,
params : DocumentFormattingParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < Vec < TextEdit > > > {
2021-02-17 23:37:05 -05:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_formattable ( & specifier ) {
return Ok ( None ) ;
}
let mark = self . performance . mark ( " formatting " , Some ( & params ) ) ;
2021-01-22 05:03:16 -05:00
let file_text = self
. documents
. content ( & specifier )
. map_err ( | _ | {
LspError ::invalid_params (
" The specified file could not be found in memory. " ,
)
} ) ?
. unwrap ( ) ;
2021-01-26 15:50:13 -05:00
let line_index = self . documents . line_index ( & specifier ) ;
2020-12-21 08:44:26 -05:00
let file_path =
if let Ok ( file_path ) = params . text_document . uri . to_file_path ( ) {
file_path
} else {
PathBuf ::from ( params . text_document . uri . path ( ) )
} ;
// TODO(lucacasonato): handle error properly
let text_edits = tokio ::task ::spawn_blocking ( move | | {
2021-05-18 02:35:46 -04:00
let config = get_typescript_config ( ) ;
match format_file ( & file_path , & file_text , config ) {
2021-01-26 15:50:13 -05:00
Ok ( new_text ) = > {
Some ( text ::get_edits ( & file_text , & new_text , line_index ) )
}
2020-12-21 08:44:26 -05:00
Err ( err ) = > {
warn! ( " Format error: {} " , err ) ;
None
}
}
} )
. await
. unwrap ( ) ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
if let Some ( text_edits ) = text_edits {
if text_edits . is_empty ( ) {
Ok ( None )
} else {
Ok ( Some ( text_edits ) )
}
} else {
2021-01-26 15:50:13 -05:00
self . client . show_message ( MessageType ::Warning , format! ( " Unable to format \" {} \" . Likely due to unrecoverable syntax errors in the file. " , specifier ) ) . await ;
2020-12-21 08:44:26 -05:00
Ok ( None )
}
}
2021-05-09 21:16:04 -04:00
async fn hover ( & mut self , params : HoverParams ) -> LspResult < Option < Hover > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position_params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " hover " , Some ( & params ) ) ;
2021-05-09 21:16:04 -04:00
2021-01-22 05:03:16 -05:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
2020-12-21 08:44:26 -05:00
let req = tsc ::RequestMethod ::GetQuickInfo ( (
specifier ,
2021-01-22 05:03:16 -05:00
line_index . offset_tsc ( params . text_document_position_params . position ) ? ,
2020-12-21 08:44:26 -05:00
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_quick_info : Option < tsc ::QuickInfo > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Unable to get quick info: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-21 08:44:26 -05:00
if let Some ( quick_info ) = maybe_quick_info {
2021-01-22 05:03:16 -05:00
let hover = quick_info . to_hover ( & line_index ) ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2021-01-22 05:03:16 -05:00
Ok ( Some ( hover ) )
2020-12-21 08:44:26 -05:00
} else {
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( None )
}
}
2021-02-04 13:53:02 -05:00
async fn code_action (
& mut self ,
params : CodeActionParams ,
) -> LspResult < Option < CodeActionResponse > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-02-04 13:53:02 -05:00
return Ok ( None ) ;
}
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " code_action " , Some ( & params ) ) ;
2021-02-04 13:53:02 -05: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 ,
} ,
2021-02-11 23:17:48 -05:00
" deno " = > match & d . code {
2021-02-17 23:37:05 -05:00
Some ( NumberOrString ::String ( code ) ) = > {
code = = " no-cache " | | code = = " no-cache-data "
}
2021-02-11 23:17:48 -05:00
_ = > false ,
} ,
2021-02-04 13:53:02 -05:00
_ = > false ,
} ,
None = > false ,
} )
. collect ( ) ;
if fixable_diagnostics . is_empty ( ) {
self . performance . measure ( mark ) ;
return Ok ( None ) ;
}
let line_index = self . get_line_index_sync ( & specifier ) . unwrap ( ) ;
2021-02-11 23:17:48 -05:00
let mut code_actions = CodeActionCollection ::default ( ) ;
2021-03-09 21:41:35 -05:00
let file_diagnostics = self
. diagnostics_server
2021-05-11 10:43:00 -04:00
. get ( & specifier , DiagnosticSource ::TypeScript )
. await ;
2021-02-04 13:53:02 -05:00
for diagnostic in & fixable_diagnostics {
2021-02-11 23:17:48 -05:00
match diagnostic . source . as_deref ( ) {
Some ( " deno-ts " ) = > {
let code = match diagnostic . code . as_ref ( ) . unwrap ( ) {
NumberOrString ::String ( code ) = > code . to_string ( ) ,
NumberOrString ::Number ( code ) = > code . to_string ( ) ,
} ;
let codes = vec! [ code ] ;
let req = tsc ::RequestMethod ::GetCodeFixes ( (
specifier . clone ( ) ,
line_index . offset_tsc ( diagnostic . range . start ) ? ,
line_index . offset_tsc ( diagnostic . range . end ) ? ,
codes ,
) ) ;
2021-02-24 22:15:55 -05:00
let actions : Vec < tsc ::CodeFixAction > =
2021-05-20 05:56:48 -04:00
match self . ts_server . request ( self . snapshot ( ) ? , req ) . await {
2021-04-07 05:47:31 -04:00
Ok ( items ) = > items ,
Err ( err ) = > {
// sometimes tsc reports errors when retrieving code actions
// because they don't reflect the current state of the document
// so we will log them to the output, but we won't send an error
// message back to the client.
2021-02-11 23:17:48 -05:00
error! ( " Error getting actions from TypeScript: {} " , err ) ;
2021-04-07 05:47:31 -04:00
Vec ::new ( )
}
} ;
2021-02-11 23:17:48 -05:00
for action in actions {
code_actions
2021-05-29 07:21:11 -04:00
. add_ts_fix_action ( & specifier , & action , diagnostic , self )
2021-02-11 23:17:48 -05:00
. await
. map_err ( | err | {
error! ( " Unable to convert fix: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
if code_actions . is_fix_all_action (
& action ,
diagnostic ,
& file_diagnostics ,
) {
code_actions
. add_ts_fix_all_action ( & action , & specifier , diagnostic ) ;
}
}
2021-02-04 13:53:02 -05:00
}
2021-02-11 23:17:48 -05:00
Some ( " deno " ) = > {
code_actions
. add_deno_fix_action ( diagnostic )
. map_err ( | err | {
error! ( " {} " , err ) ;
LspError ::internal_error ( )
} ) ?
}
_ = > ( ) ,
2021-02-04 13:53:02 -05:00
}
}
code_actions . set_preferred_fixes ( ) ;
let code_action_response = code_actions . get_response ( ) ;
self . performance . measure ( mark ) ;
Ok ( Some ( code_action_response ) )
}
2021-02-05 15:10:53 -05:00
async fn code_action_resolve (
2021-02-06 07:39:01 -05:00
& mut self ,
2021-02-05 15:10:53 -05:00
params : CodeAction ,
) -> LspResult < CodeAction > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " code_action_resolve " , Some ( & params ) ) ;
2021-02-24 22:15:55 -05:00
let result = if let Some ( data ) = params . data . clone ( ) {
let code_action_data : CodeActionData =
from_value ( data ) . map_err ( | err | {
error! ( " Unable to decode code action data: {} " , err ) ;
LspError ::invalid_params ( " The CodeAction's data is invalid. " )
} ) ? ;
let req = tsc ::RequestMethod ::GetCombinedCodeFix ( (
2021-05-29 07:21:11 -04:00
code_action_data . specifier . clone ( ) ,
2021-02-24 22:15:55 -05:00
json! ( code_action_data . fix_id . clone ( ) ) ,
) ) ;
let combined_code_actions : tsc ::CombinedCodeActions = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Unable to get combined fix from TypeScript: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
if combined_code_actions . commands . is_some ( ) {
error! ( " Deno does not support code actions with commands. " ) ;
Err ( LspError ::invalid_request ( ) )
2021-02-05 15:10:53 -05:00
} else {
2021-05-29 07:21:11 -04:00
let changes = if code_action_data . fix_id = = " fixMissingImport " {
fix_ts_import_changes (
& code_action_data . specifier ,
& combined_code_actions . changes ,
self ,
)
. map_err ( | err | {
error! ( " Unable to remap changes: {} " , err ) ;
LspError ::internal_error ( )
} ) ?
} else {
combined_code_actions . changes . clone ( )
} ;
2021-02-24 22:15:55 -05:00
let mut code_action = params . clone ( ) ;
code_action . edit =
2021-05-29 07:21:11 -04:00
ts_changes_to_edit ( & changes , self ) . await . map_err ( | err | {
error! ( " Unable to convert changes to edits: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2021-02-24 22:15:55 -05:00
Ok ( code_action )
}
} else {
// The code action doesn't need to be resolved
Ok ( params )
} ;
2021-02-05 15:10:53 -05:00
self . performance . measure ( mark ) ;
result
}
2021-01-31 22:30:41 -05:00
async fn code_lens (
& mut self ,
params : CodeLensParams ,
) -> LspResult < Option < Vec < CodeLens > > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
2021-06-07 07:38:07 -04:00
| | ! ( self . config . get_workspace_settings ( ) . enabled_code_lens ( )
| | self . config . specifier_code_lens_test ( & specifier ) )
2021-05-09 21:16:04 -04:00
{
2021-01-31 22:30:41 -05:00
return Ok ( None ) ;
}
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " code_lens " , Some ( & params ) ) ;
2021-06-07 07:38:07 -04:00
let code_lenses =
code_lens ::collect ( & specifier , self ) . await . map_err ( | err | {
2021-06-04 17:31:44 -04:00
error! ( " Error getting code lenses for \" {} \" : {} " , specifier , err ) ;
LspError ::internal_error ( )
2021-01-31 22:30:41 -05:00
} ) ? ;
self . performance . measure ( mark ) ;
2021-06-04 17:31:44 -04:00
Ok ( Some ( code_lenses ) )
2021-01-31 22:30:41 -05:00
}
async fn code_lens_resolve (
& mut self ,
2021-06-04 17:31:44 -04:00
code_lens : CodeLens ,
2021-01-31 22:30:41 -05:00
) -> LspResult < CodeLens > {
2021-06-04 17:31:44 -04:00
let mark = self . performance . mark ( " code_lens_resolve " , Some ( & code_lens ) ) ;
let result = if code_lens . data . is_some ( ) {
code_lens ::resolve_code_lens ( code_lens , self )
. await
. map_err ( | err | {
error! ( " Error resolving code lens: {} " , err ) ;
LspError ::internal_error ( )
} )
2021-01-31 22:30:41 -05:00
} else {
Err ( LspError ::invalid_params (
" Code lens is missing the \" data \" property. " ,
) )
2021-06-04 17:31:44 -04:00
} ;
self . performance . measure ( mark ) ;
result
2021-01-31 22:30:41 -05:00
}
2020-12-21 08:44:26 -05:00
async fn document_highlight (
2021-05-09 21:16:04 -04:00
& mut self ,
2020-12-21 08:44:26 -05:00
params : DocumentHighlightParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < Vec < DocumentHighlight > > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position_params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " document_highlight " , Some ( & params ) ) ;
2021-01-22 05:03:16 -05:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
2020-12-21 08:44:26 -05:00
let files_to_search = vec! [ specifier . clone ( ) ] ;
let req = tsc ::RequestMethod ::GetDocumentHighlights ( (
specifier ,
2021-01-22 05:03:16 -05:00
line_index . offset_tsc ( params . text_document_position_params . position ) ? ,
2020-12-21 08:44:26 -05:00
files_to_search ,
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_document_highlights : Option < Vec < tsc ::DocumentHighlights > > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Unable to get document highlights from TypeScript: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-21 08:44:26 -05:00
if let Some ( document_highlights ) = maybe_document_highlights {
2021-01-26 19:32:49 -05:00
let result = document_highlights
. into_iter ( )
. map ( | dh | dh . to_highlight ( & line_index ) )
. flatten ( )
. collect ( ) ;
self . performance . measure ( mark ) ;
Ok ( Some ( result ) )
2020-12-21 08:44:26 -05:00
} else {
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( None )
}
}
async fn references (
2021-01-26 04:55:04 -05:00
& mut self ,
2020-12-21 08:44:26 -05:00
params : ReferenceParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < Vec < Location > > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " references " , Some ( & params ) ) ;
2021-01-22 05:03:16 -05:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
2020-12-21 08:44:26 -05:00
let req = tsc ::RequestMethod ::GetReferences ( (
specifier ,
2021-01-22 05:03:16 -05:00
line_index . offset_tsc ( params . text_document_position . position ) ? ,
2020-12-21 08:44:26 -05:00
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_references : Option < Vec < tsc ::ReferenceEntry > > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Unable to get references from TypeScript: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-21 08:44:26 -05:00
if let Some ( references ) = maybe_references {
let mut results = Vec ::new ( ) ;
for reference in references {
if ! params . context . include_declaration & & reference . is_definition {
continue ;
}
let reference_specifier =
2021-02-17 13:47:18 -05:00
resolve_url ( & reference . document_span . file_name ) . unwrap ( ) ;
2020-12-21 08:44:26 -05:00
// TODO(lucacasonato): handle error correctly
let line_index =
self . get_line_index ( reference_specifier ) . await . unwrap ( ) ;
2021-02-17 23:37:05 -05:00
results . push ( reference . to_location ( & line_index , self ) ) ;
2020-12-21 08:44:26 -05:00
}
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( Some ( results ) )
} else {
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( None )
}
}
async fn goto_definition (
2021-01-26 04:55:04 -05:00
& mut self ,
2020-12-21 08:44:26 -05:00
params : GotoDefinitionParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < GotoDefinitionResponse > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position_params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " goto_definition " , Some ( & params ) ) ;
2021-01-22 05:03:16 -05:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
2020-12-21 08:44:26 -05:00
let req = tsc ::RequestMethod ::GetDefinition ( (
specifier ,
2021-01-22 05:03:16 -05:00
line_index . offset_tsc ( params . text_document_position_params . position ) ? ,
2020-12-21 08:44:26 -05:00
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_definition : Option < tsc ::DefinitionInfoAndBoundSpan > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Unable to get definition from TypeScript: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-21 08:44:26 -05:00
if let Some ( definition ) = maybe_definition {
2021-02-06 07:39:01 -05:00
let results = definition . to_definition ( & line_index , self ) . await ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
Ok ( results )
2020-12-21 08:44:26 -05:00
} else {
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( None )
}
}
async fn completion (
2021-05-09 21:16:04 -04:00
& mut self ,
2020-12-21 08:44:26 -05:00
params : CompletionParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < CompletionResponse > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " completion " , Some ( & params ) ) ;
2021-03-24 20:13:37 -04: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.
let response = if let Some ( response ) = completions ::get_import_completions (
& specifier ,
& params . text_document_position . position ,
2021-05-20 05:56:48 -04:00
& self . snapshot ( ) ? ,
2021-06-01 07:53:08 -04:00
self . client . clone ( ) ,
2021-04-08 21:27:27 -04:00
)
. await
{
2021-03-24 20:13:37 -04:00
Some ( response )
} else {
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let trigger_character = if let Some ( context ) = & params . context {
context . trigger_character . clone ( )
2021-01-22 05:03:16 -05:00
} else {
2021-03-24 20:13:37 -04:00
None
2021-01-22 05:03:16 -05:00
} ;
2021-03-24 20:13:37 -04:00
let position =
line_index . offset_tsc ( params . text_document_position . position ) ? ;
let req = tsc ::RequestMethod ::GetCompletions ( (
specifier . clone ( ) ,
position ,
tsc ::GetCompletionsAtPositionOptions {
user_preferences : tsc ::UserPreferences {
include_completions_with_insert_text : Some ( true ) ,
.. Default ::default ( )
} ,
trigger_character ,
2021-03-15 18:01:41 -04:00
} ,
2021-03-24 20:13:37 -04:00
) ) ;
let maybe_completion_info : Option < tsc ::CompletionInfo > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-03-24 20:13:37 -04:00
. await
. map_err ( | err | {
error! ( " Unable to get completion info from TypeScript: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-21 08:44:26 -05:00
2021-03-24 20:13:37 -04:00
if let Some ( completions ) = maybe_completion_info {
let results = completions . as_completion_response (
& line_index ,
2021-05-20 05:56:48 -04:00
& self . config . get_workspace_settings ( ) . suggest ,
2021-03-24 20:13:37 -04:00
& specifier ,
position ,
) ;
Some ( results )
} else {
None
}
} ;
self . performance . measure ( mark ) ;
Ok ( response )
2020-12-21 08:44:26 -05:00
}
2021-03-15 18:01:41 -04:00
async fn completion_resolve (
& mut self ,
params : CompletionItem ,
) -> LspResult < CompletionItem > {
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " completion_resolve " , Some ( & params ) ) ;
2021-03-24 20:13:37 -04:00
let completion_item = if let Some ( data ) = & params . data {
let data : completions ::CompletionItemData =
serde_json ::from_value ( data . clone ( ) ) . map_err ( | err | {
2021-03-15 18:01:41 -04:00
error! ( " {} " , err ) ;
LspError ::invalid_params (
" Could not decode data field of completion item. " ,
)
} ) ? ;
2021-03-24 20:13:37 -04:00
if let Some ( data ) = data . tsc {
let req = tsc ::RequestMethod ::GetCompletionDetails ( data . into ( ) ) ;
2021-05-20 05:56:48 -04:00
let maybe_completion_info : Option < tsc ::CompletionEntryDetails > = self
. ts_server
. request ( self . snapshot ( ) ? , req )
. await
. map_err ( | err | {
error! ( " Unable to get completion info from TypeScript: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2021-03-24 20:13:37 -04:00
if let Some ( completion_info ) = maybe_completion_info {
completion_info . as_completion_item ( & params )
} else {
error! (
" Received an undefined response from tsc for completion details. "
) ;
params
}
2021-03-15 18:01:41 -04:00
} else {
2021-03-24 20:13:37 -04:00
params
2021-03-15 18:01:41 -04:00
}
} else {
2021-03-24 20:13:37 -04:00
params
} ;
self . performance . measure ( mark ) ;
Ok ( completion_item )
2021-03-15 18:01:41 -04:00
}
2021-01-12 16:53:27 -05:00
async fn goto_implementation (
2021-02-06 07:39:01 -05:00
& mut self ,
2021-01-12 16:53:27 -05:00
params : GotoImplementationParams ,
) -> LspResult < Option < GotoImplementationResponse > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position_params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " goto_implementation " , Some ( & params ) ) ;
2021-01-12 16:53:27 -05:00
let line_index =
2021-01-22 05:03:16 -05:00
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
2021-01-12 16:53:27 -05:00
let req = tsc ::RequestMethod ::GetImplementation ( (
specifier ,
2021-01-22 05:03:16 -05:00
line_index . offset_tsc ( params . text_document_position_params . position ) ? ,
2021-01-12 16:53:27 -05:00
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_implementations : Option < Vec < tsc ::ImplementationLocation > > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
2021-01-12 16:53:27 -05:00
. map_err ( | err | {
2021-02-24 22:15:55 -05:00
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
2021-01-12 16:53:27 -05:00
} ) ? ;
2021-02-17 22:15:13 -05:00
let result = if let Some ( implementations ) = maybe_implementations {
let mut links = Vec ::new ( ) ;
for implementation in implementations {
if let Some ( link ) = implementation . to_link ( & line_index , self ) . await {
links . push ( link )
2021-01-12 16:53:27 -05:00
}
}
2021-02-17 22:15:13 -05:00
Some ( GotoDefinitionResponse ::Link ( links ) )
2021-01-12 16:53:27 -05:00
} else {
2021-02-17 22:15:13 -05:00
None
} ;
self . performance . measure ( mark ) ;
Ok ( result )
2021-01-12 16:53:27 -05:00
}
2021-04-02 02:21:07 -04:00
async fn folding_range (
2021-05-09 21:16:04 -04:00
& mut self ,
2021-04-02 02:21:07 -04:00
params : FoldingRangeParams ,
) -> LspResult < Option < Vec < FoldingRange > > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-04-02 02:21:07 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
let mark = self . performance . mark ( " folding_range " , Some ( & params ) ) ;
2021-04-02 02:21:07 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let req = tsc ::RequestMethod ::GetOutliningSpans ( specifier . clone ( ) ) ;
let outlining_spans : Vec < tsc ::OutliningSpan > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-02 02:21:07 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let response = if ! outlining_spans . is_empty ( ) {
let text_content =
self . get_text_content ( & specifier ) . ok_or_else ( | | {
LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) )
} ) ? ;
Some (
outlining_spans
. iter ( )
. map ( | span | {
span . to_folding_range (
& line_index ,
text_content . as_str ( ) . as_bytes ( ) ,
self . config . client_capabilities . line_folding_only ,
)
} )
. collect ::< Vec < FoldingRange > > ( ) ,
)
} else {
None
} ;
self . performance . measure ( mark ) ;
Ok ( response )
}
2021-04-19 01:11:26 -04:00
async fn incoming_calls (
& mut self ,
params : CallHierarchyIncomingCallsParams ,
) -> LspResult < Option < Vec < CallHierarchyIncomingCall > > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . item . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-04-19 01:11:26 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
let mark = self . performance . mark ( " incoming_calls " , Some ( & params ) ) ;
2021-04-19 01:11:26 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let req = tsc ::RequestMethod ::ProvideCallHierarchyIncomingCalls ( (
specifier . clone ( ) ,
line_index . offset_tsc ( params . item . selection_range . start ) ? ,
) ) ;
let incoming_calls : Vec < tsc ::CallHierarchyIncomingCall > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-19 01:11:26 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let maybe_root_path_owned = self
. config
. root_uri
. as_ref ( )
. and_then ( | uri | uri . to_file_path ( ) . ok ( ) ) ;
let mut resolved_items = Vec ::< CallHierarchyIncomingCall > ::new ( ) ;
for item in incoming_calls . iter ( ) {
if let Some ( resolved ) = item
. try_resolve_call_hierarchy_incoming_call (
self ,
maybe_root_path_owned . as_deref ( ) ,
)
. await
{
resolved_items . push ( resolved ) ;
}
}
self . performance . measure ( mark ) ;
Ok ( Some ( resolved_items ) )
}
async fn outgoing_calls (
& mut self ,
params : CallHierarchyOutgoingCallsParams ,
) -> LspResult < Option < Vec < CallHierarchyOutgoingCall > > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . item . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-04-19 01:11:26 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
let mark = self . performance . mark ( " outgoing_calls " , Some ( & params ) ) ;
2021-04-19 01:11:26 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let req = tsc ::RequestMethod ::ProvideCallHierarchyOutgoingCalls ( (
specifier . clone ( ) ,
line_index . offset_tsc ( params . item . selection_range . start ) ? ,
) ) ;
let outgoing_calls : Vec < tsc ::CallHierarchyOutgoingCall > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-19 01:11:26 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let maybe_root_path_owned = self
. config
. root_uri
. as_ref ( )
. and_then ( | uri | uri . to_file_path ( ) . ok ( ) ) ;
let mut resolved_items = Vec ::< CallHierarchyOutgoingCall > ::new ( ) ;
for item in outgoing_calls . iter ( ) {
if let Some ( resolved ) = item
. try_resolve_call_hierarchy_outgoing_call (
& line_index ,
self ,
maybe_root_path_owned . as_deref ( ) ,
)
. await
{
resolved_items . push ( resolved ) ;
}
}
self . performance . measure ( mark ) ;
Ok ( Some ( resolved_items ) )
}
async fn prepare_call_hierarchy (
& mut self ,
params : CallHierarchyPrepareParams ,
) -> LspResult < Option < Vec < CallHierarchyItem > > > {
let specifier = self
. url_map
. normalize_url ( & params . text_document_position_params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self
. performance
. mark ( " prepare_call_hierarchy " , Some ( & params ) ) ;
2021-04-19 01:11:26 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let req = tsc ::RequestMethod ::PrepareCallHierarchy ( (
specifier . clone ( ) ,
line_index . offset_tsc ( params . text_document_position_params . position ) ? ,
) ) ;
let maybe_one_or_many : Option < tsc ::OneOrMany < tsc ::CallHierarchyItem > > =
self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-19 01:11:26 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let response = if let Some ( one_or_many ) = maybe_one_or_many {
let maybe_root_path_owned = self
. config
. root_uri
. as_ref ( )
. and_then ( | uri | uri . to_file_path ( ) . ok ( ) ) ;
let mut resolved_items = Vec ::< CallHierarchyItem > ::new ( ) ;
match one_or_many {
tsc ::OneOrMany ::One ( item ) = > {
if let Some ( resolved ) = item
. try_resolve_call_hierarchy_item (
self ,
maybe_root_path_owned . as_deref ( ) ,
)
. await
{
resolved_items . push ( resolved )
}
}
tsc ::OneOrMany ::Many ( items ) = > {
for item in items . iter ( ) {
if let Some ( resolved ) = item
. try_resolve_call_hierarchy_item (
self ,
maybe_root_path_owned . as_deref ( ) ,
)
. await
{
resolved_items . push ( resolved ) ;
}
}
}
}
Some ( resolved_items )
} else {
None
} ;
self . performance . measure ( mark ) ;
Ok ( response )
}
2020-12-29 19:58:20 -05:00
async fn rename (
2021-02-06 07:39:01 -05:00
& mut self ,
2020-12-29 19:58:20 -05:00
params : RenameParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < WorkspaceEdit > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2020-12-29 19:58:20 -05:00
2021-06-02 06:29:58 -04:00
let mark = self . performance . mark ( " rename " , Some ( & params ) ) ;
2020-12-29 19:58:20 -05:00
let line_index =
2021-01-22 05:03:16 -05:00
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
2020-12-29 19:58:20 -05:00
let req = tsc ::RequestMethod ::FindRenameLocations ( (
specifier ,
2021-01-22 05:03:16 -05:00
line_index . offset_tsc ( params . text_document_position . position ) ? ,
2020-12-29 19:58:20 -05:00
true ,
true ,
false ,
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_locations : Option < Vec < tsc ::RenameLocation > > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
2020-12-29 19:58:20 -05:00
2021-01-22 05:03:16 -05:00
if let Some ( locations ) = maybe_locations {
let rename_locations = tsc ::RenameLocations { locations } ;
let workspace_edits = rename_locations
2021-02-06 07:39:01 -05:00
. into_workspace_edit ( & params . new_name , self )
2021-01-22 05:03:16 -05:00
. await
. map_err ( | err | {
2021-02-09 04:48:53 -05:00
error! ( " Failed to get workspace edits: {} " , err ) ;
2021-01-22 05:03:16 -05:00
LspError ::internal_error ( )
} ) ? ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2021-01-22 05:03:16 -05:00
Ok ( Some ( workspace_edits ) )
} else {
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2021-01-22 05:03:16 -05:00
Ok ( None )
2020-12-29 19:58:20 -05:00
}
}
2020-12-21 08:44:26 -05:00
async fn request_else (
2021-01-26 04:55:04 -05:00
& mut self ,
2020-12-21 08:44:26 -05:00
method : & str ,
params : Option < Value > ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < Value > > {
2020-12-21 08:44:26 -05:00
match method {
2021-06-01 07:53:08 -04:00
lsp_custom ::CACHE_REQUEST = > match params . map ( serde_json ::from_value ) {
2021-04-08 21:27:27 -04:00
Some ( Ok ( params ) ) = > self . cache ( params ) . await ,
2020-12-29 23:17:17 -05:00
Some ( Err ( err ) ) = > Err ( LspError ::invalid_params ( err . to_string ( ) ) ) ,
None = > Err ( LspError ::invalid_params ( " Missing parameters " ) ) ,
} ,
2021-06-01 07:53:08 -04:00
lsp_custom ::PERFORMANCE_REQUEST = > Ok ( Some ( self . get_performance ( ) ) ) ,
lsp_custom ::RELOAD_IMPORT_REGISTRIES_REQUEST = > {
self . reload_import_registries ( ) . await
}
lsp_custom ::VIRTUAL_TEXT_DOCUMENT = > {
match params . map ( serde_json ::from_value ) {
Some ( Ok ( params ) ) = > Ok ( Some (
serde_json ::to_value ( self . virtual_text_document ( params ) . await ? )
. map_err ( | err | {
error! (
" Failed to serialize virtual_text_document response: {} " ,
err
) ;
LspError ::internal_error ( )
} ) ? ,
) ) ,
Some ( Err ( err ) ) = > Err ( LspError ::invalid_params ( err . to_string ( ) ) ) ,
None = > Err ( LspError ::invalid_params ( " Missing parameters " ) ) ,
}
}
2020-12-21 08:44:26 -05:00
_ = > {
error! ( " Got a {} request, but no handler is defined " , method ) ;
2020-12-29 23:17:17 -05:00
Err ( LspError ::method_not_found ( ) )
2020-12-21 08:44:26 -05:00
}
}
}
2021-02-15 21:34:09 -05:00
2021-03-23 19:33:25 -04:00
async fn selection_range (
2021-05-09 21:16:04 -04:00
& mut self ,
2021-03-23 19:33:25 -04:00
params : SelectionRangeParams ,
) -> LspResult < Option < Vec < SelectionRange > > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-03-23 19:33:25 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
let mark = self . performance . mark ( " selection_range " , Some ( & params ) ) ;
2021-03-23 19:33:25 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let mut selection_ranges = Vec ::< SelectionRange > ::new ( ) ;
for position in params . positions {
let req = tsc ::RequestMethod ::GetSmartSelectionRange ( (
specifier . clone ( ) ,
line_index . offset_tsc ( position ) ? ,
) ) ;
let selection_range : tsc ::SelectionRange = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-03-23 19:33:25 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
selection_ranges . push ( selection_range . to_selection_range ( & line_index ) ) ;
}
self . performance . measure ( mark ) ;
Ok ( Some ( selection_ranges ) )
}
2021-04-19 21:26:36 -04:00
async fn semantic_tokens_full (
2021-05-09 21:16:04 -04:00
& mut self ,
2021-04-19 21:26:36 -04:00
params : SemanticTokensParams ,
) -> LspResult < Option < SemanticTokensResult > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-04-19 21:26:36 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
let mark = self . performance . mark ( " semantic_tokens_full " , Some ( & params ) ) ;
2021-04-19 21:26:36 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let req = tsc ::RequestMethod ::GetEncodedSemanticClassifications ( (
specifier . clone ( ) ,
tsc ::TextSpan {
start : 0 ,
length : line_index . text_content_length_utf16 ( ) . into ( ) ,
} ,
) ) ;
let semantic_classification : tsc ::Classifications = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-19 21:26:36 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let semantic_tokens : SemanticTokens =
semantic_classification . to_semantic_tokens ( & line_index ) ;
let response = if ! semantic_tokens . data . is_empty ( ) {
Some ( SemanticTokensResult ::Tokens ( semantic_tokens ) )
} else {
None
} ;
self . performance . measure ( mark ) ;
Ok ( response )
}
async fn semantic_tokens_range (
2021-05-09 21:16:04 -04:00
& mut self ,
2021-04-19 21:26:36 -04:00
params : SemanticTokensRangeParams ,
) -> LspResult < Option < SemanticTokensRangeResult > > {
2021-05-09 21:16:04 -04:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-04-19 21:26:36 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self
. performance
. mark ( " semantic_tokens_range " , Some ( & params ) ) ;
2021-04-19 21:26:36 -04:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let start = line_index . offset_tsc ( params . range . start ) ? ;
let length = line_index . offset_tsc ( params . range . end ) ? - start ;
let req = tsc ::RequestMethod ::GetEncodedSemanticClassifications ( (
specifier . clone ( ) ,
tsc ::TextSpan { start , length } ,
) ) ;
let semantic_classification : tsc ::Classifications = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-04-19 21:26:36 -04:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver {} " , err ) ;
LspError ::invalid_request ( )
} ) ? ;
let semantic_tokens : SemanticTokens =
semantic_classification . to_semantic_tokens ( & line_index ) ;
let response = if ! semantic_tokens . data . is_empty ( ) {
Some ( SemanticTokensRangeResult ::Tokens ( semantic_tokens ) )
} else {
None
} ;
self . performance . measure ( mark ) ;
Ok ( response )
}
2021-02-15 21:34:09 -05:00
async fn signature_help (
2021-05-09 21:16:04 -04:00
& mut self ,
2021-02-15 21:34:09 -05:00
params : SignatureHelpParams ,
) -> LspResult < Option < SignatureHelp > > {
2021-02-17 23:37:05 -05:00
let specifier = self
. url_map
. normalize_url ( & params . text_document_position_params . text_document . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & specifier )
| | ! self . config . specifier_enabled ( & specifier )
{
2021-05-09 21:16:04 -04:00
return Ok ( None ) ;
}
2021-06-02 06:29:58 -04:00
2021-05-11 00:54:10 -04:00
let mark = self . performance . mark ( " signature_help " , Some ( & params ) ) ;
2021-02-15 21:34:09 -05:00
let line_index =
if let Some ( line_index ) = self . get_line_index_sync ( & specifier ) {
line_index
} else {
return Err ( LspError ::invalid_params ( format! (
" An unexpected specifier ({}) was provided. " ,
specifier
) ) ) ;
} ;
let options = if let Some ( context ) = params . context {
tsc ::SignatureHelpItemsOptions {
trigger_reason : Some ( tsc ::SignatureHelpTriggerReason {
kind : context . trigger_kind . into ( ) ,
trigger_character : context . trigger_character ,
} ) ,
}
} else {
tsc ::SignatureHelpItemsOptions {
trigger_reason : None ,
}
} ;
let req = tsc ::RequestMethod ::GetSignatureHelpItems ( (
specifier ,
line_index . offset_tsc ( params . text_document_position_params . position ) ? ,
options ,
) ) ;
2021-02-24 22:15:55 -05:00
let maybe_signature_help_items : Option < tsc ::SignatureHelpItems > = self
. ts_server
2021-05-20 05:56:48 -04:00
. request ( self . snapshot ( ) ? , req )
2021-02-24 22:15:55 -05:00
. await
. map_err ( | err | {
error! ( " Failed to request to tsserver: {} " , err ) ;
LspError ::invalid_request ( )
2021-02-15 21:34:09 -05:00
} ) ? ;
if let Some ( signature_help_items ) = maybe_signature_help_items {
let signature_help = signature_help_items . into_signature_help ( ) ;
self . performance . measure ( mark ) ;
Ok ( Some ( signature_help ) )
} else {
self . performance . measure ( mark ) ;
Ok ( None )
}
}
2020-12-21 08:44:26 -05:00
}
2021-01-26 04:55:04 -05:00
#[ lspower::async_trait ]
impl lspower ::LanguageServer for LanguageServer {
async fn initialize (
& self ,
params : InitializeParams ,
) -> LspResult < InitializeResult > {
2021-03-09 21:41:35 -05:00
let mut language_server = self . 0. lock ( ) . await ;
let client = language_server . client . clone ( ) ;
let ts_server = language_server . ts_server . clone ( ) ;
language_server
. diagnostics_server
. start ( self . 0. clone ( ) , client , ts_server ) ;
language_server . initialize ( params ) . await
2021-01-26 04:55:04 -05:00
}
async fn initialized ( & self , params : InitializedParams ) {
self . 0. lock ( ) . await . initialized ( params ) . await
}
async fn shutdown ( & self ) -> LspResult < ( ) > {
self . 0. lock ( ) . await . shutdown ( ) . await
}
async fn did_open ( & self , params : DidOpenTextDocumentParams ) {
self . 0. lock ( ) . await . did_open ( params ) . await
}
async fn did_change ( & self , params : DidChangeTextDocumentParams ) {
self . 0. lock ( ) . await . did_change ( params ) . await
}
2021-02-09 17:46:12 -05:00
async fn did_save ( & self , _params : DidSaveTextDocumentParams ) {
// We don't need to do anything on save at the moment, but if this isn't
// implemented, lspower complains about it not being implemented.
}
2021-01-26 04:55:04 -05:00
async fn did_close ( & self , params : DidCloseTextDocumentParams ) {
self . 0. lock ( ) . await . did_close ( params ) . await
}
async fn did_change_configuration (
& self ,
params : DidChangeConfigurationParams ,
) {
self . 0. lock ( ) . await . did_change_configuration ( params ) . await
}
async fn did_change_watched_files (
& self ,
params : DidChangeWatchedFilesParams ,
) {
self . 0. lock ( ) . await . did_change_watched_files ( params ) . await
}
2021-04-19 21:29:27 -04:00
async fn document_symbol (
& self ,
params : DocumentSymbolParams ,
) -> LspResult < Option < DocumentSymbolResponse > > {
self . 0. lock ( ) . await . document_symbol ( params ) . await
}
2021-01-26 04:55:04 -05:00
async fn formatting (
& self ,
params : DocumentFormattingParams ,
) -> LspResult < Option < Vec < TextEdit > > > {
self . 0. lock ( ) . await . formatting ( params ) . await
}
async fn hover ( & self , params : HoverParams ) -> LspResult < Option < Hover > > {
self . 0. lock ( ) . await . hover ( params ) . await
}
2021-02-04 13:53:02 -05:00
async fn code_action (
& self ,
params : CodeActionParams ,
) -> LspResult < Option < CodeActionResponse > > {
self . 0. lock ( ) . await . code_action ( params ) . await
}
2021-02-05 15:10:53 -05:00
async fn code_action_resolve (
& self ,
params : CodeAction ,
) -> LspResult < CodeAction > {
self . 0. lock ( ) . await . code_action_resolve ( params ) . await
}
2021-01-31 22:30:41 -05:00
async fn code_lens (
& self ,
params : CodeLensParams ,
) -> LspResult < Option < Vec < CodeLens > > > {
self . 0. lock ( ) . await . code_lens ( params ) . await
}
async fn code_lens_resolve ( & self , params : CodeLens ) -> LspResult < CodeLens > {
self . 0. lock ( ) . await . code_lens_resolve ( params ) . await
}
2021-01-26 04:55:04 -05:00
async fn document_highlight (
& self ,
params : DocumentHighlightParams ,
) -> LspResult < Option < Vec < DocumentHighlight > > > {
self . 0. lock ( ) . await . document_highlight ( params ) . await
}
async fn references (
& self ,
params : ReferenceParams ,
) -> LspResult < Option < Vec < Location > > > {
self . 0. lock ( ) . await . references ( params ) . await
}
async fn goto_definition (
& self ,
params : GotoDefinitionParams ,
) -> LspResult < Option < GotoDefinitionResponse > > {
self . 0. lock ( ) . await . goto_definition ( params ) . await
}
async fn completion (
& self ,
params : CompletionParams ,
) -> LspResult < Option < CompletionResponse > > {
self . 0. lock ( ) . await . completion ( params ) . await
}
2021-03-15 18:01:41 -04:00
async fn completion_resolve (
& self ,
params : CompletionItem ,
) -> LspResult < CompletionItem > {
self . 0. lock ( ) . await . completion_resolve ( params ) . await
}
2021-01-26 04:55:04 -05:00
async fn goto_implementation (
& self ,
params : GotoImplementationParams ,
) -> LspResult < Option < GotoImplementationResponse > > {
self . 0. lock ( ) . await . goto_implementation ( params ) . await
}
2021-04-02 02:21:07 -04:00
async fn folding_range (
& self ,
params : FoldingRangeParams ,
) -> LspResult < Option < Vec < FoldingRange > > > {
self . 0. lock ( ) . await . folding_range ( params ) . await
}
2021-04-19 01:11:26 -04:00
async fn incoming_calls (
& self ,
params : CallHierarchyIncomingCallsParams ,
) -> LspResult < Option < Vec < CallHierarchyIncomingCall > > > {
self . 0. lock ( ) . await . incoming_calls ( params ) . await
}
async fn outgoing_calls (
& self ,
params : CallHierarchyOutgoingCallsParams ,
) -> LspResult < Option < Vec < CallHierarchyOutgoingCall > > > {
self . 0. lock ( ) . await . outgoing_calls ( params ) . await
}
async fn prepare_call_hierarchy (
& self ,
params : CallHierarchyPrepareParams ,
) -> LspResult < Option < Vec < CallHierarchyItem > > > {
self . 0. lock ( ) . await . prepare_call_hierarchy ( params ) . await
}
2021-01-26 04:55:04 -05:00
async fn rename (
& self ,
params : RenameParams ,
) -> LspResult < Option < WorkspaceEdit > > {
self . 0. lock ( ) . await . rename ( params ) . await
}
async fn request_else (
& self ,
method : & str ,
params : Option < Value > ,
) -> LspResult < Option < Value > > {
self . 0. lock ( ) . await . request_else ( method , params ) . await
}
2021-02-15 21:34:09 -05:00
2021-03-23 19:33:25 -04:00
async fn selection_range (
& self ,
params : SelectionRangeParams ,
) -> LspResult < Option < Vec < SelectionRange > > > {
self . 0. lock ( ) . await . selection_range ( params ) . await
}
2021-04-19 21:26:36 -04:00
async fn semantic_tokens_full (
& self ,
params : SemanticTokensParams ,
) -> LspResult < Option < SemanticTokensResult > > {
self . 0. lock ( ) . await . semantic_tokens_full ( params ) . await
}
async fn semantic_tokens_range (
& self ,
params : SemanticTokensRangeParams ,
) -> LspResult < Option < SemanticTokensRangeResult > > {
self . 0. lock ( ) . await . semantic_tokens_range ( params ) . await
}
2021-02-15 21:34:09 -05:00
async fn signature_help (
& self ,
params : SignatureHelpParams ,
) -> LspResult < Option < SignatureHelp > > {
self . 0. lock ( ) . await . signature_help ( params ) . await
}
2021-01-26 04:55:04 -05:00
}
2021-02-04 13:53:02 -05:00
// These are implementations of custom commands supported by the LSP
2021-01-26 04:55:04 -05:00
impl Inner {
2021-02-11 23:17:48 -05:00
/// Similar to `deno cache` on the command line, where modules will be cached
/// in the Deno cache, including any of their dependencies.
2021-06-01 07:53:08 -04:00
async fn cache (
& mut self ,
params : lsp_custom ::CacheParams ,
) -> LspResult < Option < Value > > {
2021-02-17 23:37:05 -05:00
let referrer = self . url_map . normalize_url ( & params . referrer . uri ) ;
2021-06-02 06:29:58 -04:00
if ! self . documents . is_diagnosable ( & referrer ) {
return Ok ( None ) ;
}
let mark = self . performance . mark ( " cache " , Some ( & params ) ) ;
2021-02-11 23:17:48 -05:00
if ! params . uris . is_empty ( ) {
for identifier in & params . uris {
2021-02-17 23:37:05 -05:00
let specifier = self . url_map . normalize_url ( & identifier . uri ) ;
2021-02-11 23:17:48 -05:00
sources ::cache ( & specifier , & self . maybe_import_map )
. await
. map_err ( | err | {
error! ( " {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
}
} else {
sources ::cache ( & referrer , & self . maybe_import_map )
. await
. map_err ( | err | {
error! ( " {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2020-12-29 23:17:17 -05:00
}
2021-02-11 23:17:48 -05:00
// now that we have dependencies loaded, we need to re-analyze them and
// invalidate some diagnostics
2021-02-12 06:49:42 -05:00
if self . documents . contains_key ( & referrer ) {
2021-02-11 23:17:48 -05:00
if let Some ( source ) = self . documents . content ( & referrer ) . unwrap ( ) {
self . analyze_dependencies ( & referrer , & source ) ;
}
2021-06-03 07:13:53 -04:00
self . diagnostics_server . invalidate ( vec! [ referrer ] ) . await ;
2021-02-11 23:17:48 -05:00
}
2021-03-09 21:41:35 -05:00
self . diagnostics_server . update ( ) . map_err ( | err | {
2020-12-29 23:17:17 -05:00
error! ( " {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2021-04-08 21:27:27 -04:00
Ok ( Some ( json! ( true ) ) )
2020-12-29 23:17:17 -05:00
}
2021-02-12 05:08:36 -05:00
fn get_performance ( & self ) -> Value {
2021-01-26 19:32:49 -05:00
let averages = self . performance . averages ( ) ;
2021-02-12 05:08:36 -05:00
json! ( { " averages " : averages } )
2021-01-26 19:32:49 -05:00
}
2021-04-08 21:27:27 -04:00
async fn reload_import_registries ( & mut self ) -> LspResult < Option < Value > > {
fs ::remove_dir_all ( & self . module_registries_location )
. await
. map_err ( | err | {
error! ( " Unable to remove registries cache: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
self . module_registries =
registries ::ModuleRegistry ::new ( & self . module_registries_location ) ;
self . update_registries ( ) . await . map_err ( | err | {
error! ( " Unable to update registries: {} " , err ) ;
LspError ::internal_error ( )
} ) ? ;
Ok ( Some ( json! ( true ) ) )
}
2020-12-21 08:44:26 -05:00
async fn virtual_text_document (
2021-02-06 07:39:01 -05:00
& mut self ,
2021-06-01 07:53:08 -04:00
params : lsp_custom ::VirtualTextDocumentParams ,
2020-12-29 23:17:17 -05:00
) -> LspResult < Option < String > > {
2021-05-11 00:54:10 -04:00
let mark = self
. performance
. mark ( " virtual_text_document " , Some ( & params ) ) ;
2021-02-17 23:37:05 -05:00
let specifier = self . url_map . normalize_url ( & params . text_document . uri ) ;
2021-02-17 13:47:18 -05:00
let contents = if specifier . as_str ( ) = = " deno:/status.md " {
2021-01-26 19:32:49 -05:00
let mut contents = String ::new ( ) ;
2021-04-19 17:10:43 -04:00
let mut documents_specifiers = self . documents . specifiers ( ) ;
documents_specifiers . sort ( ) ;
let mut sources_specifiers = self . sources . specifiers ( ) ;
sources_specifiers . sort ( ) ;
let measures = self . performance . to_vec ( ) ;
2021-01-26 19:32:49 -05:00
contents . push_str ( & format! (
2020-12-21 08:44:26 -05:00
r #" # Deno Language Server Status
2021-01-04 16:52:20 -05:00
2021-04-19 17:10:43 -04:00
- < details > < summary > Documents in memory : { } < / summary >
- { }
< / details >
- < details > < summary > Sources in memory : { } < / summary >
- { }
2021-04-20 22:41:24 -04:00
2021-04-19 17:10:43 -04:00
< / details >
- < details > < summary > Performance measures : { } < / summary >
- { }
< / details >
2021-01-26 19:32:49 -05:00
" #,
2021-04-19 17:10:43 -04:00
self . documents . len ( ) ,
documents_specifiers
. into_iter ( )
. map ( | s | s . to_string ( ) )
. collect ::< Vec < String > > ( )
. join ( " \n - " ) ,
self . sources . len ( ) ,
sources_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 - " )
2021-01-26 19:32:49 -05:00
) ) ;
2021-04-19 17:10:43 -04:00
contents
. push_str ( " \n ## Performance \n \n |Name|Duration|Count| \n |---|---|---| \n " ) ;
let mut averages = self . performance . averages ( ) ;
averages . sort ( ) ;
for average in averages {
2021-01-26 19:32:49 -05:00
contents . push_str ( & format! (
2021-04-19 17:10:43 -04:00
" |{}|{}ms|{}| \n " ,
2021-01-26 19:32:49 -05:00
average . name , average . average_duration , average . count
) ) ;
}
Some ( contents )
2020-12-21 08:44:26 -05:00
} else {
2021-02-17 13:47:18 -05:00
match specifier . scheme ( ) {
2020-12-21 08:44:26 -05:00
" asset " = > {
2021-02-06 07:39:01 -05:00
if let Some ( asset ) = self
. get_asset ( & specifier )
. await
. map_err ( | _ | LspError ::internal_error ( ) ) ?
{
Some ( asset . text )
2020-12-21 08:44:26 -05:00
} else {
2021-02-06 07:39:01 -05:00
error! ( " Missing asset: {} " , specifier ) ;
None
2020-12-21 08:44:26 -05:00
}
}
_ = > {
2021-02-15 04:32:06 -05:00
if let Some ( source ) = self . sources . get_source ( & specifier ) {
Some ( source )
2020-12-21 08:44:26 -05:00
} else {
2021-04-06 07:45:53 -04:00
error! ( " The cached source was not found: {} " , specifier ) ;
2020-12-21 08:44:26 -05:00
None
}
}
}
} ;
2021-01-26 19:32:49 -05:00
self . performance . measure ( mark ) ;
2020-12-21 08:44:26 -05:00
Ok ( contents )
}
}