Add support for rust-analyzer chaining hints (autozimu#1108)

Author: martskins

src/extensions/mod.rs

@@ -2,3 +2,43 @@ pub mod clangd;
 pub mod gopls;
 pub mod java;
 pub mod rust_analyzer;
+
+use crate::language_client::LanguageClient;
+use anyhow::Result;
+
+impl LanguageClient {
+ pub fn text_document_inlay_hints(&self, language_id: &str, filename: &str) -> Result<()> {
+ if !self.extensions_enabled(language_id)? {
+ return Ok(());
+ }
+
+ let server_name = self.get_state(|state| match state.capabilities.get(language_id) {
+ Some(c) => c
+ .server_info
+ .as_ref()
+ .map(|info| info.name.clone())
+ .unwrap_or_default(),
+ None => String::new(),
+ })?;
+
+ let hints = match server_name.as_str() {
+ rust_analyzer::SERVER_NAME => self.rust_analyzer_inlay_hints(filename)?,
+ _ => return Ok(()),
+ };
+
+ self.update_state(|state| {
+ state.inlay_hints.insert(filename.to_string(), hints);
+ Ok(())
+ })?;
+
+ Ok(())
+ }
+
+ pub fn extensions_enabled(&self, filetype: &str) -> Result<bool> {
+ let result = self.get_config(|c| match &c.enable_extensions {
+ Some(extensions) => extensions.get(filetype).cloned().unwrap_or(true),
+ None => true,
+ })?;
+ Ok(result)
+ }
+}

src/extensions/rust_analyzer.rs

@@ -1,8 +1,9 @@
-use crate::{language_client::LanguageClient, types::WorkspaceEditWithCursor};
+use crate::types;
+use crate::{language_client::LanguageClient, types::WorkspaceEditWithCursor, utils::ToUrl};
 use anyhow::{anyhow, Result};
 use jsonrpc_core::Value;
-use lsp_types::{Command, Location};
-use serde::Deserialize;
+use lsp_types::{request::Request, Command, Location, Range, TextDocumentIdentifier};
+use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 // Runnable wraps the two possible shapes of a runnable action from rust-analyzer. Old-ish versions
@@ -46,6 +47,35 @@ enum GenericRunnableKind {
  Cargo,
 }
 
+#[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub enum InlayKind {
+ TypeHint,
+ ParameterHint,
+ ChainingHint,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct InlayHint {
+ pub range: Range,
+ pub kind: InlayKind,
+ pub label: String,
+}
+
+impl Into<types::InlayHint> for InlayHint {
+ fn into(self) -> types::InlayHint {
+ types::InlayHint {
+ range: self.range,
+ label: self.label,
+ }
+ }
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InlayHintsParams {
+ text_document: TextDocumentIdentifier,
+}
+
 pub mod command {
  pub const SHOW_REFERENCES: &str = "rust-analyzer.showReferences";
  pub const SELECT_APPLY_SOURCE_CHANGE: &str = "rust-analyzer.selectAndApplySourceChange";
@@ -54,7 +84,55 @@ pub mod command {
  pub const RUN: &str = "rust-analyzer.run";
 }
 
+pub mod request {
+ pub enum InlayHintsRequest {}
+
+ impl lsp_types::request::Request for InlayHintsRequest {
+ type Params = super::InlayHintsParams;
+ type Result = Vec<super::InlayHint>;
+ const METHOD: &'static str = "rust-analyzer/inlayHints";
+ }
+}
+
+const FILETYPE: &'static str = "rust";
+pub const SERVER_NAME: &'static str = "rust-analyzer";
+
 impl LanguageClient {
+ pub fn rust_analyzer_inlay_hints(&self, filename: &str) -> Result<Vec<types::InlayHint>> {
+ let inlay_hints_enabled = self.get_state(|state| {
+ state
+ .initialization_options
+ .get(SERVER_NAME)
+ .as_ref()
+ .map(|opt| {
+ opt.pointer("/inlayHints/enable")
+ .unwrap_or(&Value::Bool(false))
+ == &Value::Bool(true)
+ })
+ .unwrap_or_default()
+ })?;
+ if !inlay_hints_enabled {
+ return Ok(vec![]);
+ }
+
+ let result: Vec<InlayHint> = self.get_client(&Some(FILETYPE.into()))?.call(
+ request::InlayHintsRequest::METHOD,
+ InlayHintsParams {
+ text_document: TextDocumentIdentifier {
+ uri: filename.to_string().to_url()?,
+ },
+ },
+ )?;
+
+ // we are only able to display chaining hints at the moment, as we can't place virtual texts in
+ // between words
+ Ok(result
+ .into_iter()
+ .filter(|h| h.kind == InlayKind::ChainingHint)
+ .map(InlayHint::into)
+ .collect())
+ }
+
  pub fn handle_rust_analyzer_command(&self, cmd: &Command) -> Result<bool> {
  match cmd.command.as_str() {
  command::SHOW_REFERENCES => {

src/language_server_protocol.rs

@@ -187,7 +187,6 @@ impl LanguageClient {
  pub fn apply_workspace_edit(&self, edit: &WorkspaceEdit) -> Result<()> {
  let mut filename = self.vim()?.get_filename(&Value::Null)?;
  let mut position = self.vim()?.get_position(&Value::Null)?;
-
  if let Some(ref changes) = edit.document_changes {
  match changes {
  DocumentChanges::Edits(ref changes) => {
@@ -735,13 +734,7 @@ impl LanguageClient {
 
  fn try_handle_command_by_client(&self, cmd: &Command) -> Result<bool> {
  let filetype: String = self.vim()?.eval("&filetype")?;
- let enabled_extensions = self.get_config(|c| {
- c.enable_extensions
- .as_ref()
- .map(|c| c.get(&filetype).copied().unwrap_or(true))
- .unwrap_or(true)
- })?;
- if !enabled_extensions {
+ if !self.extensions_enabled(&filetype)? {
  return Ok(false);
  }
 
@@ -884,7 +877,7 @@ impl LanguageClient {
  /* deprecated in lsp types, but can't initialize without it */
  root_path: Some(root.clone()),
  root_uri: Some(root.to_url()?),
- initialization_options,
+ initialization_options: initialization_options.clone(),
  capabilities: ClientCapabilities {
  text_document: Some(TextDocumentClientCapabilities {
  color_provider: Some(GenericCapability {
@@ -982,9 +975,21 @@ impl LanguageClient {
 
  let initialize_result = InitializeResult::deserialize(&result)?;
  self.update_state(|state| {
+ let server_name = initialize_result
+ .server_info
+ .as_ref()
+ .map(|info| info.name.clone());
+ match (server_name, initialization_options) {
+ (Some(name), Some(options)) => {
+ state.initialization_options.insert(name, options);
+ }
+ _ => {}
+ }
+
  state
  .capabilities
  .insert(language_id.clone(), initialize_result);
+
  Ok(())
  })?;
 
@@ -1943,6 +1948,7 @@ impl LanguageClient {
  .notify("s:ExecuteAutocmd", "LanguageClientTextDocumentDidOpenPost")?;
 
  self.text_document_code_lens(params)?;
+ self.text_document_inlay_hints(&language_id, &filename)?;
 
  Ok(())
  }
@@ -1989,7 +1995,7 @@ impl LanguageClient {
  Ok(version)
  })?;
 
- self.get_client(&Some(language_id))?.notify(
+ self.get_client(&Some(language_id.clone()))?.notify(
  lsp_types::notification::DidChangeTextDocument::METHOD,
  DidChangeTextDocumentParams {
  text_document: VersionedTextDocumentIdentifier {
@@ -2005,6 +2011,7 @@ impl LanguageClient {
  )?;
 
  self.text_document_code_lens(params)?;
+ self.text_document_inlay_hints(&language_id, &filename)?;
 
  Ok(())
  }
@@ -2019,7 +2026,7 @@ impl LanguageClient {
 
  let uri = filename.to_url()?;
 
- self.get_client(&Some(language_id))?.notify(
+ self.get_client(&Some(language_id.clone()))?.notify(
  lsp_types::notification::DidSaveTextDocument::METHOD,
  DidSaveTextDocumentParams {
  text: None,
@@ -2931,15 +2938,25 @@ impl LanguageClient {
 
  // code lens
  if UseVirtualText::All == use_virtual_text || UseVirtualText::CodeLens == use_virtual_text {
- virtual_texts.extend(self.virtual_texts_from_code_lenses(filename)?.into_iter());
+ virtual_texts.extend(
+ self.virtual_texts_from_code_lenses(filename, &viewport)?
+ .into_iter(),
+ );
+ }
+
+ // inlay hints
+ if UseVirtualText::All == use_virtual_text || UseVirtualText::CodeLens == use_virtual_text {
+ let additional_virtual_texts =
+ self.virtual_texts_from_inlay_hints(filename, &viewport)?;
+ virtual_texts.extend(additional_virtual_texts);
  }
 
  // diagnostics
  if UseVirtualText::All == use_virtual_text
  || UseVirtualText::Diagnostics == use_virtual_text
  {
  let vt_diagnostics = self
- .virtual_texts_from_diagnostics(filename, viewport)?
+ .virtual_texts_from_diagnostics(filename, &viewport)?
  .into_iter();
  virtual_texts.extend(vt_diagnostics);
  }
@@ -2958,7 +2975,7 @@ impl LanguageClient {
  fn virtual_texts_from_diagnostics(
  &self,
  filename: &str,
- viewport: viewport::Viewport,
+ viewport: &viewport::Viewport,
  ) -> Result<Vec<VirtualText>> {
  let mut virtual_texts = vec![];
  let diagnostics = self.get_state(|state| state.diagnostics.clone())?;
@@ -2987,11 +3004,52 @@ impl LanguageClient {
  Ok(virtual_texts)
  }
 
- fn virtual_texts_from_code_lenses(&self, filename: &str) -> Result<Vec<VirtualText>> {
+ fn virtual_texts_from_inlay_hints(
+ &self,
+ filename: &str,
+ viewport: &viewport::Viewport,
+ ) -> Result<Vec<VirtualText>> {
+ let inlay_hints: Vec<InlayHint> = self.get_state(|state| {
+ state
+ .inlay_hints
+ .get(filename)
+ .map(|s| {
+ s.iter()
+ .filter(|hint| viewport.overlaps(hint.range))
+ .cloned()
+ .collect()
+ })
+ .unwrap_or_default()
+ })?;
+ let hl_group = self.get_config(|c| c.code_lens_display.virtual_texthl.clone())?;
+
+ let virtual_texts = inlay_hints
+ .into_iter()
+ .map(|hint| VirtualText {
+ line: hint.range.end.line,
+ text: hint.label,
+ hl_group: hl_group.clone(),
+ })
+ .collect();
+ Ok(virtual_texts)
+ }
+
+ fn virtual_texts_from_code_lenses(
+ &self,
+ filename: &str,
+ viewport: &viewport::Viewport,
+ ) -> Result<Vec<VirtualText>> {
  let mut virtual_texts = vec![];
- let code_lenses =
- self.get_state(|state| state.code_lens.get(filename).cloned().unwrap_or_default())?;
- let code_lens_display = self.get_config(|c| c.code_lens_display.clone())?;
+ let code_lenses: Vec<CodeLens> =
+ self.get_state(|state| match state.code_lens.get(filename) {
+ Some(cls) => cls
+ .into_iter()
+ .filter(|cl| viewport.overlaps(cl.range))
+ .cloned()
+ .collect(),
+ None => vec![],
+ })?;
+ let hl_group = self.get_config(|c| c.code_lens_display.virtual_texthl.clone())?;
 
  for cl in code_lenses {
  if let Some(command) = cl.command {
@@ -3008,7 +3066,7 @@ impl LanguageClient {
  None => virtual_texts.push(VirtualText {
  line,
  text,
- hl_group: code_lens_display.virtual_texthl.clone(),
+ hl_group: hl_group.clone(),
  }),
  }
  }

src/types.rs

@@ -10,6 +10,7 @@ use crate::{viewport::Viewport, vim::Highlight};
 use anyhow::{anyhow, Result};
 use jsonrpc_core::Params;
 use log::*;
+use lsp_types::Range;
 use lsp_types::{
  CodeAction, CodeLens, Command, CompletionItem, CompletionTextEdit, Diagnostic,
  DiagnosticSeverity, DocumentHighlightKind, FileChangeType, FileEvent, Hover, HoverContents,
@@ -128,6 +129,12 @@ pub enum UseVirtualText {
  No,
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct InlayHint {
+ pub range: Range,
+ pub label: String,
+}
+
 #[derive(Serialize)]
 pub struct State {
  // Program state.
@@ -156,6 +163,8 @@ pub struct State {
  pub diagnostics: HashMap<String, Vec<Diagnostic>>,
  // filename => codeLens.
  pub code_lens: HashMap<String, Vec<CodeLens>>,
+ // filename => inlayHint.
+ pub inlay_hints: HashMap<String, Vec<InlayHint>>,
  #[serde(skip_serializing)]
  pub line_diagnostics: HashMap<(String, u64), String>,
  pub namespace_ids: HashMap<String, i64>,
@@ -175,6 +184,7 @@ pub struct State {
  pub stashed_code_action_actions: Vec<CodeAction>,
 
  pub logger: Logger,
+ pub initialization_options: HashMap<String, Value>,
 }
 
 impl State {
@@ -197,6 +207,7 @@ impl State {
  semantic_scopes: HashMap::new(),
  semantic_scope_to_hl_group_table: HashMap::new(),
  semantic_highlights: HashMap::new(),
+ inlay_hints: HashMap::new(),
  code_lens: HashMap::new(),
  diagnostics: HashMap::new(),
  line_diagnostics: HashMap::new(),
@@ -211,6 +222,7 @@ impl State {
  last_cursor_line: 0,
  last_line_diagnostic: " ".into(),
  stashed_code_action_actions: vec![],
+ initialization_options: HashMap::new(),
  logger,
  }
  }