Suppress must_use in compiler and tools

compiler-errors · compiler-errors · commit 7408d1c1b670 · 2025-03-04T17:44:34.000Z
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -2225,7 +2225,7 @@ fn add_library_search_dirs(
         return;
     }
 
-    walk_native_lib_search_dirs(
+    let _ = walk_native_lib_search_dirs(
         sess,
         self_contained_components,
         apple_sdk_root,
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -519,7 +519,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         }
                     }
                     _ => {
-                        intravisit::walk_pat(self, p);
+                        let _ = intravisit::walk_pat(self, p);
                     }
                 }
                 ControlFlow::Continue(())
@@ -542,7 +542,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     method_name,
                     sugg_let: None,
                 };
-                let_visitor.visit_body(&body);
+                let _ = let_visitor.visit_body(&body);
                 if let Some(sugg_let) = let_visitor.sugg_let
                     && let Some(self_ty) = self.node_ty_opt(sugg_let.init_hir_id)
                 {
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -1361,12 +1361,12 @@ impl SearchInterfaceForPrivateItemsVisitor<'_> {
                 GenericParamDefKind::Lifetime => {}
                 GenericParamDefKind::Type { has_default, .. } => {
                     if has_default {
-                        self.visit(self.tcx.type_of(param.def_id).instantiate_identity());
+                        let _ = self.visit(self.tcx.type_of(param.def_id).instantiate_identity());
                     }
                 }
                 // FIXME(generic_const_exprs): May want to look inside const here
                 GenericParamDefKind::Const { .. } => {
-                    self.visit(self.tcx.type_of(param.def_id).instantiate_identity());
+                    let _ = self.visit(self.tcx.type_of(param.def_id).instantiate_identity());
                 }
             }
         }
@@ -1381,19 +1381,19 @@ impl SearchInterfaceForPrivateItemsVisitor<'_> {
         // consider the ones that the user wrote. This is important
         // for the inferred outlives rules; see
         // `tests/ui/rfc-2093-infer-outlives/privacy.rs`.
-        self.visit_predicates(self.tcx.explicit_predicates_of(self.item_def_id));
+        let _ = self.visit_predicates(self.tcx.explicit_predicates_of(self.item_def_id));
         self
     }
 
     fn bounds(&mut self) -> &mut Self {
         self.in_primary_interface = false;
-        self.visit_clauses(self.tcx.explicit_item_bounds(self.item_def_id).skip_binder());
+        let _ = self.visit_clauses(self.tcx.explicit_item_bounds(self.item_def_id).skip_binder());
         self
     }
 
     fn ty(&mut self) -> &mut Self {
         self.in_primary_interface = true;
-        self.visit(self.tcx.type_of(self.item_def_id).instantiate_identity());
+        let _ = self.visit(self.tcx.type_of(self.item_def_id).instantiate_identity());
         self
     }
 
@@ -1785,7 +1785,7 @@ fn check_mod_privacy(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
 
     let module = tcx.hir_module_items(module_def_id);
     for def_id in module.definitions() {
-        rustc_ty_utils::sig_types::walk_types(tcx, def_id, &mut visitor);
+        let _ = rustc_ty_utils::sig_types::walk_types(tcx, def_id, &mut visitor);
 
         if let Some(body_id) = tcx.hir_maybe_body_owned_by(def_id) {
             visitor.visit_nested_body(body_id.id());
@@ -1798,7 +1798,11 @@ fn check_mod_privacy(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
                 let trait_ref = tcx.impl_trait_ref(id.owner_id.def_id).unwrap();
                 let trait_ref = trait_ref.instantiate_identity();
                 visitor.span = item.path.span;
-                visitor.visit_def_id(trait_ref.def_id, "trait", &trait_ref.print_only_trait_path());
+                let _ = visitor.visit_def_id(
+                    trait_ref.def_id,
+                    "trait",
+                    &trait_ref.print_only_trait_path(),
+                );
             }
         }
     }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/find_anon_type.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/find_anon_type.rs
@@ -77,15 +77,15 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {
         match arg.kind {
             hir::TyKind::BareFn(_) => {
                 self.current_index.shift_in(1);
-                intravisit::walk_ty(self, arg);
+                let _ = intravisit::walk_ty(self, arg);
                 self.current_index.shift_out(1);
                 return ControlFlow::Continue(());
             }
 
             hir::TyKind::TraitObject(bounds, ..) => {
                 for bound in bounds {
                     self.current_index.shift_in(1);
-                    self.visit_poly_trait_ref(bound);
+                    let _ = self.visit_poly_trait_ref(bound);
                     self.current_index.shift_out(1);
                 }
             }
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -743,7 +743,7 @@ fn assemble_candidates_from_trait_def<'cx, 'tcx>(
 ) {
     debug!("assemble_candidates_from_trait_def(..)");
     let mut ambiguous = false;
-    selcx.for_each_item_bound(
+    let _ = selcx.for_each_item_bound(
         obligation.predicate.self_ty(),
         |selcx, clause, _| {
             let Some(clause) = clause.as_projection_clause() else {
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -176,7 +176,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // normalization, so try to deduplicate when possible to avoid
             // unnecessary ambiguity.
             let mut distinct_normalized_bounds = FxHashSet::default();
-            self.for_each_item_bound::<!>(
+            let _ = self.for_each_item_bound::<!>(
                 placeholder_trait_predicate.self_ty(),
                 |selcx, bound, idx| {
                     let Some(bound) = bound.as_trait_clause() else {
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
@@ -112,7 +112,7 @@ where
     pub fn bind_with_vars(value: T, bound_vars: I::BoundVarKinds) -> Binder<I, T> {
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
-            value.visit_with(&mut validator);
+            let _ = value.visit_with(&mut validator);
         }
         Binder { value, bound_vars }
     }
@@ -196,7 +196,7 @@ impl<I: Interner, T> Binder<I, T> {
         let value = f(value);
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
-            value.visit_with(&mut validator);
+            let _ = value.visit_with(&mut validator);
         }
         Binder { value, bound_vars }
     }
@@ -209,7 +209,7 @@ impl<I: Interner, T> Binder<I, T> {
         let value = f(value)?;
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
-            value.visit_with(&mut validator);
+            let _ = value.visit_with(&mut validator);
         }
         Ok(Binder { value, bound_vars })
     }
diff --git a/src/librustdoc/html/length_limit/tests.rs b/src/librustdoc/html/length_limit/tests.rs
@@ -9,53 +9,53 @@ fn empty() {
 #[test]
 fn basic() {
     let mut buf = HtmlWithLimit::new(60);
-    buf.push("Hello ");
+    let _ = buf.push("Hello ");
     buf.open_tag("em");
-    buf.push("world");
+    let _ = buf.push("world");
     buf.close_tag();
-    buf.push("!");
+    let _ = buf.push("!");
     assert_eq!(buf.finish(), "Hello <em>world</em>!");
 }
 
 #[test]
 fn no_tags() {
     let mut buf = HtmlWithLimit::new(60);
-    buf.push("Hello");
-    buf.push(" world!");
+    let _ = buf.push("Hello");
+    let _ = buf.push(" world!");
     assert_eq!(buf.finish(), "Hello world!");
 }
 
 #[test]
 fn limit_0() {
     let mut buf = HtmlWithLimit::new(0);
-    buf.push("Hello ");
+    let _ = buf.push("Hello ");
     buf.open_tag("em");
-    buf.push("world");
+    let _ = buf.push("world");
     buf.close_tag();
-    buf.push("!");
+    let _ = buf.push("!");
     assert_eq!(buf.finish(), "");
 }
 
 #[test]
 fn exactly_limit() {
     let mut buf = HtmlWithLimit::new(12);
-    buf.push("Hello ");
+    let _ = buf.push("Hello ");
     buf.open_tag("em");
-    buf.push("world");
+    let _ = buf.push("world");
     buf.close_tag();
-    buf.push("!");
+    let _ = buf.push("!");
     assert_eq!(buf.finish(), "Hello <em>world</em>!");
 }
 
 #[test]
 fn multiple_nested_tags() {
     let mut buf = HtmlWithLimit::new(60);
     buf.open_tag("p");
-    buf.push("This is a ");
+    let _ = buf.push("This is a ");
     buf.open_tag("em");
-    buf.push("paragraph");
+    let _ = buf.push("paragraph");
     buf.open_tag("strong");
-    buf.push("!");
+    let _ = buf.push("!");
     buf.close_tag();
     buf.close_tag();
     buf.close_tag();
@@ -66,11 +66,11 @@ fn multiple_nested_tags() {
 fn forgot_to_close_tags() {
     let mut buf = HtmlWithLimit::new(60);
     buf.open_tag("p");
-    buf.push("This is a ");
+    let _ = buf.push("This is a ");
     buf.open_tag("em");
-    buf.push("paragraph");
+    let _ = buf.push("paragraph");
     buf.open_tag("strong");
-    buf.push("!");
+    let _ = buf.push("!");
     assert_eq!(buf.finish(), "<p>This is a <em>paragraph<strong>!</strong></em></p>");
 }
 
@@ -80,8 +80,8 @@ fn past_the_limit() {
     buf.open_tag("p");
     (0..10).try_for_each(|n| {
         buf.open_tag("strong");
-        buf.push("word#")?;
-        buf.push(&n.to_string())?;
+        let _ = buf.push("word#")?;
+        let _ = buf.push(&n.to_string())?;
         buf.close_tag();
         ControlFlow::Continue(())
     });
@@ -100,8 +100,8 @@ fn past_the_limit() {
 fn quickly_past_the_limit() {
     let mut buf = HtmlWithLimit::new(6);
     buf.open_tag("p");
-    buf.push("Hello");
-    buf.push(" World");
+    let _ = buf.push("Hello");
+    let _ = buf.push(" World");
     // intentionally not closing <p> before finishing
     assert_eq!(buf.finish(), "<p>Hello</p>");
 }
@@ -110,7 +110,7 @@ fn quickly_past_the_limit() {
 fn close_too_many() {
     let mut buf = HtmlWithLimit::new(60);
     buf.open_tag("p");
-    buf.push("Hello");
+    let _ = buf.push("Hello");
     buf.close_tag();
     // This call does not panic because there are valid cases
     // where `close_tag()` is called with no tags left to close.
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
@@ -1569,7 +1569,7 @@ fn markdown_summary_with_limit(
 
     let mut buf = HtmlWithLimit::new(length_limit);
     let mut stopped_early = false;
-    p.try_for_each(|event| {
+    let _ = p.try_for_each(|event| {
         match &event {
             Event::Text(text) => {
                 let r =
diff --git a/src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs b/src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs
@@ -127,7 +127,7 @@ impl BreakAfterExprVisitor {
         };
 
         get_enclosing_block(cx, hir_id).is_some_and(|block| {
-            visitor.visit_block(block);
+            let _ = visitor.visit_block(block);
             visitor.break_after_expr
         })
     }
diff --git a/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs b/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs
@@ -40,7 +40,7 @@ pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<
         // We've checked that `call` is a call to `Stdin::read_line()` with the right receiver,
         // now let's check if the first use of the string passed to `::read_line()`
         // is used for operations that will always fail (e.g. parsing "6\n" into a number)
-        for_each_local_use_after_expr(cx, local_id, call.hir_id, |expr| {
+        let _ = for_each_local_use_after_expr(cx, local_id, call.hir_id, |expr| {
             if let Some(parent) = get_parent_expr(cx, expr) {
                 let data = if let ExprKind::MethodCall(segment, recv, args, span) = parent.kind {
                     if args.is_empty()
diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
@@ -141,7 +141,7 @@ impl PassByRefOrValue {
         // Gather all the lifetimes found in the output type which may affect whether
         // `TRIVIALLY_COPY_PASS_BY_REF` should be linted.
         let mut output_regions = FxHashSet::default();
-        for_each_top_level_late_bound_region(fn_sig.skip_binder().output(), |region| -> ControlFlow<!> {
+        let _ = for_each_top_level_late_bound_region(fn_sig.skip_binder().output(), |region| -> ControlFlow<!> {
             output_regions.insert(region);
             ControlFlow::Continue(())
         });
diff --git a/src/tools/clippy/clippy_lints/src/unconditional_recursion.rs b/src/tools/clippy/clippy_lints/src/unconditional_recursion.rs
@@ -381,7 +381,7 @@ impl UnconditionalRecursion {
                 implemented_ty_id,
                 method_span,
             };
-            walk_body(&mut c, body);
+            let _ = walk_body(&mut c, body);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -2225,7 +2225,7 @@ fn add_library_search_dirs(`
`2225`	`2225`	`return;`
`2226`	`2226`	`}`
`2227`	`2227`
`2228`		`- walk_native_lib_search_dirs(`
	`2228`	`+ let _ = walk_native_lib_search_dirs(`
`2229`	`2229`	`sess,`
`2230`	`2230`	`self_contained_components,`
`2231`	`2231`	`apple_sdk_root,`
Original file line number	Diff line number	Diff line change
`@@ -519,7 +519,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`519`	`519`	`}`
`520`	`520`	`}`
`521`	`521`	`_ => {`
`522`		`- intravisit::walk_pat(self, p);`
	`522`	`+ let _ = intravisit::walk_pat(self, p);`
`523`	`523`	`}`
`524`	`524`	`}`
`525`	`525`	`ControlFlow::Continue(())`
`@@ -542,7 +542,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`542`	`542`	`method_name,`
`543`	`543`	`sugg_let: None,`
`544`	`544`	`};`
`545`		`- let_visitor.visit_body(&body);`
	`545`	`+ let _ = let_visitor.visit_body(&body);`
`546`	`546`	`if let Some(sugg_let) = let_visitor.sugg_let`
`547`	`547`	`&& let Some(self_ty) = self.node_ty_opt(sugg_let.init_hir_id)`
`548`	`548`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1361,12 +1361,12 @@ impl SearchInterfaceForPrivateItemsVisitor<'_> {`
`1361`	`1361`	`GenericParamDefKind::Lifetime => {}`
`1362`	`1362`	`GenericParamDefKind::Type { has_default, .. } => {`
`1363`	`1363`	`if has_default {`
`1364`		`- self.visit(self.tcx.type_of(param.def_id).instantiate_identity());`
	`1364`	`+ let _ = self.visit(self.tcx.type_of(param.def_id).instantiate_identity());`
`1365`	`1365`	`}`
`1366`	`1366`	`}`
`1367`	`1367`	`// FIXME(generic_const_exprs): May want to look inside const here`
`1368`	`1368`	`GenericParamDefKind::Const { .. } => {`
`1369`		`- self.visit(self.tcx.type_of(param.def_id).instantiate_identity());`
	`1369`	`+ let _ = self.visit(self.tcx.type_of(param.def_id).instantiate_identity());`
`1370`	`1370`	`}`
`1371`	`1371`	`}`
`1372`	`1372`	`}`
`@@ -1381,19 +1381,19 @@ impl SearchInterfaceForPrivateItemsVisitor<'_> {`
`1381`	`1381`	`// consider the ones that the user wrote. This is important`
`1382`	`1382`	`// for the inferred outlives rules; see`
`1383`	`1383`	// `tests/ui/rfc-2093-infer-outlives/privacy.rs`.
`1384`		`- self.visit_predicates(self.tcx.explicit_predicates_of(self.item_def_id));`
	`1384`	`+ let _ = self.visit_predicates(self.tcx.explicit_predicates_of(self.item_def_id));`
`1385`	`1385`	`self`
`1386`	`1386`	`}`
`1387`	`1387`
`1388`	`1388`	`fn bounds(&mut self) -> &mut Self {`
`1389`	`1389`	`self.in_primary_interface = false;`
`1390`		`- self.visit_clauses(self.tcx.explicit_item_bounds(self.item_def_id).skip_binder());`
	`1390`	`+ let _ = self.visit_clauses(self.tcx.explicit_item_bounds(self.item_def_id).skip_binder());`
`1391`	`1391`	`self`
`1392`	`1392`	`}`
`1393`	`1393`
`1394`	`1394`	`fn ty(&mut self) -> &mut Self {`
`1395`	`1395`	`self.in_primary_interface = true;`
`1396`		`- self.visit(self.tcx.type_of(self.item_def_id).instantiate_identity());`
	`1396`	`+ let _ = self.visit(self.tcx.type_of(self.item_def_id).instantiate_identity());`
`1397`	`1397`	`self`
`1398`	`1398`	`}`
`1399`	`1399`
`@@ -1785,7 +1785,7 @@ fn check_mod_privacy(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {`
`1785`	`1785`
`1786`	`1786`	`let module = tcx.hir_module_items(module_def_id);`
`1787`	`1787`	`for def_id in module.definitions() {`
`1788`		`- rustc_ty_utils::sig_types::walk_types(tcx, def_id, &mut visitor);`
	`1788`	`+ let _ = rustc_ty_utils::sig_types::walk_types(tcx, def_id, &mut visitor);`
`1789`	`1789`
`1790`	`1790`	`if let Some(body_id) = tcx.hir_maybe_body_owned_by(def_id) {`
`1791`	`1791`	`visitor.visit_nested_body(body_id.id());`
`@@ -1798,7 +1798,11 @@ fn check_mod_privacy(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {`
`1798`	`1798`	`let trait_ref = tcx.impl_trait_ref(id.owner_id.def_id).unwrap();`
`1799`	`1799`	`let trait_ref = trait_ref.instantiate_identity();`
`1800`	`1800`	`visitor.span = item.path.span;`
`1801`		`- visitor.visit_def_id(trait_ref.def_id, "trait", &trait_ref.print_only_trait_path());`
	`1801`	`+ let _ = visitor.visit_def_id(`
	`1802`	`+ trait_ref.def_id,`
	`1803`	`+ "trait",`
	`1804`	`+ &trait_ref.print_only_trait_path(),`
	`1805`	`+ );`
`1802`	`1806`	`}`
`1803`	`1807`	`}`
`1804`	`1808`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,15 +77,15 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {`
`77`	`77`	`match arg.kind {`
`78`	`78`	`hir::TyKind::BareFn(_) => {`
`79`	`79`	`self.current_index.shift_in(1);`
`80`		`- intravisit::walk_ty(self, arg);`
	`80`	`+ let _ = intravisit::walk_ty(self, arg);`
`81`	`81`	`self.current_index.shift_out(1);`
`82`	`82`	`return ControlFlow::Continue(());`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`hir::TyKind::TraitObject(bounds, ..) => {`
`86`	`86`	`for bound in bounds {`
`87`	`87`	`self.current_index.shift_in(1);`
`88`		`- self.visit_poly_trait_ref(bound);`
	`88`	`+ let _ = self.visit_poly_trait_ref(bound);`
`89`	`89`	`self.current_index.shift_out(1);`
`90`	`90`	`}`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ where`
`112`	`112`	`pub fn bind_with_vars(value: T, bound_vars: I::BoundVarKinds) -> Binder<I, T> {`
`113`	`113`	`if cfg!(debug_assertions) {`
`114`	`114`	`let mut validator = ValidateBoundVars::new(bound_vars);`
`115`		`- value.visit_with(&mut validator);`
	`115`	`+ let _ = value.visit_with(&mut validator);`
`116`	`116`	`}`
`117`	`117`	`Binder { value, bound_vars }`
`118`	`118`	`}`
`@@ -196,7 +196,7 @@ impl<I: Interner, T> Binder<I, T> {`
`196`	`196`	`let value = f(value);`
`197`	`197`	`if cfg!(debug_assertions) {`
`198`	`198`	`let mut validator = ValidateBoundVars::new(bound_vars);`
`199`		`- value.visit_with(&mut validator);`
	`199`	`+ let _ = value.visit_with(&mut validator);`
`200`	`200`	`}`
`201`	`201`	`Binder { value, bound_vars }`
`202`	`202`	`}`
`@@ -209,7 +209,7 @@ impl<I: Interner, T> Binder<I, T> {`
`209`	`209`	`let value = f(value)?;`
`210`	`210`	`if cfg!(debug_assertions) {`
`211`	`211`	`let mut validator = ValidateBoundVars::new(bound_vars);`
`212`		`- value.visit_with(&mut validator);`
	`212`	`+ let _ = value.visit_with(&mut validator);`
`213`	`213`	`}`
`214`	`214`	`Ok(Binder { value, bound_vars })`
`215`	`215`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ impl BreakAfterExprVisitor {`
`127`	`127`	`};`
`128`	`128`
`129`	`129`	`get_enclosing_block(cx, hir_id).is_some_and(\|block\| {`
`130`		`- visitor.visit_block(block);`
	`130`	`+ let _ = visitor.visit_block(block);`
`131`	`131`	`visitor.break_after_expr`
`132`	`132`	`})`
`133`	`133`	`}`