crates/rust-analyzer/src/caps.rs

   1 //! Advertizes the capabilities of the LSP Server.
   2 use std::env;
   3
   4 use lsp_types::{
   5     CallHierarchyServerCapability, ClientCapabilities, CodeActionKind, CodeActionOptions,
   6     CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
   7     DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability, HoverProviderCapability,
   8     ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
   9     SelectionRangeProviderCapability, SemanticTokensDocumentProvider, SemanticTokensLegend,
  10     SemanticTokensOptions, SemanticTokensServerCapabilities, ServerCapabilities,
  11     SignatureHelpOptions, TextDocumentSyncCapability, TextDocumentSyncKind,
  12     TextDocumentSyncOptions, TypeDefinitionProviderCapability, WorkDoneProgressOptions,
  13 };
  14 use serde_json::{json, Value};
  15
  16 use crate::semantic_tokens;
  17
  18 pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabilities {
  19     let code_action_provider = code_action_capabilities(client_caps);
  20     let semantic_tokens_provider = semantic_tokens_capabilities(client_caps);
  21     let experimental = experimental_capabilities(client_caps);
  22
  23     ServerCapabilities {
  24         text_document_sync: Some(TextDocumentSyncCapability::Options(TextDocumentSyncOptions {
  25             open_close: Some(true),
  26             change: Some(if env::var("RA_NO_INCREMENTAL_SYNC").is_ok() {
  27                 TextDocumentSyncKind::Full
  28             } else {
  29                 TextDocumentSyncKind::Incremental
  30             }),
  31             will_save: None,
  32             will_save_wait_until: None,
  33             save: Some(SaveOptions::default().into()),
  34         })),
  35         hover_provider: Some(HoverProviderCapability::Simple(true)),
  36         completion_provider: Some(CompletionOptions {
  37             resolve_provider: None,
  38             trigger_characters: Some(vec![":".to_string(), ".".to_string()]),
  39             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  40         }),
  41         signature_help_provider: Some(SignatureHelpOptions {
  42             trigger_characters: Some(vec!["(".to_string(), ",".to_string()]),
  43             retrigger_characters: None,
  44             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  45         }),
  46         declaration_provider: None,
  47         definition_provider: Some(true),
  48         type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
  49         implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
  50         references_provider: Some(true),
  51         document_highlight_provider: Some(true),
  52         document_symbol_provider: Some(true),
  53         workspace_symbol_provider: Some(true),
  54         code_action_provider: Some(code_action_provider),
  55         code_lens_provider: Some(CodeLensOptions { resolve_provider: Some(true) }),
  56         document_formatting_provider: Some(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(RenameProviderCapability::Options(RenameOptions {
  66             prepare_provider: Some(true),
  67             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  68         })),
  69         document_link_provider: None,
  70         color_provider: None,
  71         execute_command_provider: None,
  72         workspace: None,
  73         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
  74         semantic_tokens_provider,
  75         experimental,
  76     }
  77 }
  78
  79 fn experimental_capabilities(client_caps: &ClientCapabilities) -> Option<Value> {
  80     client_caps.experimental.as_ref().and_then(|it| {
  81         it.as_object().map(|map| {
  82             let mut obj = json!({});
  83             let result = obj.as_object_mut().unwrap();
  84
  85             if map.contains_key("joinLines") {
  86                 result.insert("joinLines".into(), true.into());
  87             }
  88
  89             if map.contains_key("ssr") {
  90                 result.insert("ssr".into(), true.into());
  91             }
  92
  93             if map.contains_key("onEnter") {
  94                 result.insert("onEnter".into(), true.into());
  95             }
  96
  97             if map.contains_key("parentModule") {
  98                 result.insert("parentModule".into(), true.into());
  99             }
 100
 101             if map.contains_key("runnables") {
 102                 result.insert("runnables".into(), json!({ "kinds": [ "cargo" ] }));
 103             }
 104
 105             obj
 106         })
 107     })
 108 }
 109
 110 fn semantic_tokens_capabilities(
 111     client_caps: &ClientCapabilities,
 112 ) -> Option<SemanticTokensServerCapabilities> {
 113     client_caps.text_document.as_ref().and_then(|it| it.semantic_tokens.as_ref()).map(|_|
 114             // client supports semanticTokens
 115             SemanticTokensOptions {
 116             legend: SemanticTokensLegend {
 117                 token_types: semantic_tokens::SUPPORTED_TYPES.to_vec(),
 118                 token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
 119             },
 120
 121             document_provider: Some(SemanticTokensDocumentProvider::Bool(true)),
 122             range_provider: Some(true),
 123             work_done_progress_options: Default::default(),
 124         }
 125         .into())
 126 }
 127
 128 fn code_action_capabilities(client_caps: &ClientCapabilities) -> CodeActionProviderCapability {
 129     client_caps
 130         .text_document
 131         .as_ref()
 132         .and_then(|it| it.code_action.as_ref())
 133         .and_then(|it| it.code_action_literal_support.as_ref())
 134         .map_or(CodeActionProviderCapability::Simple(true), |caps| {
 135             let mut action_kinds = vec![
 136                 CodeActionKind::EMPTY,
 137                 CodeActionKind::QUICKFIX,
 138                 CodeActionKind::REFACTOR,
 139                 CodeActionKind::REFACTOR_EXTRACT,
 140                 CodeActionKind::REFACTOR_INLINE,
 141                 CodeActionKind::REFACTOR_REWRITE,
 142             ];
 143
 144             // Not all clients can fall back gracefully for unknown values.
 145             // Microsoft.VisualStudio.LanguageServer.Protocol.CodeActionKind does not support CodeActionKind::EMPTY
 146             // So have to filter out.
 147             action_kinds
 148                 .retain(|it| caps.code_action_kind.value_set.contains(&it.as_str().to_owned()));
 149
 150             CodeActionProviderCapability::Options(CodeActionOptions {
 151                 code_action_kinds: Some(action_kinds),
 152                 work_done_progress_options: Default::default(),
 153             })
 154         })
 155 }