use std::error::Error as StdError;
use std::fmt::{self, Display};
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::SeqCst;
use std::sync::Arc;
#[derive(Debug)]
pub struct DetectDrop {
    has_dropped: Arc<AtomicBool>,
}
impl DetectDrop {
    pub fn new(has_dropped: &Arc<AtomicBool>) -> Self {
        DetectDrop {
            has_dropped: Arc::clone(has_dropped),
        }
    }
}
impl StdError for DetectDrop {}
impl Display for DetectDrop {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "oh no!")
    }
}
impl Drop for DetectDrop {
    fn drop(&mut self) {
        let already_dropped = self.has_dropped.swap(true, SeqCst);
        assert!(!already_dropped);
    }
}

mod drop;
use self::drop::DetectDrop;

use std::error::Error as StdError;
use std::fmt::{self, Display};

    #[derive(Debug)]
    struct DetectDrop {
        has_dropped: Arc<AtomicBool>,
    }
    impl StdError for DetectDrop {}
    impl Display for DetectDrop {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "does something")
        }
    }
    impl Drop for DetectDrop {
        fn drop(&mut self) {
            let already_dropped = self.has_dropped.swap(true, SeqCst);
            assert!(!already_dropped);
        }
    }

    drop(Error::new(DetectDrop {
        has_dropped: has_dropped.clone(),
    }));

    drop(Error::new(DetectDrop::new(&has_dropped)));