diff --git a/README.md b/README.md index 486e4eca..005a0a4e 100644 --- a/README.md +++ b/README.md @@ -21,11 +21,10 @@ Add this to your `Cargo.toml`: bitflags = "1.2" ``` -and this to your crate root: +and this to your source code: ```rust -#[macro_use] -extern crate bitflags; +use bitflags::bitflags; ``` ## Rust Version Support diff --git a/src/lib.rs b/src/lib.rs index 252ca880..baef6c4d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -18,8 +18,7 @@ //! # Example //! //! ``` -//! #[macro_use] -//! extern crate bitflags; +//! use bitflags::bitflags; //! //! bitflags! { //! struct Flags: u32 { @@ -47,11 +46,10 @@ //! implementations: //! //! ``` -//! #[macro_use] -//! extern crate bitflags; -//! //! use std::fmt; //! +//! use bitflags::bitflags; +//! //! bitflags! { //! struct Flags: u32 { //! const A = 0b00000001; @@ -89,10 +87,9 @@ //! the current module by adding `pub` before `struct`: //! //! ``` -//! #[macro_use] -//! extern crate bitflags; -//! //! mod example { +//! use bitflags::bitflags; +//! //! bitflags! { //! pub struct Flags1: u32 { //! const A = 0b00000001; @@ -173,8 +170,7 @@ //! on the generated struct), you can simply derive `Default`: //! //! ``` -//! #[macro_use] -//! extern crate bitflags; +//! use bitflags::bitflags; //! //! bitflags! { //! // Results in default value with bits: 0 @@ -195,8 +191,7 @@ //! If your default value is not equal to `0` you need to implement `Default` yourself: //! //! ``` -//! #[macro_use] -//! extern crate bitflags; +//! use bitflags::bitflags; //! //! bitflags! { //! struct Flags: u32 { @@ -224,8 +219,7 @@ //! Flags with a value equal to zero will have some strange behavior that one should be aware of. //! //! ``` -//! #[macro_use] -//! extern crate bitflags; +//! use bitflags::bitflags; //! //! bitflags! { //! struct Flags: u32 { @@ -249,18 +243,9 @@ //! } //! ``` -#![no_std] +#![cfg_attr(not(test), no_std)] #![doc(html_root_url = "https://docs.rs/bitflags/1.2.1")] -#[cfg(test)] -#[macro_use] -extern crate std; - -// Re-export libcore using an alias so that the macros can work without -// requiring `extern crate core` downstream. -#[doc(hidden)] -pub extern crate core as _core; - /// The macro used to generate the flag structures. /// /// See the [crate level docs](../bitflags/index.html) for complete documentation. @@ -268,8 +253,7 @@ pub extern crate core as _core; /// # Example /// /// ``` -/// #[macro_use] -/// extern crate bitflags; +/// use bitflags::bitflags; /// /// bitflags! { /// struct Flags: u32 { @@ -294,11 +278,10 @@ pub extern crate core as _core; /// implementations: /// /// ``` -/// #[macro_use] -/// extern crate bitflags; -/// /// use std::fmt; /// +/// use bitflags::bitflags; +/// /// bitflags! { /// struct Flags: u32 { /// const A = 0b00000001; @@ -332,94 +315,18 @@ pub extern crate core as _core; macro_rules! bitflags { ( $(#[$outer:meta])* - pub struct $BitFlags:ident: $T:ty { - $( - $(#[$inner:ident $($args:tt)*])* - const $Flag:ident = $value:expr; - )+ - } - $($t:tt)* - ) => { - __bitflags! { - $(#[$outer])* - (pub) $BitFlags: $T { - $( - $(#[$inner $($args)*])* - $Flag = $value; - )+ - } - } - - bitflags! { - $($t)* - } - }; - ( - $(#[$outer:meta])* - struct $BitFlags:ident: $T:ty { + $vis:vis struct $BitFlags:ident: $T:ty { $( $(#[$inner:ident $($args:tt)*])* const $Flag:ident = $value:expr; )* } - $($t:tt)* - ) => { - __bitflags! { - $(#[$outer])* - () $BitFlags: $T { - $( - $(#[$inner $($args)*])* - $Flag = $value; - )* - } - } - bitflags! { - $($t)* - } - }; - ( - $(#[$outer:meta])* - pub ($($vis:tt)+) struct $BitFlags:ident: $T:ty { - $( - $(#[$inner:ident $($args:tt)*])* - const $Flag:ident = $value:expr; - )+ - } $($t:tt)* - ) => { - __bitflags! { - $(#[$outer])* - (pub ($($vis)+)) $BitFlags: $T { - $( - $(#[$inner $($args)*])* - $Flag = $value; - )+ - } - } - - bitflags! { - $($t)* - } - }; - () => {}; -} - -#[macro_export(local_inner_macros)] -#[doc(hidden)] -macro_rules! __bitflags { - ( - $(#[$outer:meta])* - ($($vis:tt)*) $BitFlags:ident: $T:ty { - $( - $(#[$inner:ident $($args:tt)*])* - $Flag:ident = $value:expr; - )* - } ) => { $(#[$outer])* #[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)] - $($vis)* struct $BitFlags { + $vis struct $BitFlags { bits: $T, } @@ -431,7 +338,12 @@ macro_rules! __bitflags { )* } } + + bitflags! { + $($t)* + } }; + () => {}; } #[macro_export(local_inner_macros)] @@ -481,8 +393,8 @@ macro_rules! __impl_bitflags { )* } ) => { - impl $crate::_core::fmt::Debug for $BitFlags { - fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result { + impl core::fmt::Debug for $BitFlags { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { // This convoluted approach is to handle #[cfg]-based flag // omission correctly. For example it needs to support: // @@ -535,7 +447,7 @@ macro_rules! __impl_bitflags { } first = false; f.write_str("0x")?; - $crate::_core::fmt::LowerHex::fmt(&extra_bits, f)?; + core::fmt::LowerHex::fmt(&extra_bits, f)?; } if first { f.write_str("(empty)")?; @@ -543,24 +455,24 @@ macro_rules! __impl_bitflags { Ok(()) } } - impl $crate::_core::fmt::Binary for $BitFlags { - fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result { - $crate::_core::fmt::Binary::fmt(&self.bits, f) + impl core::fmt::Binary for $BitFlags { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + core::fmt::Binary::fmt(&self.bits, f) } } - impl $crate::_core::fmt::Octal for $BitFlags { - fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result { - $crate::_core::fmt::Octal::fmt(&self.bits, f) + impl core::fmt::Octal for $BitFlags { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + core::fmt::Octal::fmt(&self.bits, f) } } - impl $crate::_core::fmt::LowerHex for $BitFlags { - fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result { - $crate::_core::fmt::LowerHex::fmt(&self.bits, f) + impl core::fmt::LowerHex for $BitFlags { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + core::fmt::LowerHex::fmt(&self.bits, f) } } - impl $crate::_core::fmt::UpperHex for $BitFlags { - fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result { - $crate::_core::fmt::UpperHex::fmt(&self.bits, f) + impl core::fmt::UpperHex for $BitFlags { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + core::fmt::UpperHex::fmt(&self.bits, f) } } @@ -599,11 +511,11 @@ macro_rules! __impl_bitflags { /// Convert from underlying bit representation, unless that /// representation contains bits that do not correspond to a flag. #[inline] - pub const fn from_bits(bits: $T) -> $crate::_core::option::Option<$BitFlags> { + pub const fn from_bits(bits: $T) -> core::option::Option<$BitFlags> { if (bits & !$BitFlags::all().bits()) == 0 { - $crate::_core::option::Option::Some($BitFlags { bits }) + core::option::Option::Some($BitFlags { bits }) } else { - $crate::_core::option::Option::None + core::option::Option::None } } @@ -683,7 +595,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::BitOr for $BitFlags { + impl core::ops::BitOr for $BitFlags { type Output = $BitFlags; /// Returns the union of the two sets of flags. @@ -693,7 +605,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::BitOrAssign for $BitFlags { + impl core::ops::BitOrAssign for $BitFlags { /// Adds the set of flags. #[inline] @@ -702,7 +614,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::BitXor for $BitFlags { + impl core::ops::BitXor for $BitFlags { type Output = $BitFlags; /// Returns the left flags, but with all the right flags toggled. @@ -712,7 +624,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::BitXorAssign for $BitFlags { + impl core::ops::BitXorAssign for $BitFlags { /// Toggles the set of flags. #[inline] @@ -721,7 +633,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::BitAnd for $BitFlags { + impl core::ops::BitAnd for $BitFlags { type Output = $BitFlags; /// Returns the intersection between the two sets of flags. @@ -731,7 +643,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::BitAndAssign for $BitFlags { + impl core::ops::BitAndAssign for $BitFlags { /// Disables all flags disabled in the set. #[inline] @@ -740,7 +652,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::Sub for $BitFlags { + impl core::ops::Sub for $BitFlags { type Output = $BitFlags; /// Returns the set difference of the two sets of flags. @@ -750,7 +662,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::SubAssign for $BitFlags { + impl core::ops::SubAssign for $BitFlags { /// Disables all flags enabled in the set. #[inline] @@ -759,7 +671,7 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::ops::Not for $BitFlags { + impl core::ops::Not for $BitFlags { type Output = $BitFlags; /// Returns the complement of this set of flags. @@ -769,16 +681,16 @@ macro_rules! __impl_bitflags { } } - impl $crate::_core::iter::Extend<$BitFlags> for $BitFlags { - fn extend>(&mut self, iterator: T) { + impl core::iter::Extend<$BitFlags> for $BitFlags { + fn extend>(&mut self, iterator: T) { for item in iterator { self.insert(item) } } } - impl $crate::_core::iter::FromIterator<$BitFlags> for $BitFlags { - fn from_iter>(iterator: T) -> $BitFlags { + impl core::iter::FromIterator<$BitFlags> for $BitFlags { + fn from_iter>(iterator: T) -> $BitFlags { let mut result = Self::empty(); result.extend(iterator); result diff --git a/test_suite/Cargo.toml b/test_suite/Cargo.toml index 057a022c..ac459d5d 100644 --- a/test_suite/Cargo.toml +++ b/test_suite/Cargo.toml @@ -1,6 +1,7 @@ [project] name = "test_suite" version = "0.0.0" +edition = "2018" [dependencies] bitflags = { path = "../" } diff --git a/test_suite/tests/compile-fail/private_flags.rs b/test_suite/tests/compile-fail/private_flags.rs index 0532246a..b542cb15 100644 --- a/test_suite/tests/compile-fail/private_flags.rs +++ b/test_suite/tests/compile-fail/private_flags.rs @@ -1,7 +1,6 @@ -#[macro_use] -extern crate bitflags; - mod example { + use bitflags::bitflags + bitflags! { pub struct Flags1: u32 { const FLAG_A = 0b00000001; diff --git a/test_suite/tests/conflicting_trait_impls.rs b/test_suite/tests/conflicting_trait_impls.rs index eb7a3251..adb78c7e 100644 --- a/test_suite/tests/conflicting_trait_impls.rs +++ b/test_suite/tests/conflicting_trait_impls.rs @@ -1,11 +1,10 @@ #![no_std] -#[macro_use] -extern crate bitflags; - #[allow(unused_imports)] use core::fmt::Display; +use bitflags::bitflags; + bitflags! { /// baz struct Flags: u32 { diff --git a/test_suite/tests/external.rs b/test_suite/tests/external.rs index 4c88387f..8c513c53 100644 --- a/test_suite/tests/external.rs +++ b/test_suite/tests/external.rs @@ -1,5 +1,4 @@ -#[macro_use] -extern crate bitflags; +use bitflags::bitflags; bitflags! { /// baz diff --git a/test_suite/tests/external_no_std.rs b/test_suite/tests/external_no_std.rs index 31f87e42..07a3c99c 100644 --- a/test_suite/tests/external_no_std.rs +++ b/test_suite/tests/external_no_std.rs @@ -1,7 +1,6 @@ #![no_std] -#[macro_use] -extern crate bitflags; +use bitflags::bitflags; bitflags! { /// baz diff --git a/test_suite/tests/serde.rs b/test_suite/tests/serde.rs index 0424af5f..9f3e4528 100644 --- a/test_suite/tests/serde.rs +++ b/test_suite/tests/serde.rs @@ -1,11 +1,10 @@ -#[macro_use] -extern crate bitflags; - #[macro_use] extern crate serde_derive; extern crate serde; extern crate serde_json; +use bitflags::bitflags; + bitflags! { #[derive(Serialize, Deserialize)] struct Flags: u32 { diff --git a/test_suite/tests/u128_bitflags.rs b/test_suite/tests/u128_bitflags.rs index 7ebad3d2..8ed1546d 100644 --- a/test_suite/tests/u128_bitflags.rs +++ b/test_suite/tests/u128_bitflags.rs @@ -1,7 +1,6 @@ #![cfg(feature = "unstable")] -#[macro_use] -extern crate bitflags; +use bitflags::bitflags; bitflags! { /// baz