fix: verify self is callee part of call expr parent

Author: NKID00

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1592,13 +1592,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     && let hir::Node::Stmt(&hir::Stmt { kind: hir::StmtKind::Semi(parent), .. })
                     | hir::Node::Expr(parent) = self.tcx.parent_hir_node(path_expr.hir_id)
                 {
-                    let replacement_span =
-                        if let hir::ExprKind::Call(..) | hir::ExprKind::Struct(..) = parent.kind {
-                            // We want to replace the parts that need to go, like `()` and `{}`.
+                    // We want to also replace variant constructor part like `()` and `{}`.
+                    let replacement_span = match parent.kind {
+                        hir::ExprKind::Call(callee, ..) if callee.hir_id == path_expr.hir_id => {
                             span.with_hi(parent.span.hi())
-                        } else {
-                            span
-                        };
+                        }
+                        hir::ExprKind::Struct(..) => span.with_hi(parent.span.hi()),
+                        _ => span,
+                    };
                     match (variant.ctor, parent.kind) {
                         (None, hir::ExprKind::Struct(..)) => {
                             // We want a struct and we have a struct. We won't suggest changing

tests/ui/suggestions/incorrect-variant-in-arg.rs

@@ -0,0 +1,57 @@
+// Regression test for #146586
+
+//@ only-linux
+//@ compile-flags: --error-format=human --color=always
+
+enum Enum {
+    Unit,
+    Tuple(i32),
+    Struct { x: i32 },
+}
+
+fn foo(_: Enum) {}
+
+fn main() {
+    foo(Enum::Unit);
+    foo(Enum::Tuple);
+    foo(Enum::Struct);  // Highlight is wrong and suggestion is malformed
+    foo(Enum::Unit());
+    foo(Enum::Tuple());
+    foo(Enum::Struct());
+    foo(Enum::Unit {});
+    foo(Enum::Tuple {});
+    foo(Enum::Struct {});
+    foo(Enum::Unit(0));
+    foo(Enum::Tuple(0));
+    foo(Enum::Struct(0));
+    foo(Enum::Unit { x: 0 });
+    foo(Enum::Tuple { x: 0 });
+    foo(Enum::Struct { x: 0 });
+    foo(Enum::Unit(0, 0));
+    foo(Enum::Tuple(0, 0));
+    foo(Enum::Struct(0, 0));
+    foo(Enum::Unit { x: 0, y: 0 });
+    foo(Enum::Tuple { x: 0, y: 0 });
+    foo(Enum::Struct { x: 0, y: 0 });
+    foo(Enum::unit);  // Suggestion was malformed
+    foo(Enum::tuple);  // Suggestion could be enhanced
+    foo(Enum::r#struct);  // Suggestion was malformed
+    foo(Enum::unit());
+    foo(Enum::tuple());
+    foo(Enum::r#struct());
+    foo(Enum::unit {});  // Suggestion could be enhanced
+    foo(Enum::tuple {});  // Suggestion could be enhanced
+    foo(Enum::r#struct {});  // Suggestion could be enhanced
+    foo(Enum::unit(0));
+    foo(Enum::tuple(0));
+    foo(Enum::r#struct(0));
+    foo(Enum::unit { x: 0 });  // Suggestion could be enhanced
+    foo(Enum::tuple { x: 0 });  // Suggestion could be enhanced
+    foo(Enum::r#struct { x: 0 });
+    foo(Enum::unit(0, 0));
+    foo(Enum::tuple(0, 0));
+    foo(Enum::r#struct(0, 0));
+    foo(Enum::unit { x: 0, y: 0 });  // Suggestion could be enhanced
+    foo(Enum::tuple { x: 0, y: 0 });  // Suggestion could be enhanced
+    foo(Enum::r#struct { x: 0, y: 0 });  // Suggestion could be enhanced
+}