Add inlay hints for inferred consts

This provides an inlay hint for _ in const generic arguments.

(cherry picked from commit 535d6f07cc59abbba511769af7d9e467a4cc36f2)

Author: nicolas-guichard

crates/hir/src/semantics.rs

@@ -37,7 +37,7 @@ use hir_ty::{
     diagnostics::unsafe_operations,
     infer_query_with_inspect,
     next_solver::{
-        AnyImplId, DbInterner,
+        AnyImplId, Const as ResolvedConst, DbInterner,
         format_proof_tree::{ProofTreeData, dump_proof_tree_structured},
     },
 };
@@ -1713,6 +1713,18 @@ impl<'db> SemanticsImpl<'db> {
         analyze.type_of_type(self.db, ty)
     }
 
+    pub fn resolve_infer(
+        &self,
+        ty: &ast::InferType,
+    ) -> Option<Either<Type<'db>, ResolvedConst<'db>>> {
+        let analyze = self.analyze(ty.syntax())?;
+        if let Some(const_) = analyze.resolve_infer_type_as_const(ty) {
+            return Some(Either::Right(const_));
+        }
+        let ty = analyze.type_of_type(self.db, &ast::Type::InferType(ty.clone()))?;
+        Some(Either::Left(ty))
+    }
+
     pub fn resolve_trait(&self, path: &ast::Path) -> Option<Trait> {
         let parent_ty = path.syntax().parent().and_then(ast::Type::cast)?;
         let analyze = self.analyze(path.syntax())?;
@@ -1874,6 +1886,13 @@ impl<'db> SemanticsImpl<'db> {
         self.analyze(try_expr.syntax())?.resolve_try_expr(self.db, try_expr)
     }
 
+    pub fn resolve_underscore_expr(
+        &self,
+        underscore_expr: &ast::UnderscoreExpr,
+    ) -> Option<ResolvedConst<'db>> {
+        self.analyze(underscore_expr.syntax())?.resolve_underscore_expr(underscore_expr)
+    }
+
     /// The type that the associated `try` block, closure or function expects.
     pub fn try_expr_returned_type(&self, try_expr: &ast::TryExpr) -> Option<Type<'db>> {
         self.ancestors_with_macros(try_expr.syntax().clone()).find_map(|parent| {

crates/hir/src/source_analyzer.rs

@@ -24,7 +24,7 @@ use hir_def::{
     lang_item::LangItems,
     nameres::MacroSubNs,
     resolver::{Resolver, TypeNs, ValueNs, resolver_for_scope},
-    type_ref::{Mutability, TypeRef, TypeRefId},
+    type_ref::{ConstRef, Mutability, TypeRef, TypeRefId},
 };
 use hir_expand::{
     HirFileId, InFile,
@@ -41,8 +41,8 @@ use hir_ty::{
     lang_items::lang_items_for_bin_op,
     method_resolution::{self, CandidateId},
     next_solver::{
-        AliasTy, DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, Ty, TyKind, TypingMode,
-        infer::DbInternerInferExt,
+        AliasTy, Const as ResolvedConst, DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, Ty,
+        TyKind, TypingMode, infer::DbInternerInferExt,
     },
     traits::structurally_normalize_ty,
 };
@@ -870,6 +870,22 @@ impl<'db> SourceAnalyzer<'db> {
         Some(self.resolve_impl_method_or_trait_def(db, op_fn, substs))
     }
 
+    pub(crate) fn resolve_underscore_expr(
+        &self,
+        underscore_expr: &ast::UnderscoreExpr,
+    ) -> Option<ResolvedConst<'db>> {
+        let expr = self.expr_id(ast::Expr::UnderscoreExpr(underscore_expr.clone()))?.as_expr()?;
+        self.infer()?.const_of_const_placeholder(ConstRef { expr }.into())
+    }
+
+    pub(crate) fn resolve_infer_type_as_const(
+        &self,
+        infer_type: &ast::InferType,
+    ) -> Option<ResolvedConst<'db>> {
+        let type_ref = self.type_id(&ast::Type::InferType(infer_type.clone()))?;
+        self.infer()?.const_of_const_placeholder(type_ref.into())
+    }
+
     pub(crate) fn resolve_record_field(
         &self,
         db: &'db dyn HirDatabase,

crates/ide/src/inlay_hints.rs

@@ -240,6 +240,7 @@ fn hints(
                     },
                     ast::Expr::RangeExpr(it) => range_exclusive::hints(hints, famous_defs, config, it),
                     ast::Expr::Literal(it) => ra_fixture::hints(hints, famous_defs.0, file_id, config, it),
+                    ast::Expr::UnderscoreExpr(it) => placeholders::const_hints(hints, famous_defs, config, display_target, it),
                     _ => Some(()),
                 }
             },

crates/ide/src/inlay_hints/placeholders.rs

@@ -4,11 +4,12 @@
 //!           //^ = i32
 //! ```
 
-use hir::DisplayTarget;
+use either::Either;
+use hir::{DisplayTarget, HirDisplay};
 use ide_db::famous_defs::FamousDefs;
 use syntax::{
     AstNode,
-    ast::{InferType, Type},
+    ast::{InferType, UnderscoreExpr},
 };
 
 use crate::{InlayHint, InlayHintPosition, InlayHintsConfig, InlayKind, inlay_hints::label_of_ty};
@@ -27,9 +28,14 @@ pub(super) fn type_hints(
     let syntax = placeholder.syntax();
     let range = syntax.text_range();
 
-    let ty = sema.resolve_type(&Type::InferType(placeholder))?;
+    let type_or_const = sema.resolve_infer(&placeholder)?;
 
-    let mut label = label_of_ty(famous_defs, config, &ty, display_target)?;
+    let mut label = match type_or_const {
+        Either::Left(ty) => label_of_ty(famous_defs, config, &ty, display_target)?,
+        Either::Right(const_) => {
+            const_.display_truncated(sema.db, config.max_length, display_target).to_string().into()
+        }
+    };
     label.prepend_str("= ");
 
     acc.push(InlayHint {
@@ -45,6 +51,38 @@ pub(super) fn type_hints(
     Some(())
 }
 
+pub(super) fn const_hints(
+    acc: &mut Vec<InlayHint>,
+    FamousDefs(sema, _): &FamousDefs<'_, '_>,
+    config: &InlayHintsConfig<'_>,
+    display_target: DisplayTarget,
+    placeholder: UnderscoreExpr,
+) -> Option<()> {
+    if !config.type_hints || config.hide_inferred_type_hints {
+        return None;
+    }
+
+    let syntax = placeholder.syntax();
+    let range = syntax.text_range();
+
+    let const_ = sema.resolve_underscore_expr(&placeholder)?;
+
+    let display = const_.display_truncated(sema.db, config.max_length, display_target);
+    let label = format!("= {display}").into();
+
+    acc.push(InlayHint {
+        range,
+        kind: InlayKind::Type,
+        label,
+        text_edit: None,
+        position: InlayHintPosition::After,
+        pad_left: true,
+        pad_right: false,
+        resolve_parent: None,
+    });
+    Some(())
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{
@@ -58,17 +96,20 @@ mod tests {
     }
 
     #[test]
-    fn inferred_types() {
+    fn inferred_types_and_consts() {
         check_type_infer(
             r#"
-struct S<T>(T);
+struct S<T, const N: usize>([T; N]);
 
 fn foo() {
-    let t: (_, _, [_; _]) = (1_u32, S(2), [false] as _);
+    let t: (_, S<_, _>, [_; _]) = (1_u32, S([2, 3]) as _, [false] as _);
           //^ = u32
-             //^ = S<i32>
-                 //^ = bool
-                                                   //^ = [bool; 1]
+               //^ = i32
+                  //^ = 2
+                       //^ = bool
+                          //^ = 1
+                                                     //^ = S<i32, 2>
+                                                                   //^ = [bool; 1]
 }
 "#,
         );