[feature] crossbeam-epoch pointers impl debug

[DevinR528]

For Atomic, Owned and Shared would there be interest in a more complete Debug implementation? I had a few ideas for going about this without getting in the way

• #[cfg(feature = "debug"] would enable a whole different impl<T: Debug> Debug for _
• a method Atomic::debug(&self) -> &dyn Debug
• using autoref-specialization this would be the main impl<T: Debug> Debug for Owned and impl<T> Debug for &Owned would be the autoref fall back.

either way the general idea would be

let g = epoch::pin();
let data = self.data.load(Ordering::???);
let (raw, tag) = decompose_data::<T>(data);
let shared = self.load(Ordering::SeqCst, &g);
// this would be how all are "safely" printed unless I'm missing something
let inner = if shared.is_null() {
    &"null" as &dyn fmt::Debug
} else {
    unsafe { shared.deref() as &dyn fmt::Debug }
};
// if Debug
f.debug_struct("Atomic")
    .field("raw", &raw)
    .field("inner", inner)
    .field("tag", &tag)
    .finish()

If interested I can start a PR!

The autoref-specialization idea is an interesting one, I think I like that one the most :)

I'm curious - are there any other crates using the same kind of specialization? Seems like a really nice pattern so I wonder if it should be more popular...

[DevinR528]

I've seen a few but , my guess is its because it can only be used in a few places. The biggest problem is any time it is used in an impl<T> ... block it ruins the ability to specialize which I quickly realized is our problem here. Basically you can only use this if you have direct access to something, no type parameters and impl<T> Debug for &T is impl'ed in core.

macro_rules! call_it {
    ($me:expr) => ({
        (&$me).show()
    });
}

struct Test<T>(T);
trait Show {
    fn show(&self);
}
impl<T: fmt::Debug> Show for Test<T> {
   fn show(&self) {
      println!("value IS debug {:?}", self.as_debug())
   }
}
impl<T> Show for &Test<T> {
    fn show(&self) {
        println!("value NOT debug")
    }
}

struct NonDebug();
let x = Test("hello");
let y = Test(NonDebug);
call_it!(x);
call_it!(y);

[DevinR528]

Would using the nightly specialization feature when crossbeams nightly feature is enabled be an acceptable alternative? I have a fork with just that working but if you don't want to add more unstable stuff I totally get it.