Set the `non_uppercase_statics` lint to warn by default

37 files changed, 234 insertions, 172 deletions

diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs
index efa3402073f..82d320d5702 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 @@ 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);
diff --git a/src/libnum/rational.rs b/src/libnum/rational.rs
index 2e13d5f0148..ceaf685c19a 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 7a237670890..64c6b1739eb 100644
--- a/src/librand/reseeding.rs
+++ b/src/librand/reseeding.rs
@@ -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.
diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs
index daa4a6ad752..9804382dbd9 100644
--- a/src/librustc/driver/config.rs
+++ b/src/librustc/driver/config.rs
@@ -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),
diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
index 213e8b44813..7a59aeb5789 100644
--- a/src/librustc/lint/builtin.rs
+++ b/src/librustc/lint/builtin.rs
@@ -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;
diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs
index 9a3edbbb70b..8047c12efc2 100644
--- a/src/librustc/lint/mod.rs
+++ b/src/librustc/lint/mod.rs
@@ -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
     }
diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs
index 2a8aa791c61..ef88795762e 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 de0c36f2af3..642f66e259a 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<u8> {
diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs
index 5cc58eb264e..eda14541961 100644
--- a/src/librustc/middle/borrowck/move_data.rs
+++ b/src/librustc/middle/borrowck/move_data.rs
@@ -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);
 
diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs
index 2c79c655a99..9135ca07935 100644
--- a/src/librustc/middle/graph.rs
+++ b/src/librustc/middle/graph.rs
@@ -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 {
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 506b12de084..f88b010c28a 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 e95f640b448..0cd8510b750 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 8920994fd95..55e34ad48cd 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -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;
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index edbdf427c0b..df92251c87e 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -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;
diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs
index 2c0b2dbe2ba..13659d4b77e 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 72acba54246..1e69ce003c5 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 04a4e96ecc4..934fb0ddd3c 100644
--- a/src/librustrt/c_str.rs
+++ b/src/librustrt/c_str.rs
@@ -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)
     }
 }
diff --git a/src/librustrt/libunwind.rs b/src/librustrt/libunwind.rs
index 2e7408d9159..bb7a1227e0e 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 fcef5981f0a..8d5c49d767f 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<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));
-
-        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<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);
     }
 
     #[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()
         });
     }
diff --git a/src/librustrt/mutex.rs b/src/librustrt/mutex.rs
index 86dc9b85a79..28b0256f2e6 100644
--- a/src/librustrt/mutex.rs
+++ b/src/librustrt/mutex.rs
@@ -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__],
         };
     }
diff --git a/src/librustrt/util.rs b/src/librustrt/util.rs
index 77e3e25eb0e..9fbf4d09cd6 100644
--- a/src/librustrt/util.rs
+++ b/src/librustrt/util.rs
@@ -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 {
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 3007e160bf8..654278cf81b 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 1d479b85248..391d099de87 100644
--- a/src/libstd/bitflags.rs
+++ b/src/libstd/bitflags.rs
@@ -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
+                 ),+
             }
         }
     };
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index d8be92e4514..73a8aa442c1 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 d949a03dfc1..fa356432a67 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -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;
     );
 )
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 9c4139853c5..805db000686 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<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)]
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index 9cace9c80ef..977b3018fa7 100644
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -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));
                 }
             }
diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs
index 6d9b8821bd8..3a02d74edff 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 31860062580..f746e1f1482 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 a486ac40a97..a8c827439cc 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -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); )*
     }
 
     /**
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 8400d9aea3b..c3a3848019a 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<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
diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
index f728205c3a5..c0c3f707ecb 100644
--- a/src/libuuid/lib.rs
+++ b/src/libuuid/lib.rs
@@ -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
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 095acf56e48..1d14da73b7e 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 @@ 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!.
diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs
index 8006789d440..74bfc6e6ffc 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 600b28048b4..30d3ab17a46 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 b7feea775cb..45380235a2a 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 e920bfd412d..bbd88f1f0aa 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