enum Thingy<'a, F: Fingerprint> {
    Ref(&'a F),
    Partial(ThingPart<'a, F>)
}

impl<'a, F: Fingerprint> Fingerprint for Thingy<'a, F> {}

struct Intermediary<'a, F: Fingerprint>(Vec<Thingy<'a, F>>)

struct Leaf<'a, F: Fingerprint> {
    items: &'a [F],
    expensive: ComputedThing
}

impl<'a, F: Fingerprint> TryFrom<&'a [F]> for Leaf<'a, F> {}

use self_cell::self_cell;

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

self_cell! {
    struct Foo {
        owner: String,
        #[covariant]
        dependent: StrRef,
    }
}

fn main() {
    let foo = Foo::new("Hello World".into(), |s| StrRef(s));
} // prints garbage

        use sql::Rows;
        self_cell::self_cell! {
            struct RowsCell<'a> {
                owner: sql::Statement<'a>,
                #[covariant]
                dependent: Rows,
            }
        }

        self_cell::self_cell! {
            struct StatementCell {
                owner: sql::Connection,
                #[covariant]
                dependent: RowsCell,
            }
        }
                ----------------------
                self.stmt = Some(StatementCell::try_new(conn, |conn| {
                    RowsCell::try_new(conn.prepare(query)?, |stmt| {
                        (unsafe { &mut *(stmt as *const sql::Statement as *mut sql::Statement) })
                            .query(sql::params_from_iter(values))
                            .and_then(|mut r| {
                                r.advance()?;
                                Ok(r)
                            })
                    })
                })?);

use self_cell::self_cell;

// Remove this, and it compiles
type Result<T> = std::result::Result<T, ()>;

#[derive(Debug, Eq, PartialEq)]
struct Ast<'a>(pub Vec<&'a str>);

self_cell!(
    struct AstCell {
        owner: String,

        #[covariant]
        dependent: Ast,
    }

    impl {Debug, Eq, PartialEq}
);

fn build_ast_cell(code: &str) -> AstCell {
    // Create owning String on stack.
    let pre_processed_code = code.trim().to_string();

    // Move String into AstCell, then build Ast inplace.
    AstCell::new(pre_processed_code, |code| {
        Ast(code.split(' ').filter(|word| word.len() > 1).collect())
    })
}

fn main() {
    let ast_cell = build_ast_cell("fox = cat + dog");

    println!("ast_cell -> {:?}", &ast_cell);
    println!("ast_cell.borrow_owner() -> {:?}", ast_cell.borrow_owner());
    println!(
        "ast_cell.borrow_dependent().0[1] -> {:?}",
        ast_cell.borrow_dependent().0[1]
    );
}

use self_cell::self_cell;

type Dep1<'a> = (&'a str, &'static str);

self_cell! {
    pub struct Struct1 {
        owner: String,
        #[covariant]
        dependent: Dep1,
    }
}

type Dep2<'a> = (&'static str, &'a str);

self_cell! {
    pub struct Struct2 {
        owner: String,
        #[covariant]
        dependent: Dep2,
    }
}

fn main() {
    let hello: &'static str;
    {
        let mut x1 = Struct1::new(String::from("Hello World"), |s| (s, ""));
        let mut x2 = Struct2::new(String::new(), |_| ("", ""));
        std::mem::swap(&mut x1.unsafe_self_cell, &mut x2.unsafe_self_cell);
        hello = x2.borrow_dependent().0;

        dbg!(hello); // "Hello World"
        // hello is now a static reference in to the "Hello World" string
    }
    // the String is dropped at the end of the block above

    dbg!(hello); // prints garbage, use-after-free
}

use std::rc::Rc;
use once_self_cell::sync_once_self_cell;

struct Owner;

struct Borrowed<'a> {
    owner: &'a Owner,
    evil: Evil,
}

impl<'a> From<&'a Owner> for Borrowed<'a> {
    fn from(owner: &'a Owner) -> Borrowed<'a> {
        Borrowed {
            owner,
            evil: Evil::default(),
        }
    }
}

thread_local! {
    static STR: Rc<str> = "hello".into();
}

#[derive(Clone)]
struct Evil {
    rc: Rc<str>,
}

impl Drop for Evil {
    fn drop(&mut self) {
        let ptr = self.rc.as_ptr();
        let thread_id = std::thread::current().id();
        println!("drop rc at {:p} in thread {:?}", ptr, thread_id);
    }
}

impl Default for Evil {
    fn default() -> Evil {
        Evil {
            rc: STR.with(|x| x.clone()),
        }
    }
}

sync_once_self_cell!(
    SelfRef,
    Owner,
    Borrowed<'_>,
);

fn main() {
    let cell = SelfRef::new(Owner);
    let _evil1 = cell.get_or_init_dependent().evil.clone();
    std::thread::spawn(move || {
        let _evil2 = cell.get_or_init_dependent().evil.clone();
    });
}

use std::cell::Cell;

use self_cell::self_cell;

type O = Cell<Option<Box<u8>>>;

self_cell! {
    struct S {
        owner: O,
        #[covariant]
        dependent: D,
    }
}

struct D<'a>(&'a O);

impl Drop for D<'_> {
    fn drop(&mut self) {
        self.0.take();
    }
}

fn main() {
    let s = S::new(Cell::new(Some(Box::new(42))), |o| D(o));
    s.into_owner();
}

use self_cell::self_cell;

type X<'a> = &'a str;

self_cell! {
    pub struct Foo<'a> {
        owner: fn(&'a ()),
        #[covariant]
        dependent: X,
    }
}

fn transmute_lifetime<'a, 'b>(x: &'a str) -> &'b str {
    fn helper<'b>(s: &'b str) -> impl for<'a> FnOnce(&'a fn(&'b ())) -> &'a str {
        move |_| s
    }
    let x: Foo<'a> = Foo::new(|_| (), helper(x));
    let x: Foo<'static> = x; // coerce using variance 
    let y = Box::leak(Box::new(x));
    y.borrow_dependent()
}

fn main() {
    let r;
    {
        let s = "Hello World".to_owned();
        r = transmute_lifetime(s.as_str());
        dbg!(r); // "Hello World"
    }
    dbg!(r); // prints garbage :-)
}

use std::cell::RefCell;

use self_cell::self_cell;

struct Bar<'a>(RefCell<(Option<&'a Bar<'a>>, String)>);

self_cell! {
    struct Foo {
        owner: (),
        #[not_covariant]
        dependent: Bar,
    }
}

fn main() {
    let mut x = Foo::new((), |_| Bar(RefCell::new((None, "Hello".to_owned()))));
    x.with_dependent(|_, dep| {
        dep.0.borrow_mut().0 = Some(dep);
    });
    x.with_dependent_mut(|_, dep| {
        let r1 = dep.0.get_mut();
        let string_ref_1 = &mut r1.1;
        let mut r2 = r1.0.unwrap().0.borrow_mut();
        let string_ref_2 = &mut r2.1;

        let s = &string_ref_1[..];
        string_ref_2.clear();
        string_ref_2.shrink_to_fit();
        println!("{}", s); // prints garbage
    });
}

use once_self_cell::sync_once_self_cell;
use std::cell::Cell;

struct Owner(Cell<&'static str>);

struct Borrowed<'a>(Cell<&'a str>);

impl<'a> From<&'a Owner> for Borrowed<'a> {
    fn from(owner: &'a Owner) -> Borrowed<'a> {
        let r = owner.0.get();
        Borrowed(Cell::new(r))
    }
}

sync_once_self_cell!(
    SelfRef,
    Owner,
    Borrowed<'_>,
);

fn do_evil(cell: &SelfRef) {
    let str = String::from("short lived");
    let dep = cell.get_or_init_dependent();
    dep.0.set(&str);
}

fn main() {
    let cell = SelfRef::new(Owner(Cell::new("static string")));
    do_evil(&cell);
    let dep = cell.get_or_init_dependent();
    println!("string: {:?}", dep.0.get());
}

self_cell::self_cell!(
    struct Foo {
        owner: Vec<u8>,

        #[covariant]
        dependent: nested::Bar,
    }
);

mod nested {
    pub struct Bar<'a> {
        v: &'a u8,
    }    
}

use std::{cell::RefCell, fmt};

use self_cell::self_cell;

self_cell! {
    struct WrongVarianceExample {
        owner: (),
        #[covariant]
        dependent: Dependent,
    }
}

// this type is not covariant
type Dependent<'a> = RefCell<Box<dyn fmt::Display + 'a>>;

RefCell<Box<dyn fmt::Display + 'x>>

RefCell<Box<dyn fmt::Display + 'y>>

fn main() {
    let cell = WrongVarianceExample::new((), |_| RefCell::new(Box::new("")));
    let s = String::from("Hello World");

    // borrow_dependent unsound due to incorrectly checked variance
    *cell.borrow_dependent().borrow_mut() = Box::new(s.as_str());

    // s still exists
    cell.with_dependent(|_, d| println!("{}", d.borrow()));

    drop(s);

    // s is gone
    cell.with_dependent(|_, d| println!("{}", d.borrow()));
}

self_cell!(
    struct Node<T> {
       // ...
    }
);

struct Thing<'de>(Vec<Item<'de>>);

impl<'de> TryFrom<&'de String> for Thing<'de> {
    type Error = serde_json::Error;

    fn try_from(s: &'de String) -> Result<Self, Self::Error> {
        serde_json::from_str(s).map(Self)
    }
}

sync_try_once_self_cell(ThingStore, String, Thing<'_>);

fn use_it(s: String) -> Result<ThingStore, serde_json::Error> {
    ThingStore::new(s)
}

use self_cell::self_cell;

// Remove this, and it compiles
pub fn Ok<T>(t: T) -> Result<T, ()> {
  Result::Ok(t)
}

#[derive(Debug, Eq, PartialEq)]
struct Ast<'a>(pub Vec<&'a str>);

self_cell!(
    struct AstCell {
        owner: String,

        #[covariant]
        dependent: Ast,
    }

    impl {Debug, Eq, PartialEq}
);

fn build_ast_cell(code: &str) -> AstCell {
  // Create owning String on stack.
  let pre_processed_code = code.trim().to_string();

  // Move String into AstCell, then build Ast inplace.
  AstCell::new(pre_processed_code, |code| {
    Ast(code.split(' ').filter(|word| word.len() > 1).collect())
  })
}

fn main() {
  let ast_cell = build_ast_cell("fox = cat + dog");

  println!("ast_cell -> {:?}", &ast_cell);
  println!("ast_cell.borrow_owner() -> {:?}", ast_cell.borrow_owner());
  println!(
    "ast_cell.borrow_dependent().0[1] -> {:?}",
    ast_cell.borrow_dependent().0[1]
  );
}

AstCell::new(body, |body| blah blah)

use std::sync::Arc;

struct X(());
struct T1<'a>(&'a ());
#[derive(Debug)]
struct T2<'a>(&'a ());

self_cell::self_cell! {
    struct O1 {
        owner: Arc<X>,
        #[covariant]
        dependent: T1,
    }
}

self_cell::self_cell! {
    struct O2 {
        owner: Arc<X>,
        #[covariant]
        dependent: T2,
    }
}

unsafe fn relifetime<'a, 'b>(t: &'a T1<'a>) -> &'b T1<'b> {
    std::mem::transmute(t)
}

fn map(o: &O1, f: impl for<'this> FnOnce(&'this X, &T1<'this>) -> T2<'this>) -> O2 {
    O2::new(Arc::clone(&o.borrow_owner()), |x| {
        f(&x, unsafe { relifetime(o.borrow_dependent()) })
    })
}

fn main() {
    let o1 = O1::new(Arc::new(X(())), |x| T1(&x.0));
    let o2 = map(&o1, |_, t1| T2(t1.0));
    drop(o1);

    o2.with_dependent(|_, v| println!("{:?}", v));
}

fn borrow_dependent_mut<'a>(&'a mut self) -> &'a mut Session<'a>