Rollup merge of rust-lang#22402 - nagisa:spring-cleanup-2, r=nikomatsakis

This commit mostly replaces some of the uses of os::args with env::args.

This, for obvious reasons is based on top of rust-lang#22400. Do not r+ before that lands.

Author: Manishearth

src/libstd/env.rs

@@ -488,12 +488,20 @@ impl Iterator for Args {
     fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 
+impl ExactSizeIterator for Args {
+    fn len(&self) -> usize { self.inner.len() }
+}
+
 impl Iterator for ArgsOs {
     type Item = OsString;
     fn next(&mut self) -> Option<OsString> { self.inner.next() }
     fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 
+impl ExactSizeIterator for ArgsOs {
+    fn len(&self) -> usize { self.inner.len() }
+}
+
 /// Returns the page size of the current architecture in bytes.
 pub fn page_size() -> usize {
     os_imp::page_size()

src/libstd/sys/unix/os.rs

@@ -247,6 +247,10 @@ impl Iterator for Args {
     fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 
+impl ExactSizeIterator for Args {
+    fn len(&self) -> usize { self.iter.len() }
+}
+
 /// Returns the command line arguments
 ///
 /// Returns a list of the command line arguments.

src/libstd/sys/windows/os.rs

@@ -303,6 +303,10 @@ impl Iterator for Args {
     fn size_hint(&self) -> (usize, Option<usize>) { self.range.size_hint() }
 }
 
+impl ExactSizeIterator for Args {
+    fn len(&self) -> usize { self.range.len() }
+}
+
 impl Drop for Args {
     fn drop(&mut self) {
         unsafe { c::LocalFree(self.cur as *mut c_void); }

src/rustbook/build.rs

@@ -11,6 +11,7 @@
 //! Implementation of the `build` subcommand, used to compile a book.
 
 use std::os;
+use std::env;
 use std::old_io;
 use std::old_io::{fs, File, BufferedWriter, TempDir, IoResult};
 
@@ -80,10 +81,10 @@ fn render(book: &Book, tgt: &Path) -> CliResult<()> {
         let out_path = tgt.join(item.path.dirname());
 
         let src;
-        if os::args().len() < 3 {
+        if env::args().len() < 3 {
             src = os::getcwd().unwrap().clone();
         } else {
-            src = Path::new(os::args()[2].clone());
+            src = Path::new(env::args().nth(2).unwrap().clone());
         }
         // preprocess the markdown, rerouting markdown references to html references
         let markdown_data = try!(File::open(&src.join(&item.path)).read_to_string());
@@ -153,16 +154,16 @@ impl Subcommand for Build {
         let src;
         let tgt;
 
-        if os::args().len() < 3 {
+        if env::args().len() < 3 {
             src = cwd.clone();
         } else {
-            src = Path::new(os::args()[2].clone());
+            src = Path::new(env::args().nth(2).unwrap().clone());
         }
 
-        if os::args().len() < 4 {
+        if env::args().len() < 4 {
             tgt = cwd.join("_book");
         } else {
-            tgt = Path::new(os::args()[3].clone());
+            tgt = Path::new(env::args().nth(3).unwrap().clone());
         }
 
         try!(fs::mkdir(&tgt, old_io::USER_DIR));

src/rustbook/main.rs

@@ -13,12 +13,13 @@
 #![feature(core)]
 #![feature(io)]
 #![feature(os)]
+#![feature(env)]
 #![feature(path)]
 #![feature(rustdoc)]
 
 extern crate rustdoc;
 
-use std::os;
+use std::env;
 use subcommand::Subcommand;
 use term::Term;
 
@@ -48,7 +49,7 @@ mod javascript;
 #[cfg(not(test))] // thanks #12327
 fn main() {
     let mut term = Term::new();
-    let cmd = os::args();
+    let cmd: Vec<_> = env::args().collect();
 
     if cmd.len() <= 1 {
         help::usage()

src/rustbook/term.rs

@@ -11,7 +11,7 @@
 //! An abstraction of the terminal. Eventually, provide color and
 //! verbosity support. For now, just a wrapper around stdout/stderr.
 
-use std::os;
+use std::env;
 use std::old_io::stdio;
 
 pub struct Term {
@@ -28,6 +28,6 @@ impl Term {
     pub fn err(&mut self, msg: &str) {
         // swallow any errors
         let _ = self.err.write_line(msg);
-        os::set_exit_status(101);
+        env::set_exit_status(101);
     }
 }

src/test/bench/core-map.rs

@@ -11,7 +11,7 @@
 #![feature(unboxed_closures)]
 
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::os;
+use std::env;
 use std::rand::{Rng, IsaacRng, SeedableRng};
 use std::time::Duration;
 
@@ -20,33 +20,33 @@ fn timed<F>(label: &str, f: F) where F: FnMut() {
 }
 
 trait MutableMap {
-    fn insert(&mut self, k: uint, v: uint);
-    fn remove(&mut self, k: &uint) -> bool;
-    fn find(&self, k: &uint) -> Option<&uint>;
+    fn insert(&mut self, k: usize, v: usize);
+    fn remove(&mut self, k: &usize) -> bool;
+    fn find(&self, k: &usize) -> Option<&usize>;
 }
 
-impl MutableMap for BTreeMap<uint, uint> {
-    fn insert(&mut self, k: uint, v: uint) { self.insert(k, v); }
-    fn remove(&mut self, k: &uint) -> bool { self.remove(k).is_some() }
-    fn find(&self, k: &uint) -> Option<&uint> { self.get(k) }
+impl MutableMap for BTreeMap<usize, usize> {
+    fn insert(&mut self, k: usize, v: usize) { self.insert(k, v); }
+    fn remove(&mut self, k: &usize) -> bool { self.remove(k).is_some() }
+    fn find(&self, k: &usize) -> Option<&usize> { self.get(k) }
 }
-impl MutableMap for HashMap<uint, uint> {
-    fn insert(&mut self, k: uint, v: uint) { self.insert(k, v); }
-    fn remove(&mut self, k: &uint) -> bool { self.remove(k).is_some() }
-    fn find(&self, k: &uint) -> Option<&uint> { self.get(k) }
+impl MutableMap for HashMap<usize, usize> {
+    fn insert(&mut self, k: usize, v: usize) { self.insert(k, v); }
+    fn remove(&mut self, k: &usize) -> bool { self.remove(k).is_some() }
+    fn find(&self, k: &usize) -> Option<&usize> { self.get(k) }
 }
 
-fn ascending<M: MutableMap>(map: &mut M, n_keys: uint) {
+fn ascending<M: MutableMap>(map: &mut M, n_keys: usize) {
     println!(" Ascending integers:");
 
     timed("insert", || {
-        for i in 0u..n_keys {
+        for i in 0..n_keys {
             map.insert(i, i + 1);
         }
     });
 
     timed("search", || {
-        for i in 0u..n_keys {
+        for i in 0..n_keys {
             assert_eq!(map.find(&i).unwrap(), &(i + 1));
         }
     });
@@ -58,7 +58,7 @@ fn ascending<M: MutableMap>(map: &mut M, n_keys: uint) {
     });
 }
 
-fn descending<M: MutableMap>(map: &mut M, n_keys: uint) {
+fn descending<M: MutableMap>(map: &mut M, n_keys: usize) {
     println!(" Descending integers:");
 
     timed("insert", || {
@@ -80,32 +80,31 @@ fn descending<M: MutableMap>(map: &mut M, n_keys: uint) {
     });
 }
 
-fn vector<M: MutableMap>(map: &mut M, n_keys: uint, dist: &[uint]) {
+fn vector<M: MutableMap>(map: &mut M, n_keys: usize, dist: &[usize]) {
     timed("insert", || {
-        for i in 0u..n_keys {
+        for i in 0..n_keys {
             map.insert(dist[i], i + 1);
         }
     });
 
     timed("search", || {
-        for i in 0u..n_keys {
+        for i in 0..n_keys {
             assert_eq!(map.find(&dist[i]).unwrap(), &(i + 1));
         }
     });
 
     timed("remove", || {
-        for i in 0u..n_keys {
+        for i in 0..n_keys {
             assert!(map.remove(&dist[i]));
         }
     });
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let mut args = env::args();
     let n_keys = {
         if args.len() == 2 {
-            args[1].parse::<uint>().unwrap()
+            args.nth(1).unwrap().parse::<usize>().unwrap()
         } else {
             1000000
         }
@@ -131,37 +130,37 @@ fn main() {
     println!("{}", "\nBTreeMap:");
 
     {
-        let mut map: BTreeMap<uint,uint> = BTreeMap::new();
+        let mut map: BTreeMap<usize,usize> = BTreeMap::new();
         ascending(&mut map, n_keys);
     }
 
     {
-        let mut map: BTreeMap<uint,uint> = BTreeMap::new();
+        let mut map: BTreeMap<usize,usize> = BTreeMap::new();
         descending(&mut map, n_keys);
     }
 
     {
         println!(" Random integers:");
-        let mut map: BTreeMap<uint,uint> = BTreeMap::new();
+        let mut map: BTreeMap<usize,usize> = BTreeMap::new();
         vector(&mut map, n_keys, &rand);
     }
 
     // FIXME: #9970
     println!("{}", "\nHashMap:");
 
     {
-        let mut map: HashMap<uint,uint> = HashMap::new();
+        let mut map: HashMap<usize,usize> = HashMap::new();
         ascending(&mut map, n_keys);
     }
 
     {
-        let mut map: HashMap<uint,uint> = HashMap::new();
+        let mut map: HashMap<usize,usize> = HashMap::new();
         descending(&mut map, n_keys);
     }
 
     {
         println!(" Random integers:");
-        let mut map: HashMap<uint,uint> = HashMap::new();
+        let mut map: HashMap<usize,usize> = HashMap::new();
         vector(&mut map, n_keys, &rand);
     }
 }