redundant_closure: false positive for never return type

[Bromeon]

Lint name: redundant_closure

With this code:

fn explode() -> ! {
    panic!("never returns")
}

fn main() {
    Some(32).unwrap_or_else(|| explode());
}

Clippy emits the following warning:

warning: redundant closure
 --> src\main.rs:6:29
  |
6 |     Some(32).unwrap_or_else(|| explode());
  |                             ^^^^^^^^^^^^ help: replace the closure with the function itself: `explode`
  |
  = note: `#[warn(clippy::redundant_closure)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure

---

However, I cannot inline the closure and use the function pointer directly -- this code:

fn explode() -> ! {
    panic!("never returns")
}

fn main() {
    Some(32).unwrap_or_else(explode);
}

fails to compile with:

error[E0271]: type mismatch resolving `<fn() -> ! {explode} as std::ops::FnOnce<()>>::Output == {integer}`
 --> src\main.rs:6:14
  |
6 |     Some(32).unwrap_or_else(explode);
  |              ^^^^^^^^^^^^^^ expected `!`, found integer
  |
  = note: expected type `!`
             found type `{integer}`

For more information about this error, try `rustc --explain E0271`

---

Meta

Rust version (rustc -Vv):

rustc 1.57.0-nightly (5b210643e 2021-10-11)
binary: rustc
commit-hash: 5b210643ebf2485aafdf2494de8cf41941a64e95
commit-date: 2021-10-11
host: x86_64-pc-windows-msvc
release: 1.57.0-nightly
LLVM version: 13.0.0

Related, but not identical issues ( redundant_closure false positives):

• redundant_closure suggests wrong fix when the function being called is not Copy #1608
• False positive for redundant_closure involving lifetimes #5594
• FP redundant_closure #5939
• False positive by redundant_closure to remove a closure that is required for lifetime reasons #7497

[divagant-martian]

is this something someone new to clippy could work on? I'd be interested

[xFrednet]

Hey @divagant-martian, this is something you could potentially work on. You basically need to get the function signature that is called in the closure and check if the return type is Never. The return type can be gained by getting the function type and then calling fn_sig on it. This will probably require some digging, but should be doable. If you like to tackle this, you can comment @rustbot claim. We're also happy to help if you're stuck :)

[divagant-martian]

@rustbot claim

[WaffleLapkin]

Actually checking only for the never type doesn't seem to be enough to fix the false positives for this lint. We need to check for all coercions. For example:

fn main() {
    fn arr() -> &'static [u8; 0] { &[] }
    
    fn slice_fn(_: impl FnOnce() -> &'static [u8]) {}
    
    slice_fn(|| arr());
}

warning: redundant closure
 --> src/main.rs:6:14
  |
6 |     slice_fn(|| arr());
  |              ^^^^^^^^ help: replace the closure with the function itself: `arr`
  |
  = note: `#[warn(clippy::redundant_closure)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure

And replacing does work:

error[E0271]: type mismatch resolving `<fn() -> &'static [u8; 0] {arr} as FnOnce<()>>::Output == &'static [u8]`
 --> src/main.rs:6:5
  |
4 |     fn slice_fn(_: impl FnOnce() -> &'static [u8]) {}
  |                                     ------------- required by this bound in `slice_fn`
5 |     
6 |     slice_fn(arr);
  |     ^^^^^^^^ expected slice `[u8]`, found array `[u8; 0]`
  |
  = note: expected reference `&'static [u8]`
             found reference `&'static [u8; 0]`

(playground)