pub(super) unsafe fn pop(&self) -> PopResult<T> {
        unsafe {
            let tail = *self.tail.get();
            let next = (*tail).next.load(Ordering::Acquire);

            if !next.is_null() {
                *self.tail.get() = next;
                assert!((*tail).value.is_none());
                assert!((*next).value.is_some());
                let ret = (*next).value.take().unwrap();
                drop(Box::from_raw(tail));
                return Data(ret);
            }

            if self.head.load(Ordering::Acquire) == tail {
                Empty
            } else {
                Inconsistent
            }
        }
    }
Pops some data from this queue.

Note that the current implementation means that this function cannot
return `Option<T>`. It is possible for this queue to be in an
inconsistent state where many pushes have succeeded and completely
finished, but pops cannot return `Some(t)`. This inconsistent state
happens when a pusher is preempted at an inopportune moment.

This inconsistent state means that this queue does indeed have data, but
it does not currently have access to it at this time.

This function is unsafe because only one thread can call it at a time.
futures-channel/src/mpsc/queue.rs