Filter out non-Self supertrait predicates in unused_must_use

Author: compiler-errors

compiler/rustc_lint/src/unused.rs

@@ -251,19 +251,18 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
                         .map(|inner| MustUsePath::Boxed(Box::new(inner)))
                 }
                 ty::Adt(def, _) => is_def_must_use(cx, def.did(), span),
-                ty::Opaque(def, _) => {
+                ty::Opaque(def, substs) => {
                     elaborate_predicates_with_span(
                         cx.tcx,
-                        cx.tcx.explicit_item_bounds(def).iter().cloned(),
+                        cx.tcx.bound_explicit_item_bounds(def).subst_iter_copied(cx.tcx, substs),
                     )
                     .filter_map(|obligation| {
                         // We only look at the `DefId`, so it is safe to skip the binder here.
-                        if let ty::PredicateKind::Trait(ref poly_trait_predicate) =
+                        if let ty::PredicateKind::Trait(ref trait_predicate) =
                             obligation.predicate.kind().skip_binder()
+                            && trait_predicate.self_ty() == ty
                         {
-                            let def_id = poly_trait_predicate.trait_ref.def_id;
-
-                            is_def_must_use(cx, def_id, span)
+                            is_def_must_use(cx, trait_predicate.def_id(), span)
                         } else {
                             None
                         }

src/test/ui/lint/unused/trait-alias-supertrait.rs

@@ -0,0 +1,15 @@
+// check-pass
+
+// Make sure that we only consider *Self* supertrait predicates
+// in the `unused_must_use` lint.
+
+#![feature(trait_alias)]
+#![deny(unused_must_use)]
+
+trait Foo<T> = Sized where T: Iterator;
+
+fn test<T: Iterator>() -> impl Foo<T> {}
+
+fn main() {
+    test::<std::iter::Once<()>>();
+}