From a828e7948069f310dc5b33be8edb65e5e8e0cf9a Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 11 Feb 2015 11:47:53 -0800 Subject: [PATCH] std: Tweak the std::env OsString/String interface This commit tweaks the interface of the `std::env` module to make it more ergonomic for common usage: * `env::var` was renamed to `env::var_os` * `env::var_string` was renamed to `env::var` * `env::args` was renamed to `env::args_os` * `env::args` was re-added as a panicking iterator over string values * `env::vars` was renamed to `env::vars_os` * `env::vars` was re-added as a panicking iterator over string values. This should make common usage (e.g. unicode values everywhere) more ergonomic as well as "the default". This is also a breaking change due to the differences of what's yielded from each of these functions, but migration should be fairly easy as the defaults operate over `String` which is a common type to use. [breaking-change] --- src/compiletest/compiletest.rs | 4 +- src/compiletest/util.rs | 2 +- src/liblog/lib.rs | 2 +- src/librustc/metadata/filesearch.rs | 2 +- .../middle/infer/region_inference/graphviz.rs | 4 +- src/librustc/session/config.rs | 2 +- src/librustc_back/target/mod.rs | 2 +- src/librustc_driver/driver.rs | 4 +- src/librustc_driver/lib.rs | 5 +- src/librustc_trans/save/mod.rs | 2 +- src/librustdoc/lib.rs | 6 +- src/libstd/dynamic_lib.rs | 2 +- src/libstd/env.rs | 169 +++++++++++++----- src/libstd/os.rs | 10 +- src/libstd/rt/backtrace.rs | 2 +- src/libstd/rt/util.rs | 4 +- src/libsyntax/ext/env.rs | 4 +- src/libterm/terminfo/mod.rs | 4 +- src/libterm/terminfo/searcher.rs | 4 +- src/libtest/lib.rs | 4 +- src/test/run-pass/env-vars.rs | 4 +- 21 files changed, 162 insertions(+), 80 deletions(-) diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 3c92fa02f2040..385f1b9e79154 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -14,7 +14,6 @@ #![feature(collections)] #![feature(int_uint)] #![feature(io)] -#![feature(os)] #![feature(path)] #![feature(rustc_private)] #![feature(slicing_syntax, unboxed_closures)] @@ -48,8 +47,7 @@ pub mod common; pub mod errors; pub fn main() { - let args = env::args().map(|s| s.into_string().unwrap()).collect();; - let config = parse_config(args); + let config = parse_config(env::args().collect()); if config.valgrind_path.is_none() && config.force_valgrind { panic!("Can't find Valgrind to run Valgrind tests"); diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index 078eb7bba20a4..c046a89cba55f 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -40,7 +40,7 @@ pub fn make_new_path(path: &str) -> String { // Windows just uses PATH as the library search path, so we have to // maintain the current value while adding our own - match env::var_string(lib_path_env_var()) { + match env::var(lib_path_env_var()) { Ok(curr) => { format!("{}{}{}", path, path_div(), curr) } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 15f50188919b0..1fedf49738cdf 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -397,7 +397,7 @@ 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 env::var_string("RUST_LOG") { + let (mut directives, filter) = match env::var("RUST_LOG") { Ok(spec) => directive::parse_logging_spec(&spec[]), Err(..) => (Vec::new(), None), }; diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 1b2d82e68c19f..3caa0f5b4db4c 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -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 { - env::var_string("RUST_PATH").ok() + env::var("RUST_PATH").ok() } /// Returns the value of RUST_PATH, as a list diff --git a/src/librustc/middle/infer/region_inference/graphviz.rs b/src/librustc/middle/infer/region_inference/graphviz.rs index 362919755c35d..67875ae225224 100644 --- a/src/librustc/middle/infer/region_inference/graphviz.rs +++ b/src/librustc/middle/infer/region_inference/graphviz.rs @@ -61,13 +61,13 @@ pub fn maybe_print_constraints_for<'a, 'tcx>(region_vars: &RegionVarBindings<'a, } let requested_node : Option = - env::var_string("RUST_REGION_GRAPH_NODE").ok().and_then(|s| s.parse().ok()); + env::var("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 = env::var_string("RUST_REGION_GRAPH").ok(); + let requested_output = env::var("RUST_REGION_GRAPH").ok(); debug!("requested_output: {:?} requested_node: {:?}", requested_output, requested_node); diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 949fee45517e2..8340a49b92ae3 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1052,7 +1052,7 @@ pub fn get_unstable_features_setting() -> UnstableFeatures { // subverting the unstable features lints let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY"); // The matching key to the above, only known by the build system - let bootstrap_provided_key = env::var_string("RUSTC_BOOTSTRAP_KEY").ok(); + let bootstrap_provided_key = env::var("RUSTC_BOOTSTRAP_KEY").ok(); match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) { (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat, (true, _, _) => UnstableFeatures::Disallow, diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index afb5c948f1885..4d90c492fa240 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -384,7 +384,7 @@ impl Target { Path::new(target) }; - let target_path = env::var("RUST_TARGET_PATH") + let target_path = env::var_os("RUST_TARGET_PATH") .unwrap_or(OsString::from_str("")); // FIXME 16351: add a sane default search path? diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index d82c160fdee9b..12f5041cad14f 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -464,7 +464,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, // compiler, not for the target. let mut _old_path = OsString::from_str(""); if cfg!(windows) { - _old_path = env::var("PATH").unwrap_or(_old_path); + _old_path = env::var_os("PATH").unwrap_or(_old_path); let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths(); new_path.extend(env::split_paths(&_old_path)); env::set_var("PATH", &env::join_paths(new_path.iter()).unwrap()); @@ -737,7 +737,7 @@ pub fn phase_5_run_llvm_passes(sess: &Session, pub fn phase_6_link_output(sess: &Session, trans: &trans::CrateTranslation, outputs: &OutputFilenames) { - let old_path = env::var("PATH").unwrap_or(OsString::from_str("")); + let old_path = env::var_os("PATH").unwrap_or(OsString::from_str("")); let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths(); new_path.extend(env::split_paths(&old_path)); env::set_var("PATH", &env::join_paths(new_path.iter()).unwrap()); diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index ef6e84d3a7641..b087c0c2aa1c9 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -771,7 +771,7 @@ pub fn monitor(f: F) { // FIXME: Hacks on hacks. If the env is trying to override the stack size // then *don't* set it explicitly. - if env::var("RUST_MIN_STACK").is_none() { + if env::var_os("RUST_MIN_STACK").is_none() { cfg = cfg.stack_size(STACK_SIZE); } @@ -835,8 +835,7 @@ pub fn diagnostics_registry() -> diagnostics::registry::Registry { } pub fn main() { - let args = env::args().map(|s| s.into_string().unwrap()); - let result = run(args.collect()); + let result = run(env::args().collect()); std::env::set_exit_status(result as i32); } diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index e80564097df23..cdcd917ee5eb4 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -1551,7 +1551,7 @@ pub fn process_crate(sess: &Session, info!("Dumping crate {}", cratename); // find a path to dump our data to - let mut root_path = match env::var_string("DXR_RUST_TEMP_FOLDER") { + let mut root_path = match env::var("DXR_RUST_TEMP_FOLDER") { Ok(val) => Path::new(val), Err(..) => match odir { Some(val) => val.join("dxr"), diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 0253aaa31ca36..9d45caf76696a 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -122,10 +122,10 @@ struct Output { } pub fn main() { - static STACK_SIZE: uint = 32000000; // 32MB + const STACK_SIZE: usize = 32000000; // 32MB let res = std::thread::Builder::new().stack_size(STACK_SIZE).scoped(move || { - let s = env::args().map(|s| s.into_string().unwrap()); - main_args(&s.collect::>()) + let s = env::args().collect::>(); + main_args(&s) }).join(); env::set_exit_status(res.ok().unwrap() as i32); } diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index bee9a0d00337b..c5dd66630b420 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -101,7 +101,7 @@ impl DynamicLibrary { /// Returns the current search path for dynamic libraries being used by this /// process pub fn search_path() -> Vec { - match env::var(DynamicLibrary::envvar()) { + match env::var_os(DynamicLibrary::envvar()) { Some(var) => env::split_paths(&var).collect(), None => Vec::new(), } diff --git a/src/libstd/env.rs b/src/libstd/env.rs index e73797bc66c7f..ea18838211f26 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -71,17 +71,29 @@ static ENV_LOCK: StaticMutex = MUTEX_INIT; /// An iterator over a snapshot of the environment variables of this process. /// -/// This iterator is created through `std::env::vars()` and yields `(OsString, -/// OsString)` pairs. -pub struct Vars { inner: os_imp::Env } +/// This iterator is created through `std::env::vars()` and yields `(String, +/// String)` pairs. +pub struct Vars { inner: VarsOs } -/// Returns an iterator of (variable, value) pairs, for all the environment -/// variables of the current process. +/// An iterator over a snapshot of the environment variables of this process. +/// +/// This iterator is created through `std::env::vars_os()` and yields +/// `(OsString, OsString)` pairs. +pub struct VarsOs { inner: os_imp::Env } + +/// Returns an iterator of (variable, value) pairs of strings, for all the +/// environment variables of the current process. /// /// The returned iterator contains a snapshot of the process's environment /// variables at the time of this invocation, modifications to environment /// variables afterwards will not be reflected in the returned iterator. /// +/// # Panics +/// +/// While iterating, the returned iterator will panic if any key or value in the +/// environment is not valid unicode. If this is not desired, consider using the +/// `env::vars_os` function. +/// /// # Example /// /// ```rust @@ -90,37 +102,50 @@ pub struct Vars { inner: os_imp::Env } /// // We will iterate through the references to the element returned by /// // env::vars(); /// for (key, value) in env::vars() { -/// println!("{:?}: {:?}", key, value); +/// println!("{}: {}", key, value); /// } /// ``` pub fn vars() -> Vars { - let _g = ENV_LOCK.lock(); - Vars { inner: os_imp::env() } -} - -impl Iterator for Vars { - type Item = (OsString, OsString); - fn next(&mut self) -> Option<(OsString, OsString)> { self.inner.next() } - fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } + Vars { inner: vars_os() } } -/// Fetches the environment variable `key` from the current process, returning -/// None if the variable isn't set. +/// Returns an iterator of (variable, value) pairs of OS strings, for all the +/// environment variables of the current process. +/// +/// The returned iterator contains a snapshot of the process's environment +/// variables at the time of this invocation, modifications to environment +/// variables afterwards will not be reflected in the returned iterator. /// /// # Example /// /// ```rust /// use std::env; /// -/// let key = "HOME"; -/// match env::var(key) { -/// Some(val) => println!("{}: {:?}", key, val), -/// None => println!("{} is not defined in the environment.", key) +/// // We will iterate through the references to the element returned by +/// // env::vars_os(); +/// for (key, value) in env::vars_os() { +/// println!("{:?}: {:?}", key, value); /// } /// ``` -pub fn var(key: &K) -> Option where K: AsOsStr { +pub fn vars_os() -> VarsOs { let _g = ENV_LOCK.lock(); - os_imp::getenv(key.as_os_str()) + VarsOs { inner: os_imp::env() } +} + +impl Iterator for Vars { + type Item = (String, String); + fn next(&mut self) -> Option<(String, String)> { + self.inner.next().map(|(a, b)| { + (a.into_string().unwrap(), b.into_string().unwrap()) + }) + } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } +} + +impl Iterator for VarsOs { + type Item = (OsString, OsString); + fn next(&mut self) -> Option<(OsString, OsString)> { self.inner.next() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } /// Fetches the environment variable `key` from the current process. @@ -135,18 +160,37 @@ pub fn var(key: &K) -> Option where K: AsOsStr { /// use std::env; /// /// let key = "HOME"; -/// match env::var_string(key) { +/// match env::var(key) { /// Ok(val) => println!("{}: {:?}", key, val), /// Err(e) => println!("couldn't interpret {}: {}", key, e), /// } /// ``` -pub fn var_string(key: &K) -> Result where K: AsOsStr { - match var(key) { +pub fn var(key: &K) -> Result where K: AsOsStr { + match var_os(key) { Some(s) => s.into_string().map_err(VarError::NotUnicode), None => Err(VarError::NotPresent) } } +/// Fetches the environment variable `key` from the current process, returning +/// None if the variable isn't set. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// let key = "HOME"; +/// match env::var_os(key) { +/// Some(val) => println!("{}: {:?}", key, val), +/// None => println!("{} is not defined in the environment.", key) +/// } +/// ``` +pub fn var_os(key: &K) -> Option where K: AsOsStr { + let _g = ENV_LOCK.lock(); + os_imp::getenv(key.as_os_str()) +} + /// Possible errors from the `env::var` method. #[derive(Debug, PartialEq, Eq, Clone)] pub enum VarError { @@ -190,7 +234,7 @@ impl Error for VarError { /// /// let key = "KEY"; /// env::set_var(key, "VALUE"); -/// assert_eq!(env::var_string(key), Ok("VALUE".to_string())); +/// assert_eq!(env::var(key), Ok("VALUE".to_string())); /// ``` pub fn set_var(k: &K, v: &V) where K: AsOsStr, V: AsOsStr @@ -222,7 +266,7 @@ pub struct SplitPaths<'a> { inner: os_imp::SplitPaths<'a> } /// use std::env; /// /// let key = "PATH"; -/// match env::var(key) { +/// match env::var_os(key) { /// Some(paths) => { /// for path in env::split_paths(&paths) { /// println!("'{}'", path.display()); @@ -262,7 +306,7 @@ pub struct JoinPathsError { /// ```rust /// use std::env; /// -/// if let Some(path) = env::var("PATH") { +/// if let Some(path) = env::var_os("PATH") { /// let mut paths = env::split_paths(&path).collect::>(); /// paths.push(Path::new("/home/xyz/bin")); /// let new_path = env::join_paths(paths.iter()).unwrap(); @@ -376,11 +420,17 @@ pub fn get_exit_status() -> i32 { EXIT_STATUS.load(Ordering::SeqCst) as i32 } -/// An iterator over the arguments of a process, yielding an `OsString` value +/// An iterator over the arguments of a process, yielding an `String` value /// for each argument. /// /// This structure is created through the `std::env::args` method. -pub struct Args { inner: os_imp::Args } +pub struct Args { inner: ArgsOs } + +/// An iterator over the arguments of a process, yielding an `OsString` value +/// for each argument. +/// +/// This structure is created through the `std::env::args_os` method. +pub struct ArgsOs { inner: os_imp::Args } /// Returns the arguments which this program was started with (normally passed /// via the command line). @@ -389,6 +439,12 @@ pub struct Args { inner: os_imp::Args } /// set to arbitrary text, and it may not even exist, so this property should /// not be relied upon for security purposes. /// +/// # Panics +/// +/// The returned iterator will panic during iteration if any argument to the +/// process is not valid unicode. If this is not desired it is recommended to +/// use the `args_os` function instead. +/// /// # Example /// /// ```rust @@ -396,14 +452,43 @@ pub struct Args { inner: os_imp::Args } /// /// // Prints each argument on a separate line /// for argument in env::args() { -/// println!("{:?}", argument); +/// println!("{}", argument); /// } /// ``` pub fn args() -> Args { - Args { inner: os_imp::args() } + Args { inner: args_os() } +} + +/// Returns the arguments which this program was started with (normally passed +/// via the command line). +/// +/// The first element is traditionally the path to the executable, but it can be +/// set to arbitrary text, and it may not even exist, so this property should +/// not be relied upon for security purposes. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// // Prints each argument on a separate line +/// for argument in env::args_os() { +/// println!("{:?}", argument); +/// } +/// ``` +pub fn args_os() -> ArgsOs { + ArgsOs { inner: os_imp::args() } } impl Iterator for Args { + type Item = String; + fn next(&mut self) -> Option { + self.inner.next().map(|s| s.into_string().unwrap()) + } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } +} + +impl Iterator for ArgsOs { type Item = OsString; fn next(&mut self) -> Option { self.inner.next() } fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } @@ -706,7 +791,7 @@ mod tests { let n = format!("TEST{}", rng.gen_ascii_chars().take(10) .collect::()); let n = OsString::from_string(n); - assert!(var(&n).is_none()); + assert!(var_os(&n).is_none()); n } @@ -718,7 +803,7 @@ mod tests { fn test_set_var() { let n = make_rand_name(); set_var(&n, "VALUE"); - eq(var(&n), Some("VALUE")); + eq(var_os(&n), Some("VALUE")); } #[test] @@ -726,7 +811,7 @@ mod tests { let n = make_rand_name(); set_var(&n, "VALUE"); remove_var(&n); - eq(var(&n), None); + eq(var_os(&n), None); } #[test] @@ -734,9 +819,9 @@ mod tests { let n = make_rand_name(); set_var(&n, "1"); set_var(&n, "2"); - eq(var(&n), Some("2")); + eq(var_os(&n), Some("2")); set_var(&n, ""); - eq(var(&n), Some("")); + eq(var_os(&n), Some("")); } #[test] @@ -749,7 +834,7 @@ mod tests { } let n = make_rand_name(); set_var(&n, s.as_slice()); - eq(var(&n), Some(s.as_slice())); + eq(var_os(&n), Some(s.as_slice())); } #[test] @@ -767,22 +852,22 @@ mod tests { let n = make_rand_name(); let s = repeat("x").take(10000).collect::(); set_var(&n, &s); - eq(var(&n), Some(s.as_slice())); + eq(var_os(&n), Some(s.as_slice())); remove_var(&n); - eq(var(&n), None); + eq(var_os(&n), None); } #[test] fn test_env_set_var() { let n = make_rand_name(); - let mut e = vars(); + let mut e = vars_os(); set_var(&n, "VALUE"); assert!(!e.any(|(k, v)| { &*k == &*n && &*v == "VALUE" })); - assert!(vars().any(|(k, v)| { + assert!(vars_os().any(|(k, v)| { &*k == &*n && &*v == "VALUE" })); } diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 526b5edd4cbde..ca7183a97d433 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -125,7 +125,7 @@ pub fn getcwd() -> IoResult { #[deprecated(since = "1.0.0", reason = "use env::vars instead")] #[unstable(feature = "os")] pub fn env() -> Vec<(String,String)> { - env::vars().map(|(k, v)| { + env::vars_os().map(|(k, v)| { (k.to_string_lossy().into_owned(), v.to_string_lossy().into_owned()) }).collect() } @@ -135,7 +135,7 @@ pub fn env() -> Vec<(String,String)> { #[deprecated(since = "1.0.0", reason = "use env::vars instead")] #[unstable(feature = "os")] pub fn env_as_bytes() -> Vec<(Vec, Vec)> { - env::vars().map(|(k, v)| (byteify(k), byteify(v))).collect() + env::vars_os().map(|(k, v)| (byteify(k), byteify(v))).collect() } /// Fetches the environment variable `n` from the current process, returning @@ -159,10 +159,10 @@ pub fn env_as_bytes() -> Vec<(Vec, Vec)> { /// None => println!("{} is not defined in the environment.", key) /// } /// ``` -#[deprecated(since = "1.0.0", reason = "use env::var or env::var_string instead")] +#[deprecated(since = "1.0.0", reason = "use env::var or env::var_os instead")] #[unstable(feature = "os")] pub fn getenv(n: &str) -> Option { - env::var_string(n).ok() + env::var(n).ok() } /// Fetches the environment variable `n` byte vector from the current process, @@ -174,7 +174,7 @@ pub fn getenv(n: &str) -> Option { #[deprecated(since = "1.0.0", reason = "use env::var instead")] #[unstable(feature = "os")] pub fn getenv_as_bytes(n: &str) -> Option> { - env::var(n).map(byteify) + env::var_os(n).map(byteify) } #[cfg(unix)] diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index 2af5a486d0d78..ced84d7551eef 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -29,7 +29,7 @@ pub fn log_enabled() -> bool { _ => {} } - let val = match env::var("RUST_BACKTRACE") { + let val = match env::var_os("RUST_BACKTRACE") { Some(..) => 2, None => 1, }; diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index 703dca4d29bf9..bb57d19ed2666 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -52,7 +52,7 @@ pub fn min_stack() -> uint { 0 => {} n => return n - 1, } - let amt = env::var_string("RUST_MIN_STACK").ok().and_then(|s| s.parse().ok()); + let amt = env::var("RUST_MIN_STACK").ok().and_then(|s| s.parse().ok()); let amt = amt.unwrap_or(2 * 1024 * 1024); // 0 is our sentinel value, so ensure that we'll never see 0 after // initialization has run @@ -63,7 +63,7 @@ pub fn min_stack() -> uint { /// Get's the number of scheduler threads requested by the environment /// either `RUST_THREADS` or `num_cpus`. pub fn default_sched_threads() -> uint { - match env::var_string("RUST_THREADS") { + match env::var("RUST_THREADS") { Ok(nstr) => { let opt_n: Option = nstr.parse().ok(); match opt_n { diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index ef9d379987932..5d56707c87a47 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -30,7 +30,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT Some(v) => v }; - let e = match env::var_string(&var[]) { + let e = match env::var(&var[]) { Err(..) => { cx.expr_path(cx.path_all(sp, true, @@ -101,7 +101,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) } } - let e = match env::var_string(&var[]) { + let e = match env::var(&var[]) { Err(_) => { cx.span_err(sp, &msg); cx.expr_usize(sp, 0) diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs index 0a1439ebee0f1..758191a6e1107 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -172,7 +172,7 @@ impl TerminfoTerminal { /// Returns `None` whenever the terminal cannot be created for some /// reason. pub fn new(out: T) -> Option+Send+'static>> { - let term = match env::var_string("TERM") { + let term = match env::var("TERM") { Ok(t) => t, Err(..) => { debug!("TERM environment variable not defined"); @@ -182,7 +182,7 @@ impl TerminfoTerminal { let entry = open(&term[]); if entry.is_err() { - if env::var_string("MSYSCON").ok().map_or(false, |s| { + if env::var("MSYSCON").ok().map_or(false, |s| { "mintty.exe" == s }) { // msys terminal diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs index 6ee477fc80823..fd6e6a843e1f3 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -28,14 +28,14 @@ pub fn get_dbpath_for_term(term: &str) -> Option> { let first_char = term.char_at(0); // Find search directory - match env::var_string("TERMINFO") { + match env::var("TERMINFO") { Ok(dir) => dirs_to_search.push(Path::new(dir)), Err(..) => { if homedir.is_some() { // ncurses compatibility; dirs_to_search.push(homedir.unwrap().join(".terminfo")) } - match env::var_string("TERMINFO_DIRS") { + match env::var("TERMINFO_DIRS") { Ok(dirs) => for i in dirs.split(':') { if i == "" { dirs_to_search.push(Path::new("/usr/share/terminfo")); diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index f3edd90b4fa5b..e7a70ed0d6960 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -385,7 +385,7 @@ pub fn parse_opts(args: &[String]) -> Option { let mut nocapture = matches.opt_present("nocapture"); if !nocapture { - nocapture = env::var("RUST_TEST_NOCAPTURE").is_some(); + nocapture = env::var("RUST_TEST_NOCAPTURE").is_ok(); } let color = match matches.opt_str("color").as_ref().map(|s| &**s) { @@ -811,7 +811,7 @@ fn run_tests(opts: &TestOpts, fn get_concurrency() -> uint { use std::rt; - match env::var_string("RUST_TEST_TASKS") { + match env::var("RUST_TEST_TASKS") { Ok(s) => { let opt_n: Option = s.parse().ok(); match opt_n { diff --git a/src/test/run-pass/env-vars.rs b/src/test/run-pass/env-vars.rs index 892041b964889..659e5b3a8c2f8 100644 --- a/src/test/run-pass/env-vars.rs +++ b/src/test/run-pass/env-vars.rs @@ -11,8 +11,8 @@ use std::env::*; fn main() { - for (k, v) in vars() { - let v2 = var(&k); + for (k, v) in vars_os() { + let v2 = var_os(&k); // MingW seems to set some funky environment variables like // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned // from vars() but not visible from var().