consider Result<T, !>/ControlFlow<!, T> the same as T for must_use lint

(or more accurately `Result<T, Uninhabited>`/`ControlFlow<Uninhabited, T>`).

This generalizes a previous change where we only did this for `T = ()`.

Author: WaffleLapkin

compiler/rustc_lint/src/unused.rs

@@ -259,6 +259,10 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
             Opaque(Box<Self>),
             TraitObject(Box<Self>),
             TupleElement(Vec<(usize, Self)>),
+            /// `Result<T, Uninhabited>`
+            Result(Box<Self>),
+            /// `ControlFlow<Uninhabited, T>`
+            ControlFlow(Box<Self>),
             Array(Box<Self>, u64),
             /// The root of the unused_closures lint.
             Closure(Span),
@@ -291,21 +295,23 @@ 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<(), !>`).
+                // Consider `Result<T, Uninhabited>` (e.g. `Result<(), !>`) equivalent to `T`.
                 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)
+                    let ok_ty = args.type_at(0);
+                    is_ty_must_use(cx, ok_ty, expr, span).map(Box::new).map(MustUsePath::Result)
                 }
-                // Suppress warnings on `ControlFlow<Uninhabited, ()>` (e.g. `ControlFlow<!, ()>`).
+                // Consider `ControlFlow<Uninhabited, T>` (e.g. `ControlFlow<!, ()>`) equivalent to `T`.
                 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)
+                    let continue_ty = args.type_at(1);
+                    is_ty_must_use(cx, continue_ty, expr, span)
+                        .map(Box::new)
+                        .map(MustUsePath::ControlFlow)
                 }
                 ty::Adt(def, _) => is_def_must_use(cx, def.did(), span),
                 ty::Alias(ty::Opaque | ty::Projection, ty::AliasTy { def_id: def, .. }) => {
@@ -498,6 +504,32 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
                         );
                     }
                 }
+                MustUsePath::Result(path) => {
+                    let descr_post =
+                        &format!(" in a `Result` with an uninhabited error{descr_post}");
+                    emit_must_use_untranslated(
+                        cx,
+                        path,
+                        descr_pre,
+                        descr_post,
+                        plural_len,
+                        true,
+                        expr_is_from_block,
+                    );
+                }
+                MustUsePath::ControlFlow(path) => {
+                    let descr_post =
+                        &format!(" in a `ControlFlow` with an uninhabited break {descr_post}");
+                    emit_must_use_untranslated(
+                        cx,
+                        path,
+                        descr_pre,
+                        descr_post,
+                        plural_len,
+                        true,
+                        expr_is_from_block,
+                    );
+                }
                 MustUsePath::Array(path, len) => {
                     let descr_pre = &format!("{descr_pre}array{plural_suffix} of ");
                     emit_must_use_untranslated(

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

@@ -93,8 +93,8 @@ fn main() {
     result_unit_unit(); //~ ERROR: unused `Result` that must be used
     result_unit_infallible();
     result_unit_never();
-    result_must_use_never(); //~ ERROR: unused `Result` that must be used
-    result_struct_never(); //~ ERROR: unused `Result` that must be used
+    result_must_use_never(); //~ ERROR: unused `MustUse` in a `Result` with an uninhabited error that must be used
+    result_struct_never();
     result_unit_myuninhabited();
     result_unit_myuninhabited_nonexhaustive(); //~ ERROR: unused `Result` that must be used
     result_unit_assoctype(S1);

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

@@ -15,29 +15,11 @@ help: use `let _ = ...` to ignore the resulting value
 LL |     let _ = result_unit_unit();
    |     +++++++
 
-error: unused `Result` that must be used
+error: unused `MustUse` in a `Result` with an uninhabited error that must be used
   --> $DIR/must_use-result-unit-uninhabited.rs:96:5
    |
 LL |     result_must_use_never();
    |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this `Result` may be an `Err` variant, which should be handled
-help: use `let _ = ...` to ignore the resulting value
-   |
-LL |     let _ = result_must_use_never();
-   |     +++++++
-
-error: unused `Result` that must be used
-  --> $DIR/must_use-result-unit-uninhabited.rs:97:5
-   |
-LL |     result_struct_never();
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this `Result` may be an `Err` variant, which should be handled
-help: use `let _ = ...` to ignore the resulting value
-   |
-LL |     let _ = result_struct_never();
-   |     +++++++
 
 error: unused `Result` that must be used
   --> $DIR/must_use-result-unit-uninhabited.rs:99:5
@@ -98,5 +80,5 @@ help: use `let _ = ...` to ignore the resulting value
 LL |         let _ = self.generate();
    |         +++++++
 
-error: aborting due to 8 previous errors
+error: aborting due to 7 previous errors