Remove the #[allow(non_uppercase_statics)] attr from bitflags!
This commit is contained in:
P1start
parent
e3ca987f74
commit
8e58771965
2 changed files with 37 additions and 42 deletions
|
|
@ -24,22 +24,22 @@
|
|||
/// ```{.rust}
|
||||
/// bitflags! {
|
||||
/// flags Flags: u32 {
|
||||
/// static FlagA = 0x00000001,
|
||||
/// static FlagB = 0x00000010,
|
||||
/// static FlagC = 0x00000100,
|
||||
/// static FlagABC = FlagA.bits
|
||||
/// | FlagB.bits
|
||||
/// | FlagC.bits,
|
||||
/// static FLAG_A = 0x00000001,
|
||||
/// static FLAG_B = 0x00000010,
|
||||
/// static FLAG_C = 0x00000100,
|
||||
/// static FLAG_ABC = FLAG_A.bits
|
||||
/// | FLAG_B.bits
|
||||
/// | FLAG_C.bits,
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let e1 = FlagA | FlagC;
|
||||
/// let e2 = FlagB | FlagC;
|
||||
/// assert!((e1 | e2) == FlagABC); // union
|
||||
/// assert!((e1 & e2) == FlagC); // intersection
|
||||
/// assert!((e1 - e2) == FlagA); // set difference
|
||||
/// assert!(!e2 == FlagA); // set complement
|
||||
/// let e1 = FLAG_A | FLAG_C;
|
||||
/// let e2 = FLAG_B | FLAG_C;
|
||||
/// assert!((e1 | e2) == FLAG_ABC); // union
|
||||
/// assert!((e1 & e2) == FLAG_C); // intersection
|
||||
/// assert!((e1 - e2) == FLAG_A); // set difference
|
||||
/// assert!(!e2 == FLAG_A); // set complement
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -50,8 +50,8 @@
|
|||
///
|
||||
/// bitflags! {
|
||||
/// flags Flags: u32 {
|
||||
/// static FlagA = 0x00000001,
|
||||
/// static FlagB = 0x00000010,
|
||||
/// static FLAG_A = 0x00000001,
|
||||
/// static FLAG_B = 0x00000010,
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
|
|
@ -69,7 +69,7 @@
|
|||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let mut flags = FlagA | FlagB;
|
||||
/// let mut flags = FLAG_A | FLAG_B;
|
||||
/// flags.clear();
|
||||
/// assert!(flags.is_empty());
|
||||
/// assert_eq!(format!("{}", flags).as_slice(), "hi!");
|
||||
|
|
@ -123,10 +123,7 @@ macro_rules! bitflags {
|
|||
bits: $T,
|
||||
}
|
||||
|
||||
$(
|
||||
#[allow(non_uppercase_statics)]
|
||||
$(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };
|
||||
)+
|
||||
$($(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+
|
||||
|
||||
impl $BitFlags {
|
||||
/// Returns an empty set of flags.
|
||||
|
|
@ -243,16 +240,14 @@ macro_rules! bitflags {
|
|||
bitflags! {
|
||||
$(#[$attr])*
|
||||
flags $BitFlags: $T {
|
||||
$(
|
||||
#[allow(non_uppercase_statics)]
|
||||
$(#[$Flag_attr])* static $Flag = $value
|
||||
),+
|
||||
$($(#[$Flag_attr])* static $Flag = $value),+
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[allow(non_uppercase_statics)]
|
||||
mod tests {
|
||||
use hash;
|
||||
use option::{Some, None};
|
||||
|
|
|
|||
|
|
@ -91,10 +91,10 @@ use std::iter;
|
|||
|
||||
bitflags! {
|
||||
flags Restrictions: u8 {
|
||||
static Unrestricted = 0b0000,
|
||||
static RestrictionStmtExpr = 0b0001,
|
||||
static RestrictionNoBarOp = 0b0010,
|
||||
static RestrictionNoStructLiteral = 0b0100
|
||||
static UNRESTRICTED = 0b0000,
|
||||
static RESTRICTION_STMT_EXPR = 0b0001,
|
||||
static RESTRICTION_NO_BAR_OP = 0b0010,
|
||||
static RESTRICTION_NO_STRUCT_LITERAL = 0b0100
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -383,7 +383,7 @@ impl<'a> Parser<'a> {
|
|||
buffer_start: 0,
|
||||
buffer_end: 0,
|
||||
tokens_consumed: 0,
|
||||
restrictions: Unrestricted,
|
||||
restrictions: UNRESTRICTED,
|
||||
quote_depth: 0,
|
||||
obsolete_set: HashSet::new(),
|
||||
mod_path_stack: Vec::new(),
|
||||
|
|
@ -2242,7 +2242,7 @@ impl<'a> Parser<'a> {
|
|||
if self.token == token::LBRACE {
|
||||
// This is a struct literal, unless we're prohibited
|
||||
// from parsing struct literals here.
|
||||
if !self.restrictions.contains(RestrictionNoStructLiteral) {
|
||||
if !self.restrictions.contains(RESTRICTION_NO_STRUCT_LITERAL) {
|
||||
// It's a struct literal.
|
||||
self.bump();
|
||||
let mut fields = Vec::new();
|
||||
|
|
@ -2771,7 +2771,7 @@ impl<'a> Parser<'a> {
|
|||
// Prevent dynamic borrow errors later on by limiting the
|
||||
// scope of the borrows.
|
||||
if self.token == token::BINOP(token::OR) &&
|
||||
self.restrictions.contains(RestrictionNoBarOp) {
|
||||
self.restrictions.contains(RESTRICTION_NO_BAR_OP) {
|
||||
return lhs;
|
||||
}
|
||||
|
||||
|
|
@ -2812,7 +2812,7 @@ impl<'a> Parser<'a> {
|
|||
pub fn parse_assign_expr(&mut self) -> P<Expr> {
|
||||
let lo = self.span.lo;
|
||||
let lhs = self.parse_binops();
|
||||
let restrictions = self.restrictions & RestrictionNoStructLiteral;
|
||||
let restrictions = self.restrictions & RESTRICTION_NO_STRUCT_LITERAL;
|
||||
match self.token {
|
||||
token::EQ => {
|
||||
self.bump();
|
||||
|
|
@ -2850,7 +2850,7 @@ impl<'a> Parser<'a> {
|
|||
return self.parse_if_let_expr();
|
||||
}
|
||||
let lo = self.last_span.lo;
|
||||
let cond = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let cond = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let thn = self.parse_block();
|
||||
let mut els: Option<P<Expr>> = None;
|
||||
let mut hi = thn.span.hi;
|
||||
|
|
@ -2868,7 +2868,7 @@ impl<'a> Parser<'a> {
|
|||
self.expect_keyword(keywords::Let);
|
||||
let pat = self.parse_pat();
|
||||
self.expect(&token::EQ);
|
||||
let expr = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let thn = self.parse_block();
|
||||
let (hi, els) = if self.eat_keyword(keywords::Else) {
|
||||
let expr = self.parse_else_expr();
|
||||
|
|
@ -2928,7 +2928,7 @@ impl<'a> Parser<'a> {
|
|||
let lo = self.last_span.lo;
|
||||
let pat = self.parse_pat();
|
||||
self.expect_keyword(keywords::In);
|
||||
let expr = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let loop_block = self.parse_block();
|
||||
let hi = self.span.hi;
|
||||
|
||||
|
|
@ -2937,7 +2937,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
pub fn parse_while_expr(&mut self, opt_ident: Option<ast::Ident>) -> P<Expr> {
|
||||
let lo = self.last_span.lo;
|
||||
let cond = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let cond = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let body = self.parse_block();
|
||||
let hi = body.span.hi;
|
||||
return self.mk_expr(lo, hi, ExprWhile(cond, body, opt_ident));
|
||||
|
|
@ -2952,7 +2952,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
fn parse_match_expr(&mut self) -> P<Expr> {
|
||||
let lo = self.last_span.lo;
|
||||
let discriminant = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let discriminant = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
self.commit_expr_expecting(&*discriminant, token::LBRACE);
|
||||
let mut arms: Vec<Arm> = Vec::new();
|
||||
while self.token != token::RBRACE {
|
||||
|
|
@ -2971,7 +2971,7 @@ impl<'a> Parser<'a> {
|
|||
guard = Some(self.parse_expr());
|
||||
}
|
||||
self.expect(&token::FAT_ARROW);
|
||||
let expr = self.parse_expr_res(RestrictionStmtExpr);
|
||||
let expr = self.parse_expr_res(RESTRICTION_STMT_EXPR);
|
||||
|
||||
let require_comma =
|
||||
!classify::expr_is_simple_block(&*expr)
|
||||
|
|
@ -2993,7 +2993,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
/// Parse an expression
|
||||
pub fn parse_expr(&mut self) -> P<Expr> {
|
||||
return self.parse_expr_res(Unrestricted);
|
||||
return self.parse_expr_res(UNRESTRICTED);
|
||||
}
|
||||
|
||||
/// Parse an expression, subject to the given restrictions
|
||||
|
|
@ -3290,9 +3290,9 @@ impl<'a> Parser<'a> {
|
|||
self.look_ahead(2, |t| {
|
||||
*t != token::COMMA && *t != token::RBRACKET
|
||||
}) {
|
||||
let start = self.parse_expr_res(RestrictionNoBarOp);
|
||||
let start = self.parse_expr_res(RESTRICTION_NO_BAR_OP);
|
||||
self.eat(&token::DOTDOTDOT);
|
||||
let end = self.parse_expr_res(RestrictionNoBarOp);
|
||||
let end = self.parse_expr_res(RESTRICTION_NO_BAR_OP);
|
||||
pat = PatRange(start, end);
|
||||
} else if is_plain_ident(&self.token) && !can_be_enum_or_struct {
|
||||
let id = self.parse_ident();
|
||||
|
|
@ -3593,7 +3593,7 @@ impl<'a> Parser<'a> {
|
|||
}
|
||||
|
||||
// Remainder are line-expr stmts.
|
||||
let e = self.parse_expr_res(RestrictionStmtExpr);
|
||||
let e = self.parse_expr_res(RESTRICTION_STMT_EXPR);
|
||||
P(spanned(lo, e.span.hi, StmtExpr(e, ast::DUMMY_NODE_ID)))
|
||||
}
|
||||
}
|
||||
|
|
@ -3602,7 +3602,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
/// Is this expression a successfully-parsed statement?
|
||||
fn expr_is_complete(&mut self, e: &Expr) -> bool {
|
||||
self.restrictions.contains(RestrictionStmtExpr) &&
|
||||
self.restrictions.contains(RESTRICTION_STMT_EXPR) &&
|
||||
!classify::expr_requires_semi_to_be_stmt(e)
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue