Lint against lowercase static mut

src/libcollectionstest/vec.rs

@@ -271,22 +271,22 @@ fn test_zip_unzip() {
 
 #[test]
 fn test_vec_truncate_drop() {
-    static mut drops: u32 = 0;
+    static mut DROPS: u32 = 0;
     struct Elem(i32);
     impl Drop for Elem {
         fn drop(&mut self) {
             unsafe {
-                drops += 1;
+                DROPS += 1;
             }
         }
     }
 
     let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
-    assert_eq!(unsafe { drops }, 0);
+    assert_eq!(unsafe { DROPS }, 0);
     v.truncate(3);
-    assert_eq!(unsafe { drops }, 2);
+    assert_eq!(unsafe { DROPS }, 2);
     v.truncate(0);
-    assert_eq!(unsafe { drops }, 5);
+    assert_eq!(unsafe { DROPS }, 5);
 }
 
 #[test]

src/libcollectionstest/vec_deque.rs

@@ -695,12 +695,12 @@ fn test_show() {
 
 #[test]
 fn test_drop() {
-    static mut drops: i32 = 0;
+    static mut DROPS: i32 = 0;
     struct Elem;
     impl Drop for Elem {
         fn drop(&mut self) {
             unsafe {
-                drops += 1;
+                DROPS += 1;
             }
         }
     }
@@ -712,17 +712,17 @@ fn test_drop() {
     ring.push_front(Elem);
     drop(ring);
 
-    assert_eq!(unsafe { drops }, 4);
+    assert_eq!(unsafe { DROPS }, 4);
 }
 
 #[test]
 fn test_drop_with_pop() {
-    static mut drops: i32 = 0;
+    static mut DROPS: i32 = 0;
     struct Elem;
     impl Drop for Elem {
         fn drop(&mut self) {
             unsafe {
-                drops += 1;
+                DROPS += 1;
             }
         }
     }
@@ -735,20 +735,20 @@ fn test_drop_with_pop() {
 
     drop(ring.pop_back());
     drop(ring.pop_front());
-    assert_eq!(unsafe { drops }, 2);
+    assert_eq!(unsafe { DROPS }, 2);
 
     drop(ring);
-    assert_eq!(unsafe { drops }, 4);
+    assert_eq!(unsafe { DROPS }, 4);
 }
 
 #[test]
 fn test_drop_clear() {
-    static mut drops: i32 = 0;
+    static mut DROPS: i32 = 0;
     struct Elem;
     impl Drop for Elem {
         fn drop(&mut self) {
             unsafe {
-                drops += 1;
+                DROPS += 1;
             }
         }
     }
@@ -759,10 +759,10 @@ fn test_drop_clear() {
     ring.push_back(Elem);
     ring.push_front(Elem);
     ring.clear();
-    assert_eq!(unsafe { drops }, 4);
+    assert_eq!(unsafe { DROPS }, 4);
 
     drop(ring);
-    assert_eq!(unsafe { drops }, 4);
+    assert_eq!(unsafe { DROPS }, 4);
 }
 
 #[test]

src/librustc_lint/bad_style.rs

@@ -355,9 +355,8 @@ impl LintPass for NonUpperCaseGlobals {
 impl LateLintPass for NonUpperCaseGlobals {
     fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
         match it.node {
-            // only check static constants
-            hir::ItemStatic(_, hir::MutImmutable, _) => {
-                NonUpperCaseGlobals::check_upper_case(cx, "static constant", it.name, it.span);
+            hir::ItemStatic(..) => {
+                NonUpperCaseGlobals::check_upper_case(cx, "static variable", it.name, it.span);
             }
             hir::ItemConst(..) => {
                 NonUpperCaseGlobals::check_upper_case(cx, "constant", it.name, it.span);

src/libstd/sync/once.rs

@@ -387,7 +387,7 @@ mod tests {
     #[test]
     fn stampede_once() {
         static O: Once = Once::new();
-        static mut run: bool = false;
+        static mut RUN: bool = false;
 
         let (tx, rx) = channel();
         for _ in 0..10 {
@@ -396,21 +396,21 @@ mod tests {
                 for _ in 0..4 { thread::yield_now() }
                 unsafe {
                     O.call_once(|| {
-                        assert!(!run);
-                        run = true;
+                        assert!(!RUN);
+                        RUN = true;
                     });
-                    assert!(run);
+                    assert!(RUN);
                 }
                 tx.send(()).unwrap();
             });
         }
 
         unsafe {
             O.call_once(|| {
-                assert!(!run);
-                run = true;
+                assert!(!RUN);
+                RUN = true;
             });
-            assert!(run);
+            assert!(RUN);
         }
 
         for _ in 0..10 {

src/rtstartup/rsbegin.rs

@@ -44,7 +44,7 @@ pub mod eh_frames {
 
     // Scratch space for unwinder's internal book-keeping.
     // This is defined as `struct object` in $GCC/libgcc/unwind-dw2-fde.h.
-    static mut obj: [isize; 6] = [0; 6];
+    static mut OBJ: [isize; 6] = [0; 6];
 
     // Unwind info registration/deregistration routines.
     // See the docs of `unwind` module in libstd.
@@ -56,13 +56,13 @@ pub mod eh_frames {
     unsafe fn init() {
         // register unwind info on module startup
         rust_eh_register_frames(&__EH_FRAME_BEGIN__ as *const u8,
-                                &mut obj as *mut _ as *mut u8);
+                                &mut OBJ as *mut _ as *mut u8);
     }
 
     unsafe fn uninit() {
         // unregister on shutdown
         rust_eh_unregister_frames(&__EH_FRAME_BEGIN__ as *const u8,
-                                  &mut obj as *mut _ as *mut u8);
+                                  &mut OBJ as *mut _ as *mut u8);
     }
 
     // MSVC-specific init/uninit routine registration

src/test/compile-fail/lint-group-style.rs

@@ -24,7 +24,7 @@ mod test {
     mod bad {
         fn CamelCase() {} //~ ERROR function `CamelCase` should have a snake case name
 
-        static bad: isize = 1; //~ ERROR static constant `bad` should have an upper case name
+        static bad: isize = 1; //~ ERROR static variable `bad` should have an upper case name
     }
 
     mod warn {

src/test/compile-fail/lint-non-uppercase-statics.rs

@@ -11,6 +11,9 @@
 #![forbid(non_upper_case_globals)]
 #![allow(dead_code)]
 
-static foo: isize = 1; //~ ERROR static constant `foo` should have an upper case name such as `FOO`
+static foo: isize = 1; //~ ERROR static variable `foo` should have an upper case name such as `FOO`
+
+static mut bar: isize = 1;
+        //~^ ERROR static variable `bar` should have an upper case name such as `BAR`
 
 fn main() { }