OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki 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
Show Stats 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;
// `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 @@ mod biguint_tests {
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 @@ mod biguint_tests {
#[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 @@ mod biguint_tests {
#[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 @@ mod biguint_tests {
a - b;
}
static mul_triples: &'static [(&'static [BigDigit],
static MUL_TRIPLES: &'static [(&'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])
];
static div_rem_quadruples: &'static [(&'static [BigDigit],
static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])]
@ -1928,7 +1931,7 @@ mod biguint_tests {
#[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 @@ mod biguint_tests {
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 @@ mod biguint_tests {
#[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 @@ 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 = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1979,7 +1982,7 @@ mod biguint_tests {
#[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 @@ mod biguint_tests {
#[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 @@ mod biguint_tests {
#[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 @@ mod biguint_tests {
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 @@ mod biguint_tests {
#[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 @@ mod bigint_tests {
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 @@ mod bigint_tests {
#[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 @@ mod bigint_tests {
#[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 @@ mod bigint_tests {
}
}
static mul_triples: &'static [(&'static [BigDigit],
static MUL_TRIPLES: &'static [(&'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])
];
static div_rem_quadruples: &'static [(&'static [BigDigit],
static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])]
@ -2532,7 +2535,7 @@ mod bigint_tests {
#[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 @@ mod bigint_tests {
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 @@ 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 = BigInt::from_slice(Plus, a_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()); }
}
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 @@ mod bigint_tests {
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 @@ mod bigint_tests {
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 @@ mod bigint_tests {
#[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 @@ mod bigint_tests {
#[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 @@ mod bigint_tests {
#[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 @@ mod bigint_tests {
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 @@ mod bigint_tests {
}
#[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);

3
src/libnum/rational.rs
View File

@ -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 {

6
src/librand/reseeding.rs
View File

@ -209,15 +209,15 @@ mod test {
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.

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

@ -494,6 +494,7 @@ pub fn get_os(triple: &str) -> Option<abi::Os> {
}
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<abi::Architecture> {
}
None
}
#[allow(non_uppercase_statics)]
static architecture_abis : &'static [(&'static str, abi::Architecture)] = &[
("i386", 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")
pub struct NonUppercaseStatics;

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

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

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

@ -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;

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.
#[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<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 =
MovePathIndex(uint::MAX);
@ -96,6 +97,7 @@ impl MoveIndex {
}
}
#[allow(non_uppercase_statics)]
static InvalidMoveIndex: MoveIndex =
MoveIndex(uint::MAX);

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

@ -57,16 +57,20 @@ pub struct Edge<E> {
#[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 {

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 {
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)];

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
// 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> {

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;
#[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;

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

@ -2197,7 +2197,10 @@ macro_rules! def_type_content_sets(
#[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;

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
// 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;

2
src/librustc_back/abi.rs
View File

@ -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;

30
src/librustrt/c_str.rs
View File

@ -733,9 +733,9 @@ mod bench {
}
}
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 @@ mod bench {
#[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 @@ mod bench {
#[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 @@ mod bench {
#[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 @@ mod bench {
#[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)
}
}

1
src/librustrt/libunwind.rs
View File

@ -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

212
src/librustrt/local_data.rs
View File

@ -416,37 +416,37 @@ mod tests {
#[test]
fn test_tls_multitask() {
static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("parent data".to_string()));
static MY_KEY: Key<String> = &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<String> = &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<String> = &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<String> = &KeyValueKey;
my_key.replace(Some("weasel".to_string()));
assert!(my_key.replace(None).unwrap() == "weasel".to_string());
static MY_KEY: Key<String> = &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 @@ mod tests {
// 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<String> = &KeyValueKey;
static MY_KEY: Key<String> = &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<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey;
static STR_KEY: Key<String> = &KeyValueKey;
static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static INT_KEY: Key<int> = &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<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey;
static STR_KEY: Key<String> = &KeyValueKey;
static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static INT_KEY: Key<int> = &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<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey;
str_key.replace(Some("parent data".to_string()));
box_key.replace(Some(box 0));
static STR_KEY: Key<String> = &KeyValueKey;
static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static INT_KEY: Key<int> = &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 @@ mod tests {
self.tx.send(());
}
}
static key: Key<Dropper> = &KeyValueKey;
static KEY: Key<Dropper> = &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 @@ mod tests {
#[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<Box<int>> = &KeyValueKey;
key.replace(Some(box 1));
static KEY: Key<Box<int>> = &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<int> = &KeyValueKey;
static key2: Key<int> = &KeyValueKey;
static key3: Key<int> = &KeyValueKey;
static key4: Key<int> = &KeyValueKey;
static key5: Key<int> = &KeyValueKey;
key1.replace(Some(1));
key2.replace(Some(2));
key3.replace(Some(3));
key4.replace(Some(4));
key5.replace(Some(5));
static KEY1: Key<int> = &KeyValueKey;
static KEY2: Key<int> = &KeyValueKey;
static KEY3: Key<int> = &KeyValueKey;
static KEY4: Key<int> = &KeyValueKey;
static KEY5: Key<int> = &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);
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<int> = &KeyValueKey;
assert_eq!(key.replace(Some(4)), None);
static KEY: Key<int> = &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 @@ mod tests {
#[bench]
fn bench_replace_none(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(None);
static KEY: Key<uint> = &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<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(Some(1u));
static KEY: Key<uint> = &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<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(Some(0u));
static KEY: Key<uint> = &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<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[99];
let key: Key<uint> = &KEYS[99];
key.replace(Some(42))
});
}
#[bench]
fn bench_1000_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[999];
let key: Key<uint> = &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<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(Some(42));
static KEY: Key<uint> = &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<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[99];
let key: Key<uint> = &KEYS[99];
key.get()
});
}
#[bench]
fn bench_1000_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[999];
let key: Key<uint> = &KEYS[999];
key.get()
});
}

8
src/librustrt/mutex.rs
View File

@ -376,8 +376,8 @@ mod imp {
#[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 @@ mod imp {
}
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__],
};
}

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);
#[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 {

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> {
#[allow(non_uppercase_statics)]
static len: uint = 16;
#[allow(non_uppercase_statics)]
static buf: [u8, ..len] = [b' ', ..len];
while n >= len {

10
src/libstd/bitflags.rs
View File

@ -123,7 +123,10 @@ macro_rules! 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 @@ macro_rules! bitflags {
bitflags! {
$(#[$attr])*
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
#![allow(experimental)]
#![allow(non_uppercase_statics)]
use prelude::*;

2
src/libstd/macros.rs
View File

@ -304,9 +304,11 @@ macro_rules! println(
#[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;
);
)

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".";
#[allow(non_uppercase_statics)]
static dot_dot_static: &'static [u8] = b"..";
#[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)
// (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));
}
}

3
src/libsyntax/abi.rs
View File

@ -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)},

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
/// not appearing in the prior table.
#[allow(non_uppercase_statics)]
pub static as_prec: uint = 12u;
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 {
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); )*
}
/**

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;
#[allow(non_uppercase_statics)]
pub static default_columns: uint = 78u;
/// 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
#[allow(non_uppercase_statics)]
static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u];
/// 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(dead_code)]
#[allow(non_uppercase_statics)]
// Tests to make sure that extraneous dead code warnings aren't emitted from
// the code generated by regex!.

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

@ -12,7 +12,7 @@
#![feature(asm)]
#![allow(dead_code)]
#![allow(dead_code, non_uppercase_statics)]
#[cfg(any(target_arch = "x86",
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
#[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]
#![allow(unused_variable)]
#![allow(non_camel_case_types)]
#![allow(non_uppercase_statics)]
#![deny(dead_code)]
#![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.
#![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