crates/rust-analyzer/src/caps.rs

   1 //! Advertises the capabilities of the LSP Server.
   2 use lsp_types::{
   3     CallHierarchyServerCapability, ClientCapabilities, CodeActionKind, CodeActionOptions,
   4     CodeActionProviderCapability, CodeLensOptions, CompletionOptions, DeclarationCapability,
   5     DocumentOnTypeFormattingOptions, FileOperationFilter, FileOperationPattern,
   6     FileOperationPatternKind, FileOperationRegistrationOptions, FoldingRangeProviderCapability,
   7     HoverProviderCapability, ImplementationProviderCapability, OneOf, RenameOptions, SaveOptions,
   8     SelectionRangeProviderCapability, SemanticTokensFullOptions, SemanticTokensLegend,
   9     SemanticTokensOptions, ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability,
  10     TextDocumentSyncKind, TextDocumentSyncOptions, TypeDefinitionProviderCapability,
  11     WorkDoneProgressOptions, WorkspaceFileOperationsServerCapabilities,
  12     WorkspaceServerCapabilities,
  13 };
  14 use serde_json::json;
  15
  16 use crate::config::{Config, RustfmtConfig};
  17 use crate::semantic_tokens;
  18
  19 pub fn server_capabilities(config: &Config) -> ServerCapabilities {
  20     ServerCapabilities {
  21         text_document_sync: Some(TextDocumentSyncCapability::Options(TextDocumentSyncOptions {
  22             open_close: Some(true),
  23             change: Some(TextDocumentSyncKind::INCREMENTAL),
  24             will_save: None,
  25             will_save_wait_until: None,
  26             save: Some(SaveOptions::default().into()),
  27         })),
  28         hover_provider: Some(HoverProviderCapability::Simple(true)),
  29         completion_provider: Some(CompletionOptions {
  30             resolve_provider: completions_resolve_provider(&config.caps),
  31             trigger_characters: Some(vec![":".to_string(), ".".to_string(), "'".to_string()]),
  32             all_commit_characters: None,
  33             completion_item: None,
  34             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  35         }),
  36         signature_help_provider: Some(SignatureHelpOptions {
  37             trigger_characters: Some(vec!["(".to_string(), ",".to_string()]),
  38             retrigger_characters: None,
  39             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  40         }),
  41         declaration_provider: Some(DeclarationCapability::Simple(true)),
  42         definition_provider: Some(OneOf::Left(true)),
  43         type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
  44         implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
  45         references_provider: Some(OneOf::Left(true)),
  46         document_highlight_provider: Some(OneOf::Left(true)),
  47         document_symbol_provider: Some(OneOf::Left(true)),
  48         workspace_symbol_provider: Some(OneOf::Left(true)),
  49         code_action_provider: Some(code_action_capabilities(&config.caps)),
  50         code_lens_provider: Some(CodeLensOptions { resolve_provider: Some(true) }),
  51         document_formatting_provider: Some(OneOf::Left(true)),
  52         document_range_formatting_provider: match config.rustfmt() {
  53             RustfmtConfig::Rustfmt { enable_range_formatting: true, .. } => Some(OneOf::Left(true)),
  54             _ => Some(OneOf::Left(false)),
  55         },
  56         document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
  57             first_trigger_character: "=".to_string(),
  58             more_trigger_character: Some(vec![".".to_string(), ">".to_string(), "{".to_string()]),
  59         }),
  60         selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
  61         folding_range_provider: Some(FoldingRangeProviderCapability::Simple(true)),
  62         rename_provider: Some(OneOf::Right(RenameOptions {
  63             prepare_provider: Some(true),
  64             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
  65         })),
  66         linked_editing_range_provider: None,
  67         document_link_provider: None,
  68         color_provider: None,
  69         execute_command_provider: None,
  70         workspace: Some(WorkspaceServerCapabilities {
  71             workspace_folders: None,
  72             file_operations: Some(WorkspaceFileOperationsServerCapabilities {
  73                 did_create: None,
  74                 will_create: None,
  75                 did_rename: None,
  76                 will_rename: Some(FileOperationRegistrationOptions {
  77                     filters: vec![
  78                         FileOperationFilter {
  79                             scheme: Some(String::from("file")),
  80                             pattern: FileOperationPattern {
  81                                 glob: String::from("**/*.rs"),
  82                                 matches: Some(FileOperationPatternKind::File),
  83                                 options: None,
  84                             },
  85                         },
  86                         FileOperationFilter {
  87                             scheme: Some(String::from("file")),
  88                             pattern: FileOperationPattern {
  89                                 glob: String::from("**"),
  90                                 matches: Some(FileOperationPatternKind::Folder),
  91                                 options: None,
  92                             },
  93                         },
  94                     ],
  95                 }),
  96                 did_delete: None,
  97                 will_delete: None,
  98             }),
  99         }),
 100         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
 101         semantic_tokens_provider: Some(
 102             SemanticTokensOptions {
 103                 legend: SemanticTokensLegend {
 104                     token_types: semantic_tokens::SUPPORTED_TYPES.to_vec(),
 105                     token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
 106                 },
 107
 108                 full: Some(SemanticTokensFullOptions::Delta { delta: Some(true) }),
 109                 range: Some(true),
 110                 work_done_progress_options: Default::default(),
 111             }
 112             .into(),
 113         ),
 114         moniker_provider: None,
 115         experimental: Some(json!({
 116             "externalDocs": true,
 117             "hoverRange": true,
 118             "joinLines": true,
 119             "matchingBrace": true,
 120             "moveItem": true,
 121             "onEnter": true,
 122             "openCargoToml": true,
 123             "parentModule": true,
 124             "runnables": {
 125                 "kinds": [ "cargo" ],
 126             },
 127             "ssr": true,
 128             "workspaceSymbolScopeKindFiltering": true,
 129         })),
 130     }
 131 }
 132
 133 fn completions_resolve_provider(client_caps: &ClientCapabilities) -> Option<bool> {
 134     if completion_item_edit_resolve(client_caps) {
 135         Some(true)
 136     } else {
 137         tracing::info!("No `additionalTextEdits` completion resolve capability was found in the client capabilities, autoimport completion is disabled");
 138         None
 139     }
 140 }
 141
 142 /// Parses client capabilities and returns all completion resolve capabilities rust-analyzer supports.
 143 pub(crate) fn completion_item_edit_resolve(caps: &ClientCapabilities) -> bool {
 144     (|| {
 145         Some(
 146             caps.text_document
 147                 .as_ref()?
 148                 .completion
 149                 .as_ref()?
 150                 .completion_item
 151                 .as_ref()?
 152                 .resolve_support
 153                 .as_ref()?
 154                 .properties
 155                 .iter()
 156                 .any(|cap_string| cap_string.as_str() == "additionalTextEdits"),
 157         )
 158     })() == Some(true)
 159 }
 160
 161 fn code_action_capabilities(client_caps: &ClientCapabilities) -> CodeActionProviderCapability {
 162     client_caps
 163         .text_document
 164         .as_ref()
 165         .and_then(|it| it.code_action.as_ref())
 166         .and_then(|it| it.code_action_literal_support.as_ref())
 167         .map_or(CodeActionProviderCapability::Simple(true), |_| {
 168             CodeActionProviderCapability::Options(CodeActionOptions {
 169                 // Advertise support for all built-in CodeActionKinds.
 170                 // Ideally we would base this off of the client capabilities
 171                 // but the client is supposed to fall back gracefully for unknown values.
 172                 code_action_kinds: Some(vec![
 173                     CodeActionKind::EMPTY,
 174                     CodeActionKind::QUICKFIX,
 175                     CodeActionKind::REFACTOR,
 176                     CodeActionKind::REFACTOR_EXTRACT,
 177                     CodeActionKind::REFACTOR_INLINE,
 178                     CodeActionKind::REFACTOR_REWRITE,
 179                 ]),
 180                 resolve_provider: Some(true),
 181                 work_done_progress_options: Default::default(),
 182             })
 183         })
 184 }