Replace some uses of deprecated os functions

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

diff --git a/src/rustbook/build.rs b/src/rustbook/build.rs
index 3c9c4bdedcc876febdf62a64dfaa8698ece966c4..6f5fc5c1969f0a8704e0f5b8fabb27b6610877c4 100644 (file)
--- a/src/rustbook/build.rs
+++ b/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 @@ fn execute(&mut self, term: &mut Term) -> CommandResult<()> {
         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));

diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs
index b29538ad62078639e9b4ca1522efca0555be3bd3..9cfcb0ba227a1a703b243d7a5777e5b45f30650f 100644 (file)
--- a/src/rustbook/main.rs
+++ b/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 @@ macro_rules! try (
 #[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()

diff --git a/src/rustbook/term.rs b/src/rustbook/term.rs
index b922bf1cdd3675fce2f370e6689094b7db1d33dd..98aa3fca184dca3f4c05e04fc9d09ba91641892d 100644 (file)
--- a/src/rustbook/term.rs
+++ b/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 @@ pub fn new() -> 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);
     }
 }

diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
index 12c95e4c60c64beff6a75fcae565e2a0a769ef55..4909d84a34f126960aadfb6e28343ceb275a34fd 100644 (file)
--- a/src/test/bench/core-map.rs
+++ b/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,18 +130,18 @@ 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);
     }
 
@@ -150,18 +149,18 @@ fn main() {
     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);
     }
 }

diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs
index 33ac8a43b437bf24dcdc17bb0641bf93b4b0f75a..1d440c4540ca3e9a1110ac2fe01646659dd372c1 100644 (file)
--- a/src/test/bench/core-set.rs
+++ b/src/test/bench/core-set.rs
@@ -20,7 +20,7 @@
 use std::collections::HashSet;
 use std::collections::hash_map::Hasher;
 use std::hash::Hash;
-use std::os;
+use std::env;
 use std::time::Duration;
 
 struct Results {
@@ -53,29 +53,29 @@ impl<T: Ord> MutableSet<T> for BTreeSet<T> {
     fn remove(&mut self, k: &T) -> bool { self.remove(k) }
     fn contains(&self, k: &T) -> bool { self.contains(k) }
 }
-impl MutableSet<uint> for BitvSet {
-    fn insert(&mut self, k: uint) { self.insert(k); }
-    fn remove(&mut self, k: &uint) -> bool { self.remove(k) }
-    fn contains(&self, k: &uint) -> bool { self.contains(k) }
+impl MutableSet<usize> for BitvSet {
+    fn insert(&mut self, k: usize) { self.insert(k); }
+    fn remove(&mut self, k: &usize) -> bool { self.remove(k) }
+    fn contains(&self, k: &usize) -> bool { self.contains(k) }
 }
 
 impl Results {
-    pub fn bench_int<T:MutableSet<uint>,
+    pub fn bench_int<T:MutableSet<usize>,
                      R:rand::Rng,
                      F:FnMut() -> T>(
                      &mut self,
                      rng: &mut R,
-                     num_keys: uint,
-                     rand_cap: uint,
+                     num_keys: usize,
+                     rand_cap: usize,
                      mut f: F) {
         {
             let mut set = f();
             timed(&mut self.sequential_ints, || {
-                for i in 0u..num_keys {
+                for i in 0..num_keys {
                     set.insert(i);
                 }
 
-                for i in 0u..num_keys {
+                for i in 0..num_keys {
                     assert!(set.contains(&i));
                 }
             })
@@ -85,19 +85,19 @@ pub fn bench_int<T:MutableSet<uint>,
             let mut set = f();
             timed(&mut self.random_ints, || {
                 for _ in 0..num_keys {
-                    set.insert(rng.gen::<uint>() % rand_cap);
+                    set.insert(rng.gen::<usize>() % rand_cap);
                 }
             })
         }
 
         {
             let mut set = f();
-            for i in 0u..num_keys {
+            for i in 0..num_keys {
                 set.insert(i);
             }
 
             timed(&mut self.delete_ints, || {
-                for i in 0u..num_keys {
+                for i in 0..num_keys {
                     assert!(set.remove(&i));
                 }
             })
@@ -109,16 +109,16 @@ pub fn bench_str<T:MutableSet<String>,
                      F:FnMut() -> T>(
                      &mut self,
                      rng: &mut R,
-                     num_keys: uint,
+                     num_keys: usize,
                      mut f: F) {
         {
             let mut set = f();
             timed(&mut self.sequential_strings, || {
-                for i in 0u..num_keys {
+                for i in 0..num_keys {
                     set.insert(i.to_string());
                 }
 
-                for i in 0u..num_keys {
+                for i in 0..num_keys {
                     assert!(set.contains(&i.to_string()));
                 }
             })
@@ -128,7 +128,7 @@ pub fn bench_str<T:MutableSet<String>,
             let mut set = f();
             timed(&mut self.random_strings, || {
                 for _ in 0..num_keys {
-                    let s = rng.gen::<uint>().to_string();
+                    let s = rng.gen::<usize>().to_string();
                     set.insert(s);
                 }
             })
@@ -136,11 +136,11 @@ pub fn bench_str<T:MutableSet<String>,
 
         {
             let mut set = f();
-            for i in 0u..num_keys {
+            for i in 0..num_keys {
                 set.insert(i.to_string());
             }
             timed(&mut self.delete_strings, || {
-                for i in 0u..num_keys {
+                for i in 0..num_keys {
                     assert!(set.remove(&i.to_string()));
                 }
             })
@@ -179,11 +179,10 @@ fn empty_results() -> Results {
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let mut args = env::args();
     let num_keys = {
         if args.len() == 2 {
-            args[1].parse::<uint>().unwrap()
+            args.nth(1).unwrap().parse::<usize>().unwrap()
         } else {
             100 // woefully inadequate for any real measurement
         }
@@ -196,7 +195,7 @@ fn main() {
         let mut rng: rand::IsaacRng = rand::SeedableRng::from_seed(seed);
         let mut results = empty_results();
         results.bench_int(&mut rng, num_keys, max, || {
-            let s: HashSet<uint> = HashSet::new();
+            let s: HashSet<usize> = HashSet::new();
             s
         });
         results.bench_str(&mut rng, num_keys, || {
@@ -210,7 +209,7 @@ fn main() {
         let mut rng: rand::IsaacRng = rand::SeedableRng::from_seed(seed);
         let mut results = empty_results();
         results.bench_int(&mut rng, num_keys, max, || {
-            let s: BTreeSet<uint> = BTreeSet::new();
+            let s: BTreeSet<usize> = BTreeSet::new();
             s
         });
         results.bench_str(&mut rng, num_keys, || {

diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index 00f8feacff8cab0710b16b85f3864a92a2e1da8c..2409487c04fc10072e225e0fe20676a67918ed52 100644 (file)
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -16,7 +16,6 @@
 use std::old_io::File;
 use std::iter::repeat;
 use std::mem::swap;
-use std::os;
 use std::env;
 use std::rand::Rng;
 use std::rand;
@@ -25,8 +24,7 @@
 use std::vec;
 
 fn main() {
-    let argv = os::args();
-    let _tests = &argv[1..argv.len()];
+    let argv: Vec<String> = env::args().collect();
 
     macro_rules! bench {
         ($id:ident) =>

diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs
index 90cc222c3deba06188dc9788ad9b35817f64367f..57889053e3c1b7a4a751451dc48a00677f87cb66 100644 (file)
--- a/src/test/bench/core-uint-to-str.rs
+++ b/src/test/bench/core-uint-to-str.rs
@@ -8,17 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
 use std::env;
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "10000000".to_string())
     } else if args.len() <= 1u {
         vec!("".to_string(), "100000".to_string())
     } else {
-        args.into_iter().collect()
+        args.collect()
     };
 
     let n = args[1].parse().unwrap();

diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 4e9c2fe99bd4a342fdecef0033ca366a2d7019fb..868202f71e10f5931310307be6ab2f469265513b 100644 (file)
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -19,7 +19,6 @@
 // version.
 
 use std::sync::mpsc::{channel, Sender, Receiver};
-use std::os;
 use std::env;
 use std::thread::Thread;
 use std::time::Duration;
@@ -94,13 +93,13 @@ fn run(args: &[String]) {
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "1000000".to_string(), "10000".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "10000".to_string(), "4".to_string())
     } else {
-        args.into_iter().map(|x| x.to_string()).collect()
+        args.map(|x| x.to_string()).collect()
     };
 
     println!("{:?}", args);

diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index 2530e8bd90707f31b2e9aa01d6693411516f64cb..c6319ad65175c96d2dfed8a8a1cae16f0f770f8a 100644 (file)
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -15,7 +15,6 @@
 // I *think* it's the same, more or less.
 
 use std::sync::mpsc::{channel, Sender, Receiver};
-use std::os;
 use std::env;
 use std::thread::Thread;
 use std::time::Duration;
@@ -101,13 +100,13 @@ fn run(args: &[String]) {
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "1000000".to_string(), "8".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "10000".to_string(), "4".to_string())
     } else {
-        args.clone().into_iter().map(|x| x.to_string()).collect()
+        args.map(|x| x.to_string()).collect()
     };
 
     println!("{:?}", args);

diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index a935a6b30864612eef5b356bf700f74c11de2274..168fe929e12542f79e4a27d5704097a96642f1e2 100644 (file)
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -18,7 +18,6 @@
 // no-pretty-expanded FIXME #15189
 // ignore-lexer-test FIXME #15679
 
-use std::os;
 use std::env;
 use std::sync::{Arc, Future, Mutex, Condvar};
 use std::time::Duration;
@@ -64,13 +63,13 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "100".to_string(), "10000".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "10".to_string(), "100".to_string())
     } else {
-        args.clone().into_iter().collect()
+        args.collect()
     };
 
     let num_tasks = args[1].parse::<uint>().unwrap();

diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs
index e4e8b4a6e6e1e2a954aadf48ba360d5a27e33c5c..4d0887f48b321d69e097dc34a25841eac20ae205 100644 (file)
--- a/src/test/bench/rt-messaging-ping-pong.rs
+++ b/src/test/bench/rt-messaging-ping-pong.rs
@@ -18,7 +18,7 @@
 // except according to those terms.
 
 use std::sync::mpsc::channel;
-use std::os;
+use std::env;
 use std::thread::Thread;
 
 // This is a simple bench that creates M pairs of tasks. These
@@ -26,10 +26,10 @@
 // canonical message-passing benchmark as it heavily strains message
 // passing and almost nothing else.
 
-fn ping_pong_bench(n: uint, m: uint) {
+fn ping_pong_bench(n: usize, m: usize) {
 
     // Create pairs of tasks that pingpong back and forth.
-    fn run_pair(n: uint) {
+    fn run_pair(n: usize) {
         // Create a channel: A->B
         let (atx, arx) = channel();
         // Create a channel: B->A
@@ -63,19 +63,13 @@ fn run_pair(n: uint) {
 
 
 fn main() {
-
-    let args = os::args();
-    let args = args;
-    let n = if args.len() == 3 {
-        args[1].parse::<uint>().unwrap()
-    } else {
-        10000
-    };
-
-    let m = if args.len() == 3 {
-        args[2].parse::<uint>().unwrap()
+    let mut args = env::args();
+    let (n, m) = if args.len() == 3 {
+        let n = args.nth(1).unwrap().parse::<usize>().unwrap();
+        let m = args.next().unwrap().parse::<usize>().unwrap();
+        (n, m)
     } else {
-        4
+        (10000, 4)
     };
 
     ping_pong_bench(n, m);

diff --git a/src/test/bench/rt-parfib.rs b/src/test/bench/rt-parfib.rs
index 13b8a5ca763ad1e5a8814c08ebdcba27d4470fa8..dadf1a3fd9a1d32b5d89d3a85fceaccfaee3ca46 100644 (file)
--- a/src/test/bench/rt-parfib.rs
+++ b/src/test/bench/rt-parfib.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 use std::sync::mpsc::channel;
-use std::os;
+use std::env;
 use std::thread::Thread;
 
 // A simple implementation of parfib. One subtree is found in a new
 // task and communicated over a oneshot pipe, the other is found
 // locally. There is no sequential-mode threshold.
 
-fn parfib(n: uint) -> uint {
+fn parfib(n: u64) -> u64 {
     if n == 0 || n == 1 {
         return 1;
     }
@@ -30,11 +30,9 @@ fn parfib(n: uint) -> uint {
 }
 
 fn main() {
-
-    let args = os::args();
-    let args = args;
+    let mut args = env::args();
     let n = if args.len() == 2 {
-        args[1].parse::<uint>().unwrap()
+        args.nth(1).unwrap().parse::<u64>().unwrap()
     } else {
         10
     };

diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs
index 933c1c218c376441004a08eb34a9405025299e4b..d07aa8850aa8306c4ca22d200db5d3a385a3d7e2 100644 (file)
--- a/src/test/bench/shootout-ackermann.rs
+++ b/src/test/bench/shootout-ackermann.rs
@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
 use std::env;
 
-fn ack(m: int, n: int) -> int {
+fn ack(m: i64, n: i64) -> i64 {
     if m == 0 {
         return n + 1
     } else {
@@ -24,13 +23,13 @@ fn ack(m: int, n: int) -> int {
 }
 
 fn main() {
-    let args = os::args();
+    let mut args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "12".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "8".to_string())
     } else {
-        args.into_iter().collect()
+        args.collect()
     };
     let n = args[1].parse().unwrap();
     println!("Ack(3,{}): {}\n", n, ack(3, n));

diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs
index 0311a1ac7c4e1e6ca4e79f69c1d660d8436730c0..6762760ed56537aa600f8ae60194caf518acd5c1 100644 (file)
--- a/src/test/bench/shootout-binarytrees.rs
+++ b/src/test/bench/shootout-binarytrees.rs
@@ -84,14 +84,13 @@ fn inner(depth: i32, iterations: i32) -> String {
 }
 
 fn main() {
-    let args = std::os::args();
-    let args = args;
+    let mut args = std::env::args();
     let n = if std::env::var_os("RUST_BENCH").is_some() {
         17
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         8
     } else {
-        args[1].parse().unwrap()
+        args.nth(1).unwrap().parse().unwrap()
     };
     let min_depth = 4;
     let max_depth = if min_depth + 2 > n {min_depth + 2} else {n};

diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 628206986c51829a7a6d31c29dd2acd619f887f6..31c786c16446d1c77b159864e17f5167d0b8b804 100644 (file)
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -230,10 +230,10 @@ fn main() {
     let nn = if std::env::var_os("RUST_BENCH").is_some() {
         200000
     } else {
-        std::os::args()
-                       .get(1)
+        std::env::args()
+                       .nth(1)
                        .and_then(|arg| arg.parse().ok())
-                       .unwrap_or(600u)
+                       .unwrap_or(600us)
     };
 
     print_complements();

diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index 92e1bc1a922c281043e468edaa880e0791572a67..2c220ab95dd76cd768292ef7b53aa5b831d677f2 100644 (file)
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -180,8 +180,8 @@ fn fannkuch(n: i32) -> (i32, i32) {
 }
 
 fn main() {
-    let n = std::os::args()
-        .get(1)
+    let n = std::env::args()
+        .nth(1)
         .and_then(|arg| arg.parse().ok())
         .unwrap_or(2i32);
 

diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index d91031b8401f3fddd06235922018c9278a42a63e..277c3ee73dff1aa8693eb4154292a13d85c8822a 100644 (file)
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -41,11 +41,11 @@
 use std::cmp::min;
 use std::old_io::{stdout, IoResult};
 use std::iter::repeat;
-use std::os;
+use std::env;
 use std::slice::bytes::copy_memory;
 
-const LINE_LEN: uint = 60;
-const LOOKUP_SIZE: uint = 4 * 1024;
+const LINE_LEN: usize = 60;
+const LOOKUP_SIZE: usize = 4 * 1024;
 const LOOKUP_SCALE: f32 = (LOOKUP_SIZE - 1) as f32;
 
 // Random number generator constants
@@ -119,7 +119,7 @@ fn new(alu: &'static str, w: &'a mut W) -> RepeatFasta<'a, W> {
         RepeatFasta { alu: alu, out: w }
     }
 
-    fn make(&mut self, n: uint) -> IoResult<()> {
+    fn make(&mut self, n: usize) -> IoResult<()> {
         let alu_len = self.alu.len();
         let mut buf = repeat(0u8).take(alu_len + LINE_LEN).collect::<Vec<_>>();
         let alu: &[u8] = self.alu.as_bytes();
@@ -188,19 +188,19 @@ fn nextc(&mut self) -> u8 {
         0
     }
 
-    fn make(&mut self, n: uint) -> IoResult<()> {
+    fn make(&mut self, n: usize) -> IoResult<()> {
         let lines = n / LINE_LEN;
         let chars_left = n % LINE_LEN;
         let mut buf = [0;LINE_LEN + 1];
 
         for _ in 0..lines {
-            for i in 0u..LINE_LEN {
+            for i in 0..LINE_LEN {
                 buf[i] = self.nextc();
             }
             buf[LINE_LEN] = '\n' as u8;
             try!(self.out.write(&buf));
         }
-        for i in 0u..chars_left {
+        for i in 0..chars_left {
             buf[i] = self.nextc();
         }
         self.out.write(&buf[..chars_left])
@@ -208,10 +208,9 @@ fn make(&mut self, n: uint) -> IoResult<()> {
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let mut args = env::args();
     let n = if args.len() > 1 {
-        args[1].parse::<uint>().unwrap()
+        args.nth(1).unwrap().parse::<usize>().unwrap()
     } else {
         5
     };

diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 5bf0862e0a1d6b8d809ca254bee45dd3c56d8a9d..fd559608011afdcbb851eb7643b30e74386abf86 100644 (file)
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -42,10 +42,9 @@
 use std::old_io::{BufferedWriter, File};
 use std::old_io;
 use std::num::Float;
-use std::os;
 use std::env;
 
-const LINE_LENGTH: uint = 60;
+const LINE_LENGTH: usize = 60;
 const IM: u32 = 139968;
 
 struct MyRandom {
@@ -86,7 +85,7 @@ fn next(&mut self) -> Option<u8> {
 }
 
 fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
-    wr: &mut W, header: &str, mut it: I, mut n: uint)
+    wr: &mut W, header: &str, mut it: I, mut n: usize)
     -> std::old_io::IoResult<()>
 {
     try!(wr.write(header.as_bytes()));
@@ -104,14 +103,13 @@ fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
 }
 
 fn run<W: Writer>(writer: &mut W) -> std::old_io::IoResult<()> {
-    let args = os::args();
-    let args = args;
+    let mut args = env::args();
     let n = if env::var_os("RUST_BENCH").is_some() {
         25000000
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         1000
     } else {
-        args[1].parse().unwrap()
+        args.nth(1).unwrap().parse().unwrap()
     };
 
     let rng = &mut MyRandom::new();

diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs
index 6a062ba3980d65606eb670b96ad1da7dd46416dc..6f9c775609af5ee6a3fd03d484140fb9753420fc 100644 (file)
--- a/src/test/bench/shootout-fibo.rs
+++ b/src/test/bench/shootout-fibo.rs
@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
 use std::env;
 
-fn fib(n: int) -> int {
+fn fib(n: i64) -> i64 {
     if n < 2 {
         return 1;
     } else {
@@ -20,13 +19,13 @@ fn fib(n: int) -> int {
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "40".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "30".to_string())
     } else {
-        args.into_iter().collect()
+        args.collect()
     };
     let n = args[1].parse().unwrap();
     println!("{}\n", fib(n));

diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index e2d51fbf4111d43f63371143e6ea59eafb5b903f..c0951ccda6ca9736b34ceab312bb33530761e9bb 100644 (file)
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -43,7 +43,7 @@
 // ignore-pretty very bad with line comments
 
 use std::old_io;
-use std::os;
+use std::env;
 use std::simd::f64x2;
 use std::sync::Arc;
 use std::thread::Thread;
@@ -197,13 +197,13 @@ fn write_line(init_i: f64, vec_init_r: &[f64], res: &mut Vec<u8>) {
 }
 
 fn main() {
-    let args = os::args();
+    let mut args = env::args();
     let res = if args.len() < 2 {
         println!("Test mode: do not dump the image because it's not utf8, \
                   which interferes with the test runner.");
         mandelbrot(1000, old_io::util::NullWriter)
     } else {
-        mandelbrot(args[1].parse().unwrap(), old_io::stdout())
+        mandelbrot(args.nth(1).unwrap().parse().unwrap(), old_io::stdout())
     };
     res.unwrap();
 }

diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 7904657bece2855dee67265f8f001d3a9c87cdf2..534dfe9548c2f73a5275abc4205b6028c5623c6f 100644 (file)
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -173,7 +173,7 @@ fn main() {
     let n = if std::env::var_os("RUST_BENCH").is_some() {
         5000000
     } else {
-        std::os::args().get(1)
+        std::env::args().nth(1)
             .and_then(|arg| arg.parse().ok())
             .unwrap_or(1000)
     };

diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 9abc808f88770f2a58269e427b523376bdd7b936..45163510a9400b92c3f6830337aa86dd2ab61bdc 100644 (file)
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -21,14 +21,13 @@
 extern crate getopts;
 
 use std::sync::mpsc::{channel, Sender};
-use std::os;
 use std::env;
 use std::result::Result::{Ok, Err};
 use std::thread::Thread;
 use std::time::Duration;
 
-fn fib(n: int) -> int {
-    fn pfib(tx: &Sender<int>, n: int) {
+fn fib(n: isize) -> isize {
+    fn pfib(tx: &Sender<isize>, n: isize) {
         if n == 0 {
             tx.send(0).unwrap();
         } else if n <= 2 {
@@ -66,7 +65,7 @@ fn parse_opts(argv: Vec<String> ) -> Config {
     }
 }
 
-fn stress_task(id: int) {
+fn stress_task(id: isize) {
     let mut i = 0;
     loop {
         let n = 15;
@@ -89,13 +88,13 @@ fn stress(num_tasks: int) {
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "20".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "8".to_string())
     } else {
-        args.into_iter().map(|x| x.to_string()).collect()
+        args.map(|x| x.to_string()).collect()
     };
 
     let opts = parse_opts(args.clone());
@@ -103,12 +102,12 @@ fn main() {
     if opts.stress {
         stress(2);
     } else {
-        let max = args[1].parse::<int>().unwrap();
+        let max = args[1].parse::<isize>().unwrap();
 
         let num_trials = 10;
 
         for n in 1..max + 1 {
-            for _ in 0u..num_trials {
+            for _ in 0..num_trials {
                 let mut fibn = None;
                 let dur = Duration::span(|| fibn = Some(fib(n)));
                 let fibn = fibn.unwrap();

diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index 8356df8d8a184264390bdf7b342eda454a5d5e88..f7572b2045301deeb8d51d972075fd0306301228 100644 (file)
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -53,13 +53,13 @@
 use std::simd::f64x2;
 
 fn main() {
-    let args = os::args();
+    let mut args = env::args();
     let answer = spectralnorm(if env::var_os("RUST_BENCH").is_some() {
         5500
     } else if args.len() < 2 {
         2000
     } else {
-        args[1].parse().unwrap()
+        args.nth(1).unwrap().parse().unwrap()
     });
     println!("{:.9}", answer);
 }

diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 8614f94da89ea87d03fdb2a70bc733876b112065..f68fb814b2113c44b068dcb3ddfe4428265abf1f 100644 (file)
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -64,13 +64,13 @@ fn roundtrip(id: i32, tx: Sender<i32>, rx: Receiver<i32>) {
 }
 
 fn main() {
-    let args = std::os::args();
+    let mut args = std::env::args();
     let token = if std::env::var_os("RUST_BENCH").is_some() {
         2000000
     } else {
-        args.get(1).and_then(|arg| arg.parse().ok()).unwrap_or(1000)
+        args.nth(1).and_then(|arg| arg.parse().ok()).unwrap_or(1000)
     };
-    let n_tasks = args.get(2)
+    let n_tasks = args.next()
                       .and_then(|arg| arg.parse().ok())
                       .unwrap_or(503);
 

diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs
index e6948a1371c9ed401b3de108cbaf0c2554a4b5c3..a54a869412e35483529c1cd943cf6c423e7e298f 100644 (file)
--- a/src/test/bench/std-smallintmap.rs
+++ b/src/test/bench/std-smallintmap.rs
@@ -11,41 +11,40 @@
 // Microbenchmark for the smallintmap library
 
 use std::collections::VecMap;
-use std::os;
 use std::env;
 use std::time::Duration;
 
-fn append_sequential(min: uint, max: uint, map: &mut VecMap<uint>) {
+fn append_sequential(min: usize, max: usize, map: &mut VecMap<usize>) {
     for i in min..max {
-        map.insert(i, i + 22u);
+        map.insert(i, i + 22);
     }
 }
 
-fn check_sequential(min: uint, max: uint, map: &VecMap<uint>) {
+fn check_sequential(min: usize, max: usize, map: &VecMap<usize>) {
     for i in min..max {
-        assert_eq!(map[i], i + 22u);
+        assert_eq!(map[i], i + 22);
     }
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "100000".to_string(), "100".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "10000".to_string(), "50".to_string())
     } else {
-        args.into_iter().collect()
+        args.collect()
     };
-    let max = args[1].parse::<uint>().unwrap();
-    let rep = args[2].parse::<uint>().unwrap();
+    let max = args[1].parse::<usize>().unwrap();
+    let rep = args[2].parse::<usize>().unwrap();
 
     let mut checkf = Duration::seconds(0);
     let mut appendf = Duration::seconds(0);
 
-    for _ in 0u..rep {
+    for _ in 0..rep {
         let mut map = VecMap::new();
-        let d1 = Duration::span(|| append_sequential(0u, max, &mut map));
-        let d2 = Duration::span(|| check_sequential(0u, max, &map));
+        let d1 = Duration::span(|| append_sequential(0, max, &mut map));
+        let d2 = Duration::span(|| check_sequential(0, max, &map));
 
         checkf = checkf + d2;
         appendf = appendf + d1;

diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index c5a64db95e6a3071632a5a3cfdbae46ab3309f28..ada8efcbf38e15a90090f64bc35e33b5932fac99 100644 (file)
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -18,7 +18,7 @@
 use std::old_io;
 use std::iter::repeat;
 use std::num::Int;
-use std::os;
+use std::env;
 
 // Computes a single solution to a given 9x9 sudoku
 //
@@ -269,8 +269,8 @@ fn check_DEFAULT_SUDOKU_solution() {
 }
 
 fn main() {
-    let args        = os::args();
-    let use_default = args.len() == 1u;
+    let args        = env::args();
+    let use_default = args.len() == 1;
     let mut sudoku = if use_default {
         Sudoku::from_vec(&DEFAULT_SUDOKU)
     } else {

diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs
index 9edb4201098d6c4a472786205995832a416c051c..a9848137e755a398794b595b6364ee34636bb178 100644 (file)
--- a/src/test/bench/task-perf-jargon-metal-smoke.rs
+++ b/src/test/bench/task-perf-jargon-metal-smoke.rs
@@ -18,7 +18,6 @@
 // ignore-pretty very bad with line comments
 
 use std::sync::mpsc::{channel, Sender};
-use std::os;
 use std::env;
 use std::thread::Thread;
 
@@ -39,13 +38,13 @@ fn child_generation(gens_left: uint, tx: Sender<()>) {
 }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "100000".to_string())
     } else if args.len() <= 1 {
         vec!("".to_string(), "100".to_string())
     } else {
-        args.clone().into_iter().collect()
+        args.collect()
     };
 
     let (tx, rx) = channel();

diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index 279b3fa432a3cb208eefc98c64d476e61209ec01..ba5e25634e8cded324ee9225cdb8fbd6fa8970c7 100644 (file)
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
 use std::env;
 use std::thread::Thread;
 
-fn f(n: uint) {
+fn f(n: usize) {
     let mut i = 0u;
     while i < n {
         let _ = Thread::scoped(move|| g()).join();
@@ -23,15 +22,15 @@ fn f(n: uint) {
 fn g() { }
 
 fn main() {
-    let args = os::args();
+    let args = env::args();
     let args = if env::var_os("RUST_BENCH").is_some() {
         vec!("".to_string(), "400".to_string())
-    } else if args.len() <= 1u {
+    } else if args.len() <= 1 {
         vec!("".to_string(), "10".to_string())
     } else {
-        args.into_iter().collect()
+        args.collect()
     };
     let n = args[1].parse().unwrap();
-    let mut i = 0u;
+    let mut i = 0;
     while i < n { Thread::spawn(move|| f(n) ); i += 1u; }
 }

diff --git a/src/test/run-fail/tls-exit-status.rs b/src/test/run-fail/tls-exit-status.rs
index 5b44e3757047b83db80c3030602f323417f8b5bd..be619e3a82cc6d3a4e50058e9b7f1d926e7433e9 100644 (file)
--- a/src/test/run-fail/tls-exit-status.rs
+++ b/src/test/run-fail/tls-exit-status.rs
@@ -11,9 +11,9 @@
 // error-pattern:nonzero
 // exec-env:RUST_NEWRT=1
 
-use std::os;
+use std::env;
 
 fn main() {
-    os::args();
+    env::args();
     panic!("please have a nonzero exit status");
 }

diff --git a/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs b/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
index c8156b95dcfcb4d696db4a2f108a530b31a28f36..89352a16d8ba2fe3792b017c9f66bebae9cd9020 100644 (file)
--- a/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
+++ b/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
+use std::env;
 use std::old_io::{File, Command};
 
 // creates broken.rs, which has the Ident \x00name_0,ctxt_0\x00
@@ -16,7 +16,7 @@
 // provided `rustc`
 
 fn main() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     let rustc = &args[1];
     let tmpdir = Path::new(&args[2]);
 

diff --git a/src/test/run-make/issue-19371/foo.rs b/src/test/run-make/issue-19371/foo.rs
index 808417d6521eabb341ce6a27087cf76955f8c7ea..c96210896fd652c94296e47b38ff632c5db31271 100644 (file)
--- a/src/test/run-make/issue-19371/foo.rs
+++ b/src/test/run-make/issue-19371/foo.rs
@@ -22,7 +22,7 @@ fn main() {
     fn main() {}
     "#;
 
-    let args = std::os::args();
+    let args: Vec<String> = std::env::args().collect();
 
     if args.len() < 4 {
         panic!("expected rustc path");

diff --git a/src/test/run-make/unicode-input/multiple_files.rs b/src/test/run-make/unicode-input/multiple_files.rs
index be67e5a066acb90596256545070040c90e7b9d76..759a1d4aff958fa110b46d34bcaf32d6a8cc76fc 100644 (file)
--- a/src/test/run-make/unicode-input/multiple_files.rs
+++ b/src/test/run-make/unicode-input/multiple_files.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::{char, os};
+use std::{char, env};
 use std::old_io::{File, Command};
 use std::rand::{thread_rng, Rng};
 
@@ -33,7 +33,7 @@ fn random_char() -> char {
 }
 
 fn main() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     let rustc = &args[1];
     let tmpdir = Path::new(&args[2]);
 

diff --git a/src/test/run-make/unicode-input/span_length.rs b/src/test/run-make/unicode-input/span_length.rs
index 95ce57da4e110c60c977e11a2857abf305340c80..5dee9104b0f6989f5fb5f3954330bc0501baa10c 100644 (file)
--- a/src/test/run-make/unicode-input/span_length.rs
+++ b/src/test/run-make/unicode-input/span_length.rs
@@ -11,7 +11,7 @@
 use std::old_io::{File, Command};
 use std::iter::repeat;
 use std::rand::{thread_rng, Rng};
-use std::{char, os};
+use std::{char, env};
 
 // creates a file with `fn main() { <random ident> }` and checks the
 // compiler emits a span of the appropriate length (for the
@@ -33,7 +33,7 @@ fn random_char() -> char {
 }
 
 fn main() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     let rustc = &args[1];
     let tmpdir = Path::new(&args[2]);
     let main_file = tmpdir.join("span_main.rs");

diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs
index b1cb4d6e42c23f46c1c7a320526cf82fcc143ae6..6f76322cb778d57a0401c4a333619c5dace9418f 100644 (file)
--- a/src/test/run-pass/backtrace.rs
+++ b/src/test/run-pass/backtrace.rs
@@ -14,7 +14,6 @@
 #![feature(unboxed_closures)]
 #![feature(unsafe_destructor)]
 
-use std::os;
 use std::env;
 use std::old_io::process::Command;
 use std::str;
@@ -86,8 +85,7 @@ fn runtest(me: &str) {
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() >= 2 && args[1] == "fail" {
         foo();
     } else if args.len() >= 2 && args[1] == "double-fail" {

diff --git a/src/test/run-pass/cleanup-shortcircuit.rs b/src/test/run-pass/cleanup-shortcircuit.rs
index b776f098b1db2f550b7850149b1ae97cba083818..59f63a79c3ddf93ffb088eb06443566ba6f69aff 100644 (file)
--- a/src/test/run-pass/cleanup-shortcircuit.rs
+++ b/src/test/run-pass/cleanup-shortcircuit.rs
@@ -20,11 +20,10 @@
 
 // Test that cleanups for the RHS of shortcircuiting operators work.
 
-use std::os;
+use std::env;
 
 pub fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
 
     // Here, the rvalue `"signal".to_string()` requires cleanup. Older versions
     // of the code had a problem that the cleanup scope for this

diff --git a/src/test/run-pass/issue-10626.rs b/src/test/run-pass/issue-10626.rs
index 9150920cf2cc7e5feb79b97ea1649a3c01d50ab1..29e4801d0a9aac66aed21b86449825d18234fd72 100644 (file)
--- a/src/test/run-pass/issue-10626.rs
+++ b/src/test/run-pass/issue-10626.rs
@@ -12,12 +12,11 @@
 // Make sure that if a process doesn't have its stdio/stderr descriptors set up
 // that we don't die in a large ball of fire
 
-use std::os;
+use std::env;
 use std::old_io::process;
 
 pub fn main () {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "child" {
         for _ in 0..1000 {
             println!("hello?");

diff --git a/src/test/run-pass/issue-13304.rs b/src/test/run-pass/issue-13304.rs
index 4dc824d9068e52043fb20eb0bceed96e466d2fdc..4a7d6be55a1625fa4730c38d3d43a8feaaf8e83b 100644 (file)
--- a/src/test/run-pass/issue-13304.rs
+++ b/src/test/run-pass/issue-13304.rs
@@ -10,13 +10,12 @@
 
 // ignore-fast
 
-use std::os;
+use std::env;
 use std::old_io;
 use std::str;
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "child" {
         child();
     } else {
@@ -25,8 +24,7 @@ fn main() {
 }
 
 fn parent() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     let mut p = old_io::process::Command::new(&args[0])
                                      .arg("child").spawn().unwrap();
     p.stdin.as_mut().unwrap().write_str("test1\ntest2\ntest3").unwrap();

diff --git a/src/test/run-pass/issue-14456.rs b/src/test/run-pass/issue-14456.rs
index 1c8066bc3c98511e35a989ad8729e45d082be66b..723db9485ca6ee110b2ced81aad5f69b60f193ae 100644 (file)
--- a/src/test/run-pass/issue-14456.rs
+++ b/src/test/run-pass/issue-14456.rs
@@ -12,10 +12,10 @@
 use std::old_io::process;
 use std::old_io::Command;
 use std::old_io;
-use std::os;
+use std::env;
 
 fn main() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "child" {
         return child()
     }
@@ -32,7 +32,7 @@ fn child() {
 }
 
 fn test() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     let mut p = Command::new(&args[0]).arg("child")
                                      .stdin(process::Ignored)
                                      .stdout(process::Ignored)

diff --git a/src/test/run-pass/issue-14940.rs b/src/test/run-pass/issue-14940.rs
index e5fead72bebeb44b5aa4acd15f83c2ad31bc6ce8..ed0e3bddbe515b8d3a5b6abce07d2528ea72ac61 100644 (file)
--- a/src/test/run-pass/issue-14940.rs
+++ b/src/test/run-pass/issue-14940.rs
@@ -8,16 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
+use std::env;
 use std::old_io::{stdio, Command};
 
 fn main() {
-    let args = os::args();
+    let mut args = env::args();
     if args.len() > 1 {
         let mut out = stdio::stdout();
         out.write(&['a' as u8; 128 * 1024]).unwrap();
     } else {
-        let out = Command::new(&args[0]).arg("child").output();
+        let out = Command::new(&args.next().unwrap()).arg("child").output();
         let out = out.unwrap();
         assert!(out.status.success());
     }

diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs
index aa45a8c5d5f7f538576fdbcb177f9cfbd84fa902..aa176d5b0f04197fa482b9a929f3df414a539fc4 100644 (file)
--- a/src/test/run-pass/issue-15149.rs
+++ b/src/test/run-pass/issue-15149.rs
@@ -11,21 +11,21 @@
 // except according to those terms.
 
 use std::slice::SliceExt;
-use std::old_io::{Command, fs, USER_RWX};
-use std::os;
+use std::old_io::{fs, USER_RWX};
+use std::process;
 use std::env;
 use std::old_path::BytesContainer;
 use std::rand::random;
 
 fn main() {
     // If we're the child, make sure we were invoked correctly
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "child" {
         // FIXME: This should check the whole `args[0]` instead of just
         // checking that it ends_with the executable name. This
         // is needed because of Windows, which has a different behavior.
         // See #15149 for more info.
-        return assert!(args[0].ends_with(&format!("mytest{}", os::consts::EXE_SUFFIX)[]));
+        return assert!(args[0].ends_with(&format!("mytest{}", env::consts::EXE_SUFFIX)[]));
     }
 
     test();
@@ -33,7 +33,7 @@ fn main() {
 
 fn test() {
     // If we're the parent, copy our own binary to a new directory.
-    let my_path = os::self_exe_name().unwrap();
+    let my_path = env::current_exe().unwrap();
     let my_dir  = my_path.dir_path();
 
     let random_u32: u32 = random();
@@ -42,22 +42,24 @@ fn test() {
     fs::mkdir(&child_dir, USER_RWX).unwrap();
 
     let child_path = child_dir.join(format!("mytest{}",
-                                            os::consts::EXE_SUFFIX));
+                                            env::consts::EXE_SUFFIX));
     fs::copy(&my_path, &child_path).unwrap();
 
     // Append the new directory to our own PATH.
-    let mut path = os::split_paths(env::var("PATH").ok().unwrap_or(String::new()));
-    path.push(child_dir.clone());
-    let path = os::join_paths(&path).unwrap();
+    let path = {
+        let mut paths: Vec<_> = env::split_paths(&env::var_os("PATH").unwrap()).collect();
+        paths.push(child_dir.clone());
+        env::join_paths(paths.iter()).unwrap()
+    };
 
-    let child_output = Command::new("mytest").env("PATH", path)
-                                             .arg("child")
-                                             .output().unwrap();
+    let child_output = process::Command::new("mytest").env("PATH", &path)
+                                                      .arg("child")
+                                                      .output().unwrap();
 
     assert!(child_output.status.success(),
             format!("child assertion failed\n child stdout:\n {}\n child stderr:\n {}",
-                    child_output.output.container_as_str().unwrap(),
-                    child_output.error.container_as_str().unwrap()));
+                    child_output.stdout.container_as_str().unwrap(),
+                    child_output.stderr.container_as_str().unwrap()));
 
     fs::rmdir_recursive(&child_dir).unwrap();
 

diff --git a/src/test/run-pass/issue-16272.rs b/src/test/run-pass/issue-16272.rs
index d73ca1b11a5555fef9b8d3aca29d3f0e5f65b6ae..3bab78ab0df9f0ca3959ff1ea010a0f9a5ff0b0b 100644 (file)
--- a/src/test/run-pass/issue-16272.rs
+++ b/src/test/run-pass/issue-16272.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 use std::old_io::{process, Command};
-use std::os;
+use std::env;
 
 fn main() {
-    let len = os::args().len();
+    let len = env::args().len();
 
     if len == 1 {
         test();
@@ -22,7 +22,7 @@ fn main() {
 }
 
 fn test() {
-    let status = Command::new(os::self_exe_name().unwrap())
+    let status = Command::new(env::current_exe().unwrap())
                          .arg("foo").arg("")
                          .stdout(process::InheritFd(1))
                          .stderr(process::InheritFd(2))

diff --git a/src/test/run-pass/issue-20091.rs b/src/test/run-pass/issue-20091.rs
index 3ef63a53a6dea195780df58473d88e2c6b573b12..4d20e6360ad4fdda2654b0047b475e37b2fcdaac 100644 (file)
--- a/src/test/run-pass/issue-20091.rs
+++ b/src/test/run-pass/issue-20091.rs
@@ -11,11 +11,11 @@
 // ignore-windows currently windows requires UTF-8 for spawning processes
 
 use std::old_io::Command;
-use std::os;
+use std::env;
 
 fn main() {
-    if os::args().len() == 1 {
-        assert!(Command::new(os::self_exe_name().unwrap()).arg(b"\xff")
+    if env::args().len() == 1 {
+        assert!(Command::new(env::current_exe().unwrap()).arg(b"\xff")
                         .status().unwrap().success())
     }
 }

diff --git a/src/test/run-pass/issue-4541.rs b/src/test/run-pass/issue-4541.rs
index f10303e8d8479a1eb433c4dbe1122628e3a84de5..1f090d8b622e05686fe7589b6db102ada1fa3de7 100644 (file)
--- a/src/test/run-pass/issue-4541.rs
+++ b/src/test/run-pass/issue-4541.rs
@@ -9,8 +9,7 @@
 // except according to those terms.
 
 fn parse_args() -> String {
-    let args = ::std::os::args();
-    let args = args;
+    let args: Vec<_> = ::std::env::args().collect();
     let mut n = 0;
 
     while n < args.len() {

diff --git a/src/test/run-pass/issue-4542.rs b/src/test/run-pass/issue-4542.rs
index ae72de50d26d838d48999e67fe86ff52288580f7..521e1b40f992e5d1b305172840ee6aaa9257bad0 100644 (file)
--- a/src/test/run-pass/issue-4542.rs
+++ b/src/test/run-pass/issue-4542.rs
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os;
+use std::env;
 
 pub fn main() {
-    for arg in &os::args() {
-        match (*arg).clone() {
+    for arg in env::args() {
+        match arg.clone() {
             _s => { }
         }
     }

diff --git a/src/test/run-pass/logging-separate-lines.rs b/src/test/run-pass/logging-separate-lines.rs
index 1be0ee4a285514c4ab5c23db4f92f866a521c083..b90d881569917c054304355ea4cf2c3365ec0c34 100644 (file)
--- a/src/test/run-pass/logging-separate-lines.rs
+++ b/src/test/run-pass/logging-separate-lines.rs
@@ -16,12 +16,11 @@
 extern crate log;
 
 use std::old_io::Command;
-use std::os;
+use std::env;
 use std::str;
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "child" {
         debug!("foo");
         debug!("bar");

diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
index ca9ee469e38976ec8e49f729de97a428fb17db33..f574259c375fc86886bda5882c28f1987479e760 100644 (file)
--- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs
+++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
@@ -16,7 +16,7 @@
 #![feature(asm)]
 
 use std::old_io::process::Command;
-use std::os;
+use std::env;
 use std::thread::Thread;
 
 // lifted from the test module
@@ -34,8 +34,7 @@ fn recurse() {
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "recurse" {
         let _t = Thread::scoped(recurse);
     } else {

diff --git a/src/test/run-pass/out-of-stack-no-split.rs b/src/test/run-pass/out-of-stack-no-split.rs
index fba86d74816790438fe07d986d7ccf82c49f5ee4..948c4d064d723ef7f9302e763324853c13a14b39 100644 (file)
--- a/src/test/run-pass/out-of-stack-no-split.rs
+++ b/src/test/run-pass/out-of-stack-no-split.rs
@@ -17,7 +17,7 @@
 #![feature(asm)]
 
 use std::old_io::process::Command;
-use std::os;
+use std::env;
 
 // lifted from the test module
 // Inlining to avoid llvm turning the recursive functions into tail calls,
@@ -34,7 +34,7 @@ fn recurse() {
 }
 
 fn main() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "recurse" {
         recurse();
     } else {

diff --git a/src/test/run-pass/out-of-stack.rs b/src/test/run-pass/out-of-stack.rs
index 7dfd46fb995a207706de5f9326a7c820b1e06275..cc5eb69bb87e39ced535bccb2618f5bf29af23da 100644 (file)
--- a/src/test/run-pass/out-of-stack.rs
+++ b/src/test/run-pass/out-of-stack.rs
@@ -13,7 +13,7 @@
 #![feature(asm)]
 
 use std::old_io::process::Command;
-use std::os;
+use std::env;
 
 // lifted from the test module
 // Inlining to avoid llvm turning the recursive functions into tail calls,
@@ -34,8 +34,7 @@ fn loud_recurse() {
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "silent" {
         silent_recurse();
     } else if args.len() > 1 && args[1] == "loud" {

diff --git a/src/test/run-pass/process-spawn-with-unicode-params.rs b/src/test/run-pass/process-spawn-with-unicode-params.rs
index 15cc128d380db4db7cb62aed971fe25ce7bfb5ce..017784990f4178ece9fcc4dff70c6cbca120b35e 100644 (file)
--- a/src/test/run-pass/process-spawn-with-unicode-params.rs
+++ b/src/test/run-pass/process-spawn-with-unicode-params.rs
@@ -20,12 +20,13 @@
 use std::old_io::fs;
 use std::old_io::Command;
 use std::os;
+use std::env;
 use std::old_path::Path;
 
 fn main() {
-    let my_args = os::args();
+    let my_args = env::args().collect::<Vec<_>>();
     let my_cwd  = os::getcwd().unwrap();
-    let my_env  = os::env();
+    let my_env  = env::vars().collect::<Vec<_>>();
     let my_path = Path::new(os::self_exe_name().unwrap());
     let my_dir  = my_path.dir_path();
     let my_ext  = my_path.extension_str().unwrap_or("");

diff --git a/src/test/run-pass/segfault-no-out-of-stack.rs b/src/test/run-pass/segfault-no-out-of-stack.rs
index a2706dca7d3ea3d0edb036e724e9f51479cb1c84..492736c2252a0148612a2e948a6ebb6ceb169bb2 100644 (file)
--- a/src/test/run-pass/segfault-no-out-of-stack.rs
+++ b/src/test/run-pass/segfault-no-out-of-stack.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 use std::old_io::process::Command;
-use std::os;
+use std::env;
 
 fn main() {
-    let args = os::args();
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "segfault" {
         unsafe { *(0 as *mut int) = 1 }; // trigger a segfault
     } else {

diff --git a/src/test/run-pass/signal-exit-status.rs b/src/test/run-pass/signal-exit-status.rs
index 856eb241addc3279eb8131ffb554084ebec1c781..776d897938dd3c5ae556c8043430aae50cd0b90c 100644 (file)
--- a/src/test/run-pass/signal-exit-status.rs
+++ b/src/test/run-pass/signal-exit-status.rs
@@ -10,12 +10,11 @@
 
 // ignore-windows
 
-use std::os;
+use std::env;
 use std::old_io::process::{Command, ExitSignal, ExitStatus};
 
 pub fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() >= 2 && args[1] == "signal" {
         // Raise a segfault.
         unsafe { *(0 as *mut int) = 0; }

diff --git a/src/test/run-pass/sigpipe-should-be-ignored.rs b/src/test/run-pass/sigpipe-should-be-ignored.rs
index de8f76518fc00c0cbdbe91f0230b2ccd8214dd91..d1428c6be19ef880f06645c74a59908b90dd7b04 100644 (file)
--- a/src/test/run-pass/sigpipe-should-be-ignored.rs
+++ b/src/test/run-pass/sigpipe-should-be-ignored.rs
@@ -12,6 +12,7 @@
 // doesn't die in a ball of fire, but rather it's gracefully handled.
 
 use std::os;
+use std::env;
 use std::old_io::PipeStream;
 use std::old_io::Command;
 
@@ -25,8 +26,7 @@ fn test() {
 }
 
 fn main() {
-    let args = os::args();
-    let args = args;
+    let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "test" {
         return test();
     }