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),
         }

futures-macro/src/join.rs

@@ -13,7 +13,7 @@ struct Join {
 
 impl Parse for Join {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let mut join = Join::default();
+        let mut join = Self::default();
 
         while !input.is_empty() {
             join.fut_exprs.push(input.parse::<Expr>()?);

futures-macro/src/select.rs

@@ -27,7 +27,7 @@ enum CaseKind {
 
 impl Parse for Select {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let mut select = Select {
+        let mut select = Self {
             complete: None,
             default: None,
             normal_fut_exprs: vec![],

futures-task/src/future_obj.rs

@@ -42,8 +42,8 @@ unsafe fn remove_drop_lifetime<'a, T>(ptr: unsafe fn (*mut (dyn Future<Output =
 impl<'a, T> LocalFutureObj<'a, T> {
     /// Create a `LocalFutureObj` from a custom trait object representation.
     #[inline]
-    pub fn new<F: UnsafeFutureObj<'a, T> + 'a>(f: F) -> LocalFutureObj<'a, T> {
-        LocalFutureObj {
+    pub fn new<F: UnsafeFutureObj<'a, T> + 'a>(f: F) -> Self {
+        Self {
             future: unsafe { remove_future_lifetime(f.into_raw()) },
             drop_fn: unsafe { remove_drop_lifetime(F::drop) },
             _marker: PhantomData,
@@ -72,7 +72,7 @@ impl<T> fmt::Debug for LocalFutureObj<'_, T> {
 
 impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T> {
     #[inline]
-    fn from(f: FutureObj<'a, T>) -> LocalFutureObj<'a, T> {
+    fn from(f: FutureObj<'a, T>) -> Self {
         f.0
     }
 }
@@ -113,8 +113,8 @@ unsafe impl<T> Send for FutureObj<'_, T> {}
 impl<'a, T> FutureObj<'a, T> {
     /// Create a `FutureObj` from a custom trait object representation.
     #[inline]
-    pub fn new<F: UnsafeFutureObj<'a, T> + Send>(f: F) -> FutureObj<'a, T> {
-        FutureObj(LocalFutureObj::new(f))
+    pub fn new<F: UnsafeFutureObj<'a, T> + Send>(f: F) -> Self {
+        Self(LocalFutureObj::new(f))
     }
 }
 
@@ -296,49 +296,49 @@ mod if_alloc {
 
     impl<'a, F: Future<Output = ()> + Send + 'a> From<Box<F>> for FutureObj<'a, ()> {
         fn from(boxed: Box<F>) -> Self {
-            FutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a> From<Box<dyn Future<Output = ()> + Send + 'a>> for FutureObj<'a, ()> {
         fn from(boxed: Box<dyn Future<Output = ()> + Send + 'a>) -> Self {
-            FutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a, F: Future<Output = ()> + Send + 'a> From<Pin<Box<F>>> for FutureObj<'a, ()> {
         fn from(boxed: Pin<Box<F>>) -> Self {
-            FutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a> From<Pin<Box<dyn Future<Output = ()> + Send + 'a>>> for FutureObj<'a, ()> {
         fn from(boxed: Pin<Box<dyn Future<Output = ()> + Send + 'a>>) -> Self {
-            FutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a, F: Future<Output = ()> + 'a> From<Box<F>> for LocalFutureObj<'a, ()> {
         fn from(boxed: Box<F>) -> Self {
-            LocalFutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a> From<Box<dyn Future<Output = ()> + 'a>> for LocalFutureObj<'a, ()> {
         fn from(boxed: Box<dyn Future<Output = ()> + 'a>) -> Self {
-            LocalFutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a, F: Future<Output = ()> + 'a> From<Pin<Box<F>>> for LocalFutureObj<'a, ()> {
         fn from(boxed: Pin<Box<F>>) -> Self {
-            LocalFutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 
     impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a>>> for LocalFutureObj<'a, ()> {
         fn from(boxed: Pin<Box<dyn Future<Output = ()> + 'a>>) -> Self {
-            LocalFutureObj::new(boxed)
+            Self::new(boxed)
         }
     }
 }

futures-task/src/waker_ref.rs

@@ -22,7 +22,7 @@ impl<'a> WakerRef<'a> {
         // copy the underlying (raw) waker without calling a clone,
         // as we won't call Waker::drop either.
         let waker = ManuallyDrop::new(unsafe { core::ptr::read(waker) });
-        WakerRef {
+        Self {
             waker,
             _marker: PhantomData,
         }
@@ -35,7 +35,7 @@ impl<'a> WakerRef<'a> {
     /// by the caller), and the [`Waker`] doesn't need to or must not be
     /// destroyed.
     pub fn new_unowned(waker: ManuallyDrop<Waker>) -> Self {
-        WakerRef {
+        Self {
             waker,
             _marker: PhantomData,
         }

futures-test/src/assert_unmoved.rs

@@ -24,7 +24,7 @@ use std::thread::panicking;
 pub struct AssertUnmoved<T> {
     #[pin]
     inner: T,
-    this_ptr: *const AssertUnmoved<T>,
+    this_ptr: *const Self,
 }
 
 // Safety: having a raw pointer in a struct makes it `!Send`, however the

futures-test/src/io/limited.rs

@@ -21,8 +21,8 @@ pub struct Limited<Io> {
 }
 
 impl<Io> Limited<Io> {
-    pub(crate) fn new(io: Io, limit: usize) -> Limited<Io> {
-        Limited { io, limit }
+    pub(crate) fn new(io: Io, limit: usize) -> Self {
+        Self { io, limit }
     }
 
     /// Acquires a reference to the underlying I/O object that this adaptor is