Compiler Explorer

Source code

//! Add ` -Zpolonius ` to the flags (top-right) to make
//! compilation pass.

// Handle the `for<'any> FnOnce(…) -> Option<R<'any>>`
    /// Trait alias for `FnOnce(Arg) -> Option< _ >`.
    pub
    trait FnOnceReturningAnOption<Arg>
    where
        Self : FnOnce(Arg) -> Option<Self::Ret>,
    {
        type Ret;
    }

impl<F : ?Sized, Arg, R>
        FnOnceReturningAnOption<Arg>
    for
        F
    where
        Self : FnOnce(Arg) -> Option<R>,
    {
        type Ret = R;
    }

pub
fn polonius<'r, T, F> (
                // ^ generic type to apply to all possible closures.
    borrow: &'r mut T,
    branch: F,
) -> Result< // <- we "forward the branch", but with data attached to the fallback one (`Err(…)`).
        <F as FnOnceReturningAnOption<&'r mut T>>::Ret, // <- "plot twist": `'any` above was `'r` !
        &'r mut T, // <- through Arcane Magic™ we get to transmute the `None` into an `Err(borrow)`
    >
where
    F : for<'any> // <- higher-order lifetime ensures the `&mut T` infected with it…
        FnOnce(&'any mut T)      // …can only escape the closure…
                                                 // vvvv … through its return type and its return type only.
          -> Option< <F as FnOnceReturningAnOption<&'any mut T>>::Ret >
          // ^^^^^^ The `Some` / `None` discriminant represents the branch info.
    ,
    // the "technical part" 😅
    F : for<'any> FnOnceReturningAnOption<&'any mut T> ,
    // So here, our pseudo-code `_<'any>`
    // is
    // `<F as FnOnceReturningAnOption<&'any mut T>>::Ret`
{      
    let tentative_borrow = &mut *borrow; // reborrow 
    if let Some(borrower) = branch(tentative_borrow) {
        /* within this branch, the reborrow needs to last for `'r` */
        return Ok(borrower);
    }
    /* but within this branch, the reborrow needs to have ended: only Polonius supports that kind of logic */

// give the borrow back
    Err(borrow) // <- without Polonius this is denied
}