feat: show truncated parts of inlay hints in tooltips

Author: roife

crates/hir-ty/src/display.rs

@@ -64,6 +64,14 @@ use crate::{
 pub trait HirWrite: fmt::Write {
     fn start_location_link(&mut self, _location: ModuleDefId) {}
     fn end_location_link(&mut self) {}
+    /// Returns whether a new truncated part is created during this call. If so,
+    /// the caller should call `end_truncated` at the end. Otherwise, the caller
+    /// should not call `end_truncated`. This ensures that the truncated part is
+    /// not nested.
+    fn start_truncated(&mut self) -> bool {
+        false
+    }
+    fn end_truncated(&mut self) {}
 }
 
 // String will ignore link metadata
@@ -392,19 +400,23 @@ impl HirFormatter<'_> {
         sep: &str,
     ) -> Result<(), HirDisplayError> {
         let mut first = true;
+        let mut in_truncated = false;
         for e in iter {
             if !first {
                 write!(self, "{sep}")?;
             }
             first = false;
 
             // Abbreviate multiple omitted types with a single ellipsis.
-            if self.should_truncate() {
-                return write!(self, "{TYPE_HINT_TRUNCATION}");
-            }
+            in_truncated = !in_truncated && self.should_truncate() && self.fmt.start_truncated();
 
             e.hir_fmt(self)?;
         }
+
+        if in_truncated {
+            self.fmt.end_truncated();
+        }
+
         Ok(())
     }
 
@@ -599,9 +611,8 @@ impl<T: HirDisplay + Internable> HirDisplay for Interned<T> {
 
 impl HirDisplay for ProjectionTy {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
-        }
+        let in_truncated = f.should_truncate() && f.fmt.start_truncated();
+
         let trait_ref = self.trait_ref(f.db);
         let self_ty = trait_ref.self_type_parameter(Interner);
 
@@ -664,19 +675,30 @@ impl HirDisplay for ProjectionTy {
                 .name
                 .display(f.db, f.edition())
         )?;
+
         let proj_params =
             &self.substitution.as_slice(Interner)[trait_ref.substitution.len(Interner)..];
-        hir_fmt_generics(f, proj_params, None, None)
+        hir_fmt_generics(f, proj_params, None, None)?;
+
+        if in_truncated {
+            f.fmt.end_truncated();
+        }
+
+        Ok(())
     }
 }
 
 impl HirDisplay for OpaqueTy {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
+        let in_truncated = f.should_truncate() && f.fmt.start_truncated();
+
+        self.substitution.at(Interner, 0).hir_fmt(f)?;
+
+        if in_truncated {
+            f.fmt.end_truncated();
         }
 
-        self.substitution.at(Interner, 0).hir_fmt(f)
+        Ok(())
     }
 }
 
@@ -1039,9 +1061,7 @@ impl HirDisplay for Ty {
         &self,
         f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_>,
     ) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
-        }
+        let in_truncated = f.should_truncate() && f.fmt.start_truncated();
 
         match self.kind(Interner) {
             TyKind::Never => write!(f, "!")?,
@@ -1451,11 +1471,15 @@ impl HirDisplay for Ty {
                         _ => unreachable!(),
                     }
                     if sig.params().is_empty() {
-                    } else if f.should_truncate() {
-                        write!(f, "{TYPE_HINT_TRUNCATION}")?;
                     } else {
+                        let in_truncated = f.should_truncate() && f.fmt.start_truncated();
+
                         f.write_joined(sig.params(), ", ")?;
-                    };
+
+                        if in_truncated {
+                            f.fmt.end_truncated();
+                        }
+                    }
                     match f.closure_style {
                         ClosureStyle::ImplFn => write!(f, ")")?,
                         ClosureStyle::RANotation => write!(f, "|")?,
@@ -1632,6 +1656,11 @@ impl HirDisplay for Ty {
             }
             TyKind::CoroutineWitness(..) => write!(f, "{{coroutine witness}}")?,
         }
+
+        if in_truncated {
+            f.fmt.end_truncated();
+        }
+
         Ok(())
     }
 }
@@ -1983,9 +2012,7 @@ impl HirDisplay for TraitRef {
 
 impl HirDisplay for WhereClause {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
-        }
+        let in_truncated = f.should_truncate() && f.fmt.start_truncated();
 
         match self {
             WhereClause::Implemented(trait_ref) => {
@@ -2017,6 +2044,11 @@ impl HirDisplay for WhereClause {
             WhereClause::TypeOutlives(..) => {}
             WhereClause::LifetimeOutlives(..) => {}
         }
+
+        if in_truncated {
+            f.fmt.end_truncated();
+        }
+
         Ok(())
     }
 }

crates/ide/src/inlay_hints.rs

@@ -12,7 +12,7 @@ use ide_db::{FileRange, RootDatabase, famous_defs::FamousDefs, text_edit::TextEd
 use ide_db::{FxHashSet, text_edit::TextEdit};
 use itertools::Itertools;
 use smallvec::{SmallVec, smallvec};
-use stdx::never;
+use stdx::{always, never};
 use syntax::{
     SmolStr, SyntaxNode, TextRange, TextSize, WalkEvent,
     ast::{self, AstNode, HasGenericParams},
@@ -672,6 +672,8 @@ struct InlayHintLabelBuilder<'a> {
     last_part: String,
     resolve: bool,
     location: Option<LazyProperty<FileRange>>,
+    tooltip: Option<LazyProperty<InlayTooltip>>,
+    in_truncated_part: bool,
 }
 
 impl fmt::Write for InlayHintLabelBuilder<'_> {
@@ -682,6 +684,10 @@ impl fmt::Write for InlayHintLabelBuilder<'_> {
 
 impl HirWrite for InlayHintLabelBuilder<'_> {
     fn start_location_link(&mut self, def: ModuleDefId) {
+        // If the label is truncated, we do not need to add the location link.
+        if self.in_truncated_part {
+            return;
+        }
         never!(self.location.is_some(), "location link is already started");
         self.make_new_part();
 
@@ -697,7 +703,40 @@ impl HirWrite for InlayHintLabelBuilder<'_> {
     }
 
     fn end_location_link(&mut self) {
+        if self.in_truncated_part {
+            return;
+        }
+        self.make_new_part();
+    }
+
+    fn start_truncated(&mut self) -> bool {
+        never!(self.location.is_some(), "location link is already started");
+        // If currently in the truncated part, do not create a new part and continue writing into
+        // the `last_part`.
+        if self.in_truncated_part {
+            return false;
+        }
+
         self.make_new_part();
+        self.last_part.push_str("```rust\n");
+        self.in_truncated_part = true;
+        true
+    }
+
+    fn end_truncated(&mut self) {
+        always!(self.in_truncated_part, "truncated is not started");
+
+        if self.resolve {
+            self.last_part = "…".to_owned();
+            self.tooltip = Some(LazyProperty::Lazy);
+        } else {
+            let mut tooltip = mem::replace(&mut self.last_part, "…".to_owned());
+            tooltip.push_str("\n```");
+            self.tooltip = Some(LazyProperty::Computed(InlayTooltip::Markdown(tooltip)));
+        }
+
+        self.make_new_part();
+        self.in_truncated_part = false;
     }
 }
 
@@ -708,7 +747,7 @@ impl InlayHintLabelBuilder<'_> {
             self.result.parts.push(InlayHintLabelPart {
                 text,
                 linked_location: self.location.take(),
-                tooltip: None,
+                tooltip: self.tooltip.take(),
             });
         }
     }
@@ -778,6 +817,8 @@ fn label_of_ty(
         db: sema.db,
         last_part: String::new(),
         location: None,
+        tooltip: None,
+        in_truncated_part: false,
         result: InlayHintLabel::default(),
         resolve: config.fields_to_resolve.resolve_label_location,
     };