ref_from_bytes's inclusion of the input reference in the Err() result doesn't play nice with popular error-handling library anyhow

[kit299]

This code does not compile, but it seems to me that it should.

use zerocopy::*; // 0.8.24
use anyhow::{format_err, Result}; // 1.0.97

#[derive(Debug, FromBytes, Immutable, Unaligned, KnownLayout)]
#[repr(C, packed)]
struct Header {
	version: u8
}

fn main() {
    print_header(vec![1_u8]).unwrap();
}

fn print_header(bytes: Vec<u8>) -> Result<()> {
    let hdr = Header::ref_from_bytes(&bytes)?;

    println!("{:#?}", hdr);
    Ok(())
}

The reported error is this:

// error[E0597]: `bytes` does not live long enough
fn print_header(bytes: Vec<u8>) -> Result<()> {
//              ----- binding `bytes` declared here
    let hdr = Header::ref_from_bytes(&bytes)?;
//            -----------------------^^^^^^-
//            |                      |
//            |                      borrowed value does not live long enough
//            argument requires that `bytes` is borrowed for `'static`
    println!("{:#?}", hdr);
    Ok(())
}
//- `bytes` dropped here while still borrowed

I found that rather puzzling, but I am far from experienced with rust, so that's not unusual.
Requiring the value to be parsed to be 'static seems like it would make the library extremely difficult to use in a real-world application.

If you were to change the function definition to expect a &[u8] instead of Vec<u8> the error changes:

// error[E0521]: borrowed data escapes outside of function
fn print_header(bytes: &[u8]) -> Result<()> {
//              -----  - let's call the lifetime of this reference `'1`
//              |
//              `bytes` is a reference that is only valid in the function body
    let hdr = Header::ref_from_bytes(&bytes)?;
//            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//            |
//            `bytes` escapes the function body here
//            argument requires that `'1` must outlive `'static`
    println!("{:#?}", hdr);

This error is more useful. How does bytes escape the function body there?

Of course, it is the ? operator. anyhow requires error types to be 'static and zerocopy includes the reference to be parsed in the error value. So the compiler forces the input bytes to be 'static in case of the Err() outcome.

I believe this is very similar to (if not the same as) the issue described here: #2262

So the problem can be resolved by switching the line:

let hdr = Header::ref_from_bytes(&bytes)?;

to either

let hdr = Header::ref_from_bytes(&bytes).unwrap();

or

let hdr = Header::ref_from_bytes(&bytes)
    .map_err(|_| format_err!("ref_from_bytes failed"))?;

And in that linked discussion, in addition to other changes, the user also switches ? to .unwrap(). They don't mention use of anyhow specifically in that discussion however.

I'm not really sure what my question is.
Is this issue something that an experienced rust developer would immediately recognize and fix? Or is this awkward ergonomics that might be worth looking into?

I have no problem just mapping the error to something else, but thought I'd raise the issue just in case there was a better solution.

[jswrenn]

It's anyhow that imposes the 'static requirement, since — under the hood — anyhow Boxes up (and type erases) the error value. The requirement specifically comes from this conversion, which is implicitly invoked by ?.

The correct solution is, yes, to map zerocopy's error to something else that meets these requirements. We're lightly looking into providing an API that would make this easier, but it's not on our near-term roadmap right now.

[kit299]

Great, thanks for the quick reply.