must_use on throws fn

[ijackson]

Hi. Thanks for this nice crate. I have only been using it a few hours and it is already improving my life. I have found a situation where I can write something with an obvious meaning but which doesn't do what I would have hoped:

This function

#[must_use] #[throws(X)] fn x() ->  usize { 42 }

can be called, and the value 42 discarded, without any warning. This is probably not what the programmer intended when they wrote #[must_use].

I suspect that fixing this is not going to be simple. When considering Rust without Fehler, there does not appear to be a way to write a function that returns a Result<T,E> where the caller is required to both handle E and do something with T. (Other than making the whole type T must_use, which may not be desirable or possible.)

My full test program:

use fehler::throws;
use thiserror::Error;

#[derive(Error,Debug)]
#[error("X")]
struct X ();

#[must_use] #[throws(X)] fn x() ->        usize    {    42  }
#[must_use]              fn y() -> Result<usize,X> { Ok(43) }
#[must_use]              fn z() ->        usize    {    44  }

#[throws(X)]
fn main() {
                               x()?;
                               y()?;
  { #![allow(unused_must_use)] z(); }
}

[withoutboats]

Unfortunately there's no way to fix this in fehler, because its implemented as a procedural macro.

[ijackson]

Would it be easy to spot this case and at least warn about it? [throws] implies that the Result must be used. So adding [must_use] is an attempt to do this sadly-impossible thing and it would be nice to let the programmer know that this constraint wasn't going to be enforced.

[withoutboats]

The compiler could have a warning that a must_use on a function that returns a must_use type is redundant.