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, FileOperationFilter, FileOperationPattern,
   9     FileOperationPatternKind, FileOperationRegistrationOptions, FoldingRangeProviderCapability,
  10     HoverProviderCapability, ImplementationProviderCapability, OneOf, RenameOptions, SaveOptions,
  11     SelectionRangeProviderCapability, SemanticTokensFullOptions, SemanticTokensLegend,
  12     SemanticTokensOptions, ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability,
  13     TextDocumentSyncKind, TextDocumentSyncOptions, TypeDefinitionProviderCapability,
  14     WorkDoneProgressOptions, WorkspaceFileOperationsServerCapabilities,
  15     WorkspaceServerCapabilities,
  16 };
  17 use rustc_hash::FxHashSet;
  18 use serde_json::json;
  19
  20 use crate::semantic_tokens;
  21
  22 pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabilities {
  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: completions_resolve_provider(client_caps),
  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(OneOf::Left(true)),
  48         type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
  49         implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
  50         references_provider: Some(OneOf::Left(true)),
  51         document_highlight_provider: Some(OneOf::Left(true)),
  52         document_symbol_provider: Some(OneOf::Left(true)),
  53         workspace_symbol_provider: Some(OneOf::Left(true)),
  54         code_action_provider: Some(code_action_capabilities(client_caps)),
  55         code_lens_provider: Some(CodeLensOptions { resolve_provider: Some(true) }),
  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         linked_editing_range_provider: None,
  70         document_link_provider: None,
  71         color_provider: None,
  72         execute_command_provider: None,
  73         workspace: Some(WorkspaceServerCapabilities {
  74             workspace_folders: None,
  75             file_operations: Some(WorkspaceFileOperationsServerCapabilities {
  76                 did_create: None,
  77                 will_create: None,
  78                 did_rename: None,
  79                 will_rename: Some(FileOperationRegistrationOptions {
  80                     filters: vec![
  81                         FileOperationFilter {
  82                             scheme: Some(String::from("file")),
  83                             pattern: FileOperationPattern {
  84                                 glob: String::from("**/*.rs"),
  85                                 matches: Some(FileOperationPatternKind::File),
  86                                 options: None,
  87                             },
  88                         },
  89                         FileOperationFilter {
  90                             scheme: Some(String::from("file")),
  91                             pattern: FileOperationPattern {
  92                                 glob: String::from("**"),
  93                                 matches: Some(FileOperationPatternKind::Folder),
  94                                 options: None,
  95                             },
  96                         },
  97                     ],
  98                 }),
  99                 did_delete: None,
 100                 will_delete: None,
 101             }),
 102         }),
 103         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
 104         semantic_tokens_provider: Some(
 105             SemanticTokensOptions {
 106                 legend: SemanticTokensLegend {
 107                     token_types: semantic_tokens::SUPPORTED_TYPES.to_vec(),
 108                     token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
 109                 },
 110
 111                 full: Some(SemanticTokensFullOptions::Delta { delta: Some(true) }),
 112                 range: Some(true),
 113                 work_done_progress_options: Default::default(),
 114             }
 115             .into(),
 116         ),
 117         moniker_provider: None,
 118         experimental: Some(json!({
 119             "joinLines": true,
 120             "ssr": true,
 121             "onEnter": true,
 122             "parentModule": true,
 123             "runnables": {
 124                 "kinds": [ "cargo" ],
 125             },
 126         })),
 127     }
 128 }
 129
 130 fn completions_resolve_provider(client_caps: &ClientCapabilities) -> Option<bool> {
 131     if enabled_completions_resolve_capabilities(client_caps)?.is_empty() {
 132         log::info!("No `additionalTextEdits` completion resolve capability was found in the client capabilities, autoimport completion is disabled");
 133         None
 134     } else {
 135         Some(true)
 136     }
 137 }
 138
 139 /// Parses client capabilities and returns all completion resolve capabilities rust-analyzer supports.
 140 pub(crate) fn enabled_completions_resolve_capabilities(
 141     caps: &ClientCapabilities,
 142 ) -> Option<FxHashSet<CompletionResolveCapability>> {
 143     Some(
 144         caps.text_document
 145             .as_ref()?
 146             .completion
 147             .as_ref()?
 148             .completion_item
 149             .as_ref()?
 150             .resolve_support
 151             .as_ref()?
 152             .properties
 153             .iter()
 154             .filter_map(|cap_string| match cap_string.as_str() {
 155                 "additionalTextEdits" => Some(CompletionResolveCapability::AdditionalTextEdits),
 156                 "detail" => Some(CompletionResolveCapability::Detail),
 157                 "documentation" => Some(CompletionResolveCapability::Documentation),
 158                 _unsupported => None,
 159             })
 160             .collect(),
 161     )
 162 }
 163
 164 fn code_action_capabilities(client_caps: &ClientCapabilities) -> CodeActionProviderCapability {
 165     client_caps
 166         .text_document
 167         .as_ref()
 168         .and_then(|it| it.code_action.as_ref())
 169         .and_then(|it| it.code_action_literal_support.as_ref())
 170         .map_or(CodeActionProviderCapability::Simple(true), |_| {
 171             CodeActionProviderCapability::Options(CodeActionOptions {
 172                 // Advertise support for all built-in CodeActionKinds.
 173                 // Ideally we would base this off of the client capabilities
 174                 // but the client is supposed to fall back gracefully for unknown values.
 175                 code_action_kinds: Some(vec![
 176                     CodeActionKind::EMPTY,
 177                     CodeActionKind::QUICKFIX,
 178                     CodeActionKind::REFACTOR,
 179                     CodeActionKind::REFACTOR_EXTRACT,
 180                     CodeActionKind::REFACTOR_INLINE,
 181                     CodeActionKind::REFACTOR_REWRITE,
 182                 ]),
 183                 resolve_provider: Some(true),
 184                 work_done_progress_options: Default::default(),
 185             })
 186         })
 187 }