Unrolled build for rust-lang#132760

rust-timer · web-flow · commit f3f92814d663 · 2024-11-09T04:45:41.000-05:00
Rollup merge of rust-lang#132760 - dianne:iter-into-iter, r=lcnr Don't suggest `.into_iter()` on iterators This makes the the suggestion to call `.into_iter()` only consider unsatisfied `Iterator` bounds for the receiver type itself. That way, it ignores predicates generated by trying to auto-ref the receiver (the result of which usually won't implement `Iterator`). Fixes rust-lang#127511 Unfortunately, the error in that case is still confusing: it labels `Iterator` as an unsatisfied bound because `&impl Iterator: Iterator` can't be satisfied, despite that not being required or helpful. I'd like to handle that in a separate PR. ~~I'm hoping fixing rust-lang#124802 will fix it too.~~ It doesn't look connected to that issue. Still, I think it'd be clearest to visually distinguish unsatisfied predicates from different attempts at `pick_method`; I'll make a PR for that soon.
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -100,9 +100,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         ty: Ty<'tcx>,
         span: Span,
         unsatisfied_predicates: &Vec<(
-            ty::Predicate<'_>,
-            Option<ty::Predicate<'_>>,
-            Option<ObligationCause<'_>>,
+            ty::Predicate<'tcx>,
+            Option<ty::Predicate<'tcx>>,
+            Option<ObligationCause<'tcx>>,
         )>,
     ) -> bool {
         fn predicate_bounds_generic_param<'tcx>(
@@ -131,15 +131,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
-        fn is_iterator_predicate(predicate: ty::Predicate<'_>, tcx: TyCtxt<'_>) -> bool {
+        let is_iterator_predicate = |predicate: ty::Predicate<'tcx>| -> bool {
             if let ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_pred)) =
                 predicate.kind().as_ref().skip_binder()
             {
-                tcx.is_diagnostic_item(sym::Iterator, trait_pred.trait_ref.def_id)
+                self.tcx.is_diagnostic_item(sym::Iterator, trait_pred.trait_ref.def_id)
+                    // ignore unsatisfied predicates generated from trying to auto-ref ty (#127511)
+                    && trait_pred.trait_ref.self_ty() == ty
             } else {
                 false
             }
-        }
+        };
 
         // Does the `ty` implement `IntoIterator`?
         let Some(into_iterator_trait) = self.tcx.get_diagnostic_item(sym::IntoIterator) else {
@@ -164,15 +166,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         generics,
                         generic_param,
                         self.tcx,
-                    ) && is_iterator_predicate(unsatisfied.0, self.tcx)
+                    ) && is_iterator_predicate(unsatisfied.0)
                     {
                         return true;
                     }
                 }
             }
             ty::Slice(..) | ty::Adt(..) | ty::Alias(ty::Opaque, _) => {
                 for unsatisfied in unsatisfied_predicates.iter() {
-                    if is_iterator_predicate(unsatisfied.0, self.tcx) {
+                    if is_iterator_predicate(unsatisfied.0) {
                         return true;
                     }
                 }
diff --git a/tests/ui/iterators/iterator-does-not-need-into-iter.rs b/tests/ui/iterators/iterator-does-not-need-into-iter.rs
@@ -0,0 +1,18 @@
+//! regression test for #127511: don't suggest `.into_iter()` on iterators
+
+trait Missing {}
+trait HasMethod {
+    fn foo(self);
+}
+impl<T: Iterator + Missing> HasMethod for T {
+    fn foo(self) {}
+}
+
+fn get_iter() -> impl Iterator {
+    core::iter::once(())
+}
+
+fn main() {
+    get_iter().foo();
+    //~^ ERROR the method `foo` exists for opaque type `impl Iterator`, but its trait bounds were not satisfied [E0599]
+}
diff --git a/tests/ui/iterators/iterator-does-not-need-into-iter.stderr b/tests/ui/iterators/iterator-does-not-need-into-iter.stderr
@@ -0,0 +1,28 @@
+error[E0599]: the method `foo` exists for opaque type `impl Iterator`, but its trait bounds were not satisfied
+  --> $DIR/iterator-does-not-need-into-iter.rs:16:16
+   |
+LL |     get_iter().foo();
+   |                ^^^ method cannot be called on `impl Iterator` due to unsatisfied trait bounds
+   |
+note: the following trait bounds were not satisfied:
+      `&impl Iterator: Iterator`
+      `&impl Iterator: Missing`
+      `&mut impl Iterator: Missing`
+      `impl Iterator: Missing`
+  --> $DIR/iterator-does-not-need-into-iter.rs:7:9
+   |
+LL | impl<T: Iterator + Missing> HasMethod for T {
+   |         ^^^^^^^^   ^^^^^^^  ---------     -
+   |         |          |
+   |         |          unsatisfied trait bound introduced here
+   |         unsatisfied trait bound introduced here
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `HasMethod` defines an item `foo`, perhaps you need to implement it
+  --> $DIR/iterator-does-not-need-into-iter.rs:4:1
+   |
+LL | trait HasMethod {
+   | ^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.

Original file line number	Diff line number	Diff line change
`@@ -100,9 +100,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`100`	`100`	`ty: Ty<'tcx>,`
`101`	`101`	`span: Span,`
`102`	`102`	`unsatisfied_predicates: &Vec<(`
`103`		`- ty::Predicate<'_>,`
`104`		`- Option<ty::Predicate<'_>>,`
`105`		`- Option<ObligationCause<'_>>,`
	`103`	`+ ty::Predicate<'tcx>,`
	`104`	`+ Option<ty::Predicate<'tcx>>,`
	`105`	`+ Option<ObligationCause<'tcx>>,`
`106`	`106`	`)>,`
`107`	`107`	`) -> bool {`
`108`	`108`	`fn predicate_bounds_generic_param<'tcx>(`
`@@ -131,15 +131,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
`134`		`- fn is_iterator_predicate(predicate: ty::Predicate<'_>, tcx: TyCtxt<'_>) -> bool {`
	`134`	`+ let is_iterator_predicate = \|predicate: ty::Predicate<'tcx>\| -> bool {`
`135`	`135`	`if let ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_pred)) =`
`136`	`136`	`predicate.kind().as_ref().skip_binder()`
`137`	`137`	`{`
`138`		`- tcx.is_diagnostic_item(sym::Iterator, trait_pred.trait_ref.def_id)`
	`138`	`+ self.tcx.is_diagnostic_item(sym::Iterator, trait_pred.trait_ref.def_id)`
	`139`	`+ // ignore unsatisfied predicates generated from trying to auto-ref ty (#127511)`
	`140`	`+ && trait_pred.trait_ref.self_ty() == ty`
`139`	`141`	`} else {`
`140`	`142`	`false`
`141`	`143`	`}`
`142`		`- }`
	`144`	`+ };`
`143`	`145`
`144`	`146`	// Does the `ty` implement `IntoIterator`?
`145`	`147`	`let Some(into_iterator_trait) = self.tcx.get_diagnostic_item(sym::IntoIterator) else {`
`@@ -164,15 +166,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`164`	`166`	`generics,`
`165`	`167`	`generic_param,`
`166`	`168`	`self.tcx,`
`167`		`- ) && is_iterator_predicate(unsatisfied.0, self.tcx)`
	`169`	`+ ) && is_iterator_predicate(unsatisfied.0)`
`168`	`170`	`{`
`169`	`171`	`return true;`
`170`	`172`	`}`
`171`	`173`	`}`
`172`	`174`	`}`
`173`	`175`	`ty::Slice(..) \| ty::Adt(..) \| ty::Alias(ty::Opaque, _) => {`
`174`	`176`	`for unsatisfied in unsatisfied_predicates.iter() {`
`175`		`- if is_iterator_predicate(unsatisfied.0, self.tcx) {`
	`177`	`+ if is_iterator_predicate(unsatisfied.0) {`
`176`	`178`	`return true;`
`177`	`179`	`}`
`178`	`180`	`}`