API soundness issues

[steffahn]

Implied bounds from non-static T in Parc<T>::project

use pared::sync::Parc;

fn main() {
    let s = "Hello World!".to_owned();
    let x = Parc::new(&());
    let x = x.project(|_| s.as_str()); // why this works?
                                       // even though there are seemingly so many
                                       // 'static bounds already?
                                       // here's a short explanation:

    // it first coerces the Parc<&'static ()> to some Parc<&'short ()>,
    // and then the callback to project, for<'a> FnOnce(&'a &'short ()) -> &'a str
    // is only required to be able to handle any lifetime `'a` with `'short: 'a`
    // which is fine as long as `'short` is shorter than up to the point `s` drops

    println!("{:?}", &*x); // "Hello World!"
    drop(s);
    println!("{:?}", &*x); // garbage / use-after-free
}

A possible fix I could imagine is adding T: 'static to project.

This issue is – very roughly – inspired by Kimundi/owning-ref-rs#71

Dropping of non-'static content through Parc::from_arc

This is probably just clearly missing the U: 'static, since… this just works:

use pared::sync::Parc;
use std::sync::Arc;

struct PrintOnDrop<'a>(&'a str);
impl Drop for PrintOnDrop<'_> {
    fn drop(&mut self) {
        println!("dropping: {:?}", self.0);
    }
}

fn main() {
    let s = "Hello World!".to_owned();
    let arc = Arc::new(PrintOnDrop(&s));
    let p = Parc::from_arc(&arc, |_| &());
    drop(arc);
    drop(s);
    // finally
    drop(p); // garbage / use-after-free

    // type being Parc<()> means this is a type
    // that doesn't have any lifetime restrictions anymore
    // i.e. this can still be used/dropped AFTER `s` is gone,
    // without complaints from the compiler
}

---

The same applies to Prc and to try_ variants of the APIs.