Merge #11088

11088: closes #10446 hide type inlay hints r=Veykril a=Heinenen Passes tests as described in #10446 Works for all happy cases, there may be some cases that I forgot as I am not that familiar with Rust and r-a (yet). Co-authored-by: Heinenen <th.m.heinen@gmail.com>

Author: bors[bot]

crates/ide/src/inlay_hints.rs

@@ -257,26 +257,23 @@ fn is_named_constructor(
  }?;
  let expr = match expr {
  ast::Expr::CallExpr(call) => match call.expr()? {
- ast::Expr::PathExpr(p) => p,
+ ast::Expr::PathExpr(path) => path,
  _ => return None,
  },
+ ast::Expr::PathExpr(path) => path,
  _ => return None,
  };
  let path = expr.path()?;
 
- // Check for tuple-struct or tuple-variant in which case we can check the last segment
  let callable = sema.type_of_expr(&ast::Expr::PathExpr(expr))?.original.as_callable(sema.db);
  let callable_kind = callable.map(|it| it.kind());
- if let Some(hir::CallableKind::TupleStruct(_) | hir::CallableKind::TupleEnumVariant(_)) =
- callable_kind
- {
- if let Some(ctor) = path.segment() {
- return (ctor.to_string() == ty_name).then(|| ());
+ let qual_seg = match callable_kind {
+ Some(hir::CallableKind::Function(_) | hir::CallableKind::TupleEnumVariant(_)) => {
+ path.qualifier()?.segment()
  }
- }
+ _ => path.segment(),
+ }?;
 
- // otherwise use the qualifying segment as the constructor name
- let qual_seg = path.qualifier()?.segment()?;
  let ctor_name = match qual_seg.kind()? {
  ast::PathSegmentKind::Name(name_ref) => {
  match qual_seg.generic_arg_list().map(|it| it.generic_args()) {
@@ -1341,7 +1338,7 @@ fn main() {
  }
 
  #[test]
- fn skip_constructor_type_hints() {
+ fn skip_constructor_and_enum_type_hints() {
  check_with_config(
  InlayHintsConfig {
  type_hints: true,
@@ -1351,9 +1348,16 @@ fn main() {
  max_length: None,
  },
  r#"
-//- minicore: try
+//- minicore: try, option
 use core::ops::ControlFlow;
 
+mod x {
+ pub mod y { pub struct Foo; }
+ pub struct Foo;
+ pub enum AnotherEnum {
+ Variant()
+ };
+}
 struct Struct;
 struct TupleStruct();
 
@@ -1373,13 +1377,39 @@ impl Generic<i32> {
  }
 }
 
+enum Enum {
+ Variant(u32)
+}
+
+fn times2(value: i32) -> i32 {
+ 2 * value
+}
+
 fn main() {
+ let enumb = Enum::Variant(0);
+
+ let strukt = x::Foo;
+ let strukt = x::y::Foo;
+ let strukt = Struct;
  let strukt = Struct::new();
+
  let tuple_struct = TupleStruct();
+
  let generic0 = Generic::new();
- // ^^^^^^^^ Generic<i32>
- let generic1 = Generic::<i32>::new();
- let generic2 = <Generic<i32>>::new();
+ // ^^^^^^^^ Generic<i32>
+ let generic1 = Generic(0);
+ // ^^^^^^^^ Generic<i32>
+ let generic2 = Generic::<i32>::new();
+ let generic3 = <Generic<i32>>::new();
+ let generic4 = Generic::<i32>(0);
+
+
+ let option = Some(0);
+ // ^^^^^^ Option<i32>
+ let func = times2;
+ // ^^^^ fn times2(i32) -> i32
+ let closure = |x: i32| x * 2;
+ // ^^^^^^^ |i32| -> i32
 }
 
 fn fallible() -> ControlFlow<()> {