Rollup merge of #147382 - joshtriplett:unused-must-use-ignore-result-unit-uninhabited, r=fmease

unused_must_use: Don't warn on `Result<(), Uninhabited>` or `ControlFlow<Uninhabited, ()>`
This suppresses warnings on things like `Result<(), !>`, which helps simplify code using the common pattern of having an `Error` associated type: code will only have to check the error if there is a possibility of error.
This will, for instance, help with future refactorings of `write!` in the standard library.
As this is a user-visible change to lint behavior, it'll require a lang FCP.
---
My proposal, here, is that we handle this simple case to make common patterns more usable. This does not rule out the possibility of adding more cases in the future, including general trait-based cases. However, I don't think we should make this common case wait on the more general cases. In particular, this solution does not close any doors on replacing this special case with a general case.
This would unblock some planned work in the standard library to make `write!` more usable for infallible cases (e.g. writing into a `Vec` or `String`).

Author: Zalathar

compiler/rustc_lint/src/unused.rs

@@ -273,13 +273,13 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
 expr:&hir::Expr<'_>,
 span:Span,
 ) -> Option<MustUsePath>{
-if ty.is_unit()
-|| !ty.is_inhabited_from(
- cx.tcx,
-cx.tcx.parent_module(expr.hir_id).to_def_id(),
- cx.typing_env(),
-)
-{
+if ty.is_unit(){
+returnSome(MustUsePath::Suppressed);
+}
+let parent_mod_did = cx.tcx.parent_module(expr.hir_id).to_def_id();
+let is_uninhabited =
+|t:Ty<'tcx>| !t.is_inhabited_from(cx.tcx, parent_mod_did, cx.typing_env());
+ifis_uninhabited(ty){
 returnSome(MustUsePath::Suppressed);
 }
 
@@ -293,6 +293,22 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
 is_ty_must_use(cx, pinned_ty, expr, span)
 .map(|inner| MustUsePath::Pinned(Box::new(inner)))
 }
+// Suppress warnings on `Result<(), Uninhabited>` (e.g. `Result<(), !>`).
+ ty::Adt(def, args)
+if cx.tcx.is_diagnostic_item(sym::Result, def.did())
+ && args.type_at(0).is_unit()
+ && is_uninhabited(args.type_at(1)) =>
+{
+Some(MustUsePath::Suppressed)
+}
+// Suppress warnings on `ControlFlow<Uninhabited, ()>` (e.g. `ControlFlow<!, ()>`).
+ ty::Adt(def, args)
+if cx.tcx.is_diagnostic_item(sym::ControlFlow, def.did())
+ && args.type_at(1).is_unit()
+ && is_uninhabited(args.type_at(0)) =>
+{
+Some(MustUsePath::Suppressed)
+}
  ty::Adt(def, _) => is_def_must_use(cx, def.did(), span),
  ty::Alias(ty::Opaque | ty::Projection, ty::AliasTy{def_id: def, .. }) => {
 elaborate(cx.tcx, cx.tcx.explicit_item_self_bounds(def).iter_identity_copied())

tests/ui/lint/unused/auxiliary/must_use_result_unit_uninhabited_extern_crate.rs

@@ -0,0 +1,4 @@
+pubenumMyUninhabited{}
+
+#[non_exhaustive]
+pubenumMyUninhabitedNonexhaustive{}

tests/ui/lint/unused/must_use-result-unit-uninhabited.rs

@@ -0,0 +1,101 @@
+//@ edition: 2024
+//@ aux-crate:dep=must_use_result_unit_uninhabited_extern_crate.rs
+
+#![deny(unused_must_use)]
+#![feature(never_type)]
+
+use core::ops::{ControlFlow,ControlFlow::Continue};
+use dep::{MyUninhabited,MyUninhabitedNonexhaustive};
+
+fnresult_unit_unit() -> Result<(),()>{
+Ok(())
+}
+
+fnresult_unit_infallible() -> Result<(), core::convert::Infallible>{
+Ok(())
+}
+
+fnresult_unit_never() -> Result<(), !>{
+Ok(())
+}
+
+fnresult_unit_myuninhabited() -> Result<(),MyUninhabited>{
+Ok(())
+}
+
+fnresult_unit_myuninhabited_nonexhaustive() -> Result<(),MyUninhabitedNonexhaustive>{
+Ok(())
+}
+
+traitAssocType{
+typeError;
+}
+
+structS1;
+implAssocTypeforS1{
+typeError = !;
+}
+
+structS2;
+implAssocTypeforS2{
+typeError = ();
+}
+
+fnresult_unit_assoctype<AT:AssocType>(_:AT) -> Result<(),AT::Error>{
+Ok(())
+}
+
+traitUsesAssocType{
+typeError;
+fnmethod_use_assoc_type(&self) -> Result<(),Self::Error>;
+}
+
+implUsesAssocTypeforS1{
+typeError = !;
+fnmethod_use_assoc_type(&self) -> Result<(),Self::Error>{
+Ok(())
+}
+}
+
+implUsesAssocTypeforS2{
+typeError = ();
+fnmethod_use_assoc_type(&self) -> Result<(),Self::Error>{
+Err(())
+}
+}
+
+fncontrolflow_unit() -> ControlFlow<()>{
+Continue(())
+}
+
+fncontrolflow_infallible_unit() -> ControlFlow<core::convert::Infallible,()>{
+Continue(())
+}
+
+fncontrolflow_never() -> ControlFlow<!>{
+Continue(())
+}
+
+fnmain(){
+result_unit_unit();//~ ERROR: unused `Result` that must be used
+result_unit_infallible();
+result_unit_never();
+result_unit_myuninhabited();
+result_unit_myuninhabited_nonexhaustive();//~ ERROR: unused `Result` that must be used
+result_unit_assoctype(S1);
+result_unit_assoctype(S2);//~ ERROR: unused `Result` that must be used
+S1.method_use_assoc_type();
+S2.method_use_assoc_type();//~ ERROR: unused `Result` that must be used
+
+controlflow_unit();//~ ERROR: unused `ControlFlow` that must be used
+controlflow_infallible_unit();
+controlflow_never();
+}
+
+traitAssocTypeBeforeMonomorphisation{
+typeError;
+fngenerate(&self) -> Result<(),Self::Error>;
+fnprocess(&self){
+self.generate();//~ ERROR: unused `Result` that must be used
+}
+}

tests/ui/lint/unused/must_use-result-unit-uninhabited.stderr

@@ -0,0 +1,78 @@
+error: unused `Result` that must be used
+ --> $DIR/must_use-result-unit-uninhabited.rs:80:5
+ |
+LL | result_unit_unit();
+ | ^^^^^^^^^^^^^^^^^^
+ |
+ = note: this `Result` may be an `Err` variant, which should be handled
+note: the lint level is defined here
+ --> $DIR/must_use-result-unit-uninhabited.rs:4:9
+ |
+LL | #![deny(unused_must_use)]
+ | ^^^^^^^^^^^^^^^
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = result_unit_unit();
+ | +++++++
+
+error: unused `Result` that must be used
+ --> $DIR/must_use-result-unit-uninhabited.rs:84:5
+ |
+LL | result_unit_myuninhabited_nonexhaustive();
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this `Result` may be an `Err` variant, which should be handled
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = result_unit_myuninhabited_nonexhaustive();
+ | +++++++
+
+error: unused `Result` that must be used
+ --> $DIR/must_use-result-unit-uninhabited.rs:86:5
+ |
+LL | result_unit_assoctype(S2);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this `Result` may be an `Err` variant, which should be handled
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = result_unit_assoctype(S2);
+ | +++++++
+
+error: unused `Result` that must be used
+ --> $DIR/must_use-result-unit-uninhabited.rs:88:5
+ |
+LL | S2.method_use_assoc_type();
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this `Result` may be an `Err` variant, which should be handled
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = S2.method_use_assoc_type();
+ | +++++++
+
+error: unused `ControlFlow` that must be used
+ --> $DIR/must_use-result-unit-uninhabited.rs:90:5
+ |
+LL | controlflow_unit();
+ | ^^^^^^^^^^^^^^^^^^
+ |
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = controlflow_unit();
+ | +++++++
+
+error: unused `Result` that must be used
+ --> $DIR/must_use-result-unit-uninhabited.rs:99:9
+ |
+LL | self.generate();
+ | ^^^^^^^^^^^^^^^
+ |
+ = note: this `Result` may be an `Err` variant, which should be handled
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = self.generate();
+ | +++++++
+
+error: aborting due to 6 previous errors
+