crates/rust-analyzer/src/caps.rs

   1 //! Advertizes the capabilities of the LSP Server.
   2 use std::env;
   3
   4 use ide::CompletionResolveCapability;
   5 use lsp_types::{
   6     CallHierarchyServerCapability, ClientCapabilities, CodeActionKind, CodeActionOptions,
   7     CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
   8     DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability, HoverProviderCapability,
   9     ImplementationProviderCapability, OneOf, RenameOptions, SaveOptions,
  10     SelectionRangeProviderCapability, SemanticTokensFullOptions, SemanticTokensLegend,
  11     SemanticTokensOptions, ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability,
  12     TextDocumentSyncKind, TextDocumentSyncOptions, TypeDefinitionProviderCapability,
  13     WorkDoneProgressOptions,
  14 };
  15 use rustc_hash::FxHashSet;
  16 use serde_json::json;
  17
  18 use crate::semantic_tokens;
  19
  20 pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabilities {
  21     ServerCapabilities {
  22         text_document_sync: Some(TextDocumentSyncCapability::Options(TextDocumentSyncOptions {
  23             open_close: Some(true),
  24             change: Some(if env::var("RA_NO_INCREMENTAL_SYNC").is_ok() {
  25                 TextDocumentSyncKind::Full
  26             } else {
  27                 TextDocumentSyncKind::Incremental
  28             }),
  29             will_save: None,
  30             will_save_wait_until: None,
  31             save: Some(SaveOptions::default().into()),
  32         })),
  33         hover_provider: Some(HoverProviderCapability::Simple(true)),
  34         completion_provider: Some(CompletionOptions {
  35             resolve_provider: completions_resolve_provider(client_caps),
  36             trigger_characters: Some(vec![":".to_string(), ".".to_string()]),
  37             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  38         }),
  39         signature_help_provider: Some(SignatureHelpOptions {
  40             trigger_characters: Some(vec!["(".to_string(), ",".to_string()]),
  41             retrigger_characters: None,
  42             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  43         }),
  44         declaration_provider: None,
  45         definition_provider: Some(OneOf::Left(true)),
  46         type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
  47         implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
  48         references_provider: Some(OneOf::Left(true)),
  49         document_highlight_provider: Some(OneOf::Left(true)),
  50         document_symbol_provider: Some(OneOf::Left(true)),
  51         workspace_symbol_provider: Some(OneOf::Left(true)),
  52         code_action_provider: Some(code_action_capabilities(client_caps)),
  53         code_lens_provider: Some(CodeLensOptions { resolve_provider: Some(true) }),
  54         document_formatting_provider: Some(OneOf::Left(true)),
  55         document_range_formatting_provider: None,
  56         document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
  57             first_trigger_character: "=".to_string(),
  58             more_trigger_character: Some(vec![".".to_string(), ">".to_string()]),
  59         }),
  60         selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
  61         semantic_highlighting: None,
  62         folding_range_provider: Some(FoldingRangeProviderCapability::Simple(true)),
  63         rename_provider: Some(OneOf::Right(RenameOptions {
  64             prepare_provider: Some(true),
  65             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  66         })),
  67         on_type_rename_provider: None,
  68         document_link_provider: None,
  69         color_provider: None,
  70         execute_command_provider: None,
  71         workspace: None,
  72         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
  73         semantic_tokens_provider: Some(
  74             SemanticTokensOptions {
  75                 legend: SemanticTokensLegend {
  76                     token_types: semantic_tokens::SUPPORTED_TYPES.to_vec(),
  77                     token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
  78                 },
  79
  80                 full: Some(SemanticTokensFullOptions::Delta { delta: Some(true) }),
  81                 range: Some(true),
  82                 work_done_progress_options: Default::default(),
  83             }
  84             .into(),
  85         ),
  86         experimental: Some(json!({
  87             "joinLines": true,
  88             "ssr": true,
  89             "onEnter": true,
  90             "parentModule": true,
  91             "runnables": {
  92                 "kinds": [ "cargo" ],
  93             },
  94         })),
  95     }
  96 }
  97
  98 fn completions_resolve_provider(client_caps: &ClientCapabilities) -> Option<bool> {
  99     if enabled_completions_resolve_capabilities(client_caps)?.is_empty() {
 100         None
 101     } else {
 102         Some(true)
 103     }
 104 }
 105
 106 /// Parses client capabilities and returns all completion resolve capabilities rust-analyzer supports.
 107 pub fn enabled_completions_resolve_capabilities(
 108     caps: &ClientCapabilities,
 109 ) -> Option<FxHashSet<CompletionResolveCapability>> {
 110     Some(
 111         caps.text_document
 112             .as_ref()?
 113             .completion
 114             .as_ref()?
 115             .completion_item
 116             .as_ref()?
 117             .resolve_support
 118             .as_ref()?
 119             .properties
 120             .iter()
 121             .filter_map(|cap_string| {
 122                 Some(match cap_string.as_str() {
 123                     "additionalTextEdits" => CompletionResolveCapability::AdditionalTextEdits,
 124                     "detail" => CompletionResolveCapability::Detail,
 125                     "documentation" => CompletionResolveCapability::Documentation,
 126                     _unsupported => return None,
 127                 })
 128             })
 129             .collect(),
 130     )
 131 }
 132
 133 fn code_action_capabilities(client_caps: &ClientCapabilities) -> CodeActionProviderCapability {
 134     client_caps
 135         .text_document
 136         .as_ref()
 137         .and_then(|it| it.code_action.as_ref())
 138         .and_then(|it| it.code_action_literal_support.as_ref())
 139         .map_or(CodeActionProviderCapability::Simple(true), |_| {
 140             CodeActionProviderCapability::Options(CodeActionOptions {
 141                 // Advertise support for all built-in CodeActionKinds.
 142                 // Ideally we would base this off of the client capabilities
 143                 // but the client is supposed to fall back gracefully for unknown values.
 144                 code_action_kinds: Some(vec![
 145                     CodeActionKind::EMPTY,
 146                     CodeActionKind::QUICKFIX,
 147                     CodeActionKind::REFACTOR,
 148                     CodeActionKind::REFACTOR_EXTRACT,
 149                     CodeActionKind::REFACTOR_INLINE,
 150                     CodeActionKind::REFACTOR_REWRITE,
 151                 ]),
 152                 resolve_provider: Some(true),
 153                 work_done_progress_options: Default::default(),
 154             })
 155         })
 156 }