Suggest adding self type to method

Author: compiler-errors

compiler/rustc_hir_typeck/src/errors.rs

@@ -210,23 +210,42 @@ pub(crate) struct DependencyOnUnitNeverTypeFallback<'tcx> {
 pubsugg:SuggestAnnotations,
 }
 
+#[derive(Clone)]
+pub(crate)enumSuggestAnnotation{
+Unit(Span),
+Path(Span),
+}
+
 #[derive(Clone)]
 pub(crate)structSuggestAnnotations{
-pubsuggestion_spans:Vec<Span>,
+pubsuggestions:Vec<SuggestAnnotation>,
 }
 implSubdiagnosticforSuggestAnnotations{
 fnadd_to_diag_with<G:EmissionGuarantee,F:SubdiagMessageOp<G>>(
 self,
 diag:&mutDiag<'_,G>,
  _:&F,
 ){
-ifself.suggestion_spans.is_empty(){
+ifself.suggestions.is_empty(){
 return;
 }
 
+letmut suggestions = vec![];
+for suggestion inself.suggestions{
+match suggestion {
+SuggestAnnotation::Unit(span) => {
+ suggestions.push((span,"()".to_string()));
+}
+SuggestAnnotation::Path(span) => {
+ suggestions.push((span.shrink_to_lo(),"<() as ".to_string()));
+ suggestions.push((span.shrink_to_hi(),">".to_string()));
+}
+}
+}
+
  diag.multipart_suggestion_verbose(
 "use `()` annotations to avoid fallback changes",
-self.suggestion_spans.into_iter().map(|span| (span,String::from("()"))).collect(),
+suggestions,
 Applicability::MachineApplicable,
 );
 }

compiler/rustc_hir_typeck/src/fallback.rs

@@ -8,6 +8,7 @@ use rustc_data_structures::graph::{self};
 use rustc_data_structures::unord::{UnordBag,UnordMap,UnordSet};
 use rustc_hir as hir;
 use rustc_hir::HirId;
+use rustc_hir::def::{DefKind,Res};
 use rustc_hir::intravisit::Visitor;
 use rustc_middle::ty::{self,Ty,TyCtxt,TypeSuperVisitable,TypeVisitable};
 use rustc_session::lint;
@@ -573,7 +574,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
 // For each diverging var, look through the HIR for a place to give it
 // a type annotation. We do this per var because we only really need one
 // per var.
-letsuggestion_spans = diverging_vids
+letsuggestions = diverging_vids
 .iter()
 .copied()
 .filter_map(|vid| {
@@ -582,27 +583,43 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
 VidVisitor{ reachable_vids,fcx:self}.visit_expr(body.value).break_value()
 })
 .collect();
- errors::SuggestAnnotations{suggestion_spans}
+ errors::SuggestAnnotations{suggestions}
 }
 }
 
+/// Try to collect a useful suggestion to preserve fallback to `()`.
 structVidVisitor<'a,'tcx>{
 reachable_vids:FxHashSet<ty::TyVid>,
 fcx:&'aFnCtxt<'a,'tcx>,
 }
 impl<'tcx>Visitor<'tcx>forVidVisitor<'_,'tcx>{
-typeResult = ControlFlow<Span>;
+typeResult = ControlFlow<errors::SuggestAnnotation>;
 
 fnvisit_ty(&mutself,hir_ty:&'tcx hir::Ty<'tcx>) -> Self::Result{
 iflet hir::TyKind::Infer = hir_ty.kind
  && let ty = self.fcx.typeck_results.borrow().node_type(hir_ty.hir_id)
  && letSome(vid) = self.fcx.root_vid(ty)
  && self.reachable_vids.contains(&vid)
 {
-returnControlFlow::Break(hir_ty.span);
+returnControlFlow::Break(errors::SuggestAnnotation::Unit(hir_ty.span));
 }
  hir::intravisit::walk_ty(self, hir_ty)
 }
+
+fnvisit_expr(&mutself,expr:&'tcx hir::Expr<'tcx>) -> Self::Result{
+iflet hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = expr.kind
+ && letRes::Def(DefKind::AssocFn, def_id) = path.res
+ && self.fcx.tcx.trait_of_item(def_id).is_some()
+ && let self_ty = self.fcx.typeck_results.borrow().node_args(expr.hir_id).type_at(0)
+ && letSome(vid) = self.fcx.root_vid(self_ty)
+ && self.reachable_vids.contains(&vid)
+ && let[.., trait_segment, _method_segment] = path.segments
+{
+let span = path.span.shrink_to_lo().to(trait_segment.ident.span);
+returnControlFlow::Break(errors::SuggestAnnotation::Path(span));
+}
+ hir::intravisit::walk_expr(self, expr)
+}
 }
 
 #[derive(Debug,Copy,Clone)]

tests/ui/editions/never-type-fallback-breaking.e2021.stderr

@@ -13,6 +13,10 @@ note: in edition 2024, the requirement `!: Default` will fail
 LL | true => Default::default(),
  | ^^^^^^^^^^^^^^^^^^
  = note: `#[warn(dependency_on_unit_never_type_fallback)]` on by default
+help: use `()` annotations to avoid fallback changes
+ |
+LL | true => <() as Default>::default(),
+ | ++++++ +
 
 warning: this function depends on never type fallback being `()`
  --> $DIR/never-type-fallback-breaking.rs:27:1

tests/ui/never_type/diverging-fallback-control-flow.nofallback.stderr

@@ -13,6 +13,10 @@ note: in edition 2024, the requirement `!: UnitDefault` will fail
 LL | x = UnitDefault::default();
  | ^^^^^^^^^^^^^^^^^^^^^^
  = note: `#[warn(dependency_on_unit_never_type_fallback)]` on by default
+help: use `()` annotations to avoid fallback changes
+ |
+LL | x = <() as UnitDefault>::default();
+ | ++++++ +
 
 warning: this function depends on never type fallback being `()`
  --> $DIR/diverging-fallback-control-flow.rs:42:1
@@ -28,6 +32,10 @@ note: in edition 2024, the requirement `!: UnitDefault` will fail
  |
 LL | x = UnitDefault::default();
  | ^^^^^^^^^^^^^^^^^^^^^^
+help: use `()` annotations to avoid fallback changes
+ |
+LL | x = <() as UnitDefault>::default();
+ | ++++++ +
 
 warning: 2 warnings emitted