Lots of fixes from clippy

Author: Clar Charr

.gitignore

@@ -74,6 +74,7 @@ __pycache__/
 /obj/
 /rt/
 /rustllvm/
+/src/etc/UnicodeData.txt
 /src/libstd_unicode/DerivedCoreProperties.txt
 /src/libstd_unicode/DerivedNormalizationProps.txt
 /src/libstd_unicode/PropList.txt

src/etc/char_private.py

@@ -121,17 +121,17 @@ def compress_normal(normal):
     return compressed
 
 def print_singletons(uppers, lowers, uppersname, lowersname):
-    print("const {}: &'static [(u8, u8)] = &[".format(uppersname))
+    print("const {}: &[(u8, u8)] = &[".format(uppersname))
     for u, c in uppers:
         print("    ({:#04x}, {}),".format(u, c))
     print("];")
-    print("const {}: &'static [u8] = &[".format(lowersname))
+    print("const {}: &[u8] = &[".format(lowersname))
     for i in range(0, len(lowers), 8):
         print("    {}".format(" ".join("{:#04x},".format(l) for l in lowers[i:i+8])))
     print("];")
 
 def print_normal(normal, normalname):
-    print("const {}: &'static [u8] = &[".format(normalname))
+    print("const {}: &[u8] = &[".format(normalname))
     for v in normal:
         print("    {}".format(" ".join("{:#04x},".format(i) for i in v)))
     print("];")
@@ -187,8 +187,8 @@ def main():
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// NOTE: The following code was generated by "src/etc/char_private.py",
-//       do not edit directly!
+//! NOTE: The following code was generated by `src/etc/char_private.py`;
+//!       do not edit directly!
 
 fn check(x: u16, singletonuppers: &[(u8, u8)], singletonlowers: &[u8],
          normal: &[u8]) -> bool {
@@ -226,12 +226,13 @@ def main():
     current
 }
 
+#[cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))]
 pub(crate) fn is_printable(x: char) -> bool {
     let x = x as u32;
     let lower = x as u16;
-    if x < 0x10000 {
+    if x < (1 << 16) {
         check(lower, SINGLETONS0U, SINGLETONS0L, NORMAL0)
-    } else if x < 0x20000 {
+    } else if x < (2 << 16) {
         check(lower, SINGLETONS1U, SINGLETONS1L, NORMAL1)
     } else {\
 """)

src/etc/dec2flt_table.py

@@ -105,6 +105,7 @@ def error(f, e, z):
 
 //! Tables of approximations of powers of ten.
 //! DO NOT MODIFY: Generated by `src/etc/dec2flt_table.py`
+#![cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))]
 """
 
 

src/liballoc/allocator.rs

@@ -204,7 +204,7 @@ impl Layout {
         // the allocator to yield an error anyway.)
 
         let len_rounded_up = len.wrapping_add(align).wrapping_sub(1) & !align.wrapping_sub(1);
-        return len_rounded_up.wrapping_sub(len);
+        len_rounded_up.wrapping_sub(len)
     }
 
     /// Creates a layout describing the record for `n` instances of
@@ -800,9 +800,9 @@ pub unsafe trait Alloc {
         // _l <= layout.size()                       [guaranteed by usable_size()]
         //       layout.size() <= new_layout.size()  [required by this method]
         if new_layout.size <= u {
-            return Ok(());
+            Ok(())
         } else {
-            return Err(CannotReallocInPlace);
+            Err(CannotReallocInPlace)
         }
     }
 
@@ -858,9 +858,9 @@ pub unsafe trait Alloc {
         //                      layout.size() <= _u  [guaranteed by usable_size()]
         // new_layout.size() <= layout.size()        [required by this method]
         if l <= new_layout.size {
-            return Ok(());
+            Ok(())
         } else {
-            return Err(CannotReallocInPlace);
+            Err(CannotReallocInPlace)
         }
     }
 

src/liballoc/arc.rs

@@ -1095,7 +1095,7 @@ impl<T: ?Sized> Clone for Weak<T> {
             }
         }
 
-        return Weak { ptr: self.ptr };
+        Weak { ptr: self.ptr }
     }
 }
 

src/liballoc/boxed.rs

@@ -120,7 +120,7 @@ pub struct Box<T: ?Sized>(Unique<T>);
 /// compiler.  Easier just to make this parallel type for now.
 ///
 /// FIXME (pnkfelix): Currently the `box` protocol only supports
-/// creating instances of sized types. This IntermediateBox is
+/// creating instances of sized types. This `IntermediateBox` is
 /// designed to be forward-compatible with a future protocol that
 /// supports creating instances of unsized types; that is why the type
 /// parameter has the `?Sized` generalization marker, and is also why

src/liballoc/clippy.toml

@@ -0,0 +1 @@
+doc-valid-idents = ["TimSort"]

src/liballoc/linked_list.rs

@@ -1032,7 +1032,7 @@ impl<'a, T> IterMut<'a, T> {
     }
 }
 
-/// An iterator produced by calling `drain_filter` on LinkedList.
+/// An iterator produced by calling `drain_filter` on `LinkedList`.
 #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
 pub struct DrainFilter<'a, T: 'a, F: 'a>
     where F: FnMut(&mut T) -> bool,

src/liballoc/raw_vec.rs

@@ -18,23 +18,25 @@ use super::boxed::Box;
 
 /// A low-level utility for more ergonomically allocating, reallocating, and deallocating
 /// a buffer of memory on the heap without having to worry about all the corner cases
-/// involved. This type is excellent for building your own data structures like Vec and VecDeque.
+/// involved. This type is excellent for building your own data structures like `Vec` and
+/// `VecDeque`.
+///
 /// In particular:
 ///
-/// * Produces Unique::empty() on zero-sized types
-/// * Produces Unique::empty() on zero-length allocations
+/// * Produces `Unique::empty()` on zero-sized types
+/// * Produces `Unique::empty()` on zero-length allocations
 /// * Catches all overflows in capacity computations (promotes them to "capacity overflow" panics)
-/// * Guards against 32-bit systems allocating more than isize::MAX bytes
+/// * Guards against 32-bit systems allocating more than `isize::MAX` bytes
 /// * Guards against overflowing your length
 /// * Aborts on OOM
-/// * Avoids freeing Unique::empty()
-/// * Contains a ptr::Unique and thus endows the user with all related benefits
+/// * Avoids freeing `Unique::empty()`
+/// * Contains a `ptr::Unique` and thus endows the user with all related benefits
 ///
 /// This type does not in anyway inspect the memory that it manages. When dropped it *will*
-/// free its memory, but it *won't* try to Drop its contents. It is up to the user of RawVec
-/// to handle the actual things *stored* inside of a RawVec.
+/// free its memory, but it *won't* try to Drop its contents. It is up to the user of `RawVec`
+/// to handle the actual things *stored* inside of a `RawVec`.
 ///
-/// Note that a RawVec always forces its capacity to be usize::MAX for zero-sized types.
+/// Note that a `RawVec` always forces its capacity to be `usize::MAX` for zero-sized types.
 /// This enables you to use capacity growing logic catch the overflows in your length
 /// that might occur with zero-sized types.
 ///

src/liballoc/str.rs

@@ -27,7 +27,7 @@
 //! We can explicitly specify `hello_world`'s lifetime as well:
 //!
 //! ```
-//! let hello_world: &'static str = "Hello, world!";
+//! let hello_world: &str = "Hello, world!";
 //! ```
 //!
 //! *[See also the `str` primitive type](../../std/primitive.str.html).*
@@ -1995,7 +1995,7 @@ impl str {
     pub fn to_uppercase(&self) -> String {
         let mut s = String::with_capacity(self.len());
         s.extend(self.chars().flat_map(|c| c.to_uppercase()));
-        return s;
+        s
     }
 
     /// Escapes each char in `s` with [`char::escape_debug`].