fmt

ntex-bytes/src/buf/uninit_slice.rs

@@ -1,8 +1,7 @@
 use core::fmt;
 use core::mem::MaybeUninit;
 use core::ops::{
-    Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo,
+    Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
-    RangeToInclusive,
 };
 
 /// Uninitialized byte slice.
@@ -42,10 +41,7 @@ impl UninitSlice {
     /// let slice = unsafe { UninitSlice::from_raw_parts_mut(ptr, len) };
     /// ```
     #[inline]
-    pub unsafe fn from_raw_parts_mut<'a>(
+    pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
-        ptr: *mut u8,
-        len: usize,
-    ) -> &'a mut UninitSlice {
         let maybe_init: &mut [MaybeUninit<u8>] =
             core::slice::from_raw_parts_mut(ptr as *mut _, len);
         &mut *(maybe_init as *mut [MaybeUninit<u8>] as *mut UninitSlice)

ntex-bytes/src/bytes.rs

@@ -466,8 +466,7 @@ impl Bytes {
             }
         } else {
             Bytes {
-                inner: BytesMut::copy_from_slice_in(data, PoolId::DEFAULT.pool_ref())
+                inner: BytesMut::copy_from_slice_in(data, PoolId::DEFAULT.pool_ref()).inner,
-                    .inner,
             }
         }
     }
@@ -717,8 +716,7 @@ impl Bytes {
                 }
             } else {
                 Bytes {
-                    inner: BytesMut::copy_from_slice_in_priv(self, self.inner.pool())
+                    inner: BytesMut::copy_from_slice_in_priv(self, self.inner.pool()).inner,
-                        .inner,
                 }
             };
         }
@@ -2369,8 +2367,7 @@ impl Inner {
             let new_cap = len + additional;
 
             // Promote to a vector
-            *self =
+            *self = Inner::from_slice(new_cap, self.as_ref(), PoolId::DEFAULT.pool_ref());
-                Inner::from_slice(new_cap, self.as_ref(), PoolId::DEFAULT.pool_ref());
             return;
         }
 

ntex-bytes/tests/test_bytes.rs

@@ -26,9 +26,7 @@ fn test_size() {
     assert_eq!(32, std::mem::size_of::<Option<Bytes>>());
 
     let mut t = BytesMut::new();
-    t.extend_from_slice(
+    t.extend_from_slice(&b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"[..]);
-        &b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"[..],
-    );
 
     let val = t.freeze();
     assert!(val.is_inline());

ntex-macros/tests/test_macro.rs

@@ -2,8 +2,8 @@ use futures::{future, Future};
 use ntex::http::{Method, StatusCode};
 use ntex::web::{test, types::Path, App, Error, HttpResponse, HttpResponseBuilder};
 use ntex_macros::{
-    web_connect, web_delete, web_get, web_head, web_options, web_patch, web_post,
+    web_connect, web_delete, web_get, web_head, web_options, web_patch, web_post, web_put,
-    web_put, web_trace,
+    web_trace,
 };
 
 // Make sure that we can name function as 'config'

ntex-router/src/de.rs

@@ -26,11 +26,8 @@ macro_rules! parse_single_value {
         {
             if self.path.len() != 1 {
                 Err(de::value::Error::custom(
-                    format!(
+                    format!("wrong number of parameters: {} expected 1", self.path.len())
-                        "wrong number of parameters: {} expected 1",
+                        .as_str(),
-                        self.path.len()
-                    )
-                    .as_str(),
                 ))
             } else {
                 let v = self.path[0].parse().map_err(|_| {
@@ -109,11 +106,7 @@ impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T>
         visitor.visit_newtype_struct(self)
     }
 
-    fn deserialize_tuple<V>(
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        self,
-        len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
@@ -562,8 +555,7 @@ mod tests {
         assert_eq!(s.0, "name");
         assert_eq!(s.1, "user1");
 
-        let s: &str =
+        let s: &str = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
-            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(s, "name");
 
         let mut path = Path::new("/name/user1/");
@@ -572,8 +564,7 @@ mod tests {
             ("value", PathItem::Static("32")),
         ];
 
-        let s: Test1 =
+        let s: Test1 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
-            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(s.0, "name");
         assert_eq!(s.1, 32);
 
@@ -583,8 +574,7 @@ mod tests {
         assert_eq!((s.0).0, "name");
         assert_eq!((s.0).1, 32);
 
-        let s: Test2 =
+        let s: Test2 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
-            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(s.key, "name");
         assert_eq!(s.value, 32);
 
@@ -624,8 +614,7 @@ mod tests {
         let i: i8 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(i, 32);
 
-        let i: (i8,) =
+        let i: (i8,) = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
-            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(i, (32,));
 
         let i: Result<(i8, i8), _> =
@@ -634,13 +623,11 @@ mod tests {
 
         #[derive(Deserialize)]
         struct Test(i8);
-        let i: Test =
+        let i: Test = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
-            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(i.0, 32);
 
         path.segments.push(("value2", PathItem::Static("32")));
-        let i: Result<i8, _> =
+        let i: Result<i8, _> = de::Deserialize::deserialize(PathDeserializer::new(&path));
-            de::Deserialize::deserialize(PathDeserializer::new(&path));
         assert!(i.is_err());
     }
 
@@ -666,8 +653,7 @@ mod tests {
     fn test_extract_enum_value() {
         let mut path = Path::new("/val1/");
         path.segments = vec![("val", PathItem::Static("val1"))];
-        let i: Test3 =
+        let i: Test3 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
-            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(i.val, TestEnum::Val1);
 
         let mut path = Path::new("/val3/");

ntex-router/src/path.rs

@@ -163,9 +163,7 @@ impl<T: ResourcePath> Path<T> {
     }
 
     /// Try to deserialize matching parameters to a specified type `U`
-    pub fn load<'de, U: serde::Deserialize<'de>>(
+    pub fn load<'de, U: serde::Deserialize<'de>>(&'de self) -> Result<U, de::value::Error> {
-        &'de self,
-    ) -> Result<U, de::value::Error> {
         de::Deserialize::deserialize(PathDeserializer::new(self))
     }
 }

ntex-router/src/resource.rs

@@ -346,8 +346,7 @@ impl ResourceDef {
 
         loop {
             let start = if pattern.starts_with('/') { 1 } else { 0 };
-            let idx = if let Some(idx) = pattern[start..].find(|c| c == '{' || c == '/')
+            let idx = if let Some(idx) = pattern[start..].find(|c| c == '{' || c == '/') {
-            {
                 idx + start
             } else {
                 break;
@@ -551,8 +550,7 @@ mod tests {
         assert_eq!(tree.find(&mut resource), Some(1));
         assert_eq!(resource.get("id").unwrap(), "012345");
 
-        let re =
+        let re = ResourceDef::new("/u/test/v{version}-no-{minor}xx/resource/{id}/{name}");
-            ResourceDef::new("/u/test/v{version}-no-{minor}xx/resource/{id}/{name}");
         let tree = Tree::new(&re, 1);
         let mut resource = Path::new("/u/test/v1-no-3xx/resource/320120/name");
         assert_eq!(tree.find(&mut resource), Some(1));

ntex-router/src/router.rs

@@ -37,10 +37,7 @@ impl<T, U> Router<T, U> {
         }
     }
 
-    pub fn recognize_mut<R, P>(
+    pub fn recognize_mut<R, P>(&mut self, resource: &mut R) -> Option<(&mut T, ResourceId)>
-        &mut self,
-        resource: &mut R,
-    ) -> Option<(&mut T, ResourceId)>
     where
         R: Resource<P>,
         P: ResourcePath,

ntex-router/src/tree.rs

@@ -161,11 +161,7 @@ impl Tree {
         self.find_checked_inner(resource, true, &|_, _| true)
     }
 
-    pub(crate) fn find_checked<T, R, F>(
+    pub(crate) fn find_checked<T, R, F>(&self, resource: &mut R, check: &F) -> Option<usize>
-        &self,
-        resource: &mut R,
-        check: &F,
-    ) -> Option<usize>
     where
         T: ResourcePath,
         R: Resource<T>,
@@ -494,9 +490,7 @@ impl Tree {
                                 if let Item::Value(ref val) = val {
                                     let v = match val {
                                         Value::Val(v) | Value::Prefix(v) => *v,
-                                        Value::Slash(_) | Value::PrefixSlash(_) => {
+                                        Value::Slash(_) | Value::PrefixSlash(_) => continue,
-                                            continue
-                                        }
                                     };
                                     if check(v, resource) {
                                         return Some((v, skip));
@@ -537,16 +531,14 @@ impl Tree {
                                         }
                                     }
                                     Value::Prefix(v) => {
-                                        if p == PathState::Slash || p == PathState::Tail
+                                        if p == PathState::Slash || p == PathState::Tail {
-                                        {
                                             *v
                                         } else {
                                             continue;
                                         }
                                     }
                                     Value::PrefixSlash(v) => {
-                                        if p == PathState::Slash || p == PathState::Tail
+                                        if p == PathState::Slash || p == PathState::Tail {
-                                        {
                                             *v
                                         } else {
                                             continue;

ntex-rt/src/arbiter.rs

@@ -11,8 +11,7 @@ use crate::{system::System, Runtime};
 
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
-    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> =
+    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
-        RefCell::new(HashMap::new());
 );
 
 pub(super) static COUNT: AtomicUsize = AtomicUsize::new(0);
@@ -173,9 +172,8 @@ impl Arbiter {
 
     /// Set item to current arbiter's storage
     pub fn set_item<T: 'static>(item: T) {
-        STORAGE.with(move |cell| {
+        STORAGE
-            cell.borrow_mut().insert(TypeId::of::<T>(), Box::new(item))
+            .with(move |cell| cell.borrow_mut().insert(TypeId::of::<T>(), Box::new(item)));
-        });
     }
 
     /// Check if arbiter storage contains item
@@ -211,9 +209,7 @@ impl Arbiter {
             let mut st = cell.borrow_mut();
             let item = st
                 .get_mut(&TypeId::of::<T>())
-                .and_then(|boxed| {
+                .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
-                    (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut()
-                })
                 .unwrap();
             f(item)
         })

ntex-rt/src/tokio.rs

@@ -77,9 +77,7 @@ pub fn from_tcp_stream(stream: net::TcpStream) -> Result<Io, io::Error> {
 
 #[cfg(unix)]
 /// Convert std UnixStream to tokio's UnixStream
-pub fn from_unix_stream(
+pub fn from_unix_stream(stream: std::os::unix::net::UnixStream) -> Result<Io, io::Error> {
-    stream: std::os::unix::net::UnixStream,
-) -> Result<Io, io::Error> {
     stream.set_nonblocking(true)?;
     Ok(Io::new(tok_io::net::UnixStream::from_std(stream)?))
 }

ntex-util/src/channel/mpsc.rs

@@ -193,10 +193,7 @@ impl<T> Unpin for Receiver<T> {}
 impl<T> Stream for Receiver<T> {
     type Item = T;
 
-    fn poll_next(
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         self.poll_recv(cx)
     }
 }

ntex-util/src/time/wheel.rs

@@ -660,8 +660,7 @@ mod tests {
         let _elapsed = Instant::now() - time;
         #[cfg(not(target_os = "macos"))]
         assert!(
-            _elapsed > Duration::from_millis(200)
+            _elapsed > Duration::from_millis(200) && _elapsed < Duration::from_millis(300),
-                && _elapsed < Duration::from_millis(300),
             "elapsed: {:?}",
             _elapsed
         );

rustfmt.toml

@@ -1,2 +1,2 @@
-max_width = 89
+max_width = 92
 reorder_imports = true