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: Some(true),
  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 {
  54             resolve_provider: resolve_provider(client_caps),
  55         }),
  56         document_formatting_provider: Some(OneOf::Left(true)),
  57         document_range_formatting_provider: None,
  58         document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
  59             first_trigger_character: "=".to_string(),
  60             more_trigger_character: Some(vec![".".to_string(), ">".to_string()]),
  61         }),
  62         selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
  63         semantic_highlighting: None,
  64         folding_range_provider: Some(FoldingRangeProviderCapability::Simple(true)),
  65         rename_provider: Some(OneOf::Right(RenameOptions {
  66             prepare_provider: Some(true),
  67             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  68         })),
  69         on_type_rename_provider: None,
  70         document_link_provider: None,
  71         color_provider: None,
  72         execute_command_provider: None,
  73         workspace: None,
  74         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
  75         semantic_tokens_provider: Some(
  76             SemanticTokensOptions {
  77                 legend: SemanticTokensLegend {
  78                     token_types: semantic_tokens::SUPPORTED_TYPES.to_vec(),
  79                     token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
  80                 },
  81
  82                 full: Some(SemanticTokensFullOptions::Delta { delta: Some(true) }),
  83                 range: Some(true),
  84                 work_done_progress_options: Default::default(),
  85             }
  86             .into(),
  87         ),
  88         experimental: Some(json!({
  89             "joinLines": true,
  90             "ssr": true,
  91             "onEnter": true,
  92             "parentModule": true,
  93             "runnables": {
  94                 "kinds": [ "cargo" ],
  95             },
  96         })),
  97     }
  98 }
  99
 100 fn resolve_provider(client_caps: &ClientCapabilities) -> Option<bool> {
 101     if enabled_resolve_capabilities(client_caps)?.is_empty() {
 102         None
 103     } else {
 104         Some(true)
 105     }
 106 }
 107
 108 /// Parses client capabilities and returns all that rust-analyzer supports.
 109 pub fn enabled_resolve_capabilities(
 110     caps: &ClientCapabilities,
 111 ) -> Option<FxHashSet<CompletionResolveCapability>> {
 112     Some(
 113         caps.text_document
 114             .as_ref()?
 115             .completion
 116             .as_ref()?
 117             .completion_item
 118             .as_ref()?
 119             .resolve_support
 120             .as_ref()?
 121             .properties
 122             .iter()
 123             .filter_map(|cap_string| {
 124                 Some(match cap_string.as_str() {
 125                     "additionalTextEdits" => CompletionResolveCapability::AdditionalTextEdits,
 126                     "detail" => CompletionResolveCapability::Detail,
 127                     "documentation" => CompletionResolveCapability::Documentation,
 128                     _unsupported => return None,
 129                 })
 130             })
 131             .collect(),
 132     )
 133 }
 134
 135 fn code_action_capabilities(client_caps: &ClientCapabilities) -> CodeActionProviderCapability {
 136     client_caps
 137         .text_document
 138         .as_ref()
 139         .and_then(|it| it.code_action.as_ref())
 140         .and_then(|it| it.code_action_literal_support.as_ref())
 141         .map_or(CodeActionProviderCapability::Simple(true), |_| {
 142             CodeActionProviderCapability::Options(CodeActionOptions {
 143                 // Advertise support for all built-in CodeActionKinds.
 144                 // Ideally we would base this off of the client capabilities
 145                 // but the client is supposed to fall back gracefully for unknown values.
 146                 code_action_kinds: Some(vec![
 147                     CodeActionKind::EMPTY,
 148                     CodeActionKind::QUICKFIX,
 149                     CodeActionKind::REFACTOR,
 150                     CodeActionKind::REFACTOR_EXTRACT,
 151                     CodeActionKind::REFACTOR_INLINE,
 152                     CodeActionKind::REFACTOR_REWRITE,
 153                 ]),
 154                 resolve_provider: Some(true),
 155                 work_done_progress_options: Default::default(),
 156             })
 157         })
 158 }