diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs index efa3402073f2eff827a091aae9f24487b3f50a8e..82d320d570223670cd16654efa1117ff5a91bcbb 100644 --- a/src/libnum/bigint.rs +++ b/src/libnum/bigint.rs @@ -86,9 +86,12 @@ pub mod BigDigit { use super::DoubleBigDigit; // `DoubleBigDigit` size dependent + #[allow(non_uppercase_statics)] pub static bits: uint = 32; + #[allow(non_uppercase_statics)] pub static base: DoubleBigDigit = 1 << bits; + #[allow(non_uppercase_statics)] static lo_mask: DoubleBigDigit = (-1 as DoubleBigDigit) >> bits; #[inline] @@ -1841,7 +1844,7 @@ fn check(n: BigUint, ans: BigInt) { BigInt::from_biguint(Plus, BigUint::new(vec!(1,2,3)))); } - static sum_triples: &'static [(&'static [BigDigit], + static SUM_TRIPLES: &'static [(&'static [BigDigit], &'static [BigDigit], &'static [BigDigit])] = &[ (&[], &[], &[]), @@ -1857,7 +1860,7 @@ fn check(n: BigUint, ans: BigInt) { #[test] fn test_add() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1870,7 +1873,7 @@ fn test_add() { #[test] fn test_sub() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1888,7 +1891,7 @@ fn test_sub_fail_on_underflow() { a - b; } - static mul_triples: &'static [(&'static [BigDigit], + static MUL_TRIPLES: &'static [(&'static [BigDigit], &'static [BigDigit], &'static [BigDigit])] = &[ (&[], &[], &[]), @@ -1914,7 +1917,7 @@ fn test_sub_fail_on_underflow() { (&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1]) ]; - static div_rem_quadruples: &'static [(&'static [BigDigit], + static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], &'static [BigDigit], &'static [BigDigit], &'static [BigDigit])] @@ -1928,7 +1931,7 @@ fn test_sub_fail_on_underflow() { #[test] fn test_mul() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1938,7 +1941,7 @@ fn test_mul() { assert!(b * a == c); } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1952,7 +1955,7 @@ fn test_mul() { #[test] fn test_div_rem() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1966,7 +1969,7 @@ fn test_div_rem() { } } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1979,7 +1982,7 @@ fn test_div_rem() { #[test] fn test_checked_add() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -1992,7 +1995,7 @@ fn test_checked_add() { #[test] fn test_checked_sub() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -2012,7 +2015,7 @@ fn test_checked_sub() { #[test] fn test_checked_mul() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -2022,7 +2025,7 @@ fn test_checked_mul() { assert!(b.checked_mul(&a).unwrap() == c); } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -2036,7 +2039,7 @@ fn test_checked_mul() { #[test] fn test_checked_div() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigUint::from_slice(a_vec); let b = BigUint::from_slice(b_vec); @@ -2440,7 +2443,7 @@ fn check(n: BigInt, ans_1: BigUint) { assert_eq!(negative.to_biguint(), None); } - static sum_triples: &'static [(&'static [BigDigit], + static SUM_TRIPLES: &'static [(&'static [BigDigit], &'static [BigDigit], &'static [BigDigit])] = &[ (&[], &[], &[]), @@ -2456,7 +2459,7 @@ fn check(n: BigInt, ans_1: BigUint) { #[test] fn test_add() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2475,7 +2478,7 @@ fn test_add() { #[test] fn test_sub() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2492,7 +2495,7 @@ fn test_sub() { } } - static mul_triples: &'static [(&'static [BigDigit], + static MUL_TRIPLES: &'static [(&'static [BigDigit], &'static [BigDigit], &'static [BigDigit])] = &[ (&[], &[], &[]), @@ -2518,7 +2521,7 @@ fn test_sub() { (&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1]) ]; - static div_rem_quadruples: &'static [(&'static [BigDigit], + static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], &'static [BigDigit], &'static [BigDigit], &'static [BigDigit])] @@ -2532,7 +2535,7 @@ fn test_sub() { #[test] fn test_mul() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2545,7 +2548,7 @@ fn test_mul() { assert!((-b) * a == -c); } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2584,7 +2587,7 @@ fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) { } } - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2594,7 +2597,7 @@ fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) { if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); } } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2627,7 +2630,7 @@ fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) { check_sub(&a.neg(), b, &q.neg(), &r.neg()); check_sub(&a.neg(), &b.neg(), q, &r.neg()); } - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2637,7 +2640,7 @@ fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) { if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); } } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2652,7 +2655,7 @@ fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) { #[test] fn test_checked_add() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2671,7 +2674,7 @@ fn test_checked_add() { #[test] fn test_checked_sub() { - for elm in sum_triples.iter() { + for elm in SUM_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2690,7 +2693,7 @@ fn test_checked_sub() { #[test] fn test_checked_mul() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2703,7 +2706,7 @@ fn test_checked_mul() { assert!((-b).checked_mul(&a).unwrap() == -c); } - for elm in div_rem_quadruples.iter() { + for elm in DIV_REM_QUADRUPLES.iter() { let (a_vec, b_vec, c_vec, d_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); @@ -2716,7 +2719,7 @@ fn test_checked_mul() { } #[test] fn test_checked_div() { - for elm in mul_triples.iter() { + for elm in MUL_TRIPLES.iter() { let (a_vec, b_vec, c_vec) = *elm; let a = BigInt::from_slice(Plus, a_vec); let b = BigInt::from_slice(Plus, b_vec); diff --git a/src/libnum/rational.rs b/src/libnum/rational.rs index 2e13d5f0148d2dfeeec1f958d36c48d55a9f642a..ceaf685c19a5154d03b89d1a25def253c3136635 100644 --- a/src/libnum/rational.rs +++ b/src/libnum/rational.rs @@ -406,10 +406,13 @@ mod test { pub static _2: Rational = Ratio { numer: 2, denom: 1}; pub static _1_2: Rational = Ratio { numer: 1, denom: 2}; pub static _3_2: Rational = Ratio { numer: 3, denom: 2}; + #[allow(non_uppercase_statics)] pub static _neg1_2: Rational = Ratio { numer: -1, denom: 2}; pub static _1_3: Rational = Ratio { numer: 1, denom: 3}; + #[allow(non_uppercase_statics)] pub static _neg1_3: Rational = Ratio { numer: -1, denom: 3}; pub static _2_3: Rational = Ratio { numer: 2, denom: 3}; + #[allow(non_uppercase_statics)] pub static _neg2_3: Rational = Ratio { numer: -2, denom: 3}; pub fn to_big(n: Rational) -> BigRational { diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 7a237670890cae68e37dbdad31478cc639a9d830..64c6b1739ebb1f962468af06d88da8026cb268dd 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -209,15 +209,15 @@ fn test_rng_reseed() { assert_eq!(string1, string2); } - static fill_bytes_v_len: uint = 13579; + static FILL_BYTES_V_LEN: uint = 13579; #[test] fn test_rng_fill_bytes() { - let mut v = Vec::from_elem(fill_bytes_v_len, 0u8); + let mut v = Vec::from_elem(FILL_BYTES_V_LEN, 0u8); ::test::rng().fill_bytes(v.as_mut_slice()); // Sanity test: if we've gotten here, `fill_bytes` has not infinitely // recursed. - assert_eq!(v.len(), fill_bytes_v_len); + assert_eq!(v.len(), FILL_BYTES_V_LEN); // To test that `fill_bytes` actually did something, check that the // average of `v` is not 0. diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs index daa4a6ad75257937c8b42b0e91fdf453e4dcda5f..9804382dbd91d913ddf5b0ac612517579a1e3689 100644 --- a/src/librustc/driver/config.rs +++ b/src/librustc/driver/config.rs @@ -494,6 +494,7 @@ pub fn get_os(triple: &str) -> Option { } None } +#[allow(non_uppercase_statics)] static os_names : &'static [(&'static str, abi::Os)] = &[ ("mingw32", abi::OsWindows), ("win32", abi::OsWindows), @@ -511,6 +512,7 @@ pub fn get_arch(triple: &str) -> Option { } None } +#[allow(non_uppercase_statics)] static architecture_abis : &'static [(&'static str, abi::Architecture)] = &[ ("i386", abi::X86), ("i486", abi::X86), diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 213e8b44813a05caff2dc3aacb2b9434cd1642e3..7a59aeb57895ddb8c28d820df38ffddb001bed2d 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -961,7 +961,7 @@ fn check_struct_def(&mut self, cx: &Context, s: &ast::StructDef, } } -declare_lint!(pub NON_UPPERCASE_STATICS, Allow, +declare_lint!(pub NON_UPPERCASE_STATICS, Warn, "static constants should have uppercase identifiers") pub struct NonUppercaseStatics; diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 9a3edbbb70bb05a49f39a808a6b635db8d51a56c..8047c12efc2917adc9b4549fb0f5a0dfcf7fafb4 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -98,6 +98,7 @@ pub fn name_lower(&self) -> String { #[macro_export] macro_rules! lint_array ( ($( $lint:expr ),*) => ( { + #[allow(non_uppercase_statics)] static array: LintArray = &[ $( $lint ),* ]; array } diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs index 2a8aa791c61a66a52d01e9faac7cd53ef268d4dd..ef88795762e43617966665217885920a7612caf9 100644 --- a/src/librustc/metadata/common.rs +++ b/src/librustc/metadata/common.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_camel_case_types)] +#![allow(non_camel_case_types, non_uppercase_statics)] use std::mem; use back::svh::Svh; diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index de0c36f2af33a41594b4b82fc1a8354827dd0dfb..642f66e259a6272025e28f45173a79ffa2450b3d 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -2028,6 +2028,7 @@ fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) { } // NB: Increment this as you change the metadata encoding version. +#[allow(non_uppercase_statics)] pub static metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 1 ]; pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec { diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index 5cc58eb264e076d196167aad6f43130da525d0fe..eda145419616ba72416e43bac6d0ae0ccaabe754 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -83,6 +83,7 @@ fn clone(&self) -> MovePathIndex { } } +#[allow(non_uppercase_statics)] static InvalidMovePathIndex: MovePathIndex = MovePathIndex(uint::MAX); @@ -96,6 +97,7 @@ fn get(&self) -> uint { } } +#[allow(non_uppercase_statics)] static InvalidMoveIndex: MoveIndex = MoveIndex(uint::MAX); diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 2c79c655a9992b806dcfc458f6f6fd5d87213dd8..9135ca07935a5d8903a79b160a9ae1223a216da8 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -57,16 +57,20 @@ pub struct Edge { #[deriving(Clone, PartialEq, Show)] pub struct NodeIndex(pub uint); +#[allow(non_uppercase_statics)] pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX); #[deriving(PartialEq)] pub struct EdgeIndex(pub uint); +#[allow(non_uppercase_statics)] pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX); // Use a private field here to guarantee no more instances are created: #[deriving(Show)] pub struct Direction { repr: uint } +#[allow(non_uppercase_statics)] pub static Outgoing: Direction = Direction { repr: 0 }; +#[allow(non_uppercase_statics)] pub static Incoming: Direction = Direction { repr: 1 }; impl NodeIndex { diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 506b12de084678f77e1bf5af7a7613b06d910d3d..f88b010c28a357d2b0d70a6189b03fd112ddb144 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -389,10 +389,12 @@ fn mk_cenum(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> Repr { fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntType { debug!("range_to_inttype: {:?} {:?}", hint, bounds); // Lists of sizes to try. u64 is always allowed as a fallback. + #[allow(non_uppercase_statics)] static choose_shortest: &'static[IntType] = &[ attr::UnsignedInt(ast::TyU8), attr::SignedInt(ast::TyI8), attr::UnsignedInt(ast::TyU16), attr::SignedInt(ast::TyI16), attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; + #[allow(non_uppercase_statics)] static at_least_32: &'static[IntType] = &[ attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs index e95f640b4486949a9259d07038c8fa19e51ff680..0cd8510b750acbaf7b88cce73a841d7fa6ac433d 100644 --- a/src/librustc/middle/trans/builder.rs +++ b/src/librustc/middle/trans/builder.rs @@ -31,8 +31,8 @@ pub struct Builder<'a, 'tcx: 'a> { // This is a really awful way to get a zero-length c-string, but better (and a // lot more efficient) than doing str::as_c_str("", ...) every time. pub fn noname() -> *const c_char { - static cnull: c_char = 0; - &cnull as *const c_char + static CNULL: c_char = 0; + &CNULL as *const c_char } impl<'a, 'tcx> Builder<'a, 'tcx> { diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 8920994fd9585df1c3c0866917bd42f64ea49ead..55e34ad48cd0c68d4c90557a8d6cb7a6bdb045ac 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -218,13 +218,20 @@ struct List { static DW_LANG_RUST: c_uint = 0x9000; +#[allow(non_uppercase_statics)] static DW_TAG_auto_variable: c_uint = 0x100; +#[allow(non_uppercase_statics)] static DW_TAG_arg_variable: c_uint = 0x101; +#[allow(non_uppercase_statics)] static DW_ATE_boolean: c_uint = 0x02; +#[allow(non_uppercase_statics)] static DW_ATE_float: c_uint = 0x04; +#[allow(non_uppercase_statics)] static DW_ATE_signed: c_uint = 0x05; +#[allow(non_uppercase_statics)] static DW_ATE_unsigned: c_uint = 0x07; +#[allow(non_uppercase_statics)] static DW_ATE_unsigned_char: c_uint = 0x08; static UNKNOWN_LINE_NUMBER: c_uint = 0; diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index edbdf427c0bc6166d8135f1717c142cb61671dd7..df92251c87e303cfe02e490e0a93874730d24e07 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2197,7 +2197,10 @@ pub struct TypeContents { #[allow(non_snake_case)] mod $mname { use middle::ty::TypeContents; - $(pub static $name: TypeContents = TypeContents { bits: $bits };)+ + $( + #[allow(non_uppercase_statics)] + pub static $name: TypeContents = TypeContents { bits: $bits }; + )+ } } ) @@ -4650,6 +4653,7 @@ pub fn unboxed_closure_upvars(tcx: &ctxt, closure_id: ast::DefId) } pub fn is_binopable(cx: &ctxt, ty: t, op: ast::BinOp) -> bool { + #![allow(non_uppercase_statics)] static tycat_other: int = 0; static tycat_bool: int = 1; static tycat_char: int = 2; diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index 2c0b2dbe2ba79d880f51e5479316d27e98410cfc..13659d4b77e1c5e1a59e601c1eec6c55aa7b374a 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -46,6 +46,8 @@ // future). If you want to resolve everything but one type, you are // probably better off writing `resolve_all - resolve_ivar`. +#![allow(non_uppercase_statics)] + use middle::ty::{FloatVar, FloatVid, IntVar, IntVid, RegionVid, TyVar, TyVid}; use middle::ty::{IntType, UintType}; use middle::ty; diff --git a/src/librustc_back/abi.rs b/src/librustc_back/abi.rs index 72acba542460cc94280db8c246f5ddcf3ac75c69..1e69ce003c557a9125d06d5a02c79e6accd3fe65 100644 --- a/src/librustc_back/abi.rs +++ b/src/librustc_back/abi.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(non_uppercase_statics)] + pub static box_field_refcnt: uint = 0u; pub static box_field_drop_glue: uint = 1u; pub static box_field_body: uint = 4u; diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs index 04a4e96ecc40ee07d7c45763220474596499ea8a..934fb0ddd3ce43dd7a4531a0bb9fca1e437ec47e 100644 --- a/src/librustrt/c_str.rs +++ b/src/librustrt/c_str.rs @@ -733,9 +733,9 @@ fn check(s: &str, c_str: *const libc::c_char) { } } - static s_short: &'static str = "Mary"; - static s_medium: &'static str = "Mary had a little lamb"; - static s_long: &'static str = "\ + static S_SHORT: &'static str = "Mary"; + static S_MEDIUM: &'static str = "Mary had a little lamb"; + static S_LONG: &'static str = "\ Mary had a little lamb, Little lamb Mary had a little lamb, Little lamb Mary had a little lamb, Little lamb @@ -752,17 +752,17 @@ fn bench_to_string(b: &mut Bencher, s: &str) { #[bench] fn bench_to_c_str_short(b: &mut Bencher) { - bench_to_string(b, s_short) + bench_to_string(b, S_SHORT) } #[bench] fn bench_to_c_str_medium(b: &mut Bencher) { - bench_to_string(b, s_medium) + bench_to_string(b, S_MEDIUM) } #[bench] fn bench_to_c_str_long(b: &mut Bencher) { - bench_to_string(b, s_long) + bench_to_string(b, S_LONG) } fn bench_to_c_str_unchecked(b: &mut Bencher, s: &str) { @@ -774,17 +774,17 @@ fn bench_to_c_str_unchecked(b: &mut Bencher, s: &str) { #[bench] fn bench_to_c_str_unchecked_short(b: &mut Bencher) { - bench_to_c_str_unchecked(b, s_short) + bench_to_c_str_unchecked(b, S_SHORT) } #[bench] fn bench_to_c_str_unchecked_medium(b: &mut Bencher) { - bench_to_c_str_unchecked(b, s_medium) + bench_to_c_str_unchecked(b, S_MEDIUM) } #[bench] fn bench_to_c_str_unchecked_long(b: &mut Bencher) { - bench_to_c_str_unchecked(b, s_long) + bench_to_c_str_unchecked(b, S_LONG) } fn bench_with_c_str(b: &mut Bencher, s: &str) { @@ -795,17 +795,17 @@ fn bench_with_c_str(b: &mut Bencher, s: &str) { #[bench] fn bench_with_c_str_short(b: &mut Bencher) { - bench_with_c_str(b, s_short) + bench_with_c_str(b, S_SHORT) } #[bench] fn bench_with_c_str_medium(b: &mut Bencher) { - bench_with_c_str(b, s_medium) + bench_with_c_str(b, S_MEDIUM) } #[bench] fn bench_with_c_str_long(b: &mut Bencher) { - bench_with_c_str(b, s_long) + bench_with_c_str(b, S_LONG) } fn bench_with_c_str_unchecked(b: &mut Bencher, s: &str) { @@ -818,16 +818,16 @@ fn bench_with_c_str_unchecked(b: &mut Bencher, s: &str) { #[bench] fn bench_with_c_str_unchecked_short(b: &mut Bencher) { - bench_with_c_str_unchecked(b, s_short) + bench_with_c_str_unchecked(b, S_SHORT) } #[bench] fn bench_with_c_str_unchecked_medium(b: &mut Bencher) { - bench_with_c_str_unchecked(b, s_medium) + bench_with_c_str_unchecked(b, S_MEDIUM) } #[bench] fn bench_with_c_str_unchecked_long(b: &mut Bencher) { - bench_with_c_str_unchecked(b, s_long) + bench_with_c_str_unchecked(b, S_LONG) } } diff --git a/src/librustrt/libunwind.rs b/src/librustrt/libunwind.rs index 2e7408d91591cc05b6cf3a12b9ac9773cc257bb4..bb7a1227e0e4708c1c70ffb327a1541fd04fb502 100644 --- a/src/librustrt/libunwind.rs +++ b/src/librustrt/libunwind.rs @@ -10,6 +10,7 @@ //! Unwind library interface +#![allow(non_uppercase_statics)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(dead_code)] // these are just bindings diff --git a/src/librustrt/local_data.rs b/src/librustrt/local_data.rs index fcef5981f0a35602c9d4e742130ac59bf1d266db..8d5c49d767f1584f41e735acb65219397b19d9e5 100644 --- a/src/librustrt/local_data.rs +++ b/src/librustrt/local_data.rs @@ -416,37 +416,37 @@ mod tests { #[test] fn test_tls_multitask() { - static my_key: Key = &KeyValueKey; - my_key.replace(Some("parent data".to_string())); + static MY_KEY: Key = &KeyValueKey; + MY_KEY.replace(Some("parent data".to_string())); task::spawn(proc() { // TLD shouldn't carry over. - assert!(my_key.get().is_none()); - my_key.replace(Some("child data".to_string())); - assert!(my_key.get().as_ref().unwrap().as_slice() == "child data"); + assert!(MY_KEY.get().is_none()); + MY_KEY.replace(Some("child data".to_string())); + assert!(MY_KEY.get().as_ref().unwrap().as_slice() == "child data"); // should be cleaned up for us }); // Must work multiple times - assert!(my_key.get().unwrap().as_slice() == "parent data"); - assert!(my_key.get().unwrap().as_slice() == "parent data"); - assert!(my_key.get().unwrap().as_slice() == "parent data"); + assert!(MY_KEY.get().unwrap().as_slice() == "parent data"); + assert!(MY_KEY.get().unwrap().as_slice() == "parent data"); + assert!(MY_KEY.get().unwrap().as_slice() == "parent data"); } #[test] fn test_tls_overwrite() { - static my_key: Key = &KeyValueKey; - my_key.replace(Some("first data".to_string())); - my_key.replace(Some("next data".to_string())); // Shouldn't leak. - assert!(my_key.get().unwrap().as_slice() == "next data"); + static MY_KEY: Key = &KeyValueKey; + MY_KEY.replace(Some("first data".to_string())); + MY_KEY.replace(Some("next data".to_string())); // Shouldn't leak. + assert!(MY_KEY.get().unwrap().as_slice() == "next data"); } #[test] fn test_tls_pop() { - static my_key: Key = &KeyValueKey; - my_key.replace(Some("weasel".to_string())); - assert!(my_key.replace(None).unwrap() == "weasel".to_string()); + static MY_KEY: Key = &KeyValueKey; + MY_KEY.replace(Some("weasel".to_string())); + assert!(MY_KEY.replace(None).unwrap() == "weasel".to_string()); // Pop must remove the data from the map. - assert!(my_key.replace(None).is_none()); + assert!(MY_KEY.replace(None).is_none()); } #[test] @@ -457,58 +457,58 @@ fn test_tls_crust_automorestack_memorial_bug() { // to get recorded as something within a rust stack segment. Then a // subsequent upcall (esp. for logging, think vsnprintf) would run on // a stack smaller than 1 MB. - static my_key: Key = &KeyValueKey; + static MY_KEY: Key = &KeyValueKey; task::spawn(proc() { - my_key.replace(Some("hax".to_string())); + MY_KEY.replace(Some("hax".to_string())); }); } #[test] fn test_tls_multiple_types() { - static str_key: Key = &KeyValueKey; - static box_key: Key> = &KeyValueKey; - static int_key: Key = &KeyValueKey; + static STR_KEY: Key = &KeyValueKey; + static BOX_KEY: Key> = &KeyValueKey; + static INT_KEY: Key = &KeyValueKey; task::spawn(proc() { - str_key.replace(Some("string data".to_string())); - box_key.replace(Some(box 0)); - int_key.replace(Some(42)); + STR_KEY.replace(Some("string data".to_string())); + BOX_KEY.replace(Some(box 0)); + INT_KEY.replace(Some(42)); }); } #[test] fn test_tls_overwrite_multiple_types() { - static str_key: Key = &KeyValueKey; - static box_key: Key> = &KeyValueKey; - static int_key: Key = &KeyValueKey; + static STR_KEY: Key = &KeyValueKey; + static BOX_KEY: Key> = &KeyValueKey; + static INT_KEY: Key = &KeyValueKey; task::spawn(proc() { - str_key.replace(Some("string data".to_string())); - str_key.replace(Some("string data 2".to_string())); - box_key.replace(Some(box 0)); - box_key.replace(Some(box 1)); - int_key.replace(Some(42)); + STR_KEY.replace(Some("string data".to_string())); + STR_KEY.replace(Some("string data 2".to_string())); + BOX_KEY.replace(Some(box 0)); + BOX_KEY.replace(Some(box 1)); + INT_KEY.replace(Some(42)); // This could cause a segfault if overwriting-destruction is done // with the crazy polymorphic transmute rather than the provided // finaliser. - int_key.replace(Some(31337)); + INT_KEY.replace(Some(31337)); }); } #[test] #[should_fail] fn test_tls_cleanup_on_failure() { - static str_key: Key = &KeyValueKey; - static box_key: Key> = &KeyValueKey; - static int_key: Key = &KeyValueKey; - str_key.replace(Some("parent data".to_string())); - box_key.replace(Some(box 0)); + static STR_KEY: Key = &KeyValueKey; + static BOX_KEY: Key> = &KeyValueKey; + static INT_KEY: Key = &KeyValueKey; + STR_KEY.replace(Some("parent data".to_string())); + BOX_KEY.replace(Some(box 0)); task::spawn(proc() { - str_key.replace(Some("string data".to_string())); - box_key.replace(Some(box 2)); - int_key.replace(Some(42)); + STR_KEY.replace(Some("string data".to_string())); + BOX_KEY.replace(Some(box 2)); + INT_KEY.replace(Some(42)); fail!(); }); // Not quite nondeterministic. - int_key.replace(Some(31337)); + INT_KEY.replace(Some(31337)); fail!(); } @@ -523,9 +523,9 @@ fn drop(&mut self) { self.tx.send(()); } } - static key: Key = &KeyValueKey; + static KEY: Key = &KeyValueKey; let _ = task::try(proc() { - key.replace(Some(Dropper{ tx: tx })); + KEY.replace(Some(Dropper{ tx: tx })); }); // At this point the task has been cleaned up and the TLD dropped. // If the channel doesn't have a value now, then the Sender was leaked. @@ -534,56 +534,56 @@ fn drop(&mut self) { #[test] fn test_static_pointer() { - static key: Key<&'static int> = &KeyValueKey; + static KEY: Key<&'static int> = &KeyValueKey; static VALUE: int = 0; - key.replace(Some(&VALUE)); + KEY.replace(Some(&VALUE)); } #[test] fn test_owned() { - static key: Key> = &KeyValueKey; - key.replace(Some(box 1)); + static KEY: Key> = &KeyValueKey; + KEY.replace(Some(box 1)); { - let k1 = key.get().unwrap(); - let k2 = key.get().unwrap(); - let k3 = key.get().unwrap(); + let k1 = KEY.get().unwrap(); + let k2 = KEY.get().unwrap(); + let k3 = KEY.get().unwrap(); assert_eq!(**k1, 1); assert_eq!(**k2, 1); assert_eq!(**k3, 1); } - key.replace(Some(box 2)); - assert_eq!(**key.get().unwrap(), 2); + KEY.replace(Some(box 2)); + assert_eq!(**KEY.get().unwrap(), 2); } #[test] fn test_same_key_type() { - static key1: Key = &KeyValueKey; - static key2: Key = &KeyValueKey; - static key3: Key = &KeyValueKey; - static key4: Key = &KeyValueKey; - static key5: Key = &KeyValueKey; - key1.replace(Some(1)); - key2.replace(Some(2)); - key3.replace(Some(3)); - key4.replace(Some(4)); - key5.replace(Some(5)); - - assert_eq!(*key1.get().unwrap(), 1); - assert_eq!(*key2.get().unwrap(), 2); - assert_eq!(*key3.get().unwrap(), 3); - assert_eq!(*key4.get().unwrap(), 4); - assert_eq!(*key5.get().unwrap(), 5); + static KEY1: Key = &KeyValueKey; + static KEY2: Key = &KeyValueKey; + static KEY3: Key = &KeyValueKey; + static KEY4: Key = &KeyValueKey; + static KEY5: Key = &KeyValueKey; + KEY1.replace(Some(1)); + KEY2.replace(Some(2)); + KEY3.replace(Some(3)); + KEY4.replace(Some(4)); + KEY5.replace(Some(5)); + + assert_eq!(*KEY1.get().unwrap(), 1); + assert_eq!(*KEY2.get().unwrap(), 2); + assert_eq!(*KEY3.get().unwrap(), 3); + assert_eq!(*KEY4.get().unwrap(), 4); + assert_eq!(*KEY5.get().unwrap(), 5); } #[test] #[should_fail] fn test_nested_get_set1() { - static key: Key = &KeyValueKey; - assert_eq!(key.replace(Some(4)), None); + static KEY: Key = &KeyValueKey; + assert_eq!(KEY.replace(Some(4)), None); - let _k = key.get(); - key.replace(Some(4)); + let _k = KEY.get(); + KEY.replace(Some(4)); } // ClearKey is a RAII class that ensures the keys are cleared from the map. @@ -601,95 +601,95 @@ fn drop(&mut self) { #[bench] fn bench_replace_none(b: &mut test::Bencher) { - static key: Key = &KeyValueKey; - let _clear = ClearKey(key); - key.replace(None); + static KEY: Key = &KeyValueKey; + let _clear = ClearKey(KEY); + KEY.replace(None); b.iter(|| { - key.replace(None) + KEY.replace(None) }); } #[bench] fn bench_replace_some(b: &mut test::Bencher) { - static key: Key = &KeyValueKey; - let _clear = ClearKey(key); - key.replace(Some(1u)); + static KEY: Key = &KeyValueKey; + let _clear = ClearKey(KEY); + KEY.replace(Some(1u)); b.iter(|| { - key.replace(Some(2)) + KEY.replace(Some(2)) }); } #[bench] fn bench_replace_none_some(b: &mut test::Bencher) { - static key: Key = &KeyValueKey; - let _clear = ClearKey(key); - key.replace(Some(0u)); + static KEY: Key = &KeyValueKey; + let _clear = ClearKey(KEY); + KEY.replace(Some(0u)); b.iter(|| { - let old = key.replace(None).unwrap(); + let old = KEY.replace(None).unwrap(); let new = old + 1; - key.replace(Some(new)) + KEY.replace(Some(new)) }); } #[bench] fn bench_100_keys_replace_last(b: &mut test::Bencher) { - static keys: [KeyValue, ..100] = [KeyValueKey, ..100]; - let _clear = keys.iter().map(ClearKey).collect::>>(); - for (i, key) in keys.iter().enumerate() { + static KEYS: [KeyValue, ..100] = [KeyValueKey, ..100]; + let _clear = KEYS.iter().map(ClearKey).collect::>>(); + for (i, key) in KEYS.iter().enumerate() { key.replace(Some(i)); } b.iter(|| { - let key: Key = &keys[99]; + let key: Key = &KEYS[99]; key.replace(Some(42)) }); } #[bench] fn bench_1000_keys_replace_last(b: &mut test::Bencher) { - static keys: [KeyValue, ..1000] = [KeyValueKey, ..1000]; - let _clear = keys.iter().map(ClearKey).collect::>>(); - for (i, key) in keys.iter().enumerate() { + static KEYS: [KeyValue, ..1000] = [KeyValueKey, ..1000]; + let _clear = KEYS.iter().map(ClearKey).collect::>>(); + for (i, key) in KEYS.iter().enumerate() { key.replace(Some(i)); } b.iter(|| { - let key: Key = &keys[999]; + let key: Key = &KEYS[999]; key.replace(Some(42)) }); - for key in keys.iter() { key.clear(); } + for key in KEYS.iter() { key.clear(); } } #[bench] fn bench_get(b: &mut test::Bencher) { - static key: Key = &KeyValueKey; - let _clear = ClearKey(key); - key.replace(Some(42)); + static KEY: Key = &KeyValueKey; + let _clear = ClearKey(KEY); + KEY.replace(Some(42)); b.iter(|| { - key.get() + KEY.get() }); } #[bench] fn bench_100_keys_get_last(b: &mut test::Bencher) { - static keys: [KeyValue, ..100] = [KeyValueKey, ..100]; - let _clear = keys.iter().map(ClearKey).collect::>>(); - for (i, key) in keys.iter().enumerate() { + static KEYS: [KeyValue, ..100] = [KeyValueKey, ..100]; + let _clear = KEYS.iter().map(ClearKey).collect::>>(); + for (i, key) in KEYS.iter().enumerate() { key.replace(Some(i)); } b.iter(|| { - let key: Key = &keys[99]; + let key: Key = &KEYS[99]; key.get() }); } #[bench] fn bench_1000_keys_get_last(b: &mut test::Bencher) { - static keys: [KeyValue, ..1000] = [KeyValueKey, ..1000]; - let _clear = keys.iter().map(ClearKey).collect::>>(); - for (i, key) in keys.iter().enumerate() { + static KEYS: [KeyValue, ..1000] = [KeyValueKey, ..1000]; + let _clear = KEYS.iter().map(ClearKey).collect::>>(); + for (i, key) in KEYS.iter().enumerate() { key.replace(Some(i)); } b.iter(|| { - let key: Key = &keys[999]; + let key: Key = &KEYS[999]; key.get() }); } diff --git a/src/librustrt/mutex.rs b/src/librustrt/mutex.rs index 86dc9b85a792dc769db4e89ae32459697222b2c2..28b0256f2e6e378bffc4435b23f7d3f795caeeab 100644 --- a/src/librustrt/mutex.rs +++ b/src/librustrt/mutex.rs @@ -376,8 +376,8 @@ mod os { #[cfg(target_arch = "arm")] static __PTHREAD_COND_SIZE__: uint = 24; - static _PTHREAD_MUTEX_SIG_init: libc::c_long = 0x32AAABA7; - static _PTHREAD_COND_SIG_init: libc::c_long = 0x3CB0B1BB; + static _PTHREAD_MUTEX_SIG_INIT: libc::c_long = 0x32AAABA7; + static _PTHREAD_COND_SIG_INIT: libc::c_long = 0x3CB0B1BB; #[repr(C)] pub struct pthread_mutex_t { @@ -391,11 +391,11 @@ pub struct pthread_cond_t { } pub static PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t { - __sig: _PTHREAD_MUTEX_SIG_init, + __sig: _PTHREAD_MUTEX_SIG_INIT, __opaque: [0, ..__PTHREAD_MUTEX_SIZE__], }; pub static PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t { - __sig: _PTHREAD_COND_SIG_init, + __sig: _PTHREAD_COND_SIG_INIT, __opaque: [0, ..__PTHREAD_COND_SIZE__], }; } diff --git a/src/librustrt/util.rs b/src/librustrt/util.rs index 77e3e25eb0e7e9e60d310f6e6bf943f46cd6460c..9fbf4d09cd60dbf0c689632c4a2483fe5fdedcef 100644 --- a/src/librustrt/util.rs +++ b/src/librustrt/util.rs @@ -28,7 +28,9 @@ pub struct Stdio(libc::c_int); +#[allow(non_uppercase_statics)] pub static Stdout: Stdio = Stdio(libc::STDOUT_FILENO); +#[allow(non_uppercase_statics)] pub static Stderr: Stdio = Stdio(libc::STDERR_FILENO); impl fmt::FormatWriter for Stdio { diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 3007e160bf8ae536078e643e20078dfb273901d0..654278cf81baf4d9ed3296d2bf032969806f1753 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -360,7 +360,9 @@ fn escape_char(writer: &mut io::Writer, v: char) -> Result<(), io::IoError> { } fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> { + #[allow(non_uppercase_statics)] static len: uint = 16; + #[allow(non_uppercase_statics)] static buf: [u8, ..len] = [b' ', ..len]; while n >= len { diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 1d479b852480c009700e819f6acd07f92b106c7e..391d099de87c6a8aa5f2983a6fb55a4a522198e6 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -123,7 +123,10 @@ pub struct $BitFlags { bits: $T, } - $($(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+ + $( + #[allow(non_uppercase_statics)] + $(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value }; + )+ impl $BitFlags { /// Returns an empty set of flags. @@ -240,7 +243,10 @@ fn not(&self) -> $BitFlags { bitflags! { $(#[$attr])* flags $BitFlags: $T { - $($(#[$Flag_attr])* static $Flag = $value),+ + $( + #[allow(non_uppercase_statics)] + $(#[$Flag_attr])* static $Flag = $value + ),+ } } }; diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index d8be92e45146005ebf7c9579b58bb6f15bc6a51b..73a8aa442c1fda6e21fb5b2d82210cfc3ade4601 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -11,6 +11,7 @@ //! Bindings for executing child processes #![allow(experimental)] +#![allow(non_uppercase_statics)] use prelude::*; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index d949a03dfc140ae9282405ad782f8b70f8cc464d..fa356432a673158e7043c48ddf4fe7ddedbecec3 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -304,9 +304,11 @@ fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! { #[macro_export] macro_rules! local_data_key( ($name:ident: $ty:ty) => ( + #[allow(non_uppercase_statics)] static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey; ); (pub $name:ident: $ty:ty) => ( + #[allow(non_uppercase_statics)] pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey; ); ) diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 9c4139853c540b275b44d91f59c7f7a39ad3c51e..805db000686a02856b0daaacec79973625e55cc6 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -457,7 +457,9 @@ fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option> { } } +#[allow(non_uppercase_statics)] static dot_static: &'static [u8] = b"."; +#[allow(non_uppercase_statics)] static dot_dot_static: &'static [u8] = b".."; #[cfg(test)] diff --git a/src/libstd/task.rs b/src/libstd/task.rs index 9cace9c80ef5ad1a5dd60f1a7dcd923c32bb38c0..977b3018fa74c24b182f3d630c94faacce26d4f7 100644 --- a/src/libstd/task.rs +++ b/src/libstd/task.rs @@ -569,10 +569,10 @@ fn test_child_doesnt_ref_parent() { // climbing the task tree to dereference each ancestor. (See #1789) // (well, it would if the constant were 8000+ - I lowered it to be more // valgrind-friendly. try this at home, instead..!) - static generations: uint = 16; + static GENERATIONS: uint = 16; fn child_no(x: uint) -> proc(): Send { return proc() { - if x < generations { + if x < GENERATIONS { TaskBuilder::new().spawn(child_no(x+1)); } } diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 6d9b8821bd8903cc58767594388f35a725c044ee..3a02d74edffb752f5e553a6a0cb65f7b6944dae0 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -47,7 +47,9 @@ pub enum Architecture { Mipsel } +#[allow(non_uppercase_statics)] static IntelBits: u32 = (1 << (X86 as uint)) | (1 << (X86_64 as uint)); +#[allow(non_uppercase_statics)] static ArmBits: u32 = (1 << (Arm as uint)); pub struct AbiData { @@ -70,6 +72,7 @@ pub enum AbiArchitecture { Archs(u32) } +#[allow(non_uppercase_statics)] static AbiDatas: &'static [AbiData] = &[ // Platform-specific ABIs AbiData {abi: Cdecl, name: "cdecl", abi_arch: Archs(IntelBits)}, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 3186006258041dd58fbe77372eb0999a62b8e400..f746e1f14822a90fbdbf4fa5e6cd1314d98dcf87 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -293,6 +293,7 @@ pub fn operator_prec(op: ast::BinOp) -> uint { /// Precedence of the `as` operator, which is a binary operator /// not appearing in the prior table. +#[allow(non_uppercase_statics)] pub static as_prec: uint = 12u; pub fn empty_generics() -> Generics { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index a486ac40a97a137beaff65a60bdcf1b9f0f0474a..a8c827439cc605a6dfc31f3e605e4b47d882f34b 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -383,12 +383,15 @@ pub mod keywords { pub mod special_idents { use ast::{Ident, Name}; - $( pub static $si_static: Ident = Ident { name: Name($si_name), ctxt: 0 }; )* + $( + #[allow(non_uppercase_statics)] + pub static $si_static: Ident = Ident { name: Name($si_name), ctxt: 0 }; + )* } pub mod special_names { use ast::Name; - $( pub static $si_static: Name = Name($si_name); )* + $( #[allow(non_uppercase_statics)] pub static $si_static: Name = Name($si_name); )* } /** diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 8400d9aea3b5958654537f6760c038f70e1f6e73..c3a3848019a5dacd862144f3575e9c93df3b6095 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -89,8 +89,10 @@ pub fn rust_printer_annotated<'a>(writer: Box, } } +#[allow(non_uppercase_statics)] pub static indent_unit: uint = 4u; +#[allow(non_uppercase_statics)] pub static default_columns: uint = 78u; /// Requires you to pass an input filename and reader so that diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs index f728205c3a57f58068aa8a9f6b130b0d2ab0e5dd..c0c3f707ecb3c80dad0e59185a49fe55db2eeb07 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -173,6 +173,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { } // Length of each hyphenated group in hex digits +#[allow(non_uppercase_statics)] static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u]; /// UUID support diff --git a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs index 095acf56e4865a39d9565e44ff44d7aee4d3c4c1..1d14da73b7eebd80fc2339a1f10144a4c487d714 100644 --- a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs +++ b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs @@ -17,6 +17,7 @@ #[deny(unused_variable)] #[deny(dead_code)] +#[allow(non_uppercase_statics)] // Tests to make sure that extraneous dead code warnings aren't emitted from // the code generated by regex!. diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs index 8006789d440c3437a2435ecc7ac6748753cf0799..74bfc6e6ffc1fb7777419194875c3d5e14c552d8 100644 --- a/src/test/compile-fail/asm-misplaced-option.rs +++ b/src/test/compile-fail/asm-misplaced-option.rs @@ -12,7 +12,7 @@ #![feature(asm)] -#![allow(dead_code)] +#![allow(dead_code, non_uppercase_statics)] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] diff --git a/src/test/compile-fail/issue-6804.rs b/src/test/compile-fail/issue-6804.rs index 600b28048b4fba1d24ab53a6a67d66bc289cf60a..30d3ab17a463e6622480b0e22fbf7478b7b225a1 100644 --- a/src/test/compile-fail/issue-6804.rs +++ b/src/test/compile-fail/issue-6804.rs @@ -30,4 +30,4 @@ fn main() { // At least one error is needed so that compilation fails #[static_assert] -static b: bool = false; //~ ERROR static assertion failed +static B: bool = false; //~ ERROR static assertion failed diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs index b7feea775cb43d45080a9171763f36b180f065eb..45380235a2a8b34aa546620e53eae95a9c92d7e7 100644 --- a/src/test/compile-fail/lint-dead-code-1.rs +++ b/src/test/compile-fail/lint-dead-code-1.rs @@ -11,6 +11,7 @@ #![no_std] #![allow(unused_variable)] #![allow(non_camel_case_types)] +#![allow(non_uppercase_statics)] #![deny(dead_code)] #![feature(lang_items)] diff --git a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs index e920bfd412d4c93cea60533e4e5ad6cc3d491080..bbd88f1f0aade81ebc1e283572bf2598235156c0 100644 --- a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs +++ b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs @@ -9,6 +9,7 @@ // except according to those terms. #![deny(unused_imports)] +#![allow(non_uppercase_statics)] // The aim of this test is to ensure that deny/allow/warn directives // are applied to individual "use" statements instead of silently