Rollup merge of #130282 - compiler-errors:over-overflow, r=BoxyUwU

Do not report an excessive number of overflow errors for an ever-growing deref impl
Check that we don't first hit the recursion limit in `get_field_candidates_considering_privacy` before probing for methods when we have a method lookup failure and we want to see if `.field.method()` exists. We also silence overflow error messages if we're probing for methods for diagnostics.
Also renames some functions to make it clearer that they're only for diagnostics, and sprinkle some `Autoderef::silence_errors` around to silence unnecessary overflow errors that come from diagnostics.
Fixes#130224.

Author: matthiaskrgr

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1049,7 +1049,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 /// trait or region sub-obligations. (presumably we could, but it's not
 /// particularly important for diagnostics...)
 pub(crate)fnderef_once_mutably_for_diagnostic(&self,expr_ty:Ty<'tcx>) -> Option<Ty<'tcx>>{
-self.autoderef(DUMMY_SP, expr_ty).nth(1).and_then(|(deref_ty, _)| {
+self.autoderef(DUMMY_SP, expr_ty).silence_errors().nth(1).and_then(|(deref_ty, _)| {
 self.infcx
 .type_implements_trait(
 self.tcx.lang_items().deref_mut_trait()?,

compiler/rustc_hir_typeck/src/expr.rs

@@ -2864,13 +2864,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 (expr_t,"")
 };
 for(found_fields, args)in
-self.get_field_candidates_considering_privacy(span, ty, mod_id, id)
+self.get_field_candidates_considering_privacy_for_diag(span, ty, mod_id, id)
 {
 let field_names = found_fields.iter().map(|field| field.name).collect::<Vec<_>>();
 letmut candidate_fields:Vec<_> = found_fields
 .into_iter()
 .filter_map(|candidate_field| {
-self.check_for_nested_field_satisfying(
+self.check_for_nested_field_satisfying_condition_for_diag(
  span,
 &|candidate_field, _| candidate_field.ident(self.tcx()) == field,
  candidate_field,
@@ -2933,7 +2933,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 .with_span_label(field.span,"private field")
 }
 
-pub(crate)fnget_field_candidates_considering_privacy(
+pub(crate)fnget_field_candidates_considering_privacy_for_diag(
 &self,
 span:Span,
 base_ty:Ty<'tcx>,
@@ -2942,7 +2942,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 ) -> Vec<(Vec<&'tcx ty::FieldDef>,GenericArgsRef<'tcx>)>{
 debug!("get_field_candidates(span: {:?}, base_t: {:?}", span, base_ty);
 
-self.autoderef(span, base_ty)
+letmut autoderef = self.autoderef(span, base_ty).silence_errors();
+let deref_chain:Vec<_> = autoderef.by_ref().collect();
+
+// Don't probe if we hit the recursion limit, since it may result in
+// quadratic blowup if we then try to further deref the results of this
+// function. This is a best-effort method, after all.
+if autoderef.reached_recursion_limit(){
+returnvec![];
+}
+
+ deref_chain
+.into_iter()
 .filter_map(move |(base_t, _)| {
 match base_t.kind(){
  ty::Adt(base_def, args)if !base_def.is_enum() => {
@@ -2975,7 +2986,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
 /// This method is called after we have encountered a missing field error to recursively
 /// search for the field
-pub(crate)fncheck_for_nested_field_satisfying(
+pub(crate)fncheck_for_nested_field_satisfying_condition_for_diag(
 &self,
 span:Span,
 matches:&implFn(&ty::FieldDef,Ty<'tcx>) -> bool,
@@ -3000,20 +3011,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 ifmatches(candidate_field, field_ty){
 returnSome(field_path);
 }else{
-for(nested_fields, subst)in
-self.get_field_candidates_considering_privacy(span, field_ty, mod_id, hir_id)
+for(nested_fields, subst)inself
+.get_field_candidates_considering_privacy_for_diag(
+ span, field_ty, mod_id, hir_id,
+)
 {
 // recursively search fields of `candidate_field` if it's a ty::Adt
 for field in nested_fields {
-ifletSome(field_path) = self.check_for_nested_field_satisfying(
- span,
- matches,
- field,
- subst,
- field_path.clone(),
- mod_id,
- hir_id,
-){
+ifletSome(field_path) = self
+.check_for_nested_field_satisfying_condition_for_diag(
+ span,
+ matches,
+ field,
+ subst,
+ field_path.clone(),
+ mod_id,
+ hir_id,
+)
+{
 returnSome(field_path);
 }
 }

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -375,7 +375,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 // If our autoderef loop had reached the recursion limit,
 // report an overflow error, but continue going on with
 // the truncated autoderef list.
-if steps.reached_recursion_limit{
+if steps.reached_recursion_limit&& !is_suggestion.0{
 self.probe(|_| {
 let ty = &steps
 .steps

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -62,14 +62,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 // It might seem that we can use `predicate_must_hold_modulo_regions`,
 // but since a Dummy binder is used to fill in the FnOnce trait's arguments,
 // type resolution always gives a "maybe" here.
-ifself.autoderef(span, ty).any(|(ty, _)| {
+ifself.autoderef(span, ty).silence_errors().any(|(ty, _)| {
 info!("check deref {:?} error", ty);
 matches!(ty.kind(), ty::Error(_) | ty::Infer(_))
 }){
 returnfalse;
 }
 
-self.autoderef(span, ty).any(|(ty, _)| {
+self.autoderef(span, ty).silence_errors().any(|(ty, _)| {
 info!("check deref {:?} impl FnOnce", ty);
 self.probe(|_| {
 let trait_ref =
@@ -90,7 +90,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 fnis_slice_ty(&self,ty:Ty<'tcx>,span:Span) -> bool{
-self.autoderef(span, ty).any(|(ty, _)| matches!(ty.kind(), ty::Slice(..) | ty::Array(..)))
+self.autoderef(span, ty)
+.silence_errors()
+.any(|(ty, _)| matches!(ty.kind(), ty::Slice(..) | ty::Array(..)))
 }
 
 fnimpl_into_iterator_should_be_iterator(
@@ -672,7 +674,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 letmut ty_str_reported = ty_str.clone();
 iflet ty::Adt(_, generics) = rcvr_ty.kind(){
 if generics.len() > 0{
-letmut autoderef = self.autoderef(span, rcvr_ty);
+letmut autoderef = self.autoderef(span, rcvr_ty).silence_errors();
 let candidate_found = autoderef.any(|(ty, _)| {
 iflet ty::Adt(adt_def, _) = ty.kind(){
 self.tcx
@@ -2237,6 +2239,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 let impl_ty = self.tcx.type_of(*impl_did).instantiate_identity();
 let target_ty = self
 .autoderef(sugg_span, rcvr_ty)
+.silence_errors()
 .find(|(rcvr_ty, _)| {
 DeepRejectCtxt::relate_rigid_infer(self.tcx).types_may_unify(*rcvr_ty, impl_ty)
 })
@@ -2352,17 +2355,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 err:&mutDiag<'_>,
 ) -> bool{
 let tcx = self.tcx;
-let field_receiver = self.autoderef(span, rcvr_ty).find_map(|(ty, _)| match ty.kind(){
- ty::Adt(def, args)if !def.is_enum() => {
-let variant = &def.non_enum_variant();
- tcx.find_field_index(item_name, variant).map(|index| {
-let field = &variant.fields[index];
-let field_ty = field.ty(tcx, args);
-(field, field_ty)
-})
-}
- _ => None,
-});
+let field_receiver =
+self.autoderef(span, rcvr_ty).silence_errors().find_map(|(ty, _)| match ty.kind(){
+ ty::Adt(def, args)if !def.is_enum() => {
+let variant = &def.non_enum_variant();
+ tcx.find_field_index(item_name, variant).map(|index| {
+let field = &variant.fields[index];
+let field_ty = field.ty(tcx, args);
+(field, field_ty)
+})
+}
+ _ => None,
+});
 ifletSome((field, field_ty)) = field_receiver {
 let scope = tcx.parent_module_from_def_id(self.body_id);
 let is_accessible = field.vis.is_accessible_from(scope, tcx);
@@ -2675,9 +2679,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 ){
 ifletSelfSource::MethodCall(expr) = source {
 let mod_id = self.tcx.parent_module(expr.hir_id).to_def_id();
-for(fields, args)in
-self.get_field_candidates_considering_privacy(span, actual, mod_id, expr.hir_id)
-{
+for(fields, args)inself.get_field_candidates_considering_privacy_for_diag(
+ span,
+ actual,
+ mod_id,
+ expr.hir_id,
+){
 let call_expr = self.tcx.hir().expect_expr(self.tcx.parent_hir_id(expr.hir_id));
 
 let lang_items = self.tcx.lang_items();
@@ -2693,7 +2700,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 letmut candidate_fields:Vec<_> = fields
 .into_iter()
 .filter_map(|candidate_field| {
-self.check_for_nested_field_satisfying(
+self.check_for_nested_field_satisfying_condition_for_diag(
  span,
 &|_, field_ty| {
 self.lookup_probe_for_diagnostic(
@@ -3195,7 +3202,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 letSelfSource::QPath(ty) = self_source else{
 return;
 };
-for(deref_ty, _)inself.autoderef(DUMMY_SP, rcvr_ty).skip(1){
+for(deref_ty, _)inself.autoderef(DUMMY_SP, rcvr_ty).silence_errors().skip(1){
 ifletOk(pick) = self.probe_for_name(
 Mode::Path,
  item_name,
@@ -4221,7 +4228,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 returnis_local(rcvr_ty);
 }
 
-self.autoderef(span, rcvr_ty).any(|(ty, _)| is_local(ty))
+self.autoderef(span, rcvr_ty).silence_errors().any(|(ty, _)| is_local(ty))
 }
 }
 

compiler/rustc_hir_typeck/src/pat.rs

@@ -2533,6 +2533,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  err.help("the semantics of slice patterns changed recently; see issue #62254");
 }elseifself
 .autoderef(span, expected_ty)
+.silence_errors()
 .any(|(ty, _)| matches!(ty.kind(), ty::Slice(..) | ty::Array(..)))
  && letSome(span) = ti.span
  && letSome(_) = ti.origin_expr

tests/ui/methods/probe-error-on-infinite-deref.rs

@@ -0,0 +1,16 @@
+use std::ops::Deref;
+
+// Make sure that method probe error reporting doesn't get too tangled up
+// on this infinite deref impl. See #130224.
+
+structWrap<T>(T);
+impl<T>DerefforWrap<T>{
+typeTarget = Wrap<Wrap<T>>;
+fnderef(&self) -> &Wrap<Wrap<T>>{todo!()}
+}
+
+fnmain(){
+Wrap(1).lmao();
+//~^ ERROR reached the recursion limit
+//~| ERROR no method named `lmao`
+}

tests/ui/methods/probe-error-on-infinite-deref.stderr

@@ -0,0 +1,21 @@
+error[E0055]: reached the recursion limit while auto-dereferencing `Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<Wrap<{integer}>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ --> $DIR/probe-error-on-infinite-deref.rs:13:13
+ |
+LL | Wrap(1).lmao();
+ | ^^^^ deref recursion limit reached
+ |
+ = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`probe_error_on_infinite_deref`)
+
+error[E0599]: no method named `lmao` found for struct `Wrap<{integer}>` in the current scope
+ --> $DIR/probe-error-on-infinite-deref.rs:13:13
+ |
+LL | struct Wrap<T>(T);
+ | -------------- method `lmao` not found for this struct
+...
+LL | Wrap(1).lmao();
+ | ^^^^ method not found in `Wrap<{integer}>`
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0055, E0599.
+For more information about an error, try `rustc --explain E0055`.