Also suggest calling constructors for external DefIds

Author: JohnTitor

compiler/rustc_typeck/src/check/method/suggest.rs

@@ -367,24 +367,34 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                 if self.is_fn_ty(rcvr_ty, span) {
                     if let SelfSource::MethodCall(expr) = source {
-                        let suggest = if let ty::FnDef(def_id, _) = rcvr_ty.kind() && let Some(local_id) = def_id.as_local() {
-                            let hir_id = tcx.hir().local_def_id_to_hir_id(local_id);
-                            let node = tcx.hir().get(hir_id);
-                            let fields = node.tuple_fields();
-
-                            if let Some(fields) = fields
-                                && let Some(DefKind::Ctor(of, _)) = self.tcx.opt_def_kind(local_id) {
-                                    Some((fields, of))
+                        let suggest = if let ty::FnDef(def_id, _) = rcvr_ty.kind() {
+                            if let Some(local_id) = def_id.as_local() {
+                                let hir_id = tcx.hir().local_def_id_to_hir_id(local_id);
+                                let node = tcx.hir().get(hir_id);
+                                let fields = node.tuple_fields();
+                                if let Some(fields) = fields
+                                    && let Some(DefKind::Ctor(of, _)) = self.tcx.opt_def_kind(local_id) {
+                                        Some((fields.len(), of))
+                                } else {
+                                    None
+                                }
                             } else {
-                                None
+                                // The logic here isn't smart but `associated_item_def_ids`
+                                // doesn't work nicely on local.
+                                if let DefKind::Ctor(of, _) = tcx.def_kind(def_id) {
+                                    let parent_def_id = tcx.parent(*def_id);
+                                    Some((tcx.associated_item_def_ids(parent_def_id).len(), of))
+                                } else {
+                                    None
+                                }
                             }
                         } else {
                             None
                         };
 
                         // If the function is a tuple constructor, we recommend that they call it
                         if let Some((fields, kind)) = suggest {
-                            suggest_call_constructor(expr.span, kind, fields.len(), &mut err);
+                            suggest_call_constructor(expr.span, kind, fields, &mut err);
                         } else {
                             // General case
                             err.span_label(

src/test/ui/typeck/issue-96738.stderr

@@ -4,7 +4,12 @@ error[E0599]: no method named `nonexistent_method` found for fn item `fn(_) -> O
 LL |     Some.nonexistent_method();
    |     ---- ^^^^^^^^^^^^^^^^^^ method not found in `fn(_) -> Option<_> {Option::<_>::Some}`
    |     |
-   |     this is a function, perhaps you wish to call it
+   |     this is the constructor of an enum variant
+   |
+help: call the constructor
+   |
+LL |     (Some)(_).nonexistent_method();
+   |     +    ++++
 
 error: aborting due to previous error