Use Rust 2018 syntax & ensure code follows up-to-date idioms

Author: lfittl

Cargo.toml

@@ -2,6 +2,7 @@
 name = "postgres_range"
 version = "0.9.1"
 authors = ["Steven Fackler <sfackler@gmail.com>"]
+edition = "2018"
 license = "MIT"
 description = "Range support for rust-postgres"
 repository = "https://github.com/sfackler/rust-postgres-range"

src/impls.rs

@@ -3,15 +3,15 @@ use postgres_types::{FromSql, IsNull, Kind, ToSql, Type};
 use postgres_types::private::BytesMut;
 use postgres_protocol::{self as protocol, types};
 
-use {BoundSided, BoundType, Normalizable, Range, RangeBound};
+use crate::{BoundSided, BoundType, Normalizable, Range, RangeBound};
 
 impl<'a, T> FromSql<'a> for Range<T>
 where
     T: PartialOrd + Normalizable + FromSql<'a>,
 {
     fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Range<T>, Box<dyn Error + Sync + Send>> {
-        let element_type = match ty.kind() {
-            &Kind::Range(ref ty) => ty,
+        let element_type = match *ty.kind() {
+            Kind::Range(ref ty) => ty,
             _ => panic!("unexpected type {:?}", ty),
         };
 
@@ -26,8 +26,8 @@ where
     }
 
     fn accepts(ty: &Type) -> bool {
-        match ty.kind() {
-            &Kind::Range(ref inner) => <T as FromSql>::accepts(inner),
+        match *ty.kind() {
+            Kind::Range(ref inner) => <T as FromSql>::accepts(inner),
             _ => false,
         }
     }
@@ -62,8 +62,8 @@ where
     T: PartialOrd + Normalizable + ToSql,
 {
     fn to_sql(&self, ty: &Type, buf: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
-        let element_type = match ty.kind() {
-            &Kind::Range(ref ty) => ty,
+        let element_type = match *ty.kind() {
+            Kind::Range(ref ty) => ty,
             _ => panic!("unexpected type {:?}", ty),
         };
 
@@ -81,8 +81,8 @@ where
     }
 
     fn accepts(ty: &Type) -> bool {
-        match ty.kind() {
-            &Kind::Range(ref inner) => <T as ToSql>::accepts(inner),
+        match *ty.kind() {
+            Kind::Range(ref inner) => <T as ToSql>::accepts(inner),
             _ => false,
         }
     }

src/lib.rs

@@ -1,16 +1,13 @@
 //! Types dealing with ranges of values
 #![doc(html_root_url = "https://sfackler.github.io/rust-postgres-range/doc/v0.9")]
+#![warn(clippy::all, rust_2018_idioms, missing_docs)]
 
-extern crate postgres_protocol;
 #[macro_use(to_sql_checked)]
 extern crate postgres_types;
 
 #[cfg(feature = "with-chrono-0_4")]
 mod chrono_04;
 
-#[cfg(test)]
-extern crate postgres;
-
 use std::cmp::Ordering;
 use std::fmt;
 use std::i32;
@@ -222,7 +219,7 @@ where
     fn clone(&self) -> RangeBound<S, T> {
         RangeBound {
             value: self.value.clone(),
-            type_: self.type_.clone(),
+            type_: self.type_,
             _m: PhantomData,
         }
     }
@@ -233,7 +230,7 @@ where
     S: BoundSided,
     T: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("RangeBound")
             .field("value", &self.value)
             .field("type_", &self.type_)
@@ -246,7 +243,7 @@ where
     S: BoundSided,
     T: fmt::Display,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let (lower, upper) = match self.type_ {
             Inclusive => ('[', ']'),
             Exclusive => ('(', ')'),
@@ -268,9 +265,9 @@ where
         self.value == other.value && self.type_ == other.type_
     }
 
-    fn ne(&self, other: &RangeBound<S, T>) -> bool {
+    /*fn ne(&self, other: &RangeBound<S, T>) -> bool {
         self.value != other.value || self.type_ != other.type_
-    }
+    }*/
 }
 
 impl<S, T> Eq for RangeBound<S, T>
@@ -326,8 +323,8 @@ where
     /// Constructs a new range bound
     pub fn new(value: T, type_: BoundType) -> RangeBound<S, T> {
         RangeBound {
-            value: value,
-            type_: type_,
+            value,
+            type_,
             _m: PhantomData,
         }
     }
@@ -343,7 +340,7 @@ where
     }
 }
 
-struct OptBound<'a, S: 'a + BoundSided, T: 'a>(Option<&'a RangeBound<S, T>>);
+struct OptBound<'a, S: BoundSided, T>(Option<&'a RangeBound<S, T>>);
 
 impl<'a, S, T> PartialEq for OptBound<'a, S, T>
 where
@@ -355,10 +352,10 @@ where
         self_ == other
     }
 
-    fn ne(&self, &OptBound(ref other): &OptBound<'a, S, T>) -> bool {
+    /*fn ne(&self, &OptBound(ref other): &OptBound<'a, S, T>) -> bool {
         let &OptBound(ref self_) = self;
         self_ != other
-    }
+    }*/
 }
 
 impl<'a, S, T> PartialOrd for OptBound<'a, S, T>
@@ -395,7 +392,7 @@ impl<T> fmt::Display for Range<T>
 where
     T: fmt::Display,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.inner {
             Empty => write!(fmt, "empty"),
             Normal(ref lower, ref upper) => {
@@ -520,7 +517,7 @@ where
         let (_, OptBound(lower)) = order(OptBound(self.lower()), OptBound(other.lower()));
         let (OptBound(upper), _) = order(OptBound(self.upper()), OptBound(other.upper()));
 
-        Range::new(lower.map(|v| v.clone()), upper.map(|v| v.clone()))
+        Range::new(lower.cloned(), upper.cloned())
     }
 
     /// Returns the union of this range with another if it is contiguous.
@@ -557,8 +554,8 @@ where
             None
         } else {
             Some(Range::new(
-                l_lower.map(|v| v.clone()),
-                u_upper.map(|v| v.clone()),
+                l_lower.cloned(),
+                u_upper.cloned(),
             ))
         }
     }
@@ -720,7 +717,7 @@ mod test {
         assert_eq!(r1, (range!('(',; ')')).intersect(&r1));
 
         let r2 = range!('(' 10i32,; ')');
-        let exp = Range::new(r2.lower().map(|v| v.clone()), r1.upper().map(|v| v.clone()));
+        let exp = Range::new(r2.lower().copied(), r1.upper().copied());
         assert_eq!(exp, r1.intersect(&r2));
         assert_eq!(exp, r2.intersect(&r1));