cargo fix --edition-idioms

Author: cuviper

benches/bench.rs

@@ -1,6 +1,5 @@
 #![feature(test)]
-extern crate fnv;
-extern crate rand;
+
 extern crate test;
 #[macro_use]
 extern crate lazy_static;
@@ -13,8 +12,6 @@ type FnvBuilder = BuildHasherDefault<FnvHasher>;
 use test::black_box;
 use test::Bencher;
 
-extern crate indexmap;
-
 use indexmap::IndexMap;
 
 use std::collections::HashMap;

benches/faststring.rs

@@ -1,12 +1,9 @@
 #![feature(test)]
-extern crate lazy_static;
-extern crate rand;
+
 extern crate test;
 
 use test::Bencher;
 
-extern crate indexmap;
-
 use indexmap::IndexMap;
 
 use std::collections::HashMap;

build.rs

@@ -1,5 +1,3 @@
-extern crate autocfg;
-
 fn main() {
     let ac = autocfg::new();
     ac.emit_sysroot_crate("std");

src/lib.rs

@@ -1,5 +1,6 @@
 // We *mostly* avoid unsafe code, but `map::core::raw` allows it to use `RawTable` buckets.
 #![deny(unsafe_code)]
+#![warn(rust_2018_idioms)]
 #![doc(html_root_url = "https://docs.rs/indexmap/1/")]
 #![no_std]
 
@@ -33,8 +34,6 @@
 //! to use alternate hashers:
 //!
 //! ```
-//! # extern crate fnv;
-//! # extern crate fxhash;
 //! use fnv::FnvBuildHasher;
 //! use fxhash::FxBuildHasher;
 //! use indexmap::{IndexMap, IndexSet};
@@ -86,8 +85,6 @@ extern crate alloc;
 #[macro_use]
 extern crate std;
 
-extern crate hashbrown;
-
 #[cfg(not(has_std))]
 use alloc::vec::{self, Vec};
 

src/macros.rs

@@ -5,8 +5,7 @@
 /// ## Example
 ///
 /// ```
-/// #[macro_use] extern crate indexmap;
-/// # fn main() {
+/// use indexmap::indexmap;
 ///
 /// let map = indexmap!{
 ///     "a" => 1,
@@ -18,7 +17,6 @@
 ///
 /// // "a" is the first key
 /// assert_eq!(map.keys().next(), Some(&"a"));
-/// # }
 /// ```
 macro_rules! indexmap {
     (@single $($x:tt)*) => (());
@@ -44,8 +42,7 @@ macro_rules! indexmap {
 /// ## Example
 ///
 /// ```
-/// #[macro_use] extern crate indexmap;
-/// # fn main() {
+/// use indexmap::indexset;
 ///
 /// let set = indexset!{
 ///     "a",
@@ -57,7 +54,6 @@ macro_rules! indexmap {
 ///
 /// // "a" is the first value
 /// assert_eq!(set.iter().next(), Some(&"a"));
-/// # }
 /// ```
 macro_rules! indexset {
     (@single $($x:tt)*) => (());

src/map.rs

@@ -129,7 +129,7 @@ where
     V: fmt::Debug,
     S: BuildHasher,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if cfg!(not(feature = "test_debug")) {
             f.debug_map().entries(self.iter()).finish()
         } else {
@@ -291,42 +291,42 @@ where
     /// in-place manipulation.
     ///
     /// Computes in **O(1)** time (amortized average).
-    pub fn entry(&mut self, key: K) -> Entry<K, V> {
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
         let hash = self.hash(&key);
         self.core.entry(hash, key)
     }
 
     /// Return an iterator over the key-value pairs of the map, in their order
-    pub fn iter(&self) -> Iter<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         Iter {
             iter: self.as_entries().iter(),
         }
     }
 
     /// Return an iterator over the key-value pairs of the map, in their order
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
         IterMut {
             iter: self.as_entries_mut().iter_mut(),
         }
     }
 
     /// Return an iterator over the keys of the map, in their order
-    pub fn keys(&self) -> Keys<K, V> {
+    pub fn keys(&self) -> Keys<'_, K, V> {
         Keys {
             iter: self.as_entries().iter(),
         }
     }
 
     /// Return an iterator over the values of the map, in their order
-    pub fn values(&self) -> Values<K, V> {
+    pub fn values(&self) -> Values<'_, K, V> {
         Values {
             iter: self.as_entries().iter(),
         }
     }
 
     /// Return an iterator over mutable references to the the values of the map,
     /// in their order
-    pub fn values_mut(&mut self) -> ValuesMut<K, V> {
+    pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
         ValuesMut {
             iter: self.as_entries_mut().iter_mut(),
         }
@@ -663,7 +663,7 @@ where
 
     /// Clears the `IndexMap`, returning all key-value pairs as a drain iterator.
     /// Keeps the allocated memory for reuse.
-    pub fn drain(&mut self, range: RangeFull) -> Drain<K, V> {
+    pub fn drain(&mut self, range: RangeFull) -> Drain<'_, K, V> {
         Drain {
             iter: self.core.drain(range),
         }
@@ -723,7 +723,7 @@ impl<K, V, S> IndexMap<K, V, S> {
 ///
 /// [`keys`]: struct.IndexMap.html#method.keys
 /// [`IndexMap`]: struct.IndexMap.html
-pub struct Keys<'a, K: 'a, V: 'a> {
+pub struct Keys<'a, K, V> {
     pub(crate) iter: SliceIter<'a, Bucket<K, V>>,
 }
 
@@ -755,7 +755,7 @@ impl<'a, K, V> Clone for Keys<'a, K, V> {
 }
 
 impl<'a, K: fmt::Debug, V> fmt::Debug for Keys<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
     }
 }
@@ -767,7 +767,7 @@ impl<'a, K: fmt::Debug, V> fmt::Debug for Keys<'a, K, V> {
 ///
 /// [`values`]: struct.IndexMap.html#method.values
 /// [`IndexMap`]: struct.IndexMap.html
-pub struct Values<'a, K: 'a, V: 'a> {
+pub struct Values<'a, K, V> {
     iter: SliceIter<'a, Bucket<K, V>>,
 }
 
@@ -799,7 +799,7 @@ impl<'a, K, V> Clone for Values<'a, K, V> {
 }
 
 impl<'a, K, V: fmt::Debug> fmt::Debug for Values<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
     }
 }
@@ -811,7 +811,7 @@ impl<'a, K, V: fmt::Debug> fmt::Debug for Values<'a, K, V> {
 ///
 /// [`values_mut`]: struct.IndexMap.html#method.values_mut
 /// [`IndexMap`]: struct.IndexMap.html
-pub struct ValuesMut<'a, K: 'a, V: 'a> {
+pub struct ValuesMut<'a, K, V> {
     iter: SliceIterMut<'a, Bucket<K, V>>,
 }
 
@@ -840,7 +840,7 @@ impl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> {
 ///
 /// [`iter`]: struct.IndexMap.html#method.iter
 /// [`IndexMap`]: struct.IndexMap.html
-pub struct Iter<'a, K: 'a, V: 'a> {
+pub struct Iter<'a, K, V> {
     iter: SliceIter<'a, Bucket<K, V>>,
 }
 
@@ -872,7 +872,7 @@ impl<'a, K, V> Clone for Iter<'a, K, V> {
 }
 
 impl<'a, K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
     }
 }
@@ -884,7 +884,7 @@ impl<'a, K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'a, K, V> {
 ///
 /// [`iter_mut`]: struct.IndexMap.html#method.iter_mut
 /// [`IndexMap`]: struct.IndexMap.html
-pub struct IterMut<'a, K: 'a, V: 'a> {
+pub struct IterMut<'a, K, V> {
     iter: SliceIterMut<'a, Bucket<K, V>>,
 }
 
@@ -936,7 +936,7 @@ impl<K, V> ExactSizeIterator for IntoIter<K, V> {
 }
 
 impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let iter = self.iter.as_slice().iter().map(Bucket::refs);
         f.debug_list().entries(iter).finish()
     }
@@ -949,11 +949,7 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
 ///
 /// [`drain`]: struct.IndexMap.html#method.drain
 /// [`IndexMap`]: struct.IndexMap.html
-pub struct Drain<'a, K, V>
-where
-    K: 'a,
-    V: 'a,
-{
+pub struct Drain<'a, K, V> {
     pub(crate) iter: vec::Drain<'a, Bucket<K, V>>,
 }
 

src/map/core.rs

@@ -62,7 +62,7 @@ where
     K: fmt::Debug,
     V: fmt::Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("IndexMapCore")
             .field("indices", &raw::DebugIndices(&self.indices))
             .field("entries", &self.entries)
@@ -129,7 +129,7 @@ impl<K, V> IndexMapCore<K, V> {
         self.entries.clear();
     }
 
-    pub(crate) fn drain(&mut self, range: RangeFull) -> Drain<Bucket<K, V>> {
+    pub(crate) fn drain(&mut self, range: RangeFull) -> Drain<'_, Bucket<K, V>> {
         self.indices.clear();
         self.entries.drain(range)
     }
@@ -225,7 +225,7 @@ impl<K, V> IndexMapCore<K, V> {
 
 /// Entry for an existing key-value pair or a vacant location to
 /// insert one.
-pub enum Entry<'a, K: 'a, V: 'a> {
+pub enum Entry<'a, K, V> {
     /// Existing slot with equivalent key.
     Occupied(OccupiedEntry<'a, K, V>),
     /// Vacant slot (no equivalent key in the map).
@@ -297,7 +297,7 @@ impl<'a, K, V> Entry<'a, K, V> {
 }
 
 impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Entry<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Entry::Vacant(ref v) => f.debug_tuple(stringify!(Entry)).field(v).finish(),
             Entry::Occupied(ref o) => f.debug_tuple(stringify!(Entry)).field(o).finish(),
@@ -352,7 +352,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
 }
 
 impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for OccupiedEntry<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct(stringify!(OccupiedEntry))
             .field("key", self.key())
             .field("value", self.get())
@@ -364,7 +364,7 @@ impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for OccupiedEntry<'a
 /// It is part of the [`Entry`] enum.
 ///
 /// [`Entry`]: enum.Entry.html
-pub struct VacantEntry<'a, K: 'a, V: 'a> {
+pub struct VacantEntry<'a, K, V> {
     map: &'a mut IndexMapCore<K, V>,
     hash: HashValue,
     key: K,
@@ -391,7 +391,7 @@ impl<'a, K, V> VacantEntry<'a, K, V> {
 }
 
 impl<'a, K: 'a + fmt::Debug, V: 'a> fmt::Debug for VacantEntry<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple(stringify!(VacantEntry))
             .field(self.key())
             .finish()
@@ -402,5 +402,5 @@ impl<'a, K: 'a + fmt::Debug, V: 'a> fmt::Debug for VacantEntry<'a, K, V> {
 fn assert_send_sync() {
     fn assert_send_sync<T: Send + Sync>() {}
     assert_send_sync::<IndexMapCore<i32, i32>>();
-    assert_send_sync::<Entry<i32, i32>>();
+    assert_send_sync::<Entry<'_, i32, i32>>();
 }

src/map/core/raw.rs

@@ -11,7 +11,7 @@ type RawBucket = hashbrown::raw::Bucket<usize>;
 
 pub(super) struct DebugIndices<'a>(pub &'a RawTable<usize>);
 impl fmt::Debug for DebugIndices<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let indices = unsafe { self.0.iter().map(|raw_bucket| raw_bucket.read()) };
         f.debug_list().entries(indices).finish()
     }
@@ -49,7 +49,7 @@ impl<K, V> IndexMapCore<K, V> {
         unsafe { self.indices.erase(raw_bucket) };
     }
 
-    pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<K, V>
+    pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<'_, K, V>
     where
         K: Eq,
     {
@@ -193,7 +193,7 @@ impl<K, V> IndexMapCore<K, V> {
 /// [`Entry`]: enum.Entry.html
 // SAFETY: The lifetime of the map reference also constrains the raw bucket,
 // which is essentially a raw pointer into the map indices.
-pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
+pub struct OccupiedEntry<'a, K, V> {
     map: &'a mut IndexMapCore<K, V>,
     raw_bucket: RawBucket,
     key: K,