rollup merge of rust-lang#21787: alexcrichton/std-env

Conflicts:
	src/libstd/sys/unix/backtrace.rs
	src/libstd/sys/unix/os.rs

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -22,6 +22,7 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(unicode)]
+#![feature(env)]
 
 #![deny(warnings)]
 
@@ -31,7 +32,7 @@ extern crate getopts;
 #[macro_use]
 extern crate log;
 
-use std::os;
+use std::env;
 use std::old_io;
 use std::old_io::fs;
 use std::thunk::Thunk;
@@ -48,7 +49,7 @@ pub mod common;
 pub mod errors;
 
 pub fn main() {
-    let args = os::args();
+    let args = env::args().map(|s| s.into_string().unwrap()).collect();;
     let config = parse_config(args);
 
     if config.valgrind_path.is_none() && config.force_valgrind {
@@ -224,15 +225,15 @@ pub fn run_tests(config: &Config) {
         //arm-linux-androideabi debug-info test uses remote debugger
         //so, we test 1 task at once.
         // also trying to isolate problems with adb_run_wrapper.sh ilooping
-        os::setenv("RUST_TEST_TASKS","1");
+        env::set_var("RUST_TEST_TASKS","1");
     }
 
     match config.mode {
         DebugInfoLldb => {
             // Some older versions of LLDB seem to have problems with multiple
             // instances running in parallel, so only run one test task at a
             // time.
-            os::setenv("RUST_TEST_TASKS", "1");
+            env::set_var("RUST_TEST_TASKS", "1");
         }
         _ => { /* proceed */ }
     }
@@ -245,7 +246,7 @@ pub fn run_tests(config: &Config) {
     old_io::test::raise_fd_limit();
     // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
     // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
-    os::setenv("__COMPAT_LAYER", "RunAsInvoker");
+    env::set_var("__COMPAT_LAYER", "RunAsInvoker");
     let res = test::run_tests_console(&opts, tests.into_iter().collect());
     match res {
         Ok(true) => {}

src/compiletest/runtest.rs

@@ -31,7 +31,7 @@ use std::old_io::process::ProcessExit;
 use std::old_io::process;
 use std::old_io::timer;
 use std::old_io;
-use std::os;
+use std::env;
 use std::iter::repeat;
 use std::str;
 use std::string::String;
@@ -1298,9 +1298,9 @@ fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> Path {
 
 fn make_exe_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    if !os::consts::EXE_SUFFIX.is_empty() {
+    if !env::consts::EXE_SUFFIX.is_empty() {
         let mut fname = f.filename().unwrap().to_vec();
-        fname.extend(os::consts::EXE_SUFFIX.bytes());
+        fname.extend(env::consts::EXE_SUFFIX.bytes());
         f.set_filename(fname);
     }
     f

src/etc/make-win-dist.py

@@ -87,6 +87,7 @@ def make_win_dist(rust_root, gcc_root, target_triple):
                     "libsetupapi.a",
                     "libshell32.a",
                     "libuser32.a",
+                    "libuserenv.a",
                     "libuuid.a",
                     "libwinhttp.a",
                     "libwinmm.a",

src/liblog/lib.rs

@@ -173,15 +173,15 @@
 #![feature(int_uint)]
 #![feature(core)]
 #![feature(io)]
-#![feature(os)]
 #![feature(std_misc)]
+#![feature(env)]
 
 use std::cell::RefCell;
 use std::fmt;
 use std::old_io::LineBufferedWriter;
 use std::old_io;
 use std::mem;
-use std::os;
+use std::env;
 use std::ptr;
 use std::rt;
 use std::slice;
@@ -397,9 +397,9 @@ fn enabled(level: u32,
 /// This is not threadsafe at all, so initialization is performed through a
 /// `Once` primitive (and this function is called from that primitive).
 fn init() {
-    let (mut directives, filter) = match os::getenv("RUST_LOG") {
-        Some(spec) => directive::parse_logging_spec(&spec[]),
-        None => (Vec::new(), None),
+    let (mut directives, filter) = match env::var_string("RUST_LOG") {
+        Ok(spec) => directive::parse_logging_spec(&spec[]),
+        Err(..) => (Vec::new(), None),
     };
 
     // Sort the provided directives by length of their name, this allows a

src/librustc/lib.rs

@@ -32,7 +32,7 @@
 #![feature(int_uint)]
 #![feature(io)]
 #![feature(libc)]
-#![feature(os)]
+#![feature(env)]
 #![feature(path)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]

src/librustc/metadata/filesearch.rs

@@ -13,9 +13,9 @@
 pub use self::FileMatch::*;
 
 use std::collections::HashSet;
+use std::env;
 use std::old_io::fs::PathExtensions;
 use std::old_io::fs;
-use std::os;
 
 use util::fs as myfs;
 use session::search_paths::{SearchPaths, PathKind};
@@ -194,7 +194,7 @@ pub fn get_or_default_sysroot() -> Path {
             })
     }
 
-    match canonicalize(os::self_exe_name()) {
+    match canonicalize(env::current_exe().ok()) {
         Some(mut p) => { p.pop(); p.pop(); p }
         None => panic!("can't determine value for sysroot")
     }
@@ -207,7 +207,7 @@ static PATH_ENTRY_SEPARATOR: &'static str = ":";
 
 /// Returns RUST_PATH as a string, without default paths added
 pub fn get_rust_path() -> Option<String> {
-    os::getenv("RUST_PATH").map(|x| x.to_string())
+    env::var_string("RUST_PATH").ok()
 }
 
 /// Returns the value of RUST_PATH, as a list
@@ -224,7 +224,7 @@ pub fn rust_path() -> Vec<Path> {
         }
         None => Vec::new()
     };
-    let mut cwd = os::getcwd().unwrap();
+    let mut cwd = env::current_dir().unwrap();
     // now add in default entries
     let cwd_dot_rust = cwd.join(".rust");
     if !env_rust_path.contains(&cwd_dot_rust) {
@@ -243,7 +243,7 @@ pub fn rust_path() -> Vec<Path> {
         }
         cwd.pop();
     }
-    let h = os::homedir();
+    let h = env::home_dir();
     for h in h.iter() {
         let p = h.join(".rust");
         if !env_rust_path.contains(&p) && p.exists() {

src/librustc/middle/infer/region_inference/graphviz.rs

@@ -27,7 +27,7 @@ use util::ppaux::Repr;
 
 use std::collections::hash_map::Entry::Vacant;
 use std::old_io::{self, File};
-use std::os;
+use std::env;
 use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 use syntax::ast;
 
@@ -59,13 +59,13 @@ pub fn maybe_print_constraints_for<'a, 'tcx>(region_vars: &RegionVarBindings<'a,
     }
 
     let requested_node : Option<ast::NodeId> =
-        os::getenv("RUST_REGION_GRAPH_NODE").and_then(|s| s.parse().ok());
+        env::var_string("RUST_REGION_GRAPH_NODE").ok().and_then(|s| s.parse().ok());
 
     if requested_node.is_some() && requested_node != Some(subject_node) {
         return;
     }
 
-    let requested_output = os::getenv("RUST_REGION_GRAPH");
+    let requested_output = env::var_string("RUST_REGION_GRAPH").ok();
     debug!("requested_output: {:?} requested_node: {:?}",
            requested_output, requested_node);
 

src/librustc/plugin/load.rs

@@ -15,7 +15,7 @@ use metadata::creader::{CrateOrString, CrateReader};
 use plugin::registry::Registry;
 
 use std::mem;
-use std::os;
+use std::env;
 use std::dynamic_lib::DynamicLibrary;
 use std::collections::HashSet;
 use syntax::ast;
@@ -233,7 +233,7 @@ impl<'a> PluginLoader<'a> {
                         path: Path,
                         symbol: String) -> PluginRegistrarFun {
         // Make sure the path contains a / or the linker will search for it.
-        let path = os::make_absolute(&path).unwrap();
+        let path = env::current_dir().unwrap().join(&path);
 
         let lib = match DynamicLibrary::open(Some(&path)) {
             Ok(lib) => lib,

src/librustc/session/mod.rs

@@ -27,7 +27,7 @@ use syntax::{ast, codemap};
 
 use rustc_back::target::Target;
 
-use std::os;
+use std::env;
 use std::cell::{Cell, RefCell};
 
 pub mod config;
@@ -347,7 +347,7 @@ pub fn build_session_(sopts: config::Options,
         if path.is_absolute() {
             path.clone()
         } else {
-            os::getcwd().unwrap().join(&path)
+            env::current_dir().unwrap().join(&path)
         }
     );
 
@@ -370,7 +370,7 @@ pub fn build_session_(sopts: config::Options,
         plugin_registrar_fn: Cell::new(None),
         default_sysroot: default_sysroot,
         local_crate_source_file: local_crate_source_file,
-        working_dir: os::getcwd().unwrap(),
+        working_dir: env::current_dir().unwrap(),
         lint_store: RefCell::new(lint::LintStore::new()),
         lints: RefCell::new(NodeMap()),
         crate_types: RefCell::new(Vec::new()),

src/librustc_back/archive.rs

@@ -14,7 +14,7 @@ use std::old_io::fs::PathExtensions;
 use std::old_io::process::{Command, ProcessOutput};
 use std::old_io::{fs, TempDir};
 use std::old_io;
-use std::os;
+use std::env;
 use std::str;
 use syntax::diagnostic::Handler as ErrorHandler;
 
@@ -224,7 +224,7 @@ impl<'a> ArchiveBuilder<'a> {
     pub fn build(self) -> Archive<'a> {
         // Get an absolute path to the destination, so `ar` will work even
         // though we run it from `self.work_dir`.
-        let abs_dst = os::getcwd().unwrap().join(&self.archive.dst);
+        let abs_dst = env::current_dir().unwrap().join(&self.archive.dst);
         assert!(!abs_dst.is_relative());
         let mut args = vec![&abs_dst];
         let mut total_len = abs_dst.as_vec().len();
@@ -283,7 +283,7 @@ impl<'a> ArchiveBuilder<'a> {
         // First, extract the contents of the archive to a temporary directory.
         // We don't unpack directly into `self.work_dir` due to the possibility
         // of filename collisions.
-        let archive = os::make_absolute(archive).unwrap();
+        let archive = env::current_dir().unwrap().join(archive);
         run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
                "x", Some(loc.path()), &[&archive]);
 

src/librustc_back/fs.rs

@@ -10,13 +10,13 @@
 
 use std::old_io;
 use std::old_io::fs;
-use std::os;
+use std::env;
 
 /// Returns an absolute path in the filesystem that `path` points to. The
 /// returned path does not contain any symlinks in its hierarchy.
 pub fn realpath(original: &Path) -> old_io::IoResult<Path> {
     static MAX_LINKS_FOLLOWED: uint = 256;
-    let original = os::make_absolute(original).unwrap();
+    let original = try!(env::current_dir()).join(original);
 
     // Right now lstat on windows doesn't work quite well
     if cfg!(windows) {

src/librustc_back/lib.rs

@@ -40,6 +40,7 @@
 #![feature(path)]
 #![feature(rustc_private)]
 #![feature(staged_api)]
+#![feature(env)]
 
 extern crate syntax;
 extern crate serialize;

src/librustc_back/rpath.rs

@@ -10,7 +10,7 @@
 
 
 use std::collections::HashSet;
-use std::os;
+use std::env;
 use std::old_io::IoError;
 use syntax::ast;
 
@@ -105,18 +105,17 @@ fn get_rpath_relative_to_output<F, G>(config: &mut RPathConfig<F, G>, lib: &Path
     F: FnOnce() -> Path,
     G: FnMut(&Path) -> Result<Path, IoError>,
 {
-    use std::os;
-
     // Mac doesn't appear to support $ORIGIN
     let prefix = if config.is_like_osx {
         "@loader_path"
     } else {
         "$ORIGIN"
     };
 
-    let mut lib = (config.realpath)(&os::make_absolute(lib).unwrap()).unwrap();
+    let cwd = env::current_dir().unwrap();
+    let mut lib = (config.realpath)(&cwd.join(lib)).unwrap();
     lib.pop();
-    let mut output = (config.realpath)(&os::make_absolute(&config.out_filename).unwrap()).unwrap();
+    let mut output = (config.realpath)(&cwd.join(&config.out_filename)).unwrap();
     output.pop();
     let relative = lib.path_relative_from(&output);
     let relative = relative.expect("could not create rpath relative to output");
@@ -131,7 +130,7 @@ fn get_install_prefix_rpath<F, G>(config: RPathConfig<F, G>) -> String where
     G: FnMut(&Path) -> Result<Path, IoError>,
 {
     let path = (config.get_install_prefix_lib_path)();
-    let path = os::make_absolute(&path).unwrap();
+    let path = env::current_dir().unwrap().join(&path);
     // FIXME (#9639): This needs to handle non-utf8 paths
     path.as_str().expect("non-utf8 component in rpath").to_string()
 }

src/librustc_back/target/mod.rs

@@ -303,7 +303,8 @@ impl Target {
     /// The error string could come from any of the APIs called, including filesystem access and
     /// JSON decoding.
     pub fn search(target: &str) -> Result<Target, String> {
-        use std::os;
+        use std::env;
+        use std::ffi::OsString;
         use std::old_io::File;
         use std::path::Path;
         use serialize::json;
@@ -383,12 +384,12 @@ impl Target {
             Path::new(target)
         };
 
-        let target_path = os::getenv("RUST_TARGET_PATH").unwrap_or(String::new());
+        let target_path = env::var("RUST_TARGET_PATH")
+                              .unwrap_or(OsString::from_str(""));
 
-        let paths = os::split_paths(&target_path[]);
         // FIXME 16351: add a sane default search path?
 
-        for dir in paths.iter() {
+        for dir in env::split_paths(&target_path) {
             let p =  dir.join(path.clone());
             if p.is_file() {
                 return load_file(&p);