Fix doc tests

Author: Daksh14

tokio/src/sync/set_once.rs

@@ -106,11 +106,14 @@ impl<T: Eq> Eq for SetOnce<T> {}
 impl<T> Drop for SetOnce<T> {
     fn drop(&mut self) {
         if self.initialized() {
+            // SAFETY: We're inside the drop implementation of SetOnce
+            // AND we're also initalized. This is the best way to ensure
+            // out data gets dropped
             unsafe {
                 let _ = self.value.with_mut(|ptr| ptr::read(ptr).assume_init());
             }
-
-            *self.value_set.get_mut() = false;
+            // no need to set the flag to false as this set once is being
+            // dropped
         }
     }
 }
@@ -230,8 +233,8 @@ impl<T> SetOnce<T> {
     /// Returns `true` if the `SetOnce` currently contains a value, and `false`
     /// otherwise.
     pub fn initialized(&self) -> bool {
-        // Using acquire ordering so any threads that read a true from this
-        // atomic is able to read the value.
+        // Using acquire ordering so we're able to read/catch any writes that
+        // are done with `Ordering::Release`
         self.value_set.load(Ordering::Acquire)
     }
 
@@ -299,25 +302,19 @@ impl<T> SetOnce<T> {
     /// Returns `None` if the cell is empty.
     pub fn into_inner(mut self) -> Option<T> {
         if self.initialized() {
-            // SAFETY: The SetOnce is initialized, we can assume the value is
-            // initialized and return that, when we return the value we give the
-            // drop handler to someone else and drop is called automatically
-            //
-            // We set the value_set as value as we just took the value out
-            // and the drop implementation will do nothing.
+            // Since we have taken ownership of self, its drop implementation
+            // will be called by the end of this function, to prevent a double
+            // free we will set the value_set to false so that the drop
+            // implementation does not try to drop the value again.
             *self.value_set.get_mut() = false;
+
+            // SAFETY: The SetOnce is currently initialized, we can assume the
+            // value is initialized and return that, when we return the value
+            // we give the drop handler to the return scope.
             Some(unsafe { self.value.with_mut(|ptr| ptr::read(ptr).assume_init()) })
         } else {
             None
         }
-        // the drop of self is called here again but it doesn't do anything since
-        // if we dont return early then value is not initialized.
-    }
-
-    /// Takes ownership of the current value, leaving the cell empty.  Returns
-    /// `None` if the cell is empty.
-    pub fn take(&mut self) -> Option<T> {
-        std::mem::take(self).into_inner()
     }
 
     /// Waits until the `SetOnce` has been initialized. Once the `SetOnce` is