Use Self keyword instead of concrete type name (#2251)

Author: taiki-e

futures-channel/src/lock.rs

@@ -36,8 +36,8 @@ unsafe impl<T: Send> Sync for Lock<T> {}
 
 impl<T> Lock<T> {
     /// Creates a new lock around the given value.
-    pub(crate) fn new(t: T) -> Lock<T> {
-        Lock {
+    pub(crate) fn new(t: T) -> Self {
+        Self {
             locked: AtomicBool::new(false),
             data: UnsafeCell::new(t),
         }

futures-channel/src/mpsc/mod.rs

@@ -334,7 +334,7 @@ struct SenderTask {
 
 impl SenderTask {
     fn new() -> Self {
-        SenderTask {
+        Self {
             task: None,
             is_parked: false,
         }
@@ -665,7 +665,7 @@ impl<T> BoundedSenderInner<T> {
     /// Returns whether the sender send to this receiver.
     fn is_connected_to(&self, receiver: &Arc<BoundedInner<T>>) -> bool {
         Arc::ptr_eq(&self.inner, &receiver)
-    } 
+    }
 
     /// Returns pointer to the Arc containing sender
     ///
@@ -896,19 +896,19 @@ impl<T> UnboundedSender<T> {
 }
 
 impl<T> Clone for Sender<T> {
-    fn clone(&self) -> Sender<T> {
-        Sender(self.0.clone())
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
     }
 }
 
 impl<T> Clone for UnboundedSender<T> {
-    fn clone(&self) -> UnboundedSender<T> {
-        UnboundedSender(self.0.clone())
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
     }
 }
 
 impl<T> Clone for UnboundedSenderInner<T> {
-    fn clone(&self) -> UnboundedSenderInner<T> {
+    fn clone(&self) -> Self {
         // Since this atomic op isn't actually guarding any memory and we don't
         // care about any orderings besides the ordering on the single atomic
         // variable, a relaxed ordering is acceptable.
@@ -928,7 +928,7 @@ impl<T> Clone for UnboundedSenderInner<T> {
             // The ABA problem doesn't matter here. We only care that the
             // number of senders never exceeds the maximum.
             if actual == curr {
-                return UnboundedSenderInner {
+                return Self {
                     inner: self.inner.clone(),
                 };
             }
@@ -939,7 +939,7 @@ impl<T> Clone for UnboundedSenderInner<T> {
 }
 
 impl<T> Clone for BoundedSenderInner<T> {
-    fn clone(&self) -> BoundedSenderInner<T> {
+    fn clone(&self) -> Self {
         // Since this atomic op isn't actually guarding any memory and we don't
         // care about any orderings besides the ordering on the single atomic
         // variable, a relaxed ordering is acceptable.
@@ -959,7 +959,7 @@ impl<T> Clone for BoundedSenderInner<T> {
             // The ABA problem doesn't matter here. We only care that the
             // number of senders never exceeds the maximum.
             if actual == curr {
-                return BoundedSenderInner {
+                return Self {
                     inner: self.inner.clone(),
                     sender_task: Arc::new(Mutex::new(SenderTask::new())),
                     maybe_parked: false,

futures-channel/src/mpsc/queue.rs

@@ -63,7 +63,7 @@ pub(super) enum PopResult<T> {
 
 #[derive(Debug)]
 struct Node<T> {
-    next: AtomicPtr<Node<T>>,
+    next: AtomicPtr<Self>,
     value: Option<T>,
 }
 
@@ -80,8 +80,8 @@ unsafe impl<T: Send> Send for Queue<T> { }
 unsafe impl<T: Send> Sync for Queue<T> { }
 
 impl<T> Node<T> {
-    unsafe fn new(v: Option<T>) -> *mut Node<T> {
-        Box::into_raw(Box::new(Node {
+    unsafe fn new(v: Option<T>) -> *mut Self {
+        Box::into_raw(Box::new(Self {
             next: AtomicPtr::new(ptr::null_mut()),
             value: v,
         }))
@@ -91,9 +91,9 @@ impl<T> Node<T> {
 impl<T> Queue<T> {
     /// Creates a new queue that is safe to share among multiple producers and
     /// one consumer.
-    pub(super) fn new() -> Queue<T> {
+    pub(super) fn new() -> Self {
         let stub = unsafe { Node::new(None) };
-        Queue {
+        Self {
             head: AtomicPtr::new(stub),
             tail: UnsafeCell::new(stub),
         }

futures-channel/src/mpsc/sink_impl.rs

@@ -49,14 +49,14 @@ impl<T> Sink<T> for UnboundedSender<T> {
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Self::Error>> {
-        UnboundedSender::poll_ready(&*self, cx)
+        Self::poll_ready(&*self, cx)
     }
 
     fn start_send(
         mut self: Pin<&mut Self>,
         msg: T,
     ) -> Result<(), Self::Error> {
-        UnboundedSender::start_send(&mut *self, msg)
+        Self::start_send(&mut *self, msg)
     }
 
     fn poll_flush(

futures-channel/src/oneshot.rs

@@ -116,8 +116,8 @@ pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
 }
 
 impl<T> Inner<T> {
-    fn new() -> Inner<T> {
-        Inner {
+    fn new() -> Self {
+        Self {
             complete: AtomicBool::new(false),
             data: Lock::new(None),
             rx_task: Lock::new(None),
@@ -366,7 +366,7 @@ impl<T> Sender<T> {
     /// [`Receiver`](Receiver) half has hung up.
     ///
     /// This is a utility wrapping [`poll_canceled`](Sender::poll_canceled)
-    /// to expose a [`Future`](core::future::Future). 
+    /// to expose a [`Future`](core::future::Future).
     pub fn cancellation(&mut self) -> Cancellation<'_, T> {
         Cancellation { inner: self }
     }

futures-core/src/future.rs

@@ -79,7 +79,7 @@ impl<F, T, E> TryFuture for F
     type Error = E;
 
     #[inline]
-    fn try_poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<F::Output> {
+    fn try_poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         self.poll(cx)
     }
 }

futures-core/src/task/__internal/atomic_waker.rs

@@ -53,7 +53,7 @@ use core::task::Waker;
 ///
 /// impl Flag {
 ///     pub fn new() -> Self {
-///         Flag(Arc::new(Inner {
+///         Self(Arc::new(Inner {
 ///             waker: AtomicWaker::new(),
 ///             set: AtomicBool::new(false),
 ///         }))
@@ -202,7 +202,7 @@ impl AtomicWaker {
         trait AssertSync: Sync {}
         impl AssertSync for Waker {}
 
-        AtomicWaker {
+        Self {
             state: AtomicUsize::new(WAITING),
             waker: UnsafeCell::new(None),
         }
@@ -398,7 +398,7 @@ impl AtomicWaker {
 
 impl Default for AtomicWaker {
     fn default() -> Self {
-        AtomicWaker::new()
+        Self::new()
     }
 }
 

futures-executor/src/local_pool.rs

@@ -118,8 +118,8 @@ fn poll_executor<T, F: FnMut(&mut Context<'_>) -> T>(mut f: F) -> T {
 
 impl LocalPool {
     /// Create a new, empty pool of tasks.
-    pub fn new() -> LocalPool {
-        LocalPool {
+    pub fn new() -> Self {
+        Self {
             pool: FuturesUnordered::new(),
             incoming: Default::default(),
         }

futures-executor/src/thread_pool.rs

@@ -80,7 +80,7 @@ impl ThreadPool {
     /// See documentation for the methods in
     /// [`ThreadPoolBuilder`](ThreadPoolBuilder) for details on the default
     /// configuration.
-    pub fn new() -> Result<ThreadPool, io::Error> {
+    pub fn new() -> Result<Self, io::Error> {
         ThreadPoolBuilder::new().create()
     }
 
@@ -168,9 +168,9 @@ impl PoolState {
 }
 
 impl Clone for ThreadPool {
-    fn clone(&self) -> ThreadPool {
+    fn clone(&self) -> Self {
         self.state.cnt.fetch_add(1, Ordering::Relaxed);
-        ThreadPool { state: self.state.clone() }
+        Self { state: self.state.clone() }
     }
 }
 
@@ -313,7 +313,7 @@ impl Task {
     /// Actually run the task (invoking `poll` on the future) on the current
     /// thread.
     fn run(self) {
-        let Task { mut future, wake_handle, mut exec } = self;
+        let Self { mut future, wake_handle, mut exec } = self;
         let waker = waker_ref(&wake_handle);
         let mut cx = Context::from_waker(&waker);
 
@@ -328,7 +328,7 @@ impl Task {
                     Poll::Pending => {}
                     Poll::Ready(()) => return wake_handle.mutex.complete(),
                 }
-                let task = Task {
+                let task = Self {
                     future,
                     wake_handle: wake_handle.clone(),
                     exec,

futures-executor/src/unpark_mutex.rs

@@ -43,8 +43,8 @@ const REPOLL: usize = 2;        // --> POLLING
 const COMPLETE: usize = 3;      // No transitions out
 
 impl<D> UnparkMutex<D> {
-    pub(crate) fn new() -> UnparkMutex<D> {
-        UnparkMutex {
+    pub(crate) fn new() -> Self {
+        Self {
             status: AtomicUsize::new(WAITING),
             inner: UnsafeCell::new(None),
         }