Warnings cleanup

Author: kmcallister

macros/src/lib.rs

@@ -11,7 +11,9 @@
 #![crate_type="dylib"]
 
 #![feature(plugin_registrar, quote, int_uint, box_syntax)]
+#![deny(warnings)]
 #![allow(unused_imports)]  // for quotes
+#![allow(unstable)]
 
 extern crate core;
 extern crate syntax;

shared/repr.rs

@@ -30,6 +30,7 @@ pub const MAX_INLINE_LEN: usize = 7;
 
 // Atoms use a compact representation which fits this enum in a single u64.
 // Inlining avoids actually constructing the unpacked representation in memory.
+#[allow(missing_copy_implementations)]
 pub enum UnpackedAtom {
     /// Pointer to a dynamic table entry.  Must be 16-byte aligned!
     Dynamic(*mut ()),
@@ -123,7 +124,7 @@ pub unsafe fn inline_orig_bytes<'a>(data: &'a u64) -> &'a [u8] {
     match UnpackedAtom::from_packed(*data) {
         Inline(len, _) => {
             let src: &[u8] = mem::transmute(inline_atom_slice(data));
-            src.slice_to(len as uint)
+            src.slice_to(len as usize)
         }
         _ => intrinsics::unreachable(),
     }

src/atom/bench.rs

@@ -49,7 +49,7 @@ macro_rules! check_type (($name:ident, $x:expr, $p:pat) => (
 macro_rules! bench_tiny_op (($name:ident, $op:ident, $ctor_x:expr, $ctor_y:expr) => (
     #[bench]
     fn $name(b: &mut Bencher) {
-        const n: uint = 1000;
+        const n: usize = 1000;
         let xs: Vec<_> = repeat($ctor_x).take(n).collect();
         let ys: Vec<_> = repeat($ctor_y).take(n).collect();
 
@@ -92,7 +92,7 @@ macro_rules! bench_one (
         fn as_slice_x_1000(b: &mut Bencher) {
             let x = $x;
             b.iter(|| {
-                for _ in range(0, 1000u) {
+                for _ in range(0, 1000) {
                     black_box(x.as_slice());
                 }
             });
@@ -104,7 +104,7 @@ macro_rules! bench_one (
         fn clone_x_1000(b: &mut Bencher) {
             let x = $x;
             b.iter(|| {
-                for _ in range(0, 1000u) {
+                for _ in range(0, 1000) {
                     black_box(x.clone());
                 }
             });
@@ -116,7 +116,7 @@ macro_rules! bench_one (
         fn clone_x_1000(b: &mut Bencher) {
             let x = $x.to_string();
             b.iter(|| {
-                for _ in range(0, 1000u) {
+                for _ in range(0, 1000) {
                     black_box(x.clone());
                 }
             });

src/atom/mod.rs

@@ -24,7 +24,7 @@ use alloc::heap;
 use alloc::boxed::Box;
 use collections::string::String;
 use std::cmp::Ordering::{self, Equal};
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::sync::Mutex;
 use std::sync::atomic::AtomicInt;
 use std::sync::atomic::Ordering::SeqCst;
@@ -41,7 +41,7 @@ macro_rules! log (($e:expr) => (()));
 pub mod repr;
 
 // Needed for memory safety of the tagging scheme!
-const ENTRY_ALIGNMENT: uint = 16;
+const ENTRY_ALIGNMENT: usize = 16;
 
 // Macro-generated table for static atoms.
 static static_atom_set: OrderedSet<&'static str> = static_atom_set!();
@@ -83,7 +83,7 @@ impl StringCache {
 
     fn add(&mut self, string_to_add: &str) -> *mut StringCacheEntry {
         let hash = xxhash::hash(&string_to_add);
-        let bucket_index = (hash & (self.buckets.len()-1) as u64) as uint;
+        let bucket_index = (hash & (self.buckets.len()-1) as u64) as usize;
         let mut ptr = self.buckets[bucket_index];
 
         while ptr != ptr::null_mut() {
@@ -132,7 +132,7 @@ impl StringCache {
 
         debug_assert!(value.ref_count.load(SeqCst) == 0);
 
-        let bucket_index = (value.hash & (self.buckets.len()-1) as u64) as uint;
+        let bucket_index = (value.hash & (self.buckets.len()-1) as u64) as usize;
 
         let mut current = self.buckets[bucket_index];
         let mut prev: *mut StringCacheEntry = ptr::null_mut();
@@ -204,7 +204,7 @@ impl Atom {
                     let buf = repr::inline_orig_bytes(&self.data);
                     str::from_utf8(buf).unwrap()
                 },
-                Static(idx) => *static_atom_set.iter().idx(idx as uint).expect("bad static atom"),
+                Static(idx) => *static_atom_set.iter().idx(idx as usize).expect("bad static atom"),
                 Dynamic(entry) => {
                     let entry = entry as *mut StringCacheEntry;
                     (*entry).string.as_slice()
@@ -485,22 +485,22 @@ mod tests {
 
     #[test]
     fn match_atom() {
-        assert_eq!(2u, match Atom::from_slice("head") {
-            atom!(br) => 1u,
-            atom!(html) | atom!(head) => 2u,
-            _ => 3u,
+        assert_eq!(2, match Atom::from_slice("head") {
+            atom!(br) => 1,
+            atom!(html) | atom!(head) => 2,
+            _ => 3,
         });
 
-        assert_eq!(3u, match Atom::from_slice("body") {
-            atom!(br) => 1u,
-            atom!(html) | atom!(head) => 2u,
-            _ => 3u,
+        assert_eq!(3, match Atom::from_slice("body") {
+            atom!(br) => 1,
+            atom!(html) | atom!(head) => 2,
+            _ => 3,
         });
 
-        assert_eq!(3u, match Atom::from_slice("zzzzzz") {
-            atom!(br) => 1u,
-            atom!(html) | atom!(head) => 2u,
-            _ => 3u,
+        assert_eq!(3, match Atom::from_slice("zzzzzz") {
+            atom!(br) => 1,
+            atom!(html) | atom!(head) => 2,
+            _ => 3,
         });
     }
 }

src/lib.rs

@@ -12,6 +12,8 @@
 
 #![feature(plugin, old_orphan_check)]
 #![no_std]
+#![deny(warnings)]
+#![allow(unstable)]
 
 #[macro_use]
 extern crate core;