Inline function assist changes logic by leading to `?` leaving the outer function

Example:

use std::{
    io::{self, Read},
    fs,
};

use anyhow::Context;

fn whatever() -> anyhow::Result<()> {
    do_stuff().context("do_stuff")
}

fn do_stuff() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;
    let mut buffer = [0; 10];

    // read up to 10 bytes
    let n = f.read(&mut buffer)?;

    println!("The bytes: {:?}", &buffer[..n]);
    Ok(())
}

// after inlining do_stuff
fn whatever() -> anyhow::Result<()> {
    {
        let mut f = File::open("foo.txt")?;
        let mut buffer = [0; 10];

        // read up to 10 bytes
        let n = f.read(&mut buffer)?;

        println!("The bytes: {:?}", &buffer[..n]);
        Ok(())
    }.context("test")
}

After inlining, the ?s exit from whatever and bypass the .context call which is thus rendered pointless.

I think the only general solution to this is emitting an immediately-invoked function instead for regular functions, and an async (move?) block for async functions:

fn whatever() -> anyhow::Result<()> {
    (|| {
        let mut f = File::open("foo.txt")?;
        let mut buffer = [0; 10];

        // read up to 10 bytes
        let n = f.read(&mut buffer)?;

        println!("The bytes: {:?}", &buffer[..n]);
        Ok(())
    })().context("test")
}

But of course that's rather ugly..

Start with the inline function assist and reproduce the example showing that ? exits the outer function before .context runs. Compare regular and async function cases, then verify that inlining preserves the original error-handling scope so the surrounding context remains effective.