Seal the Notification and IntoNotification traits

This PR seals these two traits to prevent breaking changes from causing
semver breaks. It also adds documentation to both traits.

Author: notgull

src/lib.rs

@@ -97,7 +97,8 @@ use std::time::{Duration, Instant};
 use sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
 use sync::{Arc, WithMut};
 
-pub use notify::{Additional, IntoNotification, Notification, Notify, Tag, TagWith};
+use notify::{Internal, NotificationPrivate};
+pub use notify::{IntoNotification, Notification};
 
 /// Useful traits for notifications.
 pub mod prelude {
@@ -343,13 +344,13 @@ impl<T> Event<T> {
         let notify = notify.into_notification();
 
         // Make sure the notification comes after whatever triggered it.
-        notify.fence();
+        notify.fence(notify::Internal::new());
 
         if let Some(inner) = self.try_inner() {
-            let limit = if notify.is_additional() {
+            let limit = if notify.is_additional(Internal::new()) {
                 core::usize::MAX
             } else {
-                notify.count()
+                notify.count(Internal::new())
             };
 
             // Notify if there is at least one unnotified listener and the number of notified

src/no_std.rs

@@ -18,7 +18,7 @@ mod queue;
 use node::{Node, TaskWaiting};
 use queue::Queue;
 
-use crate::notify::{GenericNotify, Notification};
+use crate::notify::{GenericNotify, Internal, Notification};
 use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::sync::cell::{Cell, UnsafeCell};
 use crate::sync::Arc;
@@ -121,15 +121,15 @@ impl<T> crate::Inner<T> {
             None => {
                 // Push it to the queue.
                 let node = Node::Notify(GenericNotify::new(
-                    notify.count(),
-                    notify.is_additional(),
+                    notify.count(Internal::new()),
+                    notify.is_additional(Internal::new()),
                     {
                         // Collect every tag we need.
                         let mut tags = {
-                            let count = notify.count();
+                            let count = notify.count(Internal::new());
                             let mut tags = Vec::with_capacity(count);
                             for _ in 0..count {
-                                tags.push(notify.next_tag());
+                                tags.push(notify.next_tag(Internal::new()));
                             }
 
                             // Convert into an iterator.
@@ -571,8 +571,8 @@ impl<T> ListenerSlab<T> {
     /// Notifies a number of listeners.
     #[cold]
     pub(crate) fn notify(&mut self, mut notify: impl Notification<Tag = T>) {
-        let mut n = notify.count();
-        let is_additional = notify.is_additional();
+        let mut n = notify.count(Internal::new());
+        let is_additional = notify.is_additional(Internal::new());
         if !is_additional {
             // Make sure we're not notifying more than we have.
             if n <= self.notified {
@@ -594,7 +594,7 @@ impl<T> ListenerSlab<T> {
                     self.start = entry.next().get();
 
                     // Set the state to `Notified` and notify.
-                    let tag = notify.next_tag();
+                    let tag = notify.next_tag(Internal::new());
                     if let State::Task(task) = entry.state().replace(State::Notified {
                         tag,
                         additional: is_additional,

src/no_std/queue.rs

@@ -129,7 +129,7 @@ impl<T> Drop for Queue<T> {
 
 #[cfg(test)]
 mod tests {
-    use crate::notify::{GenericNotify, Notification};
+    use crate::notify::{GenericNotify, Internal, NotificationPrivate};
 
     use super::*;
 
@@ -139,7 +139,7 @@ mod tests {
 
     fn node_to_num(node: Node<()>) -> usize {
         match node {
-            Node::Notify(notify) => notify.count(),
+            Node::Notify(notify) => notify.count(Internal::new()),
             _ => panic!("unexpected node"),
         }
     }