Switch to the 2018 edition

Author: meithecatte

enumflags/Cargo.toml

@@ -8,6 +8,7 @@ repository = "https://github.com/NieDzejkob/enumflags2"
 readme = "../README.md"
 keywords = ["enum", "bitflag", "flag", "bitflags"]
 documentation = "https://docs.rs/enumflags2"
+edition = "2018"
 
 [dependencies.enumflags2_derive]
 version = "0.6.3"

enumflags/src/fallible.rs

@@ -67,7 +67,7 @@ impl<T: RawBitFlags> FromBitsError<T> {
 }
 
 impl<T: RawBitFlags + fmt::Debug> fmt::Display for FromBitsError<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "Invalid bits for {:?}: {:#b}", self.flags, self.invalid)
     }
 }

enumflags/src/formatting.rs

@@ -5,7 +5,7 @@ impl<T> fmt::Debug for BitFlags<T>
 where
     T: RawBitFlags + fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let name = T::bitflags_type_name();
         let bits = DebugBinaryFormatter(&self.val);
         let iter = if !self.is_empty() {
@@ -40,7 +40,7 @@ where
     T: RawBitFlags,
     T::Type: fmt::Binary,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Binary::fmt(&self.bits(), fmt)
     }
 }
@@ -50,7 +50,7 @@ where
     T: RawBitFlags,
     T::Type: fmt::Octal,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Octal::fmt(&self.bits(), fmt)
     }
 }
@@ -60,7 +60,7 @@ where
     T: RawBitFlags,
     T::Type: fmt::LowerHex,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::LowerHex::fmt(&self.bits(), fmt)
     }
 }
@@ -70,7 +70,7 @@ where
     T: RawBitFlags,
     T::Type: fmt::UpperHex,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::UpperHex::fmt(&self.bits(), fmt)
     }
 }
@@ -79,7 +79,7 @@ where
 struct FlagFormatter<I>(I);
 
 impl<T: Debug, I: Clone + Iterator<Item=T>> Debug for FlagFormatter<I> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut iter = self.0.clone();
         if let Some(val) = iter.next() {
             Debug::fmt(&val, fmt)?;
@@ -101,7 +101,7 @@ impl<T: Debug, I: Clone + Iterator<Item=T>> Debug for FlagFormatter<I> {
 struct DebugBinaryFormatter<'a, F>(&'a F);
 
 impl<'a, F: Debug + Binary + 'a> Debug for DebugBinaryFormatter<'a, F> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Check if {:x?} or {:X?} was used; this is determined via the
         // discriminator of core::fmt::FlagV1::{DebugLowerHex, DebugUpperHex},
         // which is not an accessible type: https://github.com/rust-lang/rust/blob/d65e272a9fe3e61aa5f229c5358e35a909435575/src/libcore/fmt/mod.rs#L306

enumflags/src/lib.rs

@@ -87,8 +87,6 @@
 #![warn(missing_docs)]
 #![cfg_attr(all(not(test), not(feature = "std")), no_std)]
 
-#[cfg(any(test, feature = "std"))]
-extern crate core;
 use core::{cmp, ops};
 use core::iter::FromIterator;
 
@@ -131,9 +129,9 @@ pub mod _internal {
         }
     }
 
-    use core::ops::{BitAnd, BitOr, BitXor, Not};
-    use core::cmp::PartialOrd;
-    use core::fmt;
+    use ::core::ops::{BitAnd, BitOr, BitXor, Not};
+    use ::core::cmp::PartialOrd;
+    use ::core::fmt;
 
     pub trait BitFlagNum
         : Default
@@ -165,7 +163,7 @@ mod formatting;
 
 // impl TryFrom<T::Type> for BitFlags<T>
 mod fallible;
-pub use fallible::FromBitsError;
+pub use crate::fallible::FromBitsError;
 
 /// Represents a set of flags of some type `T`.
 /// The type must have the `#[derive(BitFlags)]` attribute applied.
@@ -390,9 +388,8 @@ where
 
 #[cfg(feature = "serde")]
 mod impl_serde {
-    extern crate serde;
-    use self::serde::{Serialize, Deserialize};
-    use self::serde::de::{Error, Unexpected};
+    use serde::{Serialize, Deserialize};
+    use serde::de::{Error, Unexpected};
     use super::{BitFlags, RawBitFlags};
 
     impl<'a, T> Deserialize<'a> for BitFlags<T>

enumflags_derive/Cargo.toml

@@ -6,6 +6,7 @@ description = "Do not use directly, use the reexport in the `enumflags2` crate.
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/NieDzejkob/enumflags2"
 keywords = ["enum", "bitflag", "flag", "bitflags"]
+edition = "2018"
 
 [lib]
 proc-macro = true

enumflags_derive/src/lib.rs

@@ -2,8 +2,7 @@
 extern crate proc_macro;
 #[macro_use]
 extern crate quote;
-extern crate syn;
-extern crate proc_macro2;
+
 use syn::{Data, Ident, DeriveInput, DataEnum, spanned::Spanned};
 use proc_macro2::TokenStream;
 use proc_macro2::Span;
@@ -43,7 +42,7 @@ enum EvaluationError {
 
 impl From<EvaluationError> for TokenStream {
     fn from(why: EvaluationError) -> TokenStream {
-        use EvaluationError::*;
+        use crate::EvaluationError::*;
 
         match why {
             LiteralOutOfRange(span) => {
@@ -65,7 +64,7 @@ impl From<EvaluationError> for TokenStream {
 /// Try to evaluate the expression given.
 fn fold_expr(expr: &syn::Expr) -> Result<u64, EvaluationError> {
     use syn::Expr;
-    use EvaluationError::*;
+    use crate::EvaluationError::*;
     match expr {
         Expr::Lit(ref expr_lit) => {
             match expr_lit.lit {