bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Set the non_uppercase_statics lint to warn by default

Browse source
This commit is contained in:
P1start 2014-09-13 13:55:37 +12:00
parent aa034cd3ba
commit 94bcd3539c
37 changed files with 233 additions and 171 deletions
Download patch file Download diff file Expand all files Collapse all files

63
src/libnum/bigint.rs
View file

@ -86,9 +86,12 @@ pub mod BigDigit {
use super::DoubleBigDigit; use super::DoubleBigDigit;
// `DoubleBigDigit` size dependent // `DoubleBigDigit` size dependent
#[allow(non_uppercase_statics)]
pub static bits: uint = 32; pub static bits: uint = 32;
#[allow(non_uppercase_statics)]
pub static base: DoubleBigDigit = 1 << bits; pub static base: DoubleBigDigit = 1 << bits;
#[allow(non_uppercase_statics)]
static lo_mask: DoubleBigDigit = (-1 as DoubleBigDigit) >> bits; static lo_mask: DoubleBigDigit = (-1 as DoubleBigDigit) >> bits;
#[inline] #[inline]
@ -1841,7 +1844,7 @@ mod biguint_tests {
BigInt::from_biguint(Plus, BigUint::new(vec!(1,2,3)))); 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],
&'static [BigDigit])] = &[ &'static [BigDigit])] = &[
(&[], &[], &[]), (&[], &[], &[]),
@ -1857,7 +1860,7 @@ mod biguint_tests {
#[test] #[test]
fn test_add() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1870,7 +1873,7 @@ mod biguint_tests {
#[test] #[test]
fn test_sub() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1888,7 +1891,7 @@ mod biguint_tests {
a - b; a - b;
} }
static mul_triples: &'static [(&'static [BigDigit], static MUL_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit], &'static [BigDigit],
&'static [BigDigit])] = &[ &'static [BigDigit])] = &[
(&[], &[], &[]), (&[], &[], &[]),
@ -1914,7 +1917,7 @@ mod biguint_tests {
(&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1]) (&[ 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], &'static [BigDigit],
&'static [BigDigit])] &'static [BigDigit])]
@ -1928,7 +1931,7 @@ mod biguint_tests {
#[test] #[test]
fn test_mul() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1938,7 +1941,7 @@ mod biguint_tests {
assert!(b * a == c); 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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1952,7 +1955,7 @@ mod biguint_tests {
#[test] #[test]
fn test_div_rem() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1966,7 +1969,7 @@ mod biguint_tests {
} }
} }
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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1979,7 +1982,7 @@ mod biguint_tests {
#[test] #[test]
fn test_checked_add() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -1992,7 +1995,7 @@ mod biguint_tests {
#[test] #[test]
fn test_checked_sub() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -2012,7 +2015,7 @@ mod biguint_tests {
#[test] #[test]
fn test_checked_mul() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -2022,7 +2025,7 @@ mod biguint_tests {
assert!(b.checked_mul(&a).unwrap() == c); 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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -2036,7 +2039,7 @@ mod biguint_tests {
#[test] #[test]
fn test_checked_div() { 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_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec); let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec); let b = BigUint::from_slice(b_vec);
@ -2440,7 +2443,7 @@ mod bigint_tests {
assert_eq!(negative.to_biguint(), None); assert_eq!(negative.to_biguint(), None);
} }
static sum_triples: &'static [(&'static [BigDigit], static SUM_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit], &'static [BigDigit],
&'static [BigDigit])] = &[ &'static [BigDigit])] = &[
(&[], &[], &[]), (&[], &[], &[]),
@ -2456,7 +2459,7 @@ mod bigint_tests {
#[test] #[test]
fn test_add() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2475,7 +2478,7 @@ mod bigint_tests {
#[test] #[test]
fn test_sub() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2492,7 +2495,7 @@ mod bigint_tests {
} }
} }
static mul_triples: &'static [(&'static [BigDigit], static MUL_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit], &'static [BigDigit],
&'static [BigDigit])] = &[ &'static [BigDigit])] = &[
(&[], &[], &[]), (&[], &[], &[]),
@ -2518,7 +2521,7 @@ mod bigint_tests {
(&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1]) (&[ 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], &'static [BigDigit],
&'static [BigDigit])] &'static [BigDigit])]
@ -2532,7 +2535,7 @@ mod bigint_tests {
#[test] #[test]
fn test_mul() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2545,7 +2548,7 @@ mod bigint_tests {
assert!((-b) * a == -c); 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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2584,7 +2587,7 @@ mod bigint_tests {
} }
} }
for elm in mul_triples.iter() { for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm; let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2594,7 +2597,7 @@ mod bigint_tests {
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); } 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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2627,7 +2630,7 @@ mod bigint_tests {
check_sub(&a.neg(), b, &q.neg(), &r.neg()); check_sub(&a.neg(), b, &q.neg(), &r.neg());
check_sub(&a.neg(), &b.neg(), q, &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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2637,7 +2640,7 @@ mod bigint_tests {
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); } 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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2652,7 +2655,7 @@ mod bigint_tests {
#[test] #[test]
fn test_checked_add() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2671,7 +2674,7 @@ mod bigint_tests {
#[test] #[test]
fn test_checked_sub() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2690,7 +2693,7 @@ mod bigint_tests {
#[test] #[test]
fn test_checked_mul() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2703,7 +2706,7 @@ mod bigint_tests {
assert!((-b).checked_mul(&a).unwrap() == -c); 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_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);
@ -2716,7 +2719,7 @@ mod bigint_tests {
} }
#[test] #[test]
fn test_checked_div() { 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_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec); let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec); let b = BigInt::from_slice(Plus, b_vec);

3
src/libnum/rational.rs
View file

@ -406,10 +406,13 @@ mod test {
pub static _2: Rational = Ratio { numer: 2, denom: 1}; pub static _2: Rational = Ratio { numer: 2, denom: 1};
pub static _1_2: Rational = Ratio { numer: 1, denom: 2}; pub static _1_2: Rational = Ratio { numer: 1, denom: 2};
pub static _3_2: Rational = Ratio { numer: 3, 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 _neg1_2: Rational = Ratio { numer: -1, denom: 2};
pub static _1_3: Rational = Ratio { numer: 1, denom: 3}; 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 _neg1_3: Rational = Ratio { numer: -1, denom: 3};
pub static _2_3: Rational = Ratio { numer: 2, 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 static _neg2_3: Rational = Ratio { numer: -2, denom: 3};
pub fn to_big(n: Rational) -> BigRational { pub fn to_big(n: Rational) -> BigRational {

6
src/librand/reseeding.rs
View file

@ -209,15 +209,15 @@ mod test {
assert_eq!(string1, string2); assert_eq!(string1, string2);
} }
static fill_bytes_v_len: uint = 13579; static FILL_BYTES_V_LEN: uint = 13579;
#[test] #[test]
fn test_rng_fill_bytes() { 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()); ::test::rng().fill_bytes(v.as_mut_slice());
// Sanity test: if we've gotten here, `fill_bytes` has not infinitely // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
// recursed. // 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 // To test that `fill_bytes` actually did something, check that the
// average of `v` is not 0. // average of `v` is not 0.

2
src/librustc/driver/config.rs
View file

@ -494,6 +494,7 @@ pub fn get_os(triple: &str) -> Option<abi::Os> {
} }
None None
} }
#[allow(non_uppercase_statics)]
static os_names : &'static [(&'static str, abi::Os)] = &[ static os_names : &'static [(&'static str, abi::Os)] = &[
("mingw32", abi::OsWindows), ("mingw32", abi::OsWindows),
("win32", abi::OsWindows), ("win32", abi::OsWindows),
@ -511,6 +512,7 @@ pub fn get_arch(triple: &str) -> Option<abi::Architecture> {
} }
None None
} }
#[allow(non_uppercase_statics)]
static architecture_abis : &'static [(&'static str, abi::Architecture)] = &[ static architecture_abis : &'static [(&'static str, abi::Architecture)] = &[
("i386", abi::X86), ("i386", abi::X86),
("i486", abi::X86), ("i486", abi::X86),

2
src/librustc/lint/builtin.rs
View file

@ -961,7 +961,7 @@ impl LintPass for NonSnakeCase {
} }
} }
declare_lint!(pub NON_UPPERCASE_STATICS, Allow, declare_lint!(pub NON_UPPERCASE_STATICS, Warn,
"static constants should have uppercase identifiers") "static constants should have uppercase identifiers")
pub struct NonUppercaseStatics; pub struct NonUppercaseStatics;

1
src/librustc/lint/mod.rs
View file

@ -98,6 +98,7 @@ macro_rules! declare_lint (
#[macro_export] #[macro_export]
macro_rules! lint_array ( ($( $lint:expr ),*) => ( macro_rules! lint_array ( ($( $lint:expr ),*) => (
{ {
#[allow(non_uppercase_statics)]
static array: LintArray = &[ $( $lint ),* ]; static array: LintArray = &[ $( $lint ),* ];
array array
} }

2
src/librustc/metadata/common.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
#![allow(non_camel_case_types)] #![allow(non_camel_case_types, non_uppercase_statics)]
use std::mem; use std::mem;
use back::svh::Svh; use back::svh::Svh;

1
src/librustc/metadata/encoder.rs
View file

@ -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. // 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 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<u8> { pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> {

2
src/librustc/middle/borrowck/move_data.rs
View file

@ -83,6 +83,7 @@ impl Clone for MovePathIndex {
} }
} }
#[allow(non_uppercase_statics)]
static InvalidMovePathIndex: MovePathIndex = static InvalidMovePathIndex: MovePathIndex =
MovePathIndex(uint::MAX); MovePathIndex(uint::MAX);
@ -96,6 +97,7 @@ impl MoveIndex {
} }
} }
#[allow(non_uppercase_statics)]
static InvalidMoveIndex: MoveIndex = static InvalidMoveIndex: MoveIndex =
MoveIndex(uint::MAX); MoveIndex(uint::MAX);

4
src/librustc/middle/graph.rs
View file

@ -57,16 +57,20 @@ pub struct Edge<E> {
#[deriving(Clone, PartialEq, Show)] #[deriving(Clone, PartialEq, Show)]
pub struct NodeIndex(pub uint); pub struct NodeIndex(pub uint);
#[allow(non_uppercase_statics)]
pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX); pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX);
#[deriving(PartialEq)] #[deriving(PartialEq)]
pub struct EdgeIndex(pub uint); pub struct EdgeIndex(pub uint);
#[allow(non_uppercase_statics)]
pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX); pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX);
// Use a private field here to guarantee no more instances are created: // Use a private field here to guarantee no more instances are created:
#[deriving(Show)] #[deriving(Show)]
pub struct Direction { repr: uint } pub struct Direction { repr: uint }
#[allow(non_uppercase_statics)]
pub static Outgoing: Direction = Direction { repr: 0 }; pub static Outgoing: Direction = Direction { repr: 0 };
#[allow(non_uppercase_statics)]
pub static Incoming: Direction = Direction { repr: 1 }; pub static Incoming: Direction = Direction { repr: 1 };
impl NodeIndex { impl NodeIndex {

2
src/librustc/middle/trans/adt.rs
View file

@ -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 { fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntType {
debug!("range_to_inttype: {:?} {:?}", hint, bounds); debug!("range_to_inttype: {:?} {:?}", hint, bounds);
// Lists of sizes to try. u64 is always allowed as a fallback. // Lists of sizes to try. u64 is always allowed as a fallback.
#[allow(non_uppercase_statics)]
static choose_shortest: &'static[IntType] = &[ static choose_shortest: &'static[IntType] = &[
attr::UnsignedInt(ast::TyU8), attr::SignedInt(ast::TyI8), attr::UnsignedInt(ast::TyU8), attr::SignedInt(ast::TyI8),
attr::UnsignedInt(ast::TyU16), attr::SignedInt(ast::TyI16), attr::UnsignedInt(ast::TyU16), attr::SignedInt(ast::TyI16),
attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)];
#[allow(non_uppercase_statics)]
static at_least_32: &'static[IntType] = &[ static at_least_32: &'static[IntType] = &[
attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)];

4
src/librustc/middle/trans/builder.rs
View file

@ -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 // 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. // lot more efficient) than doing str::as_c_str("", ...) every time.
pub fn noname() -> *const c_char { pub fn noname() -> *const c_char {
static cnull: c_char = 0; static CNULL: c_char = 0;
&cnull as *const c_char &CNULL as *const c_char
} }
impl<'a, 'tcx> Builder<'a, 'tcx> { impl<'a, 'tcx> Builder<'a, 'tcx> {

7
src/librustc/middle/trans/debuginfo.rs
View file

@ -218,13 +218,20 @@ use syntax::parse::token::special_idents;
static DW_LANG_RUST: c_uint = 0x9000; static DW_LANG_RUST: c_uint = 0x9000;
#[allow(non_uppercase_statics)]
static DW_TAG_auto_variable: c_uint = 0x100; static DW_TAG_auto_variable: c_uint = 0x100;
#[allow(non_uppercase_statics)]
static DW_TAG_arg_variable: c_uint = 0x101; static DW_TAG_arg_variable: c_uint = 0x101;
#[allow(non_uppercase_statics)]
static DW_ATE_boolean: c_uint = 0x02; static DW_ATE_boolean: c_uint = 0x02;
#[allow(non_uppercase_statics)]
static DW_ATE_float: c_uint = 0x04; static DW_ATE_float: c_uint = 0x04;
#[allow(non_uppercase_statics)]
static DW_ATE_signed: c_uint = 0x05; static DW_ATE_signed: c_uint = 0x05;
#[allow(non_uppercase_statics)]
static DW_ATE_unsigned: c_uint = 0x07; static DW_ATE_unsigned: c_uint = 0x07;
#[allow(non_uppercase_statics)]
static DW_ATE_unsigned_char: c_uint = 0x08; static DW_ATE_unsigned_char: c_uint = 0x08;
static UNKNOWN_LINE_NUMBER: c_uint = 0; static UNKNOWN_LINE_NUMBER: c_uint = 0;

6
src/librustc/middle/ty.rs
View file

@ -2197,7 +2197,10 @@ macro_rules! def_type_content_sets(
#[allow(non_snake_case)] #[allow(non_snake_case)]
mod $mname { mod $mname {
use middle::ty::TypeContents; 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 { pub fn is_binopable(cx: &ctxt, ty: t, op: ast::BinOp) -> bool {
#![allow(non_uppercase_statics)]
static tycat_other: int = 0; static tycat_other: int = 0;
static tycat_bool: int = 1; static tycat_bool: int = 1;
static tycat_char: int = 2; static tycat_char: int = 2;

2
src/librustc/middle/typeck/infer/resolve.rs
View file

@ -46,6 +46,8 @@
// future). If you want to resolve everything but one type, you are // future). If you want to resolve everything but one type, you are
// probably better off writing `resolve_all - resolve_ivar`. // 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::{FloatVar, FloatVid, IntVar, IntVid, RegionVid, TyVar, TyVid};
use middle::ty::{IntType, UintType}; use middle::ty::{IntType, UintType};
use middle::ty; use middle::ty;

2
src/librustc_back/abi.rs
View file

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
#![allow(non_uppercase_statics)]
pub static box_field_refcnt: uint = 0u; pub static box_field_refcnt: uint = 0u;
pub static box_field_drop_glue: uint = 1u; pub static box_field_drop_glue: uint = 1u;
pub static box_field_body: uint = 4u; pub static box_field_body: uint = 4u;

30
src/librustrt/c_str.rs
View file

@ -733,9 +733,9 @@ mod bench {
} }
} }
static s_short: &'static str = "Mary"; static S_SHORT: &'static str = "Mary";
static s_medium: &'static str = "Mary had a little lamb"; static S_MEDIUM: &'static str = "Mary had a little lamb";
static s_long: &'static str = "\ 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 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 @@ mod bench {
#[bench] #[bench]
fn bench_to_c_str_short(b: &mut Bencher) { fn bench_to_c_str_short(b: &mut Bencher) {
bench_to_string(b, s_short) bench_to_string(b, S_SHORT)
} }
#[bench] #[bench]
fn bench_to_c_str_medium(b: &mut Bencher) { fn bench_to_c_str_medium(b: &mut Bencher) {
bench_to_string(b, s_medium) bench_to_string(b, S_MEDIUM)
} }
#[bench] #[bench]
fn bench_to_c_str_long(b: &mut Bencher) { 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) { fn bench_to_c_str_unchecked(b: &mut Bencher, s: &str) {
@ -774,17 +774,17 @@ mod bench {
#[bench] #[bench]
fn bench_to_c_str_unchecked_short(b: &mut Bencher) { 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] #[bench]
fn bench_to_c_str_unchecked_medium(b: &mut Bencher) { 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] #[bench]
fn bench_to_c_str_unchecked_long(b: &mut Bencher) { 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) { fn bench_with_c_str(b: &mut Bencher, s: &str) {
@ -795,17 +795,17 @@ mod bench {
#[bench] #[bench]
fn bench_with_c_str_short(b: &mut Bencher) { fn bench_with_c_str_short(b: &mut Bencher) {
bench_with_c_str(b, s_short) bench_with_c_str(b, S_SHORT)
} }
#[bench] #[bench]
fn bench_with_c_str_medium(b: &mut Bencher) { fn bench_with_c_str_medium(b: &mut Bencher) {
bench_with_c_str(b, s_medium) bench_with_c_str(b, S_MEDIUM)
} }
#[bench] #[bench]
fn bench_with_c_str_long(b: &mut Bencher) { 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) { fn bench_with_c_str_unchecked(b: &mut Bencher, s: &str) {
@ -818,16 +818,16 @@ mod bench {
#[bench] #[bench]
fn bench_with_c_str_unchecked_short(b: &mut Bencher) { 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] #[bench]
fn bench_with_c_str_unchecked_medium(b: &mut Bencher) { 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] #[bench]
fn bench_with_c_str_unchecked_long(b: &mut Bencher) { 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)
} }
} }

1
src/librustrt/libunwind.rs
View file

@ -10,6 +10,7 @@
//! Unwind library interface //! Unwind library interface
#![allow(non_uppercase_statics)]
#![allow(non_camel_case_types)] #![allow(non_camel_case_types)]
#![allow(non_snake_case)] #![allow(non_snake_case)]
#![allow(dead_code)] // these are just bindings #![allow(dead_code)] // these are just bindings

212
src/librustrt/local_data.rs
View file

@ -416,37 +416,37 @@ mod tests {
#[test] #[test]
fn test_tls_multitask() { fn test_tls_multitask() {
static my_key: Key<String> = &KeyValueKey; static MY_KEY: Key<String> = &KeyValueKey;
my_key.replace(Some("parent data".to_string())); MY_KEY.replace(Some("parent data".to_string()));
task::spawn(proc() { task::spawn(proc() {
// TLD shouldn't carry over. // TLD shouldn't carry over.
assert!(my_key.get().is_none()); assert!(MY_KEY.get().is_none());
my_key.replace(Some("child data".to_string())); MY_KEY.replace(Some("child data".to_string()));
assert!(my_key.get().as_ref().unwrap().as_slice() == "child data"); assert!(MY_KEY.get().as_ref().unwrap().as_slice() == "child data");
// should be cleaned up for us // should be cleaned up for us
}); });
// Must work multiple times // 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] #[test]
fn test_tls_overwrite() { fn test_tls_overwrite() {
static my_key: Key<String> = &KeyValueKey; static MY_KEY: Key<String> = &KeyValueKey;
my_key.replace(Some("first data".to_string())); MY_KEY.replace(Some("first data".to_string()));
my_key.replace(Some("next data".to_string())); // Shouldn't leak. MY_KEY.replace(Some("next data".to_string())); // Shouldn't leak.
assert!(my_key.get().unwrap().as_slice() == "next data"); assert!(MY_KEY.get().unwrap().as_slice() == "next data");
} }
#[test] #[test]
fn test_tls_pop() { fn test_tls_pop() {
static my_key: Key<String> = &KeyValueKey; static MY_KEY: Key<String> = &KeyValueKey;
my_key.replace(Some("weasel".to_string())); MY_KEY.replace(Some("weasel".to_string()));
assert!(my_key.replace(None).unwrap() == "weasel".to_string()); assert!(MY_KEY.replace(None).unwrap() == "weasel".to_string());
// Pop must remove the data from the map. // Pop must remove the data from the map.
assert!(my_key.replace(None).is_none()); assert!(MY_KEY.replace(None).is_none());
} }
#[test] #[test]
@ -457,58 +457,58 @@ mod tests {
// to get recorded as something within a rust stack segment. Then a // to get recorded as something within a rust stack segment. Then a
// subsequent upcall (esp. for logging, think vsnprintf) would run on // subsequent upcall (esp. for logging, think vsnprintf) would run on
// a stack smaller than 1 MB. // a stack smaller than 1 MB.
static my_key: Key<String> = &KeyValueKey; static MY_KEY: Key<String> = &KeyValueKey;
task::spawn(proc() { task::spawn(proc() {
my_key.replace(Some("hax".to_string())); MY_KEY.replace(Some("hax".to_string()));
}); });
} }
#[test] #[test]
fn test_tls_multiple_types() { fn test_tls_multiple_types() {
static str_key: Key<String> = &KeyValueKey; static STR_KEY: Key<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey; static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey; static INT_KEY: Key<int> = &KeyValueKey;
task::spawn(proc() { task::spawn(proc() {
str_key.replace(Some("string data".to_string())); STR_KEY.replace(Some("string data".to_string()));
box_key.replace(Some(box 0)); BOX_KEY.replace(Some(box 0));
int_key.replace(Some(42)); INT_KEY.replace(Some(42));
}); });
} }
#[test] #[test]
fn test_tls_overwrite_multiple_types() { fn test_tls_overwrite_multiple_types() {
static str_key: Key<String> = &KeyValueKey; static STR_KEY: Key<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey; static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey; static INT_KEY: Key<int> = &KeyValueKey;
task::spawn(proc() { task::spawn(proc() {
str_key.replace(Some("string data".to_string())); STR_KEY.replace(Some("string data".to_string()));
str_key.replace(Some("string data 2".to_string())); STR_KEY.replace(Some("string data 2".to_string()));
box_key.replace(Some(box 0)); BOX_KEY.replace(Some(box 0));
box_key.replace(Some(box 1)); BOX_KEY.replace(Some(box 1));
int_key.replace(Some(42)); INT_KEY.replace(Some(42));
// This could cause a segfault if overwriting-destruction is done // This could cause a segfault if overwriting-destruction is done
// with the crazy polymorphic transmute rather than the provided // with the crazy polymorphic transmute rather than the provided
// finaliser. // finaliser.
int_key.replace(Some(31337)); INT_KEY.replace(Some(31337));
}); });
} }
#[test] #[test]
#[should_fail] #[should_fail]
fn test_tls_cleanup_on_failure() { fn test_tls_cleanup_on_failure() {
static str_key: Key<String> = &KeyValueKey; static STR_KEY: Key<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey; static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey; static INT_KEY: Key<int> = &KeyValueKey;
str_key.replace(Some("parent data".to_string())); STR_KEY.replace(Some("parent data".to_string()));
box_key.replace(Some(box 0)); BOX_KEY.replace(Some(box 0));
task::spawn(proc() { task::spawn(proc() {
str_key.replace(Some("string data".to_string())); STR_KEY.replace(Some("string data".to_string()));
box_key.replace(Some(box 2)); BOX_KEY.replace(Some(box 2));
int_key.replace(Some(42)); INT_KEY.replace(Some(42));
fail!(); fail!();
}); });
// Not quite nondeterministic. // Not quite nondeterministic.
int_key.replace(Some(31337)); INT_KEY.replace(Some(31337));
fail!(); fail!();
} }
@ -523,9 +523,9 @@ mod tests {
self.tx.send(()); self.tx.send(());
} }
} }
static key: Key<Dropper> = &KeyValueKey; static KEY: Key<Dropper> = &KeyValueKey;
let _ = task::try(proc() { 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. // 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. // If the channel doesn't have a value now, then the Sender was leaked.
@ -534,56 +534,56 @@ mod tests {
#[test] #[test]
fn test_static_pointer() { fn test_static_pointer() {
static key: Key<&'static int> = &KeyValueKey; static KEY: Key<&'static int> = &KeyValueKey;
static VALUE: int = 0; static VALUE: int = 0;
key.replace(Some(&VALUE)); KEY.replace(Some(&VALUE));
} }
#[test] #[test]
fn test_owned() { fn test_owned() {
static key: Key<Box<int>> = &KeyValueKey; static KEY: Key<Box<int>> = &KeyValueKey;
key.replace(Some(box 1)); KEY.replace(Some(box 1));
{ {
let k1 = key.get().unwrap(); let k1 = KEY.get().unwrap();
let k2 = key.get().unwrap(); let k2 = KEY.get().unwrap();
let k3 = key.get().unwrap(); let k3 = KEY.get().unwrap();
assert_eq!(**k1, 1); assert_eq!(**k1, 1);
assert_eq!(**k2, 1); assert_eq!(**k2, 1);
assert_eq!(**k3, 1); assert_eq!(**k3, 1);
} }
key.replace(Some(box 2)); KEY.replace(Some(box 2));
assert_eq!(**key.get().unwrap(), 2); assert_eq!(**KEY.get().unwrap(), 2);
} }
#[test] #[test]
fn test_same_key_type() { fn test_same_key_type() {
static key1: Key<int> = &KeyValueKey; static KEY1: Key<int> = &KeyValueKey;
static key2: Key<int> = &KeyValueKey; static KEY2: Key<int> = &KeyValueKey;
static key3: Key<int> = &KeyValueKey; static KEY3: Key<int> = &KeyValueKey;
static key4: Key<int> = &KeyValueKey; static KEY4: Key<int> = &KeyValueKey;
static key5: Key<int> = &KeyValueKey; static KEY5: Key<int> = &KeyValueKey;
key1.replace(Some(1)); KEY1.replace(Some(1));
key2.replace(Some(2)); KEY2.replace(Some(2));
key3.replace(Some(3)); KEY3.replace(Some(3));
key4.replace(Some(4)); KEY4.replace(Some(4));
key5.replace(Some(5)); KEY5.replace(Some(5));
assert_eq!(*key1.get().unwrap(), 1); assert_eq!(*KEY1.get().unwrap(), 1);
assert_eq!(*key2.get().unwrap(), 2); assert_eq!(*KEY2.get().unwrap(), 2);
assert_eq!(*key3.get().unwrap(), 3); assert_eq!(*KEY3.get().unwrap(), 3);
assert_eq!(*key4.get().unwrap(), 4); assert_eq!(*KEY4.get().unwrap(), 4);
assert_eq!(*key5.get().unwrap(), 5); assert_eq!(*KEY5.get().unwrap(), 5);
} }
#[test] #[test]
#[should_fail] #[should_fail]
fn test_nested_get_set1() { fn test_nested_get_set1() {
static key: Key<int> = &KeyValueKey; static KEY: Key<int> = &KeyValueKey;
assert_eq!(key.replace(Some(4)), None); assert_eq!(KEY.replace(Some(4)), None);
let _k = key.get(); let _k = KEY.get();
key.replace(Some(4)); KEY.replace(Some(4));
} }
// ClearKey is a RAII class that ensures the keys are cleared from the map. // ClearKey is a RAII class that ensures the keys are cleared from the map.
@ -601,95 +601,95 @@ mod tests {
#[bench] #[bench]
fn bench_replace_none(b: &mut test::Bencher) { fn bench_replace_none(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey; static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(KEY);
key.replace(None); KEY.replace(None);
b.iter(|| { b.iter(|| {
key.replace(None) KEY.replace(None)
}); });
} }
#[bench] #[bench]
fn bench_replace_some(b: &mut test::Bencher) { fn bench_replace_some(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey; static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(KEY);
key.replace(Some(1u)); KEY.replace(Some(1u));
b.iter(|| { b.iter(|| {
key.replace(Some(2)) KEY.replace(Some(2))
}); });
} }
#[bench] #[bench]
fn bench_replace_none_some(b: &mut test::Bencher) { fn bench_replace_none_some(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey; static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(KEY);
key.replace(Some(0u)); KEY.replace(Some(0u));
b.iter(|| { b.iter(|| {
let old = key.replace(None).unwrap(); let old = KEY.replace(None).unwrap();
let new = old + 1; let new = old + 1;
key.replace(Some(new)) KEY.replace(Some(new))
}); });
} }
#[bench] #[bench]
fn bench_100_keys_replace_last(b: &mut test::Bencher) { fn bench_100_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..100] = [KeyValueKey, ..100]; static KEYS: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
} }
b.iter(|| { b.iter(|| {
let key: Key<uint> = &keys[99]; let key: Key<uint> = &KEYS[99];
key.replace(Some(42)) key.replace(Some(42))
}); });
} }
#[bench] #[bench]
fn bench_1000_keys_replace_last(b: &mut test::Bencher) { fn bench_1000_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000]; static KEYS: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
} }
b.iter(|| { b.iter(|| {
let key: Key<uint> = &keys[999]; let key: Key<uint> = &KEYS[999];
key.replace(Some(42)) key.replace(Some(42))
}); });
for key in keys.iter() { key.clear(); } for key in KEYS.iter() { key.clear(); }
} }
#[bench] #[bench]
fn bench_get(b: &mut test::Bencher) { fn bench_get(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey; static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(KEY);
key.replace(Some(42)); KEY.replace(Some(42));
b.iter(|| { b.iter(|| {
key.get() KEY.get()
}); });
} }
#[bench] #[bench]
fn bench_100_keys_get_last(b: &mut test::Bencher) { fn bench_100_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..100] = [KeyValueKey, ..100]; static KEYS: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
} }
b.iter(|| { b.iter(|| {
let key: Key<uint> = &keys[99]; let key: Key<uint> = &KEYS[99];
key.get() key.get()
}); });
} }
#[bench] #[bench]
fn bench_1000_keys_get_last(b: &mut test::Bencher) { fn bench_1000_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000]; static KEYS: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
} }
b.iter(|| { b.iter(|| {
let key: Key<uint> = &keys[999]; let key: Key<uint> = &KEYS[999];
key.get() key.get()
}); });
} }

8
src/librustrt/mutex.rs
View file

@ -376,8 +376,8 @@ mod imp {
#[cfg(target_arch = "arm")] #[cfg(target_arch = "arm")]
static __PTHREAD_COND_SIZE__: uint = 24; static __PTHREAD_COND_SIZE__: uint = 24;
static _PTHREAD_MUTEX_SIG_init: libc::c_long = 0x32AAABA7; static _PTHREAD_MUTEX_SIG_INIT: libc::c_long = 0x32AAABA7;
static _PTHREAD_COND_SIG_init: libc::c_long = 0x3CB0B1BB; static _PTHREAD_COND_SIG_INIT: libc::c_long = 0x3CB0B1BB;
#[repr(C)] #[repr(C)]
pub struct pthread_mutex_t { pub struct pthread_mutex_t {
@ -391,11 +391,11 @@ mod imp {
} }
pub static PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_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__], __opaque: [0, ..__PTHREAD_MUTEX_SIZE__],
}; };
pub static PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t { 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__], __opaque: [0, ..__PTHREAD_COND_SIZE__],
}; };
} }

2
src/librustrt/util.rs
View file

@ -28,7 +28,9 @@ pub static ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) ||
pub struct Stdio(libc::c_int); pub struct Stdio(libc::c_int);
#[allow(non_uppercase_statics)]
pub static Stdout: Stdio = Stdio(libc::STDOUT_FILENO); pub static Stdout: Stdio = Stdio(libc::STDOUT_FILENO);
#[allow(non_uppercase_statics)]
pub static Stderr: Stdio = Stdio(libc::STDERR_FILENO); pub static Stderr: Stdio = Stdio(libc::STDERR_FILENO);
impl fmt::FormatWriter for Stdio { impl fmt::FormatWriter for Stdio {

2
src/libserialize/json.rs
View file

@ -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> { fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
#[allow(non_uppercase_statics)]
static len: uint = 16; static len: uint = 16;
#[allow(non_uppercase_statics)]
static buf: [u8, ..len] = [b' ', ..len]; static buf: [u8, ..len] = [b' ', ..len];
while n >= len { while n >= len {

10
src/libstd/bitflags.rs
View file

@ -123,7 +123,10 @@ macro_rules! bitflags {
bits: $T, 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 { impl $BitFlags {
/// Returns an empty set of flags. /// Returns an empty set of flags.
@ -240,7 +243,10 @@ macro_rules! bitflags {
bitflags! { bitflags! {
$(#[$attr])* $(#[$attr])*
flags $BitFlags: $T { flags $BitFlags: $T {
$($(#[$Flag_attr])* static $Flag = $value),+ $(
#[allow(non_uppercase_statics)]
$(#[$Flag_attr])* static $Flag = $value
),+
} }
} }
}; };

1
src/libstd/io/process.rs
View file

@ -11,6 +11,7 @@
//! Bindings for executing child processes //! Bindings for executing child processes
#![allow(experimental)] #![allow(experimental)]
#![allow(non_uppercase_statics)]
use prelude::*; use prelude::*;

2
src/libstd/macros.rs
View file

@ -304,9 +304,11 @@ macro_rules! println(
#[macro_export] #[macro_export]
macro_rules! local_data_key( macro_rules! local_data_key(
($name:ident: $ty:ty) => ( ($name:ident: $ty:ty) => (
#[allow(non_uppercase_statics)]
static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey; static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey;
); );
(pub $name:ident: $ty:ty) => ( (pub $name:ident: $ty:ty) => (
#[allow(non_uppercase_statics)]
pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey; pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey;
); );
) )

2
src/libstd/path/posix.rs
View file

@ -457,7 +457,9 @@ fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<Vec<&'a [u8]>> {
} }
} }
#[allow(non_uppercase_statics)]
static dot_static: &'static [u8] = b"."; static dot_static: &'static [u8] = b".";
#[allow(non_uppercase_statics)]
static dot_dot_static: &'static [u8] = b".."; static dot_dot_static: &'static [u8] = b"..";
#[cfg(test)] #[cfg(test)]

4
src/libstd/task.rs
View file

@ -569,10 +569,10 @@ mod test {
// climbing the task tree to dereference each ancestor. (See #1789) // climbing the task tree to dereference each ancestor. (See #1789)
// (well, it would if the constant were 8000+ - I lowered it to be more // (well, it would if the constant were 8000+ - I lowered it to be more
// valgrind-friendly. try this at home, instead..!) // valgrind-friendly. try this at home, instead..!)
static generations: uint = 16; static GENERATIONS: uint = 16;
fn child_no(x: uint) -> proc(): Send { fn child_no(x: uint) -> proc(): Send {
return proc() { return proc() {
if x < generations { if x < GENERATIONS {
TaskBuilder::new().spawn(child_no(x+1)); TaskBuilder::new().spawn(child_no(x+1));
} }
} }

3
src/libsyntax/abi.rs
View file

@ -47,7 +47,9 @@ pub enum Architecture {
Mipsel Mipsel
} }
#[allow(non_uppercase_statics)]
static IntelBits: u32 = (1 << (X86 as uint)) | (1 << (X86_64 as uint)); static IntelBits: u32 = (1 << (X86 as uint)) | (1 << (X86_64 as uint));
#[allow(non_uppercase_statics)]
static ArmBits: u32 = (1 << (Arm as uint)); static ArmBits: u32 = (1 << (Arm as uint));
pub struct AbiData { pub struct AbiData {
@ -70,6 +72,7 @@ pub enum AbiArchitecture {
Archs(u32) Archs(u32)
} }
#[allow(non_uppercase_statics)]
static AbiDatas: &'static [AbiData] = &[ static AbiDatas: &'static [AbiData] = &[
// Platform-specific ABIs // Platform-specific ABIs
AbiData {abi: Cdecl, name: "cdecl", abi_arch: Archs(IntelBits)}, AbiData {abi: Cdecl, name: "cdecl", abi_arch: Archs(IntelBits)},

1
src/libsyntax/ast_util.rs
View file

@ -293,6 +293,7 @@ pub fn operator_prec(op: ast::BinOp) -> uint {
/// Precedence of the `as` operator, which is a binary operator /// Precedence of the `as` operator, which is a binary operator
/// not appearing in the prior table. /// not appearing in the prior table.
#[allow(non_uppercase_statics)]
pub static as_prec: uint = 12u; pub static as_prec: uint = 12u;
pub fn empty_generics() -> Generics { pub fn empty_generics() -> Generics {

7
src/libsyntax/parse/token.rs
View file

@ -383,12 +383,15 @@ macro_rules! declare_special_idents_and_keywords {(
pub mod special_idents { pub mod special_idents {
use ast::{Ident, Name}; 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 { pub mod special_names {
use ast::Name; use ast::Name;
$( pub static $si_static: Name = Name($si_name); )* $( #[allow(non_uppercase_statics)] pub static $si_static: Name = Name($si_name); )*
} }
/** /**

2
src/libsyntax/print/pprust.rs
View file

@ -89,8 +89,10 @@ pub fn rust_printer_annotated<'a>(writer: Box<io::Writer+'static>,
} }
} }
#[allow(non_uppercase_statics)]
pub static indent_unit: uint = 4u; pub static indent_unit: uint = 4u;
#[allow(non_uppercase_statics)]
pub static default_columns: uint = 78u; pub static default_columns: uint = 78u;
/// Requires you to pass an input filename and reader so that /// Requires you to pass an input filename and reader so that

1
src/libuuid/lib.rs
View file

@ -173,6 +173,7 @@ impl fmt::Show for ParseError {
} }
// Length of each hyphenated group in hex digits // Length of each hyphenated group in hex digits
#[allow(non_uppercase_statics)]
static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u]; static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u];
/// UUID support /// UUID support

1
src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs
View file

@ -17,6 +17,7 @@ extern crate regex;
#[deny(unused_variable)] #[deny(unused_variable)]
#[deny(dead_code)] #[deny(dead_code)]
#[allow(non_uppercase_statics)]
// Tests to make sure that extraneous dead code warnings aren't emitted from // Tests to make sure that extraneous dead code warnings aren't emitted from
// the code generated by regex!. // the code generated by regex!.

2
src/test/compile-fail/asm-misplaced-option.rs
View file

@ -12,7 +12,7 @@
#![feature(asm)] #![feature(asm)]
#![allow(dead_code)] #![allow(dead_code, non_uppercase_statics)]
#[cfg(any(target_arch = "x86", #[cfg(any(target_arch = "x86",
target_arch = "x86_64"))] target_arch = "x86_64"))]

2
src/test/compile-fail/issue-6804.rs
View file

@ -30,4 +30,4 @@ fn main() {
// At least one error is needed so that compilation fails // At least one error is needed so that compilation fails
#[static_assert] #[static_assert]
static b: bool = false; //~ ERROR static assertion failed static B: bool = false; //~ ERROR static assertion failed

1
src/test/compile-fail/lint-dead-code-1.rs
View file

@ -11,6 +11,7 @@
#![no_std] #![no_std]
#![allow(unused_variable)] #![allow(unused_variable)]
#![allow(non_camel_case_types)] #![allow(non_camel_case_types)]
#![allow(non_uppercase_statics)]
#![deny(dead_code)] #![deny(dead_code)]
#![feature(lang_items)] #![feature(lang_items)]

1
src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs
View file

@ -9,6 +9,7 @@
// except according to those terms. // except according to those terms.
#![deny(unused_imports)] #![deny(unused_imports)]
#![allow(non_uppercase_statics)]
// The aim of this test is to ensure that deny/allow/warn directives // The aim of this test is to ensure that deny/allow/warn directives
// are applied to individual "use" statements instead of silently // are applied to individual "use" statements instead of silently