From fcb30a0b67b1bd4acbc3422ff74fac5d031ae1ae Mon Sep 17 00:00:00 2001 From: Sébastien Marie Date: Thu, 29 Jan 2015 08:19:28 +0100 Subject: openbsd support --- src/libstd/rt/args.rs | 5 +++-- src/libstd/rt/libunwind.rs | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'src/libstd/rt') diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index b63f2e2d73a..b3bed4af962 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -1,4 +1,4 @@ -// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -42,7 +42,8 @@ pub fn clone() -> Option>> { imp::clone() } #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd", - target_os = "dragonfly"))] + target_os = "dragonfly", + target_os = "openbsd"))] mod imp { use prelude::v1::*; diff --git a/src/libstd/rt/libunwind.rs b/src/libstd/rt/libunwind.rs index dd9923307d6..43e3a43f56d 100644 --- a/src/libstd/rt/libunwind.rs +++ b/src/libstd/rt/libunwind.rs @@ -101,7 +101,7 @@ pub type _Unwind_Exception_Cleanup_Fn = #[link(name = "gcc_s")] extern {} -#[cfg(target_os = "android")] +#[cfg(any(target_os = "android", target_os = "openbsd"))] #[link(name = "gcc")] extern {} -- cgit 1.4.1-3-g733a5 From 70ed3a48dfa301c5bb56de3e0a7c25214539b83c Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 27 Jan 2015 12:20:58 -0800 Subject: std: Add a new `env` module This is an implementation of [RFC 578][rfc] which adds a new `std::env` module to replace most of the functionality in the current `std::os` module. More details can be found in the RFC itself, but as a summary the following methods have all been deprecated: [rfc]: https://github.com/rust-lang/rfcs/pull/578 * `os::args_as_bytes` => `env::args` * `os::args` => `env::args` * `os::consts` => `env::consts` * `os::dll_filename` => no replacement, use `env::consts` directly * `os::page_size` => `env::page_size` * `os::make_absolute` => use `env::current_dir` + `join` instead * `os::getcwd` => `env::current_dir` * `os::change_dir` => `env::set_current_dir` * `os::homedir` => `env::home_dir` * `os::tmpdir` => `env::temp_dir` * `os::join_paths` => `env::join_paths` * `os::split_paths` => `env::split_paths` * `os::self_exe_name` => `env::current_exe` * `os::self_exe_path` => use `env::current_exe` + `pop` * `os::set_exit_status` => `env::set_exit_status` * `os::get_exit_status` => `env::get_exit_status` * `os::env` => `env::vars` * `os::env_as_bytes` => `env::vars` * `os::getenv` => `env::var` or `env::var_string` * `os::getenv_as_bytes` => `env::var` * `os::setenv` => `env::set_var` * `os::unsetenv` => `env::remove_var` Many function signatures have also been tweaked for various purposes, but the main changes were: * `Vec`-returning APIs now all return iterators instead * All APIs are now centered around `OsString` instead of `Vec` or `String`. There is currently on convenience API, `env::var_string`, which can be used to get the value of an environment variable as a unicode `String`. All old APIs are `#[deprecated]` in-place and will remain for some time to allow for migrations. The semantics of the APIs have been tweaked slightly with regard to dealing with invalid unicode (panic instead of replacement). The new `std::env` module is all contained within the `env` feature, so crates must add the following to access the new APIs: #![feature(env)] [breaking-change] --- src/compiletest/compiletest.rs | 11 +- src/compiletest/runtest.rs | 6 +- src/etc/make-win-dist.py | 1 + src/liblog/lib.rs | 10 +- src/librustc/lib.rs | 2 +- src/librustc/metadata/filesearch.rs | 10 +- .../middle/infer/region_inference/graphviz.rs | 6 +- src/librustc/plugin/load.rs | 4 +- src/librustc/session/mod.rs | 6 +- src/librustc_back/archive.rs | 6 +- src/librustc_back/fs.rs | 4 +- src/librustc_back/lib.rs | 1 + src/librustc_back/rpath.rs | 11 +- src/librustc_back/target/mod.rs | 9 +- src/librustc_driver/driver.rs | 23 +- src/librustc_driver/lib.rs | 13 +- src/librustc_trans/lib.rs | 2 +- src/librustc_trans/save/mod.rs | 8 +- src/librustdoc/lib.rs | 7 +- src/librustdoc/test.rs | 6 +- src/libstd/dynamic_lib.rs | 20 +- src/libstd/env.rs | 833 +++++++++++++++++++++ src/libstd/ffi/mod.rs | 7 +- src/libstd/ffi/os_str.rs | 86 ++- src/libstd/lib.rs | 1 + src/libstd/old_io/process.rs | 1 + src/libstd/old_io/tempfile.rs | 12 +- src/libstd/old_io/test.rs | 6 +- src/libstd/os.rs | 247 +++--- src/libstd/rt/backtrace.rs | 4 +- src/libstd/rt/mod.rs | 4 +- src/libstd/rt/util.rs | 9 +- src/libstd/sys/common/mutex.rs | 7 - src/libstd/sys/common/rwlock.rs | 7 - src/libstd/sys/unix/backtrace.rs | 4 +- src/libstd/sys/unix/c.rs | 53 ++ src/libstd/sys/unix/mod.rs | 4 +- src/libstd/sys/unix/os.rs | 440 ++++++++--- src/libstd/sys/unix/process.rs | 14 +- src/libstd/sys/windows/backtrace.rs | 34 +- src/libstd/sys/windows/c.rs | 190 ++++- src/libstd/sys/windows/fs.rs | 20 +- src/libstd/sys/windows/handle.rs | 31 + src/libstd/sys/windows/mod.rs | 111 ++- src/libstd/sys/windows/mutex.rs | 2 - src/libstd/sys/windows/os.rs | 453 ++++++----- src/libstd/sys/windows/pipe.rs | 18 +- src/libstd/sys/windows/process.rs | 24 +- src/libstd/sys/windows/rwlock.rs | 3 - src/libstd/sys/windows/stack_overflow.rs | 10 +- src/libstd/sys/windows/sync.rs | 2 +- src/libstd/sys/windows/tcp.rs | 9 +- src/libstd/sys/windows/thread.rs | 2 - src/libstd/sys/windows/thread_local.rs | 1 + src/libstd/sys/windows/timer.rs | 2 - src/libstd/sys/windows/tty.rs | 5 +- src/libsyntax/ext/env.rs | 14 +- src/libsyntax/lib.rs | 2 +- src/libterm/lib.rs | 3 +- src/libterm/terminfo/mod.rs | 10 +- src/libterm/terminfo/searcher.rs | 17 +- src/libtest/lib.rs | 12 +- src/test/bench/shootout-mandelbrot.rs | 7 +- src/test/compile-fail/liveness-unused.rs | 3 +- src/test/run-pass/env-home-dir.rs | 45 ++ src/test/run-pass/env-vars.rs | 22 + 66 files changed, 2175 insertions(+), 782 deletions(-) create mode 100644 src/libstd/env.rs create mode 100644 src/libstd/sys/windows/handle.rs create mode 100644 src/test/run-pass/env-home-dir.rs create mode 100644 src/test/run-pass/env-vars.rs (limited to 'src/libstd/rt') diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index b73623223fd..7c0ee7be8a4 100644 --- a/src/compiletest/compiletest.rs +++ b/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,7 +225,7 @@ 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 { @@ -232,7 +233,7 @@ pub fn run_tests(config: &Config) { // 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) => {} diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 18cb3d1d5b0..5b0ea3b4854 100644 --- a/src/compiletest/runtest.rs +++ b/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 diff --git a/src/etc/make-win-dist.py b/src/etc/make-win-dist.py index 13d05135024..defda27acc9 100644 --- a/src/etc/make-win-dist.py +++ b/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", diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 81d8c60f893..34216518c21 100644 --- a/src/liblog/lib.rs +++ b/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 diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 6ae861fcb04..2f31a2c083f 100644 --- a/src/librustc/lib.rs +++ b/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)] diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 26046cfb43d..45dd4b4dbac 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/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 { - 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 { } 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 { } 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() { diff --git a/src/librustc/middle/infer/region_inference/graphviz.rs b/src/librustc/middle/infer/region_inference/graphviz.rs index 460687629e7..87ea5436dab 100644 --- a/src/librustc/middle/infer/region_inference/graphviz.rs +++ b/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 = - 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); diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs index c420d1f15b4..c04bf755b1f 100644 --- a/src/librustc/plugin/load.rs +++ b/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, diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index e62f3145e5a..a983f995d3f 100644 --- a/src/librustc/session/mod.rs +++ b/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()), diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index ee8bc71668b..f5483e666cf 100644 --- a/src/librustc_back/archive.rs +++ b/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]); diff --git a/src/librustc_back/fs.rs b/src/librustc_back/fs.rs index 24f81b02478..acf49d1ca46 100644 --- a/src/librustc_back/fs.rs +++ b/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 { 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) { diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index 2c6b5797f57..54b3e8f2081 100644 --- a/src/librustc_back/lib.rs +++ b/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; diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index 47b909df5e8..b6a34b4beba 100644 --- a/src/librustc_back/rpath.rs +++ b/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,8 +105,6 @@ fn get_rpath_relative_to_output(config: &mut RPathConfig, lib: &Path F: FnOnce() -> Path, G: FnMut(&Path) -> Result, { - use std::os; - // Mac doesn't appear to support $ORIGIN let prefix = if config.is_like_osx { "@loader_path" @@ -114,9 +112,10 @@ fn get_rpath_relative_to_output(config: &mut RPathConfig, lib: &Path "$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(config: RPathConfig) -> String where G: FnMut(&Path) -> Result, { 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() } diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index 16adccfba57..eb7c23f95e2 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -301,7 +301,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 { - use std::os; + use std::env; + use std::ffi::OsString; use std::old_io::File; use std::path::Path; use serialize::json; @@ -379,12 +380,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); diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 9e00844b7ee..4aa4193d511 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -30,9 +30,10 @@ use rustc_privacy; use serialize::json; -use std::old_io; +use std::env; +use std::ffi::OsString; use std::old_io::fs; -use std::os; +use std::old_io; use syntax::ast; use syntax::ast_map; use syntax::attr; @@ -460,12 +461,12 @@ pub fn phase_2_configure_and_expand(sess: &Session, // dependent dlls. Note that this uses cfg!(windows) as opposed to // targ_cfg because syntax extensions are always loaded for the host // compiler, not for the target. - let mut _old_path = String::new(); + let mut _old_path = OsString::from_str(""); if cfg!(windows) { - _old_path = os::getenv("PATH").unwrap_or(_old_path); + _old_path = env::var("PATH").unwrap_or(_old_path); let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths(); - new_path.extend(os::split_paths(&_old_path[]).into_iter()); - os::setenv("PATH", os::join_paths(&new_path[]).unwrap()); + new_path.extend(env::split_paths(&_old_path)); + env::set_var("PATH", &env::join_paths(new_path.iter()).unwrap()); } let cfg = syntax::ext::expand::ExpansionConfig { crate_name: crate_name.to_string(), @@ -478,7 +479,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, syntax_exts, krate); if cfg!(windows) { - os::setenv("PATH", _old_path); + env::set_var("PATH", &_old_path); } ret } @@ -734,10 +735,10 @@ 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 = os::getenv("PATH").unwrap_or_else(||String::new()); + let old_path = env::var("PATH").unwrap_or(OsString::from_str("")); let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths(); - new_path.extend(os::split_paths(&old_path[]).into_iter()); - os::setenv("PATH", os::join_paths(&new_path[]).unwrap()); + new_path.extend(env::split_paths(&old_path)); + env::set_var("PATH", &env::join_paths(new_path.iter()).unwrap()); time(sess.time_passes(), "linking", (), |_| link::link_binary(sess, @@ -745,7 +746,7 @@ pub fn phase_6_link_output(sess: &Session, outputs, &trans.link.crate_name[])); - os::setenv("PATH", old_path); + env::set_var("PATH", &old_path); } fn escape_dep_filename(filename: &str) -> String { diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 2eada1ff174..6230f0b14a2 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -26,6 +26,7 @@ #![feature(box_syntax)] #![feature(collections)] #![feature(core)] +#![feature(env)] #![feature(int_uint)] #![feature(io)] #![feature(libc)] @@ -74,7 +75,7 @@ use rustc::util::common::time; use std::cmp::Ordering::Equal; use std::old_io; use std::iter::repeat; -use std::os; +use std::env; use std::sync::mpsc::channel; use std::thread; @@ -252,7 +253,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 = os::getenv("RUSTC_BOOTSTRAP_KEY"); + let bootstrap_provided_key = env::var_string("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, @@ -618,7 +619,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 os::getenv("RUST_MIN_STACK").is_none() { + if env::var("RUST_MIN_STACK").is_none() { cfg = cfg.stack_size(STACK_SIZE); } @@ -682,8 +683,8 @@ pub fn diagnostics_registry() -> diagnostics::registry::Registry { } pub fn main() { - let args = std::os::args(); - let result = run(args); - std::os::set_exit_status(result); + let args = env::args().map(|s| s.into_string().unwrap()); + let result = run(args.collect()); + std::env::set_exit_status(result as i32); } diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index c46c2b7e6dd..11ffade6da6 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -32,8 +32,8 @@ #![feature(hash)] #![feature(int_uint)] #![feature(io)] +#![feature(env)] #![feature(libc)] -#![feature(os)] #![feature(path)] #![feature(quote)] #![feature(rustc_diagnostic_macros)] diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index fbeaae1d1df..f429ab7599f 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -34,7 +34,7 @@ use middle::ty::{self, Ty}; use std::cell::Cell; use std::old_io::{self, File, fs}; -use std::os; +use std::env; use syntax::ast_util::{self, PostExpansionMethod}; use syntax::ast::{self, NodeId, DefId}; @@ -1551,9 +1551,9 @@ pub fn process_crate(sess: &Session, info!("Dumping crate {}", cratename); // find a path to dump our data to - let mut root_path = match os::getenv("DXR_RUST_TEMP_FOLDER") { - Some(val) => Path::new(val), - None => match odir { + let mut root_path = match env::var_string("DXR_RUST_TEMP_FOLDER") { + Ok(val) => Path::new(val), + Err(..) => match odir { Some(val) => val.join("dxr"), None => Path::new("dxr-temp"), }, diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 29e52d627cd..c9b50bdd3c1 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -21,6 +21,7 @@ #![feature(box_syntax)] #![feature(collections)] #![feature(core)] +#![feature(env)] #![feature(hash)] #![feature(int_uint)] #![feature(io)] @@ -50,6 +51,7 @@ extern crate "serialize" as rustc_serialize; // used by deriving use std::cell::RefCell; use std::collections::HashMap; +use std::env; use std::old_io::File; use std::old_io; use std::rc::Rc; @@ -121,9 +123,10 @@ struct Output { pub fn main() { static STACK_SIZE: uint = 32000000; // 32MB let res = std::thread::Builder::new().stack_size(STACK_SIZE).scoped(move || { - main_args(std::os::args().as_slice()) + let s = env::args().map(|s| s.into_string().unwrap()); + main_args(&s.collect::>()) }).join(); - std::os::set_exit_status(res.ok().unwrap()); + env::set_exit_status(res.ok().unwrap() as i32); } pub fn opts() -> Vec { diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 2f692fe99cd..29abea009e5 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -13,7 +13,7 @@ use std::sync::mpsc::channel; use std::dynamic_lib::DynamicLibrary; use std::old_io::{Command, TempDir}; use std::old_io; -use std::os; +use std::env; use std::str; use std::thread::Thread; use std::thunk::Thunk; @@ -49,7 +49,7 @@ pub fn run(input: &str, let input = config::Input::File(input_path.clone()); let sessopts = config::Options { - maybe_sysroot: Some(os::self_exe_path().unwrap().dir_path()), + maybe_sysroot: Some(env::current_exe().unwrap().dir_path().dir_path()), search_paths: libs.clone(), crate_types: vec!(config::CrateTypeDylib), externs: externs.clone(), @@ -119,7 +119,7 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths, let input = config::Input::Str(test.to_string()); let sessopts = config::Options { - maybe_sysroot: Some(os::self_exe_path().unwrap().dir_path()), + maybe_sysroot: Some(env::current_exe().unwrap().dir_path().dir_path()), search_paths: libs, crate_types: vec!(config::CrateTypeExecutable), output_types: vec!(config::OutputTypeExe), diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index f35f63143ef..46567aedbec 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -19,7 +19,7 @@ use prelude::v1::*; use ffi::CString; use mem; -use os; +use env; use str; #[allow(missing_copy_implementations)] @@ -68,8 +68,8 @@ impl DynamicLibrary { let mut search_path = DynamicLibrary::search_path(); search_path.insert(0, path.clone()); let newval = DynamicLibrary::create_path(search_path.as_slice()); - os::setenv(DynamicLibrary::envvar(), - str::from_utf8(newval.as_slice()).unwrap()); + env::set_var(DynamicLibrary::envvar(), + str::from_utf8(newval.as_slice()).unwrap()); } /// From a slice of paths, create a new vector which is suitable to be an @@ -102,18 +102,10 @@ impl DynamicLibrary { /// Returns the current search path for dynamic libraries being used by this /// process pub fn search_path() -> Vec { - let mut ret = Vec::new(); - match os::getenv_as_bytes(DynamicLibrary::envvar()) { - Some(env) => { - for portion in - env.as_slice() - .split(|a| *a == DynamicLibrary::separator()) { - ret.push(Path::new(portion)); - } - } - None => {} + match env::var(DynamicLibrary::envvar()) { + Some(var) => env::split_paths(&var).collect(), + None => Vec::new(), } - return ret; } /// Access the value at the symbol of the dynamic library diff --git a/src/libstd/env.rs b/src/libstd/env.rs new file mode 100644 index 00000000000..5070f8c547a --- /dev/null +++ b/src/libstd/env.rs @@ -0,0 +1,833 @@ +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Inspection and manipulation of the process's environment. +//! +//! This module contains methods to inspect various aspects such as +//! environment varibles, process arguments, the current directory, and various +//! other important directories. + +#![unstable(feature = "env", reason = "recently added via RFC 578")] + +use prelude::v1::*; + +use error::Error; +use ffi::{OsString, AsOsStr}; +use fmt; +use old_io::IoResult; +use sync::atomic::{AtomicIsize, ATOMIC_ISIZE_INIT, Ordering}; +use sync::{StaticMutex, MUTEX_INIT}; +use sys::os as os_imp; + +/// Returns the current working directory as a `Path`. +/// +/// # Errors +/// +/// Returns an `Err` if the current working directory value is invalid. +/// Possible cases: +/// +/// * Current directory does not exist. +/// * There are insufficient permissions to access the current directory. +/// * The internal buffer is not large enough to hold the path. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// // We assume that we are in a valid directory. +/// let p = env::current_dir().unwrap(); +/// println!("The current directory is {}", p.display()); +/// ``` +pub fn current_dir() -> IoResult { + os_imp::getcwd() +} + +/// Changes the current working directory to the specified path, returning +/// whether the change was completed successfully or not. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// use std::path::Path; +/// +/// let root = Path::new("/"); +/// assert!(env::set_current_dir(&root).is_ok()); +/// println!("Successfully changed working directory to {}!", root.display()); +/// ``` +pub fn set_current_dir(p: &Path) -> IoResult<()> { + os_imp::chdir(p) +} + +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 } + +/// Returns an iterator of (variable, value) pairs, 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; +/// +/// // We will iterate through the references to the element returned by +/// // env::vars(); +/// for (key, value) in env::vars() { +/// 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() } +} + +/// 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(key) { +/// Some(val) => println!("{}: {:?}", key, val), +/// None => println!("{} is not defined in the environment.", key) +/// } +/// ``` +pub fn var(key: &K) -> Option where K: AsOsStr { + let _g = ENV_LOCK.lock(); + os_imp::getenv(key.as_os_str()) +} + +/// Fetches the environment variable `key` from the current process. +/// +/// The returned result is `Ok(s)` if the environment variable is present and is +/// valid unicode. If the environment variable is not present, or it is not +/// valid unicode, then `Err` will be returned. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// let key = "HOME"; +/// match env::var_string(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) { + Some(s) => s.into_string().map_err(VarError::NotUnicode), + None => Err(VarError::NotPresent) + } +} + +/// Possible errors from the `env::var` method. +#[derive(Debug, PartialEq, Eq, Clone)] +pub enum VarError { + /// The specified environment variable was not present in the current + /// process's environment. + NotPresent, + + /// The specified environment variable was found, but it did not contain + /// valid unicode data. The found data is returned as a payload of this + /// variant. + NotUnicode(OsString), +} + +impl fmt::Display for VarError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + VarError::NotPresent => write!(f, "environment variable not found"), + VarError::NotUnicode(ref s) => { + write!(f, "environment variable was not valid unicode: {:?}", s) + } + } + } +} + +impl Error for VarError { + fn description(&self) -> &str { + match *self { + VarError::NotPresent => "environment variable not found", + VarError::NotUnicode(..) => "environment variable was not valid unicode", + } + } +} + +/// Sets the environment variable `k` to the value `v` for the currently running +/// process. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// let key = "KEY"; +/// env::set_var(key, "VALUE"); +/// assert_eq!(env::var_string(key), Ok("VALUE".to_string())); +/// ``` +pub fn set_var(k: &K, v: &V) + where K: AsOsStr, V: AsOsStr +{ + let _g = ENV_LOCK.lock(); + os_imp::setenv(k.as_os_str(), v.as_os_str()) +} + +/// Remove a variable from the environment entirely. +pub fn remove_var(k: &K) where K: AsOsStr { + let _g = ENV_LOCK.lock(); + os_imp::unsetenv(k.as_os_str()) +} + +/// An iterator over `Path` instances for parsing an environment variable +/// according to platform-specific conventions. +/// +/// This structure is returned from `std::env::split_paths`. +pub struct SplitPaths<'a> { inner: os_imp::SplitPaths<'a> } + +/// Parses input according to platform conventions for the `PATH` +/// environment variable. +/// +/// Returns an iterator over the paths contained in `unparsed`. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// let key = "PATH"; +/// match env::var(key) { +/// Some(paths) => { +/// for path in env::split_paths(&paths) { +/// println!("'{}'", path.display()); +/// } +/// } +/// None => println!("{} is not defined in the environment.", key) +/// } +/// ``` +pub fn split_paths(unparsed: &T) -> SplitPaths { + SplitPaths { inner: os_imp::split_paths(unparsed.as_os_str()) } +} + +impl<'a> Iterator for SplitPaths<'a> { + type Item = Path; + fn next(&mut self) -> Option { self.inner.next() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } +} + +/// Error type returned from `std::env::join_paths` when paths fail to be +/// joined. +#[derive(Debug)] +pub struct JoinPathsError { + inner: os_imp::JoinPathsError +} + +/// Joins a collection of `Path`s appropriately for the `PATH` +/// environment variable. +/// +/// Returns an `OsString` on success. +/// +/// Returns an `Err` (containing an error message) if one of the input +/// `Path`s contains an invalid character for constructing the `PATH` +/// variable (a double quote on Windows or a colon on Unix). +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// if let Some(path) = env::var("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(); +/// env::set_var("PATH", &new_path); +/// } +/// ``` +pub fn join_paths(paths: I) -> Result + where I: Iterator, T: AsOsStr +{ + os_imp::join_paths(paths).map_err(|e| { + JoinPathsError { inner: e } + }) +} + +impl fmt::Display for JoinPathsError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.inner.fmt(f) + } +} + +impl Error for JoinPathsError { + fn description(&self) -> &str { self.inner.description() } +} + +/// Optionally returns the path to the current user's home directory if known. +/// +/// # Unix +/// +/// Returns the value of the 'HOME' environment variable if it is set +/// and not equal to the empty string. +/// +/// # Windows +/// +/// Returns the value of the 'HOME' environment variable if it is +/// set and not equal to the empty string. Otherwise, returns the value of the +/// 'USERPROFILE' environment variable if it is set and not equal to the empty +/// string. +/// +/// # Example +/// +/// ```rust +/// use std::env; +/// +/// match env::home_dir() { +/// Some(ref p) => println!("{}", p.display()), +/// None => println!("Impossible to get your home dir!") +/// } +/// ``` +pub fn home_dir() -> Option { + os_imp::home_dir() +} + +/// Returns the path to a temporary directory. +/// +/// On Unix, returns the value of the 'TMPDIR' environment variable if it is +/// set, otherwise for non-Android it returns '/tmp'. If Android, since there +/// is no global temporary folder (it is usually allocated per-app), we return +/// '/data/local/tmp'. +/// +/// On Windows, returns the value of, in order, the 'TMP', 'TEMP', +/// 'USERPROFILE' environment variable if any are set and not the empty +/// string. Otherwise, tmpdir returns the path to the Windows directory. +pub fn temp_dir() -> Path { + os_imp::temp_dir() +} + +/// Optionally returns the filesystem path to the current executable which is +/// running but with the executable name. +/// +/// The path returned is not necessarily a "real path" to the executable as +/// there may be intermediate symlinks. +/// +/// # Errors +/// +/// Acquring the path to the current executable is a platform-specific operation +/// that can fail for a good number of reasons. Some errors can include, but not +/// be limited to filesystem operations failing or general syscall failures. +/// +/// # Examples +/// +/// ```rust +/// use std::env; +/// +/// match env::current_exe() { +/// Ok(exe_path) => println!("Path of this executable is: {}", +/// exe_path.display()), +/// Err(e) => println!("failed to get current exe path: {}", e), +/// }; +/// ``` +pub fn current_exe() -> IoResult { + os_imp::current_exe() +} + +static EXIT_STATUS: AtomicIsize = ATOMIC_ISIZE_INIT; + +/// Sets the process exit code +/// +/// Sets the exit code returned by the process if all supervised tasks +/// terminate successfully (without panicking). If the current root task panics +/// and is supervised by the scheduler then any user-specified exit status is +/// ignored and the process exits with the default panic status. +/// +/// Note that this is not synchronized against modifications of other threads. +pub fn set_exit_status(code: i32) { + EXIT_STATUS.store(code as isize, Ordering::SeqCst) +} + +/// Fetches the process's current exit code. This defaults to 0 and can change +/// by calling `set_exit_status`. +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 +/// for each argument. +/// +/// This structure is created through the `std::env::args` method. +pub struct Args { inner: os_imp::Args } + +/// 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() { +/// println!("{:?}", argument); +/// } +/// ``` +pub fn args() -> Args { + Args { inner: os_imp::args() } +} + +impl Iterator for Args { + type Item = OsString; + fn next(&mut self) -> Option { self.inner.next() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } +} + +/// Returns the page size of the current architecture in bytes. +pub fn page_size() -> usize { + os_imp::page_size() +} + +/// Constants associated with the current target +#[cfg(target_os = "linux")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `linux`. + pub const OS: &'static str = "linux"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, `lib`. + pub const DLL_PREFIX: &'static str = "lib"; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.so`. + pub const DLL_SUFFIX: &'static str = ".so"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `so`. + pub const DLL_EXTENSION: &'static str = "so"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + +/// Constants associated with the current target +#[cfg(target_os = "macos")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `macos`. + pub const OS: &'static str = "macos"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, `lib`. + pub const DLL_PREFIX: &'static str = "lib"; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.dylib`. + pub const DLL_SUFFIX: &'static str = ".dylib"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `dylib`. + pub const DLL_EXTENSION: &'static str = "dylib"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + +/// Constants associated with the current target +#[cfg(target_os = "ios")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `ios`. + pub const OS: &'static str = "ios"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + +/// Constants associated with the current target +#[cfg(target_os = "freebsd")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `freebsd`. + pub const OS: &'static str = "freebsd"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, `lib`. + pub const DLL_PREFIX: &'static str = "lib"; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.so`. + pub const DLL_SUFFIX: &'static str = ".so"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `so`. + pub const DLL_EXTENSION: &'static str = "so"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + +/// Constants associated with the current target +#[cfg(target_os = "dragonfly")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `dragonfly`. + pub const OS: &'static str = "dragonfly"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, `lib`. + pub const DLL_PREFIX: &'static str = "lib"; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.so`. + pub const DLL_SUFFIX: &'static str = ".so"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `so`. + pub const DLL_EXTENSION: &'static str = "so"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + +/// Constants associated with the current target +#[cfg(target_os = "android")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `android`. + pub const OS: &'static str = "android"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, `lib`. + pub const DLL_PREFIX: &'static str = "lib"; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.so`. + pub const DLL_SUFFIX: &'static str = ".so"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `so`. + pub const DLL_EXTENSION: &'static str = "so"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + +/// Constants associated with the current target +#[cfg(target_os = "windows")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "windows"; + + /// A string describing the specific operating system in use: in this + /// case, `windows`. + pub const OS: &'static str = "windows"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, the empty string. + pub const DLL_PREFIX: &'static str = ""; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.dll`. + pub const DLL_SUFFIX: &'static str = ".dll"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `dll`. + pub const DLL_EXTENSION: &'static str = "dll"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, `.exe`. + pub const EXE_SUFFIX: &'static str = ".exe"; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, `exe`. + pub const EXE_EXTENSION: &'static str = "exe"; +} + +#[cfg(target_arch = "x86")] +mod arch_consts { + pub const ARCH: &'static str = "x86"; +} + +#[cfg(target_arch = "x86_64")] +mod arch_consts { + pub const ARCH: &'static str = "x86_64"; +} + +#[cfg(target_arch = "arm")] +mod arch_consts { + pub const ARCH: &'static str = "arm"; +} + +#[cfg(target_arch = "aarch64")] +mod arch_consts { + pub const ARCH: &'static str = "aarch64"; +} + +#[cfg(target_arch = "mips")] +mod arch_consts { + pub const ARCH: &'static str = "mips"; +} + +#[cfg(target_arch = "mipsel")] +mod arch_consts { + pub const ARCH: &'static str = "mipsel"; +} + +#[cfg(target_arch = "powerpc")] +mod arch_consts { + pub const ARCH: &'static str = "powerpc"; +} + +#[cfg(test)] +mod tests { + use prelude::v1::*; + use super::*; + use iter::repeat; + use rand::{self, Rng}; + use ffi::{OsString, OsStr}; + + fn make_rand_name() -> OsString { + let mut rng = rand::thread_rng(); + let n = format!("TEST{}", rng.gen_ascii_chars().take(10) + .collect::()); + let n = OsString::from_string(n); + assert!(var(&n).is_none()); + n + } + + fn eq(a: Option, b: Option<&str>) { + assert_eq!(a.as_ref().map(|s| &**s), b.map(OsStr::from_str).map(|s| &*s)); + } + + #[test] + fn test_set_var() { + let n = make_rand_name(); + set_var(&n, "VALUE"); + eq(var(&n), Some("VALUE")); + } + + #[test] + fn test_remove_var() { + let n = make_rand_name(); + set_var(&n, "VALUE"); + remove_var(&n); + eq(var(&n), None); + } + + #[test] + fn test_set_var_overwrite() { + let n = make_rand_name(); + set_var(&n, "1"); + set_var(&n, "2"); + eq(var(&n), Some("2")); + set_var(&n, ""); + eq(var(&n), Some("")); + } + + #[test] + fn test_var_big() { + let mut s = "".to_string(); + let mut i = 0; + while i < 100 { + s.push_str("aaaaaaaaaa"); + i += 1; + } + let n = make_rand_name(); + set_var(&n, s.as_slice()); + eq(var(&n), Some(s.as_slice())); + } + + #[test] + fn test_self_exe_path() { + let path = current_exe(); + assert!(path.is_ok()); + let path = path.unwrap(); + + // Hard to test this function + assert!(path.is_absolute()); + } + + #[test] + fn test_env_set_get_huge() { + let n = make_rand_name(); + let s = repeat("x").take(10000).collect::(); + set_var(&n, &s); + eq(var(&n), Some(s.as_slice())); + remove_var(&n); + eq(var(&n), None); + } + + #[test] + fn test_env_set_var() { + let n = make_rand_name(); + + let mut e = vars(); + set_var(&n, "VALUE"); + assert!(!e.any(|(k, v)| { + &*k == &*n && &*v == "VALUE" + })); + + assert!(vars().any(|(k, v)| { + &*k == &*n && &*v == "VALUE" + })); + } + + #[test] + fn test() { + assert!((!Path::new("test-path").is_absolute())); + + current_dir().unwrap(); + } + + #[test] + #[cfg(windows)] + fn split_paths_windows() { + fn check_parse(unparsed: &str, parsed: &[&str]) -> bool { + split_paths(unparsed).collect::>() == + parsed.iter().map(|s| Path::new(*s)).collect::>() + } + + assert!(check_parse("", &mut [""])); + assert!(check_parse(r#""""#, &mut [""])); + assert!(check_parse(";;", &mut ["", "", ""])); + assert!(check_parse(r"c:\", &mut [r"c:\"])); + assert!(check_parse(r"c:\;", &mut [r"c:\", ""])); + assert!(check_parse(r"c:\;c:\Program Files\", + &mut [r"c:\", r"c:\Program Files\"])); + assert!(check_parse(r#"c:\;c:\"foo"\"#, &mut [r"c:\", r"c:\foo\"])); + assert!(check_parse(r#"c:\;c:\"foo;bar"\;c:\baz"#, + &mut [r"c:\", r"c:\foo;bar\", r"c:\baz"])); + } + + #[test] + #[cfg(unix)] + fn split_paths_unix() { + fn check_parse(unparsed: &str, parsed: &[&str]) -> bool { + split_paths(unparsed).collect::>() == + parsed.iter().map(|s| Path::new(*s)).collect::>() + } + + assert!(check_parse("", &mut [""])); + assert!(check_parse("::", &mut ["", "", ""])); + assert!(check_parse("/", &mut ["/"])); + assert!(check_parse("/:", &mut ["/", ""])); + assert!(check_parse("/:/usr/local", &mut ["/", "/usr/local"])); + } + + #[test] + #[cfg(unix)] + fn join_paths_unix() { + fn test_eq(input: &[&str], output: &str) -> bool { + &*join_paths(input.iter().map(|s| *s)).unwrap() == + OsStr::from_str(output) + } + + assert!(test_eq(&[], "")); + assert!(test_eq(&["/bin", "/usr/bin", "/usr/local/bin"], + "/bin:/usr/bin:/usr/local/bin")); + assert!(test_eq(&["", "/bin", "", "", "/usr/bin", ""], + ":/bin:::/usr/bin:")); + assert!(join_paths(["/te:st"].iter().map(|s| *s)).is_err()); + } + + #[test] + #[cfg(windows)] + fn join_paths_windows() { + fn test_eq(input: &[&str], output: &str) -> bool { + &*join_paths(input.iter().map(|s| *s)).unwrap() == + OsStr::from_str(output) + } + + assert!(test_eq(&[], "")); + assert!(test_eq(&[r"c:\windows", r"c:\"], + r"c:\windows;c:\")); + assert!(test_eq(&["", r"c:\windows", "", "", r"c:\", ""], + r";c:\windows;;;c:\;")); + assert!(test_eq(&[r"c:\te;st", r"c:\"], + r#""c:\te;st";c:\"#)); + assert!(join_paths([r#"c:\te"st"#].iter().map(|s| *s)).is_err()); + } + } diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs index 69ada28a4b4..76f925a23f1 100644 --- a/src/libstd/ffi/mod.rs +++ b/src/libstd/ffi/mod.rs @@ -20,7 +20,12 @@ pub use self::c_str::c_str_to_bytes_with_nul; pub use self::os_str::OsString; pub use self::os_str::OsStr; -pub use self::os_str::AsOsStr; mod c_str; mod os_str; + +/// Freely convertible to an `&OsStr` slice. +pub trait AsOsStr { + /// Convert to an `&OsStr` slice. + fn as_os_str(&self) -> &OsStr; +} diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs index 18e2aa8c098..57489e86230 100644 --- a/src/libstd/ffi/os_str.rs +++ b/src/libstd/ffi/os_str.rs @@ -41,9 +41,11 @@ use string::{String, CowString}; use ops; use cmp; use hash::{Hash, Hasher, Writer}; +use path::{Path, GenericPath}; use sys::os_str::{Buf, Slice}; use sys_common::{AsInner, IntoInner, FromInner}; +use super::AsOsStr; /// Owned, mutable OS strings. #[derive(Clone)] @@ -69,6 +71,11 @@ impl OsString { OsString { inner: Buf::from_str(s) } } + /// Constructs a new empty `OsString`. + pub fn new() -> OsString { + OsString { inner: Buf::from_string(String::new()) } + } + /// Convert the `OsString` into a `String` if it contains valid Unicode data. /// /// On failure, ownership of the original `OsString` is returned. @@ -117,6 +124,62 @@ impl Debug for OsString { } } +impl PartialEq for OsString { + fn eq(&self, other: &OsString) -> bool { + &**self == &**other + } +} + +impl PartialEq for OsString { + fn eq(&self, other: &str) -> bool { + &**self == other + } +} + +impl PartialEq for str { + fn eq(&self, other: &OsString) -> bool { + &**other == self + } +} + +impl Eq for OsString {} + +impl PartialOrd for OsString { + #[inline] + fn partial_cmp(&self, other: &OsString) -> Option { + (&**self).partial_cmp(&**other) + } + #[inline] + fn lt(&self, other: &OsString) -> bool { &**self < &**other } + #[inline] + fn le(&self, other: &OsString) -> bool { &**self <= &**other } + #[inline] + fn gt(&self, other: &OsString) -> bool { &**self > &**other } + #[inline] + fn ge(&self, other: &OsString) -> bool { &**self >= &**other } +} + +impl PartialOrd for OsString { + #[inline] + fn partial_cmp(&self, other: &str) -> Option { + (&**self).partial_cmp(other) + } +} + +impl Ord for OsString { + #[inline] + fn cmp(&self, other: &OsString) -> cmp::Ordering { + (&**self).cmp(&**other) + } +} + +impl<'a, S: Hasher + Writer> Hash for OsString { + #[inline] + fn hash(&self, state: &mut S) { + (&**self).hash(state) + } +} + impl OsStr { /// Coerce directly from a `&str` slice to a `&OsStr` slice. pub fn from_str(s: &str) -> &OsStr { @@ -222,10 +285,10 @@ impl ToOwned for OsStr { fn to_owned(&self) -> OsString { self.to_os_string() } } -/// Freely convertible to an `&OsStr` slice. -pub trait AsOsStr { - /// Convert to an `&OsStr` slice. - fn as_os_str(&self) -> &OsStr; +impl<'a, T: AsOsStr + ?Sized> AsOsStr for &'a T { + fn as_os_str(&self) -> &OsStr { + (*self).as_os_str() + } } impl AsOsStr for OsStr { @@ -252,6 +315,21 @@ impl AsOsStr for String { } } +#[cfg(unix)] +impl AsOsStr for Path { + fn as_os_str(&self) -> &OsStr { + unsafe { mem::transmute(self.as_vec()) } + } +} + +#[cfg(windows)] +impl AsOsStr for Path { + fn as_os_str(&self) -> &OsStr { + // currently .as_str() is actually infallible on windows + OsStr::from_str(self.as_str().unwrap()) + } +} + impl FromInner for OsString { fn from_inner(buf: Buf) -> OsString { OsString { inner: buf } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 96aebb735ef..487efb43326 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -250,6 +250,7 @@ pub mod ffi; pub mod fmt; pub mod old_io; pub mod os; +pub mod env; pub mod path; pub mod rand; pub mod time; diff --git a/src/libstd/old_io/process.rs b/src/libstd/old_io/process.rs index f253f9799e9..81903d0a97e 100644 --- a/src/libstd/old_io/process.rs +++ b/src/libstd/old_io/process.rs @@ -231,6 +231,7 @@ impl Command { self } // Get a mutable borrow of the environment variable map for this `Command`. + #[allow(deprecated)] fn get_env_map<'a>(&'a mut self) -> &'a mut EnvMap { match self.env { Some(ref mut map) => map, diff --git a/src/libstd/old_io/tempfile.rs b/src/libstd/old_io/tempfile.rs index 20cbde5db71..83a42549424 100644 --- a/src/libstd/old_io/tempfile.rs +++ b/src/libstd/old_io/tempfile.rs @@ -10,13 +10,13 @@ //! Temporary files and directories +use env; +use iter::{IteratorExt}; use old_io::{fs, IoError, IoErrorKind, IoResult}; use old_io; -use iter::IteratorExt; use ops::Drop; -use option::Option; use option::Option::{None, Some}; -use os; +use option::Option; use path::{Path, GenericPath}; use rand::{Rng, thread_rng}; use result::Result::{Ok, Err}; @@ -97,8 +97,8 @@ impl TempDir { /// If no directory can be created, `Err` is returned. pub fn new_in(tmpdir: &Path, prefix: &str) -> IoResult { if !tmpdir.is_absolute() { - let abs_tmpdir = try!(os::make_absolute(tmpdir)); - return TempDir::new_in(&abs_tmpdir, prefix); + let cur_dir = try!(env::current_dir()); + return TempDir::new_in(&cur_dir.join(tmpdir), prefix); } let mut rng = thread_rng(); @@ -132,7 +132,7 @@ impl TempDir { /// /// If no directory can be created, `Err` is returned. pub fn new(prefix: &str) -> IoResult { - TempDir::new_in(&os::tmpdir(), prefix) + TempDir::new_in(&env::temp_dir(), prefix) } /// Unwrap the wrapped `std::path::Path` from the `TempDir` wrapper. diff --git a/src/libstd/old_io/test.rs b/src/libstd/old_io/test.rs index f49e2397d42..3f4e070e30d 100644 --- a/src/libstd/old_io/test.rs +++ b/src/libstd/old_io/test.rs @@ -12,8 +12,8 @@ use prelude::v1::*; +use env; use libc; -use os; use std::old_io::net::ip::*; use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; @@ -41,7 +41,7 @@ fn next_test_unix_socket() -> String { pub fn next_test_unix() -> Path { let string = next_test_unix_socket(); if cfg!(unix) { - os::tmpdir().join(string) + env::temp_dir().join(string) } else { Path::new(format!("{}{}", r"\\.\pipe\", string)) } @@ -87,7 +87,7 @@ fn base_port() -> u16 { ]; // FIXME (#9639): This needs to handle non-utf8 paths - let path = os::getcwd().unwrap(); + let path = env::current_dir().unwrap(); let path_s = path.as_str().unwrap(); let mut final_base = base; diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 600ca60349a..27e843d2383 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -34,29 +34,32 @@ use self::MemoryMapKind::*; use self::MapOption::*; use self::MapError::*; +use boxed::Box; use clone::Clone; +use env; use error::{FromError, Error}; +use ffi::{OsString, OsStr}; use fmt; -use old_io::{IoResult, IoError}; use iter::{Iterator, IteratorExt}; -use marker::{Copy, Send}; use libc::{c_void, c_int, c_char}; use libc; -use boxed::Box; +use marker::{Copy, Send}; +use old_io::{IoResult, IoError}; use ops::{Drop, FnOnce}; -use option::Option; use option::Option::{Some, None}; +use option::Option; use path::{Path, GenericPath, BytesContainer}; -use sys; -use sys::os as os_imp; use ptr::PtrExt; use ptr; -use result::Result; use result::Result::{Err, Ok}; +use result::Result; use slice::{AsSlice, SliceExt}; use str::{Str, StrExt}; +use str; use string::{String, ToString}; use sync::atomic::{AtomicIsize, ATOMIC_ISIZE_INIT, Ordering}; +use sys::os as os_imp; +use sys; use vec::Vec; #[cfg(unix)] use ffi::{self, CString}; @@ -97,23 +100,10 @@ pub const TMPBUF_SZ : uint = 1000u; /// let current_working_directory = os::getcwd().unwrap(); /// println!("The current directory is {:?}", current_working_directory.display()); /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to std::env::current_dir")] +#[unstable(feature = "os")] pub fn getcwd() -> IoResult { - sys::os::getcwd() -} - -/* -Accessing environment variables is not generally threadsafe. -Serialize access through a global lock. -*/ -fn with_env_lock(f: F) -> T where - F: FnOnce() -> T, -{ - use sync::{StaticMutex, MUTEX_INIT}; - - static LOCK: StaticMutex = MUTEX_INIT; - - let _guard = LOCK.lock(); - f() + env::current_dir() } /// Returns a vector of (variable, value) pairs, for all the environment @@ -132,37 +122,22 @@ fn with_env_lock(f: F) -> T where /// println!("'{}': '{}'", key, value ); /// } /// ``` +#[deprecated(since = "1.0.0", reason = "use env::vars instead")] +#[unstable(feature = "os")] pub fn env() -> Vec<(String,String)> { - env_as_bytes().into_iter().map(|(k,v)| { - let k = String::from_utf8_lossy(k.as_slice()).into_owned(); - let v = String::from_utf8_lossy(v.as_slice()).into_owned(); - (k,v) + env::vars().map(|(k, v)| { + (k.to_string_lossy().into_owned(), v.to_string_lossy().into_owned()) }).collect() } /// Returns a vector of (variable, value) byte-vector pairs for all the /// environment variables of the current process. -pub fn env_as_bytes() -> Vec<(Vec,Vec)> { - unsafe { - fn env_convert(input: Vec>) -> Vec<(Vec, Vec)> { - let mut pairs = Vec::new(); - for p in input.iter() { - let mut it = p.splitn(1, |b| *b == b'='); - let key = it.next().unwrap().to_vec(); - let default: &[u8] = &[]; - let val = it.next().unwrap_or(default).to_vec(); - pairs.push((key, val)); - } - pairs - } - with_env_lock(|| { - let unparsed_environ = sys::os::get_env_pairs(); - env_convert(unparsed_environ) - }) - } +#[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() } -#[cfg(unix)] /// Fetches the environment variable `n` from the current process, returning /// None if the variable isn't set. /// @@ -184,52 +159,32 @@ 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")] +#[unstable(feature = "os")] pub fn getenv(n: &str) -> Option { - getenv_as_bytes(n).map(|v| String::from_utf8_lossy(v.as_slice()).into_owned()) + env::var_string(n).ok() } -#[cfg(unix)] /// Fetches the environment variable `n` byte vector from the current process, /// returning None if the variable isn't set. /// /// # Panics /// /// Panics if `n` has any interior NULs. +#[deprecated(since = "1.0.0", reason = "use env::var instead")] +#[unstable(feature = "os")] pub fn getenv_as_bytes(n: &str) -> Option> { - unsafe { - with_env_lock(|| { - let s = CString::from_slice(n.as_bytes()); - let s = libc::getenv(s.as_ptr()) as *const _; - if s.is_null() { - None - } else { - Some(ffi::c_str_to_bytes(&s).to_vec()) - } - }) - } + env::var(n).map(byteify) } -#[cfg(windows)] -/// Fetches the environment variable `n` from the current process, returning -/// None if the variable isn't set. -pub fn getenv(n: &str) -> Option { - unsafe { - with_env_lock(|| { - use sys::os::fill_utf16_buf_and_decode; - let mut n: Vec = n.utf16_units().collect(); - n.push(0); - fill_utf16_buf_and_decode(|buf, sz| { - libc::GetEnvironmentVariableW(n.as_ptr(), buf, sz) - }) - }) - } +#[cfg(unix)] +fn byteify(s: OsString) -> Vec { + use os::unix::*; + s.into_vec() } - #[cfg(windows)] -/// Fetches the environment variable `n` byte vector from the current process, -/// returning None if the variable isn't set. -pub fn getenv_as_bytes(n: &str) -> Option> { - getenv(n).map(|s| s.into_bytes()) +fn byteify(s: OsString) -> Vec { + s.to_string_lossy().as_bytes().to_vec() } /// Sets the environment variable `n` to the value `v` for the currently running @@ -247,68 +202,30 @@ pub fn getenv_as_bytes(n: &str) -> Option> { /// None => println!("{} is not defined in the environment.", key) /// } /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to env::set_var")] +#[unstable(feature = "os")] pub fn setenv(n: &str, v: T) { #[cfg(unix)] fn _setenv(n: &str, v: &[u8]) { - unsafe { - with_env_lock(|| { - let k = CString::from_slice(n.as_bytes()); - let v = CString::from_slice(v); - if libc::funcs::posix01::unistd::setenv(k.as_ptr(), - v.as_ptr(), 1) != 0 { - panic!(IoError::last_error()); - } - }) - } + use os::unix::*; + let v: OsString = OsStringExt::from_vec(v.to_vec()); + env::set_var(n, &v) } #[cfg(windows)] fn _setenv(n: &str, v: &[u8]) { - let mut n: Vec = n.utf16_units().collect(); - n.push(0); - let mut v: Vec = ::str::from_utf8(v).unwrap().utf16_units().collect(); - v.push(0); - - unsafe { - with_env_lock(|| { - if libc::SetEnvironmentVariableW(n.as_ptr(), v.as_ptr()) == 0 { - panic!(IoError::last_error()); - } - }) - } + let v = str::from_utf8(v).unwrap(); + env::set_var(n, v) } _setenv(n, v.container_as_bytes()) } /// Remove a variable from the environment entirely. +#[deprecated(since = "1.0.0", reason = "renamed to env::remove_var")] +#[unstable(feature = "os")] pub fn unsetenv(n: &str) { - #[cfg(unix)] - fn _unsetenv(n: &str) { - unsafe { - with_env_lock(|| { - let nbuf = CString::from_slice(n.as_bytes()); - if libc::funcs::posix01::unistd::unsetenv(nbuf.as_ptr()) != 0 { - panic!(IoError::last_error()); - } - }) - } - } - - #[cfg(windows)] - fn _unsetenv(n: &str) { - let mut n: Vec = n.utf16_units().collect(); - n.push(0); - unsafe { - with_env_lock(|| { - if libc::SetEnvironmentVariableW(n.as_ptr(), ptr::null()) == 0 { - panic!(IoError::last_error()); - } - }) - } - } - - _unsetenv(n) + env::remove_var(n) } /// Parses input according to platform conventions for the `PATH` @@ -328,8 +245,12 @@ pub fn unsetenv(n: &str) { /// None => println!("{} is not defined in the environment.", key) /// } /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to env::split_paths")] +#[unstable(feature = "os")] pub fn split_paths(unparsed: T) -> Vec { - sys::os::split_paths(unparsed.container_as_bytes()) + let b = unparsed.container_as_bytes(); + let s = str::from_utf8(b).unwrap(); + env::split_paths(s).collect() } /// Joins a collection of `Path`s appropriately for the `PATH` @@ -353,8 +274,14 @@ pub fn split_paths(unparsed: T) -> Vec { /// paths.push(Path::new("/home/xyz/bin")); /// os::setenv(key, os::join_paths(paths.as_slice()).unwrap()); /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to env::join_paths")] +#[unstable(feature = "os")] pub fn join_paths(paths: &[T]) -> Result, &'static str> { - sys::os::join_paths(paths) + env::join_paths(paths.iter().map(|s| { + str::from_utf8(s.container_as_bytes()).unwrap() + })).map(|s| { + s.to_string_lossy().into_owned().into_bytes() + }).map_err(|_| "failed to join paths") } /// A low-level OS in-memory pipe. @@ -388,6 +315,8 @@ pub unsafe fn pipe() -> IoResult { /// Returns the proper dll filename for the given basename of a file /// as a String. #[cfg(not(target_os="ios"))] +#[deprecated(since = "1.0.0", reason = "this function will be removed, use the constants directly")] +#[unstable(feature = "os")] pub fn dll_filename(base: &str) -> String { format!("{}{}{}", consts::DLL_PREFIX, base, consts::DLL_SUFFIX) } @@ -405,8 +334,10 @@ pub fn dll_filename(base: &str) -> String { /// None => println!("Unable to get the path of this executable!") /// }; /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to env::current_exe")] +#[unstable(feature = "os")] pub fn self_exe_name() -> Option { - sys::os::load_self().and_then(Path::new_opt) + env::current_exe().ok() } /// Optionally returns the filesystem path to the current executable which is @@ -424,8 +355,10 @@ pub fn self_exe_name() -> Option { /// None => println!("Impossible to fetch the path of this executable.") /// }; /// ``` +#[deprecated(since = "1.0.0", reason = "use env::current_exe + dir_path/pop")] +#[unstable(feature = "os")] pub fn self_exe_path() -> Option { - self_exe_name().map(|mut p| { p.pop(); p }) + env::current_exe().ok().map(|mut p| { p.pop(); p }) } /// Optionally returns the path to the current user's home directory if known. @@ -452,6 +385,9 @@ pub fn self_exe_path() -> Option { /// None => println!("Impossible to get your home dir!") /// } /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to env::home_dir")] +#[allow(deprecated)] +#[unstable(feature = "os")] pub fn homedir() -> Option { #[inline] #[cfg(unix)] @@ -487,6 +423,9 @@ pub fn homedir() -> Option { /// On Windows, returns the value of, in order, the 'TMP', 'TEMP', /// 'USERPROFILE' environment variable if any are set and not the empty /// string. Otherwise, tmpdir returns the path to the Windows directory. +#[deprecated(since = "1.0.0", reason = "renamed to env::temp_dir")] +#[allow(deprecated)] +#[unstable(feature = "os")] pub fn tmpdir() -> Path { return lookup(); @@ -542,11 +481,13 @@ pub fn tmpdir() -> Path { // NB: this is here rather than in path because it is a form of environment // querying; what it does depends on the process working directory, not just // the input paths. +#[deprecated(since = "1.0.0", reason = "use env::current_dir + .join directly")] +#[unstable(feature = "os")] pub fn make_absolute(p: &Path) -> IoResult { if p.is_absolute() { Ok(p.clone()) } else { - getcwd().map(|mut cwd| { + env::current_dir().map(|mut cwd| { cwd.push(p); cwd }) @@ -565,6 +506,8 @@ pub fn make_absolute(p: &Path) -> IoResult { /// assert!(os::change_dir(&root).is_ok()); /// println!("Successfully changed working directory to {}!", root.display()); /// ``` +#[deprecated(since = "1.0.0", reason = "renamed to env::set_current_dir")] +#[unstable(feature = "os")] pub fn change_dir(p: &Path) -> IoResult<()> { return sys::os::chdir(p); } @@ -592,8 +535,6 @@ pub fn last_os_error() -> String { error_string(errno() as uint) } -static EXIT_STATUS: AtomicIsize = ATOMIC_ISIZE_INIT; - /// Sets the process exit code /// /// Sets the exit code returned by the process if all supervised tasks @@ -602,14 +543,18 @@ static EXIT_STATUS: AtomicIsize = ATOMIC_ISIZE_INIT; /// ignored and the process exits with the default panic status. /// /// Note that this is not synchronized against modifications of other threads. +#[deprecated(since = "1.0.0", reason = "renamed to env::set_exit_status")] +#[unstable(feature = "os")] pub fn set_exit_status(code: int) { - EXIT_STATUS.store(code, Ordering::SeqCst) + env::set_exit_status(code as i32) } /// Fetches the process's current exit code. This defaults to 0 and can change /// by calling `set_exit_status`. +#[deprecated(since = "1.0.0", reason = "renamed to env::get_exit_status")] +#[unstable(feature = "os")] pub fn get_exit_status() -> int { - EXIT_STATUS.load(Ordering::SeqCst) + env::get_exit_status() as isize } #[cfg(target_os = "macos")] @@ -726,7 +671,7 @@ fn real_args() -> Vec { // Push it onto the list. let ptr = ptr as *const u16; let buf = slice::from_raw_buf(&ptr, len); - let opt_s = String::from_utf16(sys::os::truncate_utf16_at_nul(buf)); + let opt_s = String::from_utf16(sys::truncate_utf16_at_nul(buf)); opt_s.ok().expect("CommandLineToArgvW returned invalid UTF-16") }).collect(); @@ -777,12 +722,16 @@ extern "system" { /// println!("{}", argument); /// } /// ``` +#[deprecated(since = "1.0.0", reason = "use env::args instead")] +#[unstable(feature = "os")] pub fn args() -> Vec { real_args() } /// Returns the arguments which this program was started with (normally passed /// via the command line) as byte vectors. +#[deprecated(since = "1.0.0", reason = "use env::args_raw instead")] +#[unstable(feature = "os")] pub fn args_as_bytes() -> Vec> { real_args_as_bytes() } @@ -790,11 +739,13 @@ pub fn args_as_bytes() -> Vec> { #[cfg(target_os = "macos")] extern { // These functions are in crt_externs.h. - pub fn _NSGetArgc() -> *mut c_int; - pub fn _NSGetArgv() -> *mut *mut *mut c_char; + fn _NSGetArgc() -> *mut c_int; + fn _NSGetArgv() -> *mut *mut *mut c_char; } /// Returns the page size of the current architecture in bytes. +#[deprecated(since = "1.0.0", reason = "renamed to env::page_size")] +#[unstable(feature = "os")] pub fn page_size() -> uint { sys::os::page_size() } @@ -970,7 +921,7 @@ impl MemoryMap { let mut fd = -1; let mut offset = 0; let mut custom_flags = false; - let len = round_up(min_len, page_size()); + let len = round_up(min_len, env::page_size()); for &o in options.iter() { match o { @@ -1020,7 +971,7 @@ impl MemoryMap { /// Granularity that the offset or address must be for `MapOffset` and /// `MapAddr` respectively. pub fn granularity() -> uint { - page_size() + env::page_size() } } @@ -1049,7 +1000,7 @@ impl MemoryMap { let mut executable = false; let mut handle: HANDLE = libc::INVALID_HANDLE_VALUE; let mut offset: uint = 0; - let len = round_up(min_len, page_size()); + let len = round_up(min_len, env::page_size()); for &o in options.iter() { match o { @@ -1184,6 +1135,8 @@ impl MemoryMap { } #[cfg(target_os = "linux")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; @@ -1215,6 +1168,8 @@ pub mod consts { } #[cfg(target_os = "macos")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; @@ -1246,6 +1201,8 @@ pub mod consts { } #[cfg(target_os = "ios")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; @@ -1265,6 +1222,8 @@ pub mod consts { } #[cfg(target_os = "freebsd")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; @@ -1296,6 +1255,8 @@ pub mod consts { } #[cfg(target_os = "dragonfly")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; @@ -1327,6 +1288,8 @@ pub mod consts { } #[cfg(target_os = "android")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; @@ -1358,6 +1321,8 @@ pub mod consts { } #[cfg(target_os = "windows")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index f2d66e1a4d7..905cc06c4f0 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -14,7 +14,7 @@ use prelude::v1::*; -use os; +use env; use sync::atomic::{self, Ordering}; pub use sys::backtrace::write; @@ -29,7 +29,7 @@ pub fn log_enabled() -> bool { _ => {} } - let val = match os::getenv("RUST_BACKTRACE") { + let val = match env::var("RUST_BACKTRACE") { Some(..) => 2, None => 1, }; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 7e19f1cac2c..00088d6d99a 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -65,7 +65,7 @@ fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int { use prelude::v1::*; use mem; - use os; + use env; use rt; use sys_common::thread_info::{self, NewThread}; use sys_common; @@ -131,7 +131,7 @@ fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int { if failed { rt::DEFAULT_ERROR_CODE } else { - os::get_exit_status() + env::get_exit_status() as isize } } diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index f5727a38b69..86d21cf7278 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -13,6 +13,7 @@ use prelude::v1::*; use cmp; +use env; use fmt; use intrinsics; use libc::{self, uintptr_t}; @@ -51,7 +52,7 @@ pub fn min_stack() -> uint { 0 => {} n => return n - 1, } - let amt = os::getenv("RUST_MIN_STACK").and_then(|s| s.parse().ok()); + let amt = env::var_string("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 @@ -62,15 +63,15 @@ 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 os::getenv("RUST_THREADS") { - Some(nstr) => { + match env::var_string("RUST_THREADS") { + Ok(nstr) => { let opt_n: Option = nstr.parse().ok(); match opt_n { Some(n) if n > 0 => n, _ => panic!("`RUST_THREADS` is `{}`, should be a positive integer", nstr) } } - None => { + Err(..) => { if limit_thread_creation_due_to_osx_and_valgrind() { 1 } else { diff --git a/src/libstd/sys/common/mutex.rs b/src/libstd/sys/common/mutex.rs index 9aea0fb3b31..0ca22826700 100644 --- a/src/libstd/sys/common/mutex.rs +++ b/src/libstd/sys/common/mutex.rs @@ -24,13 +24,6 @@ unsafe impl Sync for Mutex {} pub const MUTEX_INIT: Mutex = Mutex(imp::MUTEX_INIT); impl Mutex { - /// Creates a newly initialized mutex. - /// - /// Behavior is undefined if the mutex is moved after the first method is - /// called on the mutex. - #[inline] - pub unsafe fn new() -> Mutex { Mutex(imp::Mutex::new()) } - /// Lock the mutex blocking the current thread until it is available. /// /// Behavior is undefined if the mutex has been moved between this and any diff --git a/src/libstd/sys/common/rwlock.rs b/src/libstd/sys/common/rwlock.rs index df016b9e293..fe374e1fd78 100644 --- a/src/libstd/sys/common/rwlock.rs +++ b/src/libstd/sys/common/rwlock.rs @@ -21,13 +21,6 @@ pub struct RWLock(imp::RWLock); pub const RWLOCK_INIT: RWLock = RWLock(imp::RWLOCK_INIT); impl RWLock { - /// Creates a new instance of an RWLock. - /// - /// Usage of an RWLock is undefined if it is moved after its first use (any - /// function calls below). - #[inline] - pub unsafe fn new() -> RWLock { RWLock(imp::RWLock::new()) } - /// Acquire shared access to the underlying lock, blocking the current /// thread to do so. /// diff --git a/src/libstd/sys/unix/backtrace.rs b/src/libstd/sys/unix/backtrace.rs index e310b8f6d90..51186feeaf4 100644 --- a/src/libstd/sys/unix/backtrace.rs +++ b/src/libstd/sys/unix/backtrace.rs @@ -240,7 +240,7 @@ fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> { #[cfg(not(any(target_os = "macos", target_os = "ios")))] fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> { - use os; + use env; use ptr; //////////////////////////////////////////////////////////////////////// @@ -319,7 +319,7 @@ fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> { if !STATE.is_null() { return STATE } let selfname = if cfg!(target_os = "freebsd") || cfg!(target_os = "dragonfly") { - os::self_exe_name() + env::current_exe().ok() } else { None }; diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs index 9016d1a2c99..7a17e8b6f1e 100644 --- a/src/libstd/sys/unix/c.rs +++ b/src/libstd/sys/unix/c.rs @@ -66,6 +66,53 @@ pub const MSG_DONTWAIT: libc::c_int = 0x40; pub const WNOHANG: libc::c_int = 1; +#[cfg(target_os = "linux")] +pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 70; +#[cfg(any(target_os = "macos", + target_os = "freebsd"))] +pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 71; +#[cfg(target_os = "android")] +pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 0x0048; + +#[repr(C)] +#[cfg(target_os = "linux")] +pub struct passwd { + pub pw_name: *mut libc::c_char, + pub pw_passwd: *mut libc::c_char, + pub pw_uid: libc::uid_t, + pub pw_gid: libc::gid_t, + pub pw_gecos: *mut libc::c_char, + pub pw_dir: *mut libc::c_char, + pub pw_shell: *mut libc::c_char, +} + +#[repr(C)] +#[cfg(any(target_os = "macos", + target_os = "freebsd"))] +pub struct passwd { + pub pw_name: *mut libc::c_char, + pub pw_passwd: *mut libc::c_char, + pub pw_uid: libc::uid_t, + pub pw_gid: libc::gid_t, + pub pw_change: libc::time_t, + pub pw_class: *mut libc::c_char, + pub pw_gecos: *mut libc::c_char, + pub pw_dir: *mut libc::c_char, + pub pw_shell: *mut libc::c_char, + pub pw_expire: libc::time_t, +} + +#[repr(C)] +#[cfg(target_os = "android")] +pub struct passwd { + pub pw_name: *mut libc::c_char, + pub pw_passwd: *mut libc::c_char, + pub pw_uid: libc::uid_t, + pub pw_gid: libc::gid_t, + pub pw_dir: *mut libc::c_char, + pub pw_shell: *mut libc::c_char, +} + extern { pub fn gettimeofday(timeval: *mut libc::timeval, tzp: *mut libc::c_void) -> libc::c_int; @@ -92,6 +139,12 @@ extern { pub fn sigaddset(set: *mut sigset_t, signum: libc::c_int) -> libc::c_int; pub fn sigdelset(set: *mut sigset_t, signum: libc::c_int) -> libc::c_int; pub fn sigemptyset(set: *mut sigset_t) -> libc::c_int; + + pub fn getpwuid_r(uid: libc::uid_t, + pwd: *mut passwd, + buf: *mut libc::c_char, + buflen: libc::size_t, + result: *mut *mut passwd) -> libc::c_int; } #[cfg(any(target_os = "macos", target_os = "ios"))] diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index f2f2e7436bf..b03b9046966 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -141,7 +141,7 @@ pub fn retry (mut f: F) -> T where let one: T = Int::one(); loop { let n = f(); - if n == -one && os::errno() == libc::EINTR as int { } + if n == -one && os::errno() == libc::EINTR as i32 { } else { return n } } } @@ -155,7 +155,7 @@ pub fn ms_to_timeval(ms: u64) -> libc::timeval { pub fn wouldblock() -> bool { let err = os::errno(); - err == libc::EWOULDBLOCK as int || err == libc::EAGAIN as int + err == libc::EWOULDBLOCK as i32 || err == libc::EAGAIN as i32 } pub fn set_nonblocking(fd: sock_t, nb: bool) -> IoResult<()> { diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index dd343baa7c9..68818b07b7f 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -1,4 +1,4 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -11,93 +11,64 @@ //! Implementation of `std::os` functionality for unix systems use prelude::v1::*; +use os::unix::*; -use error::{FromError, Error}; -use ffi::{self, CString}; +use error::Error as StdError; +use ffi::{self, CString, OsString, OsStr, AsOsStr}; use fmt; -use old_io::{IoError, IoResult}; +use iter; use libc::{self, c_int, c_char, c_void}; -use os::TMPBUF_SZ; -use os; -use path::{BytesContainer}; +use mem; +use old_io::{IoResult, IoError, fs}; use ptr; +use slice; use str; +use sys::c; use sys::fs::FileDesc; +use vec; -const BUF_BYTES : uint = 2048u; +const BUF_BYTES: usize = 2048; +const TMPBUF_SZ: usize = 128; /// Returns the platform-specific value of errno -pub fn errno() -> int { +pub fn errno() -> i32 { #[cfg(any(target_os = "macos", target_os = "ios", target_os = "freebsd"))] - fn errno_location() -> *const c_int { - extern { - fn __error() -> *const c_int; - } - unsafe { - __error() - } + unsafe fn errno_location() -> *const c_int { + extern { fn __error() -> *const c_int; } + __error() } #[cfg(target_os = "dragonfly")] - fn errno_location() -> *const c_int { - extern { - fn __dfly_error() -> *const c_int; - } - unsafe { - __dfly_error() - } + unsafe fn errno_location() -> *const c_int { + extern { fn __dfly_error() -> *const c_int; } + __dfly_error() } #[cfg(any(target_os = "linux", target_os = "android"))] - fn errno_location() -> *const c_int { - extern { - fn __errno_location() -> *const c_int; - } - unsafe { - __errno_location() - } + unsafe fn errno_location() -> *const c_int { + extern { fn __errno_location() -> *const c_int; } + __errno_location() } unsafe { - (*errno_location()) as int + (*errno_location()) as i32 } } /// Get a detailed string description for the given error number pub fn error_string(errno: i32) -> String { - #[cfg(any(target_os = "macos", - target_os = "ios", - target_os = "android", - target_os = "freebsd", - target_os = "dragonfly"))] - fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: libc::size_t) - -> c_int { - extern { - fn strerror_r(errnum: c_int, buf: *mut c_char, - buflen: libc::size_t) -> c_int; - } - unsafe { - strerror_r(errnum, buf, buflen) - } - } - - // GNU libc provides a non-compliant version of strerror_r by default - // and requires macros to instead use the POSIX compliant variant. - // So we just use __xpg_strerror_r which is always POSIX compliant #[cfg(target_os = "linux")] - fn strerror_r(errnum: c_int, buf: *mut c_char, - buflen: libc::size_t) -> c_int { - extern { - fn __xpg_strerror_r(errnum: c_int, - buf: *mut c_char, - buflen: libc::size_t) - -> c_int; - } - unsafe { - __xpg_strerror_r(errnum, buf, buflen) - } + extern { + #[link_name = "__xpg_strerror_r"] + fn strerror_r(errnum: c_int, buf: *mut c_char, + buflen: libc::size_t) -> c_int; + } + #[cfg(not(target_os = "linux"))] + extern { + fn strerror_r(errnum: c_int, buf: *mut c_char, + buflen: libc::size_t) -> c_int; } let mut buf = [0 as c_char; TMPBUF_SZ]; @@ -113,15 +84,6 @@ pub fn error_string(errno: i32) -> String { } } -pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> { - let mut fds = [0; 2]; - if libc::pipe(fds.as_mut_ptr()) == 0 { - Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true))) - } else { - Err(super::last_error()) - } -} - pub fn getcwd() -> IoResult { let mut buf = [0 as c_char; BUF_BYTES]; unsafe { @@ -133,43 +95,69 @@ pub fn getcwd() -> IoResult { } } -pub unsafe fn get_env_pairs() -> Vec> { - extern { - fn rust_env_pairs() -> *const *const c_char; - } - let mut environ = rust_env_pairs(); - if environ as uint == 0 { - panic!("os::env() failure getting env string from OS: {}", - os::last_os_error()); +pub fn chdir(p: &Path) -> IoResult<()> { + let p = CString::from_slice(p.as_vec()); + unsafe { + match libc::chdir(p.as_ptr()) == (0 as c_int) { + true => Ok(()), + false => Err(IoError::last_error()), + } } - let mut result = Vec::new(); - while *environ != ptr::null() { - let env_pair = ffi::c_str_to_bytes(&*environ).to_vec(); - result.push(env_pair); - environ = environ.offset(1); +} + +pub struct SplitPaths<'a> { + iter: iter::Map<&'a [u8], Path, + slice::Split<'a, u8, fn(&u8) -> bool>, + fn(&'a [u8]) -> Path>, +} + +pub fn split_paths<'a>(unparsed: &'a OsStr) -> SplitPaths<'a> { + fn is_colon(b: &u8) -> bool { *b == b':' } + let unparsed = unparsed.as_byte_slice(); + SplitPaths { + iter: unparsed.split(is_colon as fn(&u8) -> bool) + .map(Path::new as fn(&'a [u8]) -> Path) } - result } -pub fn split_paths(unparsed: &[u8]) -> Vec { - unparsed.split(|b| *b == b':').map(Path::new).collect() +impl<'a> Iterator for SplitPaths<'a> { + type Item = Path; + fn next(&mut self) -> Option { self.iter.next() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } -pub fn join_paths(paths: &[T]) -> Result, &'static str> { +#[derive(Debug)] +pub struct JoinPathsError; + +pub fn join_paths(paths: I) -> Result + where I: Iterator, T: AsOsStr +{ let mut joined = Vec::new(); let sep = b':'; - for (i, path) in paths.iter().map(|p| p.container_as_bytes()).enumerate() { + for (i, path) in paths.enumerate() { + let path = path.as_os_str().as_byte_slice(); if i > 0 { joined.push(sep) } - if path.contains(&sep) { return Err("path segment contains separator `:`") } + if path.contains(&sep) { + return Err(JoinPathsError) + } joined.push_all(path); } + Ok(OsStringExt::from_vec(joined)) +} - Ok(joined) +impl fmt::Display for JoinPathsError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + "path segment contains separator `:`".fmt(f) + } +} + +impl StdError for JoinPathsError { + fn description(&self) -> &str { "failed to join paths" } } #[cfg(target_os = "freebsd")] -pub fn load_self() -> Option> { +pub fn current_exe() -> IoResult { unsafe { use libc::funcs::bsd44::*; use libc::consts::os::extra::*; @@ -181,66 +169,276 @@ pub fn load_self() -> Option> { let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, ptr::null_mut(), &mut sz, ptr::null_mut(), 0u as libc::size_t); - if err != 0 { return None; } - if sz == 0 { return None; } + if err != 0 { return Err(IoError::last_error()); } + if sz == 0 { return Err(IoError::last_error()); } let mut v: Vec = Vec::with_capacity(sz as uint); let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, v.as_mut_ptr() as *mut libc::c_void, &mut sz, ptr::null_mut(), 0u as libc::size_t); - if err != 0 { return None; } - if sz == 0 { return None; } + if err != 0 { return Err(IoError::last_error()); } + if sz == 0 { return Err(IoError::last_error()); } v.set_len(sz as uint - 1); // chop off trailing NUL - Some(v) + Ok(Path::new(v)) } } #[cfg(target_os = "dragonfly")] -pub fn load_self() -> Option> { - use old_io; - - match old_io::fs::readlink(&Path::new("/proc/curproc/file")) { - Ok(path) => Some(path.into_vec()), - Err(..) => None - } +pub fn current_exe() -> IoResult { + fs::readlink(&Path::new("/proc/curproc/file")) } #[cfg(any(target_os = "linux", target_os = "android"))] -pub fn load_self() -> Option> { - use old_io; - - match old_io::fs::readlink(&Path::new("/proc/self/exe")) { - Ok(path) => Some(path.into_vec()), - Err(..) => None - } +pub fn current_exe() -> IoResult { + fs::readlink(&Path::new("/proc/self/exe")) } #[cfg(any(target_os = "macos", target_os = "ios"))] -pub fn load_self() -> Option> { +pub fn current_exe() -> IoResult { unsafe { use libc::funcs::extra::_NSGetExecutablePath; let mut sz: u32 = 0; _NSGetExecutablePath(ptr::null_mut(), &mut sz); - if sz == 0 { return None; } + if sz == 0 { return Err(IoError::last_error()); } let mut v: Vec = Vec::with_capacity(sz as uint); let err = _NSGetExecutablePath(v.as_mut_ptr() as *mut i8, &mut sz); - if err != 0 { return None; } + if err != 0 { return Err(IoError::last_error()); } v.set_len(sz as uint - 1); // chop off trailing NUL - Some(v) + Ok(Path::new(v)) } } -pub fn chdir(p: &Path) -> IoResult<()> { - let p = CString::from_slice(p.as_vec()); +pub struct Args { + iter: vec::IntoIter, + _dont_send_or_sync_me: *mut (), +} + +impl Iterator for Args { + type Item = OsString; + fn next(&mut self) -> Option { self.iter.next() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } +} + +/// Returns the command line arguments +/// +/// Returns a list of the command line arguments. +#[cfg(target_os = "macos")] +pub fn args() -> Args { + extern { + // These functions are in crt_externs.h. + fn _NSGetArgc() -> *mut c_int; + fn _NSGetArgv() -> *mut *mut *mut c_char; + } + + let vec = unsafe { + let (argc, argv) = (*_NSGetArgc() as isize, + *_NSGetArgv() as *const *const c_char); + range(0, argc as isize).map(|i| { + let bytes = ffi::c_str_to_bytes(&*argv.offset(i)).to_vec(); + OsStringExt::from_vec(bytes) + }).collect::>() + }; + Args { + iter: vec.into_iter(), + _dont_send_or_sync_me: 0 as *mut (), + } +} + +// As _NSGetArgc and _NSGetArgv aren't mentioned in iOS docs +// and use underscores in their names - they're most probably +// are considered private and therefore should be avoided +// Here is another way to get arguments using Objective C +// runtime +// +// In general it looks like: +// res = Vec::new() +// let args = [[NSProcessInfo processInfo] arguments] +// for i in range(0, [args count]) +// res.push([args objectAtIndex:i]) +// res +#[cfg(target_os = "ios")] +pub fn args() -> Args { + use iter::range; + use mem; + + #[link(name = "objc")] + extern { + fn sel_registerName(name: *const libc::c_uchar) -> Sel; + fn objc_msgSend(obj: NsId, sel: Sel, ...) -> NsId; + fn objc_getClass(class_name: *const libc::c_uchar) -> NsId; + } + + #[link(name = "Foundation", kind = "framework")] + extern {} + + type Sel = *const libc::c_void; + type NsId = *const libc::c_void; + + let mut res = Vec::new(); + unsafe { - match libc::chdir(p.as_ptr()) == (0 as c_int) { - true => Ok(()), - false => Err(IoError::last_error()), + let processInfoSel = sel_registerName("processInfo\0".as_ptr()); + let argumentsSel = sel_registerName("arguments\0".as_ptr()); + let utf8Sel = sel_registerName("UTF8String\0".as_ptr()); + let countSel = sel_registerName("count\0".as_ptr()); + let objectAtSel = sel_registerName("objectAtIndex:\0".as_ptr()); + + let klass = objc_getClass("NSProcessInfo\0".as_ptr()); + let info = objc_msgSend(klass, processInfoSel); + let args = objc_msgSend(info, argumentsSel); + + let cnt: int = mem::transmute(objc_msgSend(args, countSel)); + for i in range(0, cnt) { + let tmp = objc_msgSend(args, objectAtSel, i); + let utf_c_str: *const libc::c_char = + mem::transmute(objc_msgSend(tmp, utf8Sel)); + let bytes = ffi::c_str_to_bytes(&utf_c_str).to_vec(); + res.push(OsString::from_vec(bytes)) + } + } + + Args { iter: res.into_iter(), _dont_send_or_sync_me: 0 as *mut _ } +} + +#[cfg(any(target_os = "linux", + target_os = "android", + target_os = "freebsd", + target_os = "dragonfly"))] +pub fn args() -> Args { + use rt; + let bytes = rt::args::clone().unwrap_or(Vec::new()); + let v: Vec = bytes.into_iter().map(|v| { + OsStringExt::from_vec(v) + }).collect(); + Args { iter: v.into_iter(), _dont_send_or_sync_me: 0 as *mut _ } +} + +pub struct Env { + iter: vec::IntoIter<(OsString, OsString)>, + _dont_send_or_sync_me: *mut (), +} + +impl Iterator for Env { + type Item = (OsString, OsString); + fn next(&mut self) -> Option<(OsString, OsString)> { self.iter.next() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } +} + +#[cfg(target_os = "macos")] +pub unsafe fn environ() -> *mut *const *const c_char { + extern { fn _NSGetEnviron() -> *mut *const *const c_char; } + _NSGetEnviron() +} + +#[cfg(not(target_os = "macos"))] +pub unsafe fn environ() -> *mut *const *const c_char { + extern { static mut environ: *const *const c_char; } + &mut environ +} + +/// Returns a vector of (variable, value) byte-vector pairs for all the +/// environment variables of the current process. +pub fn env() -> Env { + return unsafe { + let mut environ = *environ(); + if environ as usize == 0 { + panic!("os::env() failure getting env string from OS: {}", + IoError::last_error()); + } + let mut result = Vec::new(); + while *environ != ptr::null() { + result.push(parse(ffi::c_str_to_bytes(&*environ))); + environ = environ.offset(1); + } + Env { iter: result.into_iter(), _dont_send_or_sync_me: 0 as *mut _ } + }; + + fn parse(input: &[u8]) -> (OsString, OsString) { + let mut it = input.splitn(1, |b| *b == b'='); + let key = it.next().unwrap().to_vec(); + let default: &[u8] = &[]; + let val = it.next().unwrap_or(default).to_vec(); + (OsStringExt::from_vec(key), OsStringExt::from_vec(val)) + } +} + +pub fn getenv(k: &OsStr) -> Option { + unsafe { + let s = CString::from_slice(k.as_byte_slice()); + let s = libc::getenv(s.as_ptr()) as *const _; + if s.is_null() { + None + } else { + Some(OsStringExt::from_vec(ffi::c_str_to_bytes(&s).to_vec())) + } + } +} + +pub fn setenv(k: &OsStr, v: &OsStr) { + unsafe { + let k = CString::from_slice(k.as_byte_slice()); + let v = CString::from_slice(v.as_byte_slice()); + if libc::funcs::posix01::unistd::setenv(k.as_ptr(), v.as_ptr(), 1) != 0 { + panic!("failed setenv: {}", IoError::last_error()); + } + } +} + +pub fn unsetenv(n: &OsStr) { + unsafe { + let nbuf = CString::from_slice(n.as_byte_slice()); + if libc::funcs::posix01::unistd::unsetenv(nbuf.as_ptr()) != 0 { + panic!("failed unsetenv: {}", IoError::last_error()); } } } -pub fn page_size() -> uint { +pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> { + let mut fds = [0; 2]; + if libc::pipe(fds.as_mut_ptr()) == 0 { + Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true))) + } else { + Err(IoError::last_error()) + } +} + +pub fn page_size() -> usize { unsafe { - libc::sysconf(libc::_SC_PAGESIZE) as uint + libc::sysconf(libc::_SC_PAGESIZE) as usize } } + +pub fn temp_dir() -> Path { + getenv("TMPDIR".as_os_str()).map(|p| Path::new(p.into_vec())).unwrap_or_else(|| { + if cfg!(target_os = "android") { + Path::new("/data/local/tmp") + } else { + Path::new("/tmp") + } + }) +} + +pub fn home_dir() -> Option { + getenv("HOME".as_os_str()).or_else(|| unsafe { + let mut amt = match libc::sysconf(c::_SC_GETPW_R_SIZE_MAX) { + n if n < 0 => 512 as usize, + n => n as usize, + }; + let me = libc::getuid(); + loop { + let mut buf = Vec::with_capacity(amt); + let mut passwd: c::passwd = mem::zeroed(); + let mut result = 0 as *mut _; + match c::getpwuid_r(me, &mut passwd, buf.as_mut_ptr(), + buf.capacity() as libc::size_t, + &mut result) { + 0 if !result.is_null() => {} + _ => return None + } + let ptr = passwd.pw_dir as *const _; + let bytes = ffi::c_str_to_bytes(&ptr).to_vec(); + return Some(OsStringExt::from_vec(bytes)) + } + }).map(|os| { + Path::new(os.into_vec()) + }) +} diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index b004a47f8a3..ae648d13959 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -72,18 +72,6 @@ impl Process { } } - #[cfg(target_os = "macos")] - unsafe fn set_environ(envp: *const c_void) { - extern { fn _NSGetEnviron() -> *mut *const c_void; } - - *_NSGetEnviron() = envp; - } - #[cfg(not(target_os = "macos"))] - unsafe fn set_environ(envp: *const c_void) { - extern { static mut environ: *const c_void; } - environ = envp; - } - unsafe fn set_cloexec(fd: c_int) { let ret = c::ioctl(fd, c::FIOCLEX); assert_eq!(ret, 0); @@ -269,7 +257,7 @@ impl Process { fail(&mut output); } if !envp.is_null() { - set_environ(envp); + *sys::os::environ() = envp as *const _; } let _ = execvp(*argv, argv as *mut _); fail(&mut output); diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs index 1be1a412ffa..66712b9e3a1 100644 --- a/src/libstd/sys/windows/backtrace.rs +++ b/src/libstd/sys/windows/backtrace.rs @@ -7,29 +7,31 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. -/// As always, windows has something very different than unix, we mainly want -/// to avoid having to depend too much on libunwind for windows. -/// -/// If you google around, you'll find a fair bit of references to built-in -/// functions to get backtraces on windows. It turns out that most of these are -/// in an external library called dbghelp. I was unable to find this library -/// via `-ldbghelp`, but it is apparently normal to do the `dlopen` equivalent -/// of it. -/// -/// You'll also find that there's a function called CaptureStackBackTrace -/// mentioned frequently (which is also easy to use), but sadly I didn't have a -/// copy of that function in my mingw install (maybe it was broken?). Instead, -/// this takes the route of using StackWalk64 in order to walk the stack. + +//! As always, windows has something very different than unix, we mainly want +//! to avoid having to depend too much on libunwind for windows. +//! +//! If you google around, you'll find a fair bit of references to built-in +//! functions to get backtraces on windows. It turns out that most of these are +//! in an external library called dbghelp. I was unable to find this library +//! via `-ldbghelp`, but it is apparently normal to do the `dlopen` equivalent +//! of it. +//! +//! You'll also find that there's a function called CaptureStackBackTrace +//! mentioned frequently (which is also easy to use), but sadly I didn't have a +//! copy of that function in my mingw install (maybe it was broken?). Instead, +//! this takes the route of using StackWalk64 in order to walk the stack. + +#![allow(dead_code)] use dynamic_lib::DynamicLibrary; use ffi; -use core::ops::Index; use intrinsics; use old_io::{IoResult, Writer}; use libc; use mem; use ops::Drop; -use option::Option::{Some, None}; +use option::Option::{Some}; use path::Path; use ptr; use result::Result::{Ok, Err}; @@ -296,7 +298,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> { // According to windows documentation, all dbghelp functions are // single-threaded. static LOCK: StaticMutex = MUTEX_INIT; - let _g = unsafe { LOCK.lock() }; + let _g = LOCK.lock(); // Open up dbghelp.dll, we don't link to it explicitly because it can't // always be found. Additionally, it's nice having fewer dependencies. diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index da3b7ee2f2f..0355565cf00 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -10,17 +10,21 @@ //! C definitions used by libnative that don't belong in liblibc -#![allow(overflowing_literals)] -#![allow(dead_code)] -#![allow(non_camel_case_types)] +#![allow(bad_style, dead_code, overflowing_literals)] use libc; -use prelude::v1::*; -pub const WSADESCRIPTION_LEN: uint = 256; -pub const WSASYS_STATUS_LEN: uint = 128; +pub use self::GET_FILEEX_INFO_LEVELS::*; +pub use self::FILE_INFO_BY_HANDLE_CLASS::*; +pub use libc::consts::os::extra::{ + FILE_ATTRIBUTE_READONLY, + FILE_ATTRIBUTE_DIRECTORY, +}; + +pub const WSADESCRIPTION_LEN: usize = 256; +pub const WSASYS_STATUS_LEN: usize = 128; pub const FIONBIO: libc::c_long = 0x8004667e; -pub const FD_SETSIZE: uint = 64; +pub const FD_SETSIZE: usize = 64; pub const MSG_DONTWAIT: libc::c_int = 0; pub const ERROR_ILLEGAL_CHARACTER: libc::c_int = 582; pub const ENABLE_ECHO_INPUT: libc::DWORD = 0x4; @@ -32,12 +36,15 @@ pub const ENABLE_QUICK_EDIT_MODE: libc::DWORD = 0x40; pub const WSA_INVALID_EVENT: WSAEVENT = 0 as WSAEVENT; pub const FD_ACCEPT: libc::c_long = 0x08; -pub const FD_MAX_EVENTS: uint = 10; +pub const FD_MAX_EVENTS: usize = 10; pub const WSA_INFINITE: libc::DWORD = libc::INFINITE; pub const WSA_WAIT_TIMEOUT: libc::DWORD = libc::consts::os::extra::WAIT_TIMEOUT; pub const WSA_WAIT_EVENT_0: libc::DWORD = libc::consts::os::extra::WAIT_OBJECT_0; pub const WSA_WAIT_FAILED: libc::DWORD = libc::consts::os::extra::WAIT_FAILED; +pub const ERROR_NO_MORE_FILES: libc::DWORD = 18; +pub const TOKEN_READ: libc::DWORD = 0x20008; + #[repr(C)] #[cfg(target_arch = "x86")] pub struct WSADATA { @@ -80,7 +87,7 @@ pub struct fd_set { } pub fn fd_set(set: &mut fd_set, s: libc::SOCKET) { - set.fd_array[set.fd_count as uint] = s; + set.fd_array[set.fd_count as usize] = s; set.fd_count += 1; } @@ -110,6 +117,69 @@ pub struct CONSOLE_SCREEN_BUFFER_INFO { } pub type PCONSOLE_SCREEN_BUFFER_INFO = *mut CONSOLE_SCREEN_BUFFER_INFO; +#[repr(C)] +pub struct WIN32_FILE_ATTRIBUTE_DATA { + pub dwFileAttributes: libc::DWORD, + pub ftCreationTime: libc::FILETIME, + pub ftLastAccessTime: libc::FILETIME, + pub ftLastWriteTime: libc::FILETIME, + pub nFileSizeHigh: libc::DWORD, + pub nFileSizeLow: libc::DWORD, +} + +#[repr(C)] +pub struct BY_HANDLE_FILE_INFORMATION { + pub dwFileAttributes: libc::DWORD, + pub ftCreationTime: libc::FILETIME, + pub ftLastAccessTime: libc::FILETIME, + pub ftLastWriteTime: libc::FILETIME, + pub dwVolumeSerialNumber: libc::DWORD, + pub nFileSizeHigh: libc::DWORD, + pub nFileSizeLow: libc::DWORD, + pub nNumberOfLinks: libc::DWORD, + pub nFileIndexHigh: libc::DWORD, + pub nFileIndexLow: libc::DWORD, +} + +pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION; + +#[repr(C)] +pub enum GET_FILEEX_INFO_LEVELS { + GetFileExInfoStandard, + GetFileExMaxInfoLevel +} + +#[repr(C)] +pub enum FILE_INFO_BY_HANDLE_CLASS { + FileBasicInfo = 0, + FileStandardInfo = 1, + FileNameInfo = 2, + FileRenameInfo = 3, + FileDispositionInfo = 4, + FileAllocationInfo = 5, + FileEndOfFileInfo = 6, + FileStreamInfo = 7, + FileCompressionInfo = 8, + FileAttributeTagInfo = 9, + FileIdBothDirectoryInfo = 10, // 0xA + FileIdBothDirectoryRestartInfo = 11, // 0xB + FileIoPriorityHintInfo = 12, // 0xC + FileRemoteProtocolInfo = 13, // 0xD + FileFullDirectoryInfo = 14, // 0xE + FileFullDirectoryRestartInfo = 15, // 0xF + FileStorageInfo = 16, // 0x10 + FileAlignmentInfo = 17, // 0x11 + FileIdInfo = 18, // 0x12 + FileIdExtdDirectoryInfo = 19, // 0x13 + FileIdExtdDirectoryRestartInfo = 20, // 0x14 + MaximumFileInfoByHandlesClass +} + +#[repr(C)] +pub struct FILE_END_OF_FILE_INFO { + pub EndOfFile: libc::LARGE_INTEGER, +} + #[link(name = "ws2_32")] extern "system" { pub fn WSAStartup(wVersionRequested: libc::WORD, @@ -156,31 +226,29 @@ extern "system" { } pub mod compat { - use intrinsics::{atomic_store_relaxed, transmute}; - use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID}; use prelude::v1::*; + use ffi::CString; + use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID}; + use sync::atomic::{AtomicUsize, Ordering}; extern "system" { fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE; fn GetProcAddress(hModule: HMODULE, lpProcName: LPCSTR) -> LPVOID; } - // store_func() is idempotent, so using relaxed ordering for the atomics - // should be enough. This way, calling a function in this compatibility - // layer (after it's loaded) shouldn't be any slower than a regular DLL - // call. - unsafe fn store_func(ptr: *mut uint, module: &str, symbol: &str, fallback: uint) { + fn store_func(ptr: &AtomicUsize, module: &str, symbol: &str, + fallback: usize) -> usize { let mut module: Vec = module.utf16_units().collect(); module.push(0); let symbol = CString::from_slice(symbol.as_bytes()); - let handle = GetModuleHandleW(module.as_ptr()); - let func: uint = transmute(GetProcAddress(handle, symbol.as_ptr())); - atomic_store_relaxed(ptr, if func == 0 { - fallback - } else { - func - }) + let func = unsafe { + let handle = GetModuleHandleW(module.as_ptr()); + GetProcAddress(handle, symbol.as_ptr()) as usize + }; + let value = if func == 0 {fallback} else {func}; + ptr.store(value, Ordering::SeqCst); + value } /// Macro for creating a compatibility fallback for a Windows function @@ -192,29 +260,36 @@ pub mod compat { /// }) /// ``` /// - /// Note that arguments unused by the fallback implementation should not be called `_` as - /// they are used to be passed to the real function if available. + /// Note that arguments unused by the fallback implementation should not be + /// called `_` as they are used to be passed to the real function if + /// available. macro_rules! compat_fn { ($module:ident::$symbol:ident($($argname:ident: $argtype:ty),*) -> $rettype:ty { $fallback:expr }) => ( #[inline(always)] pub unsafe fn $symbol($($argname: $argtype),*) -> $rettype { - static mut ptr: extern "system" fn($($argname: $argtype),*) -> $rettype = thunk; - - extern "system" fn thunk($($argname: $argtype),*) -> $rettype { - unsafe { - ::sys::c::compat::store_func(&mut ptr as *mut _ as *mut uint, - stringify!($module), - stringify!($symbol), - fallback as uint); - ::intrinsics::atomic_load_relaxed(&ptr)($($argname),*) - } + use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; + use mem; + + static PTR: AtomicUsize = ATOMIC_USIZE_INIT; + + fn load() -> usize { + ::sys::c::compat::store_func(&PTR, + stringify!($module), + stringify!($symbol), + fallback as usize) } extern "system" fn fallback($($argname: $argtype),*) -> $rettype { $fallback } - ::intrinsics::atomic_load_relaxed(&ptr)($($argname),*) + let addr = match PTR.load(Ordering::SeqCst) { + 0 => load(), + n => n, + }; + let f: extern "system" fn($($argtype),*) -> $rettype = + mem::transmute(addr); + f($($argname),*) } ) } @@ -229,10 +304,7 @@ pub mod compat { use libc::c_uint; use libc::types::os::arch::extra::{DWORD, LPCWSTR, BOOLEAN, HANDLE}; use libc::consts::os::extra::ERROR_CALL_NOT_IMPLEMENTED; - - extern "system" { - fn SetLastError(dwErrCode: DWORD); - } + use sys::c::SetLastError; compat_fn! { kernel32::CreateSymbolicLinkW(_lpSymlinkFileName: LPCWSTR, @@ -282,4 +354,42 @@ extern "system" { hConsoleOutput: libc::HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO, ) -> libc::BOOL; + + pub fn GetFileAttributesExW(lpFileName: libc::LPCWSTR, + fInfoLevelId: GET_FILEEX_INFO_LEVELS, + lpFileInformation: libc::LPVOID) -> libc::BOOL; + pub fn RemoveDirectoryW(lpPathName: libc::LPCWSTR) -> libc::BOOL; + pub fn SetFileAttributesW(lpFileName: libc::LPCWSTR, + dwFileAttributes: libc::DWORD) -> libc::BOOL; + pub fn GetFileAttributesW(lpFileName: libc::LPCWSTR) -> libc::DWORD; + pub fn GetFileInformationByHandle(hFile: libc::HANDLE, + lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) + -> libc::BOOL; + + pub fn SetLastError(dwErrCode: libc::DWORD); + pub fn GetCommandLineW() -> *mut libc::LPCWSTR; + pub fn LocalFree(ptr: *mut libc::c_void); + pub fn CommandLineToArgvW(lpCmdLine: *mut libc::LPCWSTR, + pNumArgs: *mut libc::c_int) -> *mut *mut u16; + pub fn SetFileTime(hFile: libc::HANDLE, + lpCreationTime: *const libc::FILETIME, + lpLastAccessTime: *const libc::FILETIME, + lpLastWriteTime: *const libc::FILETIME) -> libc::BOOL; + pub fn SetFileInformationByHandle(hFile: libc::HANDLE, + FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, + lpFileInformation: libc::LPVOID, + dwBufferSize: libc::DWORD) -> libc::BOOL; + pub fn GetTempPathW(nBufferLength: libc::DWORD, + lpBuffer: libc::LPCWSTR) -> libc::DWORD; + pub fn OpenProcessToken(ProcessHandle: libc::HANDLE, + DesiredAccess: libc::DWORD, + TokenHandle: *mut libc::HANDLE) -> libc::BOOL; + pub fn GetCurrentProcess() -> libc::HANDLE; +} + +#[link(name = "userenv")] +extern "system" { + pub fn GetUserProfileDirectoryW(hToken: libc::HANDLE, + lpProfileDir: libc::LPCWSTR, + lpcchSize: *mut libc::DWORD) -> libc::BOOL; } diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index 80cdf9782f2..304d7e01532 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -10,20 +10,15 @@ //! Blocking Windows-based file I/O -use alloc::arc::Arc; use libc::{self, c_int}; use mem; -use sys::os::fill_utf16_buf_and_decode; -use path; use ptr; -use str; use old_io; use prelude::v1::*; use sys; -use sys::os; -use sys_common::{keep_going, eof, mkerr_libc}; +use sys_common::{mkerr_libc}; use old_io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode}; use old_io::{IoResult, IoError, FileStat, SeekStyle}; @@ -262,7 +257,7 @@ pub fn readdir(p: &Path) -> IoResult> { let mut more_files = 1 as libc::BOOL; while more_files != 0 { { - let filename = os::truncate_utf16_at_nul(&wfd.cFileName); + let filename = super::truncate_utf16_at_nul(&wfd.cFileName); match String::from_utf16(filename) { Ok(filename) => paths.push(Path::new(filename)), Err(..) => { @@ -368,19 +363,12 @@ pub fn readlink(p: &Path) -> IoResult { } // Specify (sz - 1) because the documentation states that it's the size // without the null pointer - let ret = fill_utf16_buf_and_decode(|buf, sz| unsafe { + let ret = super::fill_utf16_buf(|buf, sz| unsafe { GetFinalPathNameByHandleW(handle, buf as *const u16, sz - 1, libc::VOLUME_NAME_DOS) - }); - let ret = match ret { - Some(ref s) if s.starts_with(r"\\?\") => { // " - Ok(Path::new(&s[4..])) - } - Some(s) => Ok(Path::new(s)), - None => Err(super::last_error()), - }; + }, super::os2path); assert!(unsafe { libc::CloseHandle(handle) } != 0); return ret; } diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs new file mode 100644 index 00000000000..6737eeef125 --- /dev/null +++ b/src/libstd/sys/windows/handle.rs @@ -0,0 +1,31 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use prelude::v1::*; + +use libc::{self, HANDLE}; + +pub struct Handle(HANDLE); + +unsafe impl Send for Handle {} +unsafe impl Sync for Handle {} + +impl Handle { + pub fn new(handle: HANDLE) -> Handle { + Handle(handle) + } +} + +impl Drop for Handle { + fn drop(&mut self) { + unsafe { let _ = libc::CloseHandle(self.0); } + } +} + diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index e8b65c9b64e..8dd467eba9e 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -11,18 +11,14 @@ #![allow(missing_docs)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] -#![allow(unused_imports)] -#![allow(dead_code)] -#![allow(unused_unsafe)] -#![allow(unused_mut)] - -extern crate libc; use prelude::v1::*; -use num; +use ffi::OsStr; +use libc; use mem; use old_io::{self, IoResult, IoError}; +use os::windows::OsStrExt; use sync::{Once, ONCE_INIT}; macro_rules! helper_init { (static $name:ident: Helper<$m:ty>) => ( @@ -38,9 +34,10 @@ macro_rules! helper_init { (static $name:ident: Helper<$m:ty>) => ( pub mod backtrace; pub mod c; -pub mod ext; pub mod condvar; +pub mod ext; pub mod fs; +pub mod handle; pub mod helper_signal; pub mod mutex; pub mod os; @@ -48,12 +45,12 @@ pub mod os_str; pub mod pipe; pub mod process; pub mod rwlock; -pub mod sync; pub mod stack_overflow; +pub mod sync; pub mod tcp; -pub mod time; pub mod thread; pub mod thread_local; +pub mod time; pub mod timer; pub mod tty; pub mod udp; @@ -158,7 +155,7 @@ pub fn ms_to_timeval(ms: u64) -> libc::timeval { pub fn wouldblock() -> bool { let err = os::errno(); - err == libc::WSAEWOULDBLOCK as uint + err == libc::WSAEWOULDBLOCK as i32 } pub fn set_nonblocking(fd: sock_t, nb: bool) -> IoResult<()> { @@ -191,17 +188,93 @@ pub fn unimpl() -> IoError { } } -pub fn to_utf16(s: Option<&str>) -> IoResult> { +fn to_utf16(s: Option<&str>) -> IoResult> { match s { - Some(s) => Ok({ - let mut s = s.utf16_units().collect::>(); - s.push(0); - s - }), + Some(s) => Ok(to_utf16_os(OsStr::from_str(s))), None => Err(IoError { kind: old_io::InvalidInput, desc: "valid unicode input required", - detail: None - }) + detail: None, + }), + } +} + +fn to_utf16_os(s: &OsStr) -> Vec { + let mut v: Vec<_> = s.encode_wide().collect(); + v.push(0); + v +} + +// Many Windows APIs follow a pattern of where we hand the a buffer and then +// they will report back to us how large the buffer should be or how many bytes +// currently reside in the buffer. This function is an abstraction over these +// functions by making them easier to call. +// +// The first callback, `f1`, is yielded a (pointer, len) pair which can be +// passed to a syscall. The `ptr` is valid for `len` items (u16 in this case). +// The closure is expected to return what the syscall returns which will be +// interpreted by this function to determine if the syscall needs to be invoked +// again (with more buffer space). +// +// Once the syscall has completed (errors bail out early) the second closure is +// yielded the data which has been read from the syscall. The return value +// from this closure is then the return value of the function. +fn fill_utf16_buf(mut f1: F1, f2: F2) -> IoResult + where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD, + F2: FnOnce(&[u16]) -> T +{ + // Start off with a stack buf but then spill over to the heap if we end up + // needing more space. + let mut stack_buf = [0u16; 512]; + let mut heap_buf = Vec::new(); + unsafe { + let mut n = stack_buf.len(); + loop { + let buf = if n <= stack_buf.len() { + &mut stack_buf[] + } else { + let extra = n - heap_buf.len(); + heap_buf.reserve(extra); + heap_buf.set_len(n); + &mut heap_buf[] + }; + + // This function is typically called on windows API functions which + // will return the correct length of the string, but these functions + // also return the `0` on error. In some cases, however, the + // returned "correct length" may actually be 0! + // + // To handle this case we call `SetLastError` to reset it to 0 and + // then check it again if we get the "0 error value". If the "last + // error" is still 0 then we interpret it as a 0 length buffer and + // not an actual error. + c::SetLastError(0); + let k = match f1(buf.as_mut_ptr(), n as libc::DWORD) { + 0 if libc::GetLastError() == 0 => 0, + 0 => return Err(IoError::last_error()), + n => n, + } as usize; + if k == n && libc::GetLastError() == + libc::ERROR_INSUFFICIENT_BUFFER as libc::DWORD { + n *= 2; + } else if k >= n { + n = k; + } else { + return Ok(f2(&buf[..k])) + } + } + } +} + +fn os2path(s: &[u16]) -> Path { + // FIXME: this should not be a panicking conversion (aka path reform) + Path::new(String::from_utf16(s).unwrap()) +} + +pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { + match v.iter().position(|c| *c == 0) { + // don't include the 0 + Some(i) => &v[..i], + None => v } } diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs index 828ad795ed3..75495efc7cb 100644 --- a/src/libstd/sys/windows/mutex.rs +++ b/src/libstd/sys/windows/mutex.rs @@ -37,8 +37,6 @@ pub unsafe fn raw(m: &Mutex) -> ffi::PSRWLOCK { // no guarantees of fairness. impl Mutex { - #[inline] - pub unsafe fn new() -> Mutex { MUTEX_INIT } #[inline] pub unsafe fn lock(&self) { ffi::AcquireSRWLockExclusive(self.inner.get()) diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index a82259ad5ec..c71e2d057c3 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -10,48 +10,32 @@ //! Implementation of `std::os` functionality for Windows -// FIXME: move various extern bindings from here into liblibc or -// something similar +#![allow(bad_style)] use prelude::v1::*; +use os::windows::*; +use error::Error as StdError; +use ffi::{OsString, OsStr, AsOsStr}; use fmt; -use old_io::{IoResult, IoError}; -use iter::repeat; -use libc::{c_int, c_void}; -use libc; -use os; -use path::BytesContainer; +use iter::Range; +use libc::types::os::arch::extra::LPWCH; +use libc::{self, c_int, c_void}; +use mem; +use old_io::{IoError, IoResult}; use ptr; use slice; +use sys::c; use sys::fs::FileDesc; +use sys::handle::Handle as RawHandle; -use os::TMPBUF_SZ; -use libc::types::os::arch::extra::DWORD; +use libc::funcs::extra::kernel32::{ + GetEnvironmentStringsW, + FreeEnvironmentStringsW +}; -const BUF_BYTES : uint = 2048u; - -/// Return a slice of `v` ending at (and not including) the first NUL -/// (0). -pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { - match v.iter().position(|c| *c == 0) { - // don't include the 0 - Some(i) => &v[..i], - None => v - } -} - -pub fn errno() -> uint { - use libc::types::os::arch::extra::DWORD; - - #[link_name = "kernel32"] - extern "system" { - fn GetLastError() -> DWORD; - } - - unsafe { - GetLastError() as uint - } +pub fn errno() -> i32 { + unsafe { libc::GetLastError() as i32 } } /// Get a detailed string description for the given error number @@ -80,7 +64,7 @@ pub fn error_string(errnum: i32) -> String { // MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT) let langId = 0x0800 as DWORD; - let mut buf = [0 as WCHAR; TMPBUF_SZ]; + let mut buf = [0 as WCHAR; 2048]; unsafe { let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | @@ -94,200 +78,170 @@ pub fn error_string(errnum: i32) -> String { if res == 0 { // Sometimes FormatMessageW can fail e.g. system doesn't like langId, let fm_err = errno(); - return format!("OS Error {} (FormatMessageW() returned error {})", errnum, fm_err); + return format!("OS Error {} (FormatMessageW() returned error {})", + errnum, fm_err); } - let msg = String::from_utf16(truncate_utf16_at_nul(&buf)); + let b = buf.iter().position(|&b| b == 0).unwrap_or(buf.len()); + let msg = String::from_utf16(&buf[..b]); match msg { - Ok(msg) => format!("OS Error {}: {}", errnum, msg), + Ok(msg) => msg, Err(..) => format!("OS Error {} (FormatMessageW() returned \ invalid UTF-16)", errnum), } } } -pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> { - // Windows pipes work subtly differently than unix pipes, and their - // inheritance has to be handled in a different way that I do not - // fully understand. Here we explicitly make the pipe non-inheritable, - // which means to pass it to a subprocess they need to be duplicated - // first, as in std::run. - let mut fds = [0; 2]; - match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint, - (libc::O_BINARY | libc::O_NOINHERIT) as c_int) { - 0 => { - assert!(fds[0] != -1 && fds[0] != 0); - assert!(fds[1] != -1 && fds[1] != 0); - Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true))) - } - _ => Err(IoError::last_error()), - } +pub struct Env { + base: LPWCH, + cur: LPWCH, } -pub fn fill_utf16_buf_and_decode(mut f: F) -> Option where - F: FnMut(*mut u16, DWORD) -> DWORD, -{ - unsafe { - let mut n = TMPBUF_SZ as DWORD; - let mut res = None; - let mut done = false; - while !done { - let mut buf: Vec = repeat(0u16).take(n as uint).collect(); - let k = f(buf.as_mut_ptr(), n); - if k == (0 as DWORD) { - done = true; - } else if k == n && - libc::GetLastError() == - libc::ERROR_INSUFFICIENT_BUFFER as DWORD { - n *= 2 as DWORD; - } else if k >= n { - n = k; - } else { - done = true; - } - if k != 0 && done { - let sub = &buf[.. (k as uint)]; - // We want to explicitly catch the case when the - // closure returned invalid UTF-16, rather than - // set `res` to None and continue. - let s = String::from_utf16(sub).ok() - .expect("fill_utf16_buf_and_decode: closure created invalid UTF-16"); - res = Some(s) +impl Iterator for Env { + type Item = (OsString, OsString); + + fn next(&mut self) -> Option<(OsString, OsString)> { + unsafe { + if *self.cur == 0 { return None } + let p = &*self.cur; + let mut len = 0; + while *(p as *const _).offset(len) != 0 { + len += 1; } + let p = p as *const u16; + let s = slice::from_raw_buf(&p, len as usize); + self.cur = self.cur.offset(len + 1); + + let (k, v) = match s.iter().position(|&b| b == '=' as u16) { + Some(n) => (&s[..n], &s[n+1..]), + None => (s, &[][]), + }; + Some((OsStringExt::from_wide(k), OsStringExt::from_wide(v))) } - return res; } } -pub fn getcwd() -> IoResult { - use libc::DWORD; - use libc::GetCurrentDirectoryW; - use old_io::OtherIoError; +impl Drop for Env { + fn drop(&mut self) { + unsafe { FreeEnvironmentStringsW(self.base); } + } +} - let mut buf = [0 as u16; BUF_BYTES]; +pub fn env() -> Env { unsafe { - if libc::GetCurrentDirectoryW(buf.len() as DWORD, buf.as_mut_ptr()) == 0 as DWORD { - return Err(IoError::last_error()); + let ch = GetEnvironmentStringsW(); + if ch as usize == 0 { + panic!("failure getting env string from OS: {}", + IoError::last_error()); } + Env { base: ch, cur: ch } } +} - match String::from_utf16(truncate_utf16_at_nul(&buf)) { - Ok(ref cwd) => Ok(Path::new(cwd)), - Err(..) => Err(IoError { - kind: OtherIoError, - desc: "GetCurrentDirectoryW returned invalid UTF-16", - detail: None, - }), - } +pub struct SplitPaths<'a> { + data: EncodeWide<'a>, + must_yield: bool, } -pub unsafe fn get_env_pairs() -> Vec> { - use libc::funcs::extra::kernel32::{ - GetEnvironmentStringsW, - FreeEnvironmentStringsW - }; - let ch = GetEnvironmentStringsW(); - if ch as uint == 0 { - panic!("os::env() failure getting env string from OS: {}", - os::last_os_error()); +pub fn split_paths(unparsed: &OsStr) -> SplitPaths { + SplitPaths { + data: unparsed.encode_wide(), + must_yield: true, } - // Here, we lossily decode the string as UTF16. - // - // The docs suggest that the result should be in Unicode, but - // Windows doesn't guarantee it's actually UTF16 -- it doesn't - // validate the environment string passed to CreateProcess nor - // SetEnvironmentVariable. Yet, it's unlikely that returning a - // raw u16 buffer would be of practical use since the result would - // be inherently platform-dependent and introduce additional - // complexity to this code. - // - // Using the non-Unicode version of GetEnvironmentStrings is even - // worse since the result is in an OEM code page. Characters that - // can't be encoded in the code page would be turned into question - // marks. - let mut result = Vec::new(); - let mut i = 0; - while *ch.offset(i) != 0 { - let p = &*ch.offset(i); - let mut len = 0; - while *(p as *const _).offset(len) != 0 { - len += 1; - } - let p = p as *const u16; - let s = slice::from_raw_buf(&p, len as uint); - result.push(String::from_utf16_lossy(s).into_bytes()); - i += len as int + 1; - } - FreeEnvironmentStringsW(ch); - result } -pub fn split_paths(unparsed: &[u8]) -> Vec { - // On Windows, the PATH environment variable is semicolon separated. Double - // quotes are used as a way of introducing literal semicolons (since - // c:\some;dir is a valid Windows path). Double quotes are not themselves - // permitted in path names, so there is no way to escape a double quote. - // Quoted regions can appear in arbitrary locations, so - // - // c:\foo;c:\som"e;di"r;c:\bar - // - // Should parse as [c:\foo, c:\some;dir, c:\bar]. - // - // (The above is based on testing; there is no clear reference available - // for the grammar.) - - let mut parsed = Vec::new(); - let mut in_progress = Vec::new(); - let mut in_quote = false; - - for b in unparsed.iter() { - match *b { - b';' if !in_quote => { - parsed.push(Path::new(in_progress.as_slice())); - in_progress.truncate(0) - } - b'"' => { +impl<'a> Iterator for SplitPaths<'a> { + type Item = Path; + fn next(&mut self) -> Option { + // On Windows, the PATH environment variable is semicolon separated. + // Double quotes are used as a way of introducing literal semicolons + // (since c:\some;dir is a valid Windows path). Double quotes are not + // themselves permitted in path names, so there is no way to escape a + // double quote. Quoted regions can appear in arbitrary locations, so + // + // c:\foo;c:\som"e;di"r;c:\bar + // + // Should parse as [c:\foo, c:\some;dir, c:\bar]. + // + // (The above is based on testing; there is no clear reference available + // for the grammar.) + + + let must_yield = self.must_yield; + self.must_yield = false; + + let mut in_progress = Vec::new(); + let mut in_quote = false; + for b in self.data.by_ref() { + if b == '"' as u16 { in_quote = !in_quote; + } else if b == ';' as u16 && !in_quote { + self.must_yield = true; + break + } else { + in_progress.push(b) } - _ => { - in_progress.push(*b); - } + } + + if !must_yield && in_progress.is_empty() { + None + } else { + Some(super::os2path(&in_progress[])) } } - parsed.push(Path::new(in_progress)); - parsed } -pub fn join_paths(paths: &[T]) -> Result, &'static str> { +#[derive(Show)] +pub struct JoinPathsError; + +pub fn join_paths(paths: I) -> Result + where I: Iterator, T: AsOsStr +{ let mut joined = Vec::new(); - let sep = b';'; + let sep = b';' as u16; - for (i, path) in paths.iter().map(|p| p.container_as_bytes()).enumerate() { + for (i, path) in paths.enumerate() { + let path = path.as_os_str(); if i > 0 { joined.push(sep) } - if path.contains(&b'"') { - return Err("path segment contains `\"`"); - } else if path.contains(&sep) { - joined.push(b'"'); - joined.push_all(path); - joined.push(b'"'); + let v = path.encode_wide().collect::>(); + if v.contains(&(b'"' as u16)) { + return Err(JoinPathsError) + } else if v.contains(&sep) { + joined.push(b'"' as u16); + joined.push_all(&v[]); + joined.push(b'"' as u16); } else { - joined.push_all(path); + joined.push_all(&v[]); } } - Ok(joined) + Ok(OsStringExt::from_wide(&joined[])) } -pub fn load_self() -> Option> { - unsafe { - fill_utf16_buf_and_decode(|buf, sz| { - libc::GetModuleFileNameW(ptr::null_mut(), buf, sz) - }).map(|s| s.to_string().into_bytes()) +impl fmt::Display for JoinPathsError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + "path segment contains `\"`".fmt(f) } } +impl StdError for JoinPathsError { + fn description(&self) -> &str { "failed to join paths" } +} + +pub fn current_exe() -> IoResult { + super::fill_utf16_buf(|buf, sz| unsafe { + libc::GetModuleFileNameW(ptr::null_mut(), buf, sz) + }, super::os2path) +} + +pub fn getcwd() -> IoResult { + super::fill_utf16_buf(|buf, sz| unsafe { + libc::GetCurrentDirectoryW(sz, buf) + }, super::os2path) +} + pub fn chdir(p: &Path) -> IoResult<()> { - let mut p = p.as_str().unwrap().utf16_units().collect::>(); + let mut p = p.as_os_str().encode_wide().collect::>(); p.push(0); unsafe { @@ -298,39 +252,124 @@ pub fn chdir(p: &Path) -> IoResult<()> { } } -pub fn page_size() -> uint { - use mem; +pub fn getenv(k: &OsStr) -> Option { + let k = super::to_utf16_os(k); + super::fill_utf16_buf(|buf, sz| unsafe { + libc::GetEnvironmentVariableW(k.as_ptr(), buf, sz) + }, |buf| { + OsStringExt::from_wide(buf) + }).ok() +} + +pub fn setenv(k: &OsStr, v: &OsStr) { + let k = super::to_utf16_os(k); + let v = super::to_utf16_os(v); + unsafe { - let mut info = mem::zeroed(); - libc::GetSystemInfo(&mut info); + if libc::SetEnvironmentVariableW(k.as_ptr(), v.as_ptr()) == 0 { + panic!("failed to set env: {}", IoError::last_error()); + } + } +} - return info.dwPageSize as uint; +pub fn unsetenv(n: &OsStr) { + let v = super::to_utf16_os(n); + unsafe { + if libc::SetEnvironmentVariableW(v.as_ptr(), ptr::null()) == 0 { + panic!("failed to unset env: {}", IoError::last_error()); + } } } -#[cfg(test)] -mod tests { - use super::truncate_utf16_at_nul; +pub struct Args { + range: Range, + cur: *mut *mut u16, +} - #[test] - fn test_truncate_utf16_at_nul() { - let v = []; - let b: &[u16] = &[]; - assert_eq!(truncate_utf16_at_nul(&v), b); +impl Iterator for Args { + type Item = OsString; + fn next(&mut self) -> Option { + self.range.next().map(|i| unsafe { + let ptr = *self.cur.offset(i); + let mut len = 0; + while *ptr.offset(len) != 0 { len += 1; } + + // Push it onto the list. + let ptr = ptr as *const u16; + let buf = slice::from_raw_buf(&ptr, len as usize); + OsStringExt::from_wide(buf) + }) + } + fn size_hint(&self) -> (usize, Option) { self.range.size_hint() } +} - let v = [0, 2, 3]; - assert_eq!(truncate_utf16_at_nul(&v), b); +impl Drop for Args { + fn drop(&mut self) { + unsafe { c::LocalFree(self.cur as *mut c_void); } + } +} - let v = [1, 0, 3]; - let b: &[u16] = &[1]; - assert_eq!(truncate_utf16_at_nul(&v), b); +pub fn args() -> Args { + unsafe { + let mut nArgs: c_int = 0; + let lpCmdLine = c::GetCommandLineW(); + let szArgList = c::CommandLineToArgvW(lpCmdLine, &mut nArgs); - let v = [1, 2, 0]; - let b: &[u16] = &[1, 2]; - assert_eq!(truncate_utf16_at_nul(&v), b); + Args { cur: szArgList, range: range(0, nArgs as isize) } + } +} - let v = [1, 2, 3]; - let b: &[u16] = &[1, 2, 3]; - assert_eq!(truncate_utf16_at_nul(&v), b); +pub fn page_size() -> usize { + unsafe { + let mut info = mem::zeroed(); + libc::GetSystemInfo(&mut info); + return info.dwPageSize as usize; + } +} + +pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> { + // Windows pipes work subtly differently than unix pipes, and their + // inheritance has to be handled in a different way that I do not + // fully understand. Here we explicitly make the pipe non-inheritable, + // which means to pass it to a subprocess they need to be duplicated + // first, as in std::run. + let mut fds = [0; 2]; + match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint, + (libc::O_BINARY | libc::O_NOINHERIT) as c_int) { + 0 => { + assert!(fds[0] != -1 && fds[0] != 0); + assert!(fds[1] != -1 && fds[1] != 0); + Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true))) + } + _ => Err(IoError::last_error()), } } + +pub fn temp_dir() -> Path { + super::fill_utf16_buf(|buf, sz| unsafe { + c::GetTempPathW(sz, buf) + }, super::os2path).unwrap() +} + +pub fn home_dir() -> Option { + getenv("HOME".as_os_str()).or_else(|| { + getenv("USERPROFILE".as_os_str()) + }).map(|os| { + // FIXME: OsString => Path + Path::new(os.to_str().unwrap()) + }).or_else(|| unsafe { + let me = c::GetCurrentProcess(); + let mut token = ptr::null_mut(); + if c::OpenProcessToken(me, c::TOKEN_READ, &mut token) == 0 { + return None + } + let _handle = RawHandle::new(token); + super::fill_utf16_buf(|buf, mut sz| { + match c::GetUserProfileDirectoryW(token, buf, &mut sz) { + 0 if libc::GetLastError() != 0 => 0, + 0 => sz, + n => n as libc::DWORD, + } + }, super::os2path).ok() + }) +} diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index 0bc2a827272..1f228b7d32e 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -352,7 +352,7 @@ impl UnixStream { fn cancel_io(&self) -> IoResult<()> { match unsafe { c::CancelIoEx(self.handle(), ptr::null_mut()) } { - 0 if os::errno() == libc::ERROR_NOT_FOUND as uint => { + 0 if os::errno() == libc::ERROR_NOT_FOUND as i32 => { Ok(()) } 0 => Err(super::last_error()), @@ -374,7 +374,7 @@ impl UnixStream { // acquire the lock. // // See comments in close_read() about why this lock is necessary. - let guard = unsafe { self.inner.lock.lock() }; + let guard = self.inner.lock.lock(); if self.read_closed() { return Err(eof()) } @@ -392,7 +392,7 @@ impl UnixStream { // If our errno doesn't say that the I/O is pending, then we hit some // legitimate error and return immediately. - if os::errno() != libc::ERROR_IO_PENDING as uint { + if os::errno() != libc::ERROR_IO_PENDING as i32 { return Err(super::last_error()) } @@ -417,7 +417,7 @@ impl UnixStream { // If we succeeded, or we failed for some reason other than // CancelIoEx, return immediately if ret != 0 { return Ok(bytes_read as uint) } - if os::errno() != libc::ERROR_OPERATION_ABORTED as uint { + if os::errno() != libc::ERROR_OPERATION_ABORTED as i32 { return Err(super::last_error()) } @@ -450,7 +450,7 @@ impl UnixStream { // going after we woke up. // // See comments in close_read() about why this lock is necessary. - let guard = unsafe { self.inner.lock.lock() }; + let guard = self.inner.lock.lock(); if self.write_closed() { return Err(epipe()) } @@ -465,7 +465,7 @@ impl UnixStream { drop(guard); if ret == 0 { - if err != libc::ERROR_IO_PENDING as uint { + if err != libc::ERROR_IO_PENDING as i32 { return Err(decode_error_detailed(err as i32)) } // Process a timeout if one is pending @@ -481,7 +481,7 @@ impl UnixStream { // aborted, then check to see if the write half was actually // closed or whether we woke up from the read half closing. if ret == 0 { - if os::errno() != libc::ERROR_OPERATION_ABORTED as uint { + if os::errno() != libc::ERROR_OPERATION_ABORTED as i32 { return Err(super::last_error()) } if !wait_succeeded.is_ok() { @@ -525,14 +525,14 @@ impl UnixStream { // close_read() between steps 1 and 2. By atomically executing steps 1 // and 2 with a lock with respect to close_read(), we're guaranteed that // no thread will erroneously sit in a read forever. - let _guard = unsafe { self.inner.lock.lock() }; + let _guard = self.inner.lock.lock(); self.inner.read_closed.store(true, Ordering::SeqCst); self.cancel_io() } pub fn close_write(&mut self) -> IoResult<()> { // see comments in close_read() for why this lock is necessary - let _guard = unsafe { self.inner.lock.lock() }; + let _guard = self.inner.lock.lock(); self.inner.write_closed.store(true, Ordering::SeqCst); self.cancel_io() } diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 3d66718d00b..043fdb38805 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -10,28 +10,27 @@ use prelude::v1::*; +use collections::hash_map::Hasher; use collections; +use env; use ffi::CString; use hash::Hash; -use collections::hash_map::Hasher; +use libc::{pid_t, c_void}; +use libc; +use mem; use old_io::fs::PathExtensions; -use old_io::process::{ProcessExit, ExitStatus, ExitSignal}; +use old_io::process::{ProcessExit, ExitStatus}; use old_io::{IoResult, IoError}; use old_io; -use libc::{pid_t, c_void, c_int}; -use libc; -use mem; use os; use path::BytesContainer; use ptr; use str; -use sys::fs::FileDesc; use sync::{StaticMutex, MUTEX_INIT}; +use sys::fs::FileDesc; -use sys::fs; -use sys::{self, retry, c, wouldblock, set_nonblocking, ms_to_timeval, timer}; -use sys_common::helper_thread::Helper; -use sys_common::{AsInner, mkerr_libc, timeout}; +use sys::timer; +use sys_common::{AsInner, timeout}; pub use sys_common::ProcessConfig; @@ -106,6 +105,7 @@ impl Process { return ret; } + #[allow(deprecated)] pub fn spawn(cfg: &C, in_fd: Option

, out_fd: Option

, err_fd: Option

) -> IoResult @@ -128,7 +128,7 @@ impl Process { use libc::funcs::extra::msvcrt::get_osfhandle; use mem; - use iter::{Iterator, IteratorExt}; + use iter::IteratorExt; use str::StrExt; if cfg.gid().is_some() || cfg.uid().is_some() { @@ -149,7 +149,7 @@ impl Process { // program exists. for path in os::split_paths(v.container_as_bytes()).into_iter() { let path = path.join(cfg.program().as_bytes()) - .with_extension(os::consts::EXE_EXTENSION); + .with_extension(env::consts::EXE_EXTENSION); if path.exists() { return Some(CString::from_slice(path.as_vec())) } diff --git a/src/libstd/sys/windows/rwlock.rs b/src/libstd/sys/windows/rwlock.rs index 88ce85c39f6..76fe352ed77 100644 --- a/src/libstd/sys/windows/rwlock.rs +++ b/src/libstd/sys/windows/rwlock.rs @@ -18,9 +18,6 @@ pub const RWLOCK_INIT: RWLock = RWLock { }; impl RWLock { - #[inline] - pub unsafe fn new() -> RWLock { RWLOCK_INIT } - #[inline] pub unsafe fn read(&self) { ffi::AcquireSRWLockShared(self.inner.get()) diff --git a/src/libstd/sys/windows/stack_overflow.rs b/src/libstd/sys/windows/stack_overflow.rs index 0cb4c573ae3..b0410701ee1 100644 --- a/src/libstd/sys/windows/stack_overflow.rs +++ b/src/libstd/sys/windows/stack_overflow.rs @@ -14,7 +14,7 @@ use ptr; use mem; use libc; use libc::types::os::arch::extra::{LPVOID, DWORD, LONG, BOOL}; -use sys_common::{stack, thread_info}; +use sys_common::stack; pub struct Handler { _data: *mut libc::c_void @@ -30,14 +30,6 @@ impl Drop for Handler { fn drop(&mut self) {} } -// get_task_info is called from an exception / signal handler. -// It returns the guard page of the current task or 0 if that -// guard page doesn't exist. None is returned if there's currently -// no local task. -unsafe fn get_task_guard_page() -> uint { - thread_info::stack_guard() -} - // This is initialized in init() and only read from after static mut PAGE_SIZE: uint = 0; diff --git a/src/libstd/sys/windows/sync.rs b/src/libstd/sys/windows/sync.rs index d60646b7db9..7614104c98b 100644 --- a/src/libstd/sys/windows/sync.rs +++ b/src/libstd/sys/windows/sync.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use libc::{BOOL, DWORD, c_void, LPVOID, c_ulong}; +use libc::{BOOL, DWORD, LPVOID, c_ulong}; use libc::types::os::arch::extra::BOOLEAN; pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; diff --git a/src/libstd/sys/windows/tcp.rs b/src/libstd/sys/windows/tcp.rs index 64e440331c1..4804ca510cb 100644 --- a/src/libstd/sys/windows/tcp.rs +++ b/src/libstd/sys/windows/tcp.rs @@ -14,12 +14,11 @@ use libc; use mem; use ptr; use prelude::v1::*; -use super::{last_error, last_net_error, retry, sock_t}; +use super::{last_error, last_net_error, sock_t}; use sync::Arc; use sync::atomic::{AtomicBool, Ordering}; -use sys::fs::FileDesc; use sys::{self, c, set_nonblocking, wouldblock, timer}; -use sys_common::{self, timeout, eof, net}; +use sys_common::{timeout, eof, net}; pub use sys_common::net::TcpStream; @@ -202,10 +201,6 @@ impl TcpAcceptor { Err(eof()) } - pub fn socket_name(&mut self) -> IoResult { - net::sockname(self.socket(), libc::getsockname) - } - pub fn set_timeout(&mut self, timeout: Option) { self.deadline = timeout.map(|a| timer::now() + a).unwrap_or(0); } diff --git a/src/libstd/sys/windows/thread.rs b/src/libstd/sys/windows/thread.rs index a94adcb3bc7..a38dc9b2d34 100644 --- a/src/libstd/sys/windows/thread.rs +++ b/src/libstd/sys/windows/thread.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use core::prelude::*; - use boxed::Box; use cmp; use mem; diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index 0f8ceed39a6..cc731738afe 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -233,6 +233,7 @@ unsafe extern "system" fn on_tls_callback(h: LPVOID, } } +#[allow(dead_code)] // actually called above unsafe fn run_dtors() { let mut any_run = true; for _ in 0..5 { diff --git a/src/libstd/sys/windows/timer.rs b/src/libstd/sys/windows/timer.rs index 34f3c418c55..d156dd801f9 100644 --- a/src/libstd/sys/windows/timer.rs +++ b/src/libstd/sys/windows/timer.rs @@ -28,8 +28,6 @@ use ptr; use old_io::IoResult; use sync::mpsc::{channel, Sender, Receiver, TryRecvError}; -use sys::c; -use sys::fs::FileDesc; use sys_common::helper_thread::Helper; helper_init! { static HELPER: Helper } diff --git a/src/libstd/sys/windows/tty.rs b/src/libstd/sys/windows/tty.rs index 6ecabfa9853..f02c8e49f41 100644 --- a/src/libstd/sys/windows/tty.rs +++ b/src/libstd/sys/windows/tty.rs @@ -38,7 +38,7 @@ use str::from_utf8; use super::c::{ENABLE_ECHO_INPUT, ENABLE_EXTENDED_FLAGS}; use super::c::{ENABLE_INSERT_MODE, ENABLE_LINE_INPUT}; use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE}; -use super::c::{ERROR_ILLEGAL_CHARACTER, CONSOLE_SCREEN_BUFFER_INFO}; +use super::c::{CONSOLE_SCREEN_BUFFER_INFO}; use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode}; use super::c::{GetConsoleScreenBufferInfo}; @@ -155,9 +155,6 @@ impl TTY { (info.srWindow.Bottom + 1 - info.srWindow.Top) as int)), } } - - // Let us magically declare this as a TTY - pub fn isatty(&self) -> bool { true } } impl Drop for TTY { diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index 9f6bf352b04..9aa454ae8d5 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -21,7 +21,7 @@ use ext::base; use ext::build::AstBuilder; use parse::token; -use std::os; +use std::env; pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { @@ -30,8 +30,8 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT Some(v) => v }; - let e = match os::getenv(&var[]) { - None => { + let e = match env::var_string(&var[]) { + Err(..) => { cx.expr_path(cx.path_all(sp, true, vec!(cx.ident_of("std"), @@ -48,7 +48,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT ast::MutImmutable)), Vec::new())) } - Some(s) => { + Ok(s) => { cx.expr_call_global(sp, vec!(cx.ident_of("std"), cx.ident_of("option"), @@ -101,12 +101,12 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) } } - let e = match os::getenv(var.get()) { - None => { + let e = match env::var_string(var.get()) { + Err(..) => { cx.span_err(sp, msg.get()); cx.expr_usize(sp, 0) } - Some(s) => cx.expr_str(sp, token::intern_and_get_ident(&s[])) + Ok(s) => cx.expr_str(sp, token::intern_and_get_ident(&s[])) }; MacExpr::new(e) } diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 73424136cfb..54b37483f8c 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -28,11 +28,11 @@ #![feature(box_syntax)] #![feature(collections)] #![feature(core)] +#![feature(env)] #![feature(hash)] #![feature(int_uint)] #![feature(io)] #![feature(libc)] -#![feature(os)] #![feature(path)] #![feature(quote, unsafe_destructor)] #![feature(rustc_private)] diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index 27a46fb5a68..219c9baf4c8 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -55,13 +55,14 @@ #![feature(core)] #![feature(int_uint)] #![feature(io)] -#![feature(os)] #![feature(path)] #![feature(rustc_private)] #![feature(slicing_syntax)] #![feature(staged_api)] #![feature(std_misc)] #![feature(unicode)] +#![feature(env)] +#![cfg_attr(windows, feature(libc))] #[macro_use] extern crate log; diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs index d126717ce68..17c1e8cdb8c 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -12,7 +12,7 @@ use std::collections::HashMap; use std::old_io::IoResult; -use std::os; +use std::env; use attr; use color; @@ -172,9 +172,9 @@ impl TerminfoTerminal { /// Returns `None` whenever the terminal cannot be created for some /// reason. pub fn new(out: T) -> Option+Send+'static>> { - let term = match os::getenv("TERM") { - Some(t) => t, - None => { + let term = match env::var_string("TERM") { + Ok(t) => t, + Err(..) => { debug!("TERM environment variable not defined"); return None; } @@ -182,7 +182,7 @@ impl TerminfoTerminal { let entry = open(&term[]); if entry.is_err() { - if os::getenv("MSYSCON").map_or(false, |s| { + if env::var_string("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 1e84c0462d6..74c986cd9e2 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -14,8 +14,7 @@ use std::old_io::File; use std::old_io::fs::PathExtensions; -use std::os::getenv; -use std::os; +use std::env; /// Return path to database entry for `term` pub fn get_dbpath_for_term(term: &str) -> Option> { @@ -23,21 +22,21 @@ pub fn get_dbpath_for_term(term: &str) -> Option> { return None; } - let homedir = os::homedir(); + let homedir = env::home_dir(); let mut dirs_to_search = Vec::new(); let first_char = term.char_at(0); // Find search directory - match getenv("TERMINFO") { - Some(dir) => dirs_to_search.push(Path::new(dir)), - None => { + match env::var_string("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 getenv("TERMINFO_DIRS") { - Some(dirs) => for i in dirs.split(':') { + match env::var_string("TERMINFO_DIRS") { + Ok(dirs) => for i in dirs.split(':') { if i == "" { dirs_to_search.push(Path::new("/usr/share/terminfo")); } else { @@ -48,7 +47,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option> { // According to /etc/terminfo/README, after looking at // ~/.terminfo, ncurses will search /etc/terminfo, then // /lib/terminfo, and eventually /usr/share/terminfo. - None => { + Err(..) => { dirs_to_search.push(Path::new("/etc/terminfo")); dirs_to_search.push(Path::new("/lib/terminfo")); dirs_to_search.push(Path::new("/usr/share/terminfo")); diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index f22c58c54a6..2295f122822 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -38,10 +38,10 @@ #![feature(box_syntax)] #![feature(collections)] #![feature(core)] +#![feature(env)] #![feature(hash)] #![feature(int_uint)] #![feature(io)] -#![feature(os)] #![feature(path)] #![feature(rustc_private)] #![feature(staged_api)] @@ -75,7 +75,7 @@ use std::old_io::{File, ChanReader, ChanWriter}; use std::old_io; use std::iter::repeat; use std::num::{Float, Int}; -use std::os; +use std::env; use std::sync::mpsc::{channel, Sender}; use std::thread::{self, Thread}; use std::thunk::{Thunk, Invoke}; @@ -388,7 +388,7 @@ pub fn parse_opts(args: &[String]) -> Option { let mut nocapture = matches.opt_present("nocapture"); if !nocapture { - nocapture = os::getenv("RUST_TEST_NOCAPTURE").is_some(); + nocapture = env::var("RUST_TEST_NOCAPTURE").is_some(); } let color = match matches.opt_str("color").as_ref().map(|s| s.as_slice()) { @@ -817,15 +817,15 @@ fn run_tests(opts: &TestOpts, fn get_concurrency() -> uint { use std::rt; - match os::getenv("RUST_TEST_TASKS") { - Some(s) => { + match env::var_string("RUST_TEST_TASKS") { + Ok(s) => { let opt_n: Option = s.parse().ok(); match opt_n { Some(n) if n > 0 => n, _ => panic!("RUST_TEST_TASKS is `{}`, should be a positive integer.", s) } } - None => { + Err(..) => { rt::default_sched_threads() } } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 4a9c5a91dcf..ac32b584801 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -48,12 +48,12 @@ use std::simd::f64x2; use std::sync::Arc; use std::thread::Thread; -const ITER: int = 50; +const ITER: usize = 50; const LIMIT: f64 = 2.0; -const WORKERS: uint = 16; +const WORKERS: usize = 16; #[inline(always)] -fn mandelbrot(w: uint, mut out: W) -> old_io::IoResult<()> { +fn mandelbrot(w: usize, mut out: W) -> old_io::IoResult<()> { assert!(WORKERS % 2 == 0); // Ensure w and h are multiples of 8. @@ -198,7 +198,6 @@ fn write_line(init_i: f64, vec_init_r: &[f64], res: &mut Vec) { fn main() { let args = os::args(); - let args = args.as_slice(); 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."); diff --git a/src/test/compile-fail/liveness-unused.rs b/src/test/compile-fail/liveness-unused.rs index ebcf46f7277..960d9ef0f2f 100644 --- a/src/test/compile-fail/liveness-unused.rs +++ b/src/test/compile-fail/liveness-unused.rs @@ -12,7 +12,6 @@ #![deny(unused_assignments)] #![allow(dead_code, non_camel_case_types)] #![feature(core)] -#![feature(os)] fn f1(x: isize) { //~^ ERROR unused variable: `x` @@ -98,7 +97,7 @@ fn f5c() { for (_, x) in [1is, 2, 3].iter().enumerate() { //~^ ERROR unused variable: `x` continue; - std::os::set_exit_status(*x); //~ WARNING unreachable statement + drop(*x as i32); //~ WARNING unreachable statement } } diff --git a/src/test/run-pass/env-home-dir.rs b/src/test/run-pass/env-home-dir.rs new file mode 100644 index 00000000000..5623e98c928 --- /dev/null +++ b/src/test/run-pass/env-home-dir.rs @@ -0,0 +1,45 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::env::*; + +#[cfg(unix)] +fn main() { + let oldhome = var("HOME"); + + set_var("HOME", "/home/MountainView"); + assert!(home_dir() == Some(Path::new("/home/MountainView"))); + + remove_var("HOME"); + assert!(home_dir().is_some()); +} + +#[cfg(windows)] +fn main() { + let oldhome = var("HOME"); + let olduserprofile = var("USERPROFILE"); + + remove_var("HOME"); + remove_var("USERPROFILE"); + + assert!(home_dir().is_some()); + + set_var("HOME", "/home/MountainView"); + assert!(home_dir() == Some(Path::new("/home/MountainView"))); + + remove_var("HOME"); + + set_var("USERPROFILE", "/home/MountainView"); + assert!(home_dir() == Some(Path::new("/home/MountainView"))); + + set_var("HOME", "/home/MountainView"); + set_var("USERPROFILE", "/home/PaloAlto"); + assert!(home_dir() == Some(Path::new("/home/MountainView"))); +} diff --git a/src/test/run-pass/env-vars.rs b/src/test/run-pass/env-vars.rs new file mode 100644 index 00000000000..892041b9648 --- /dev/null +++ b/src/test/run-pass/env-vars.rs @@ -0,0 +1,22 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::env::*; + +fn main() { + for (k, v) in vars() { + let v2 = var(&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(). + assert!(v2.is_none() || v2.as_ref().map(|s| &**s) == Some(&*v), + "bad vars->var transition: {:?} {:?} {:?}", k, v, v2); + } +} -- cgit 1.4.1-3-g733a5 From 134cf707dfb8f37d735d20ff261366b7c2d916a6 Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sat, 31 Jan 2015 09:16:56 -0500 Subject: register snapshots --- src/libcollections/slice.rs | 6 ----- src/libcollections/str.rs | 5 ---- src/libcollections/string.rs | 12 ---------- src/libcollections/vec.rs | 22 ------------------ src/libcore/array.rs | 3 --- src/libcore/fmt/mod.rs | 53 ------------------------------------------- src/libcore/fmt/rt/v1.rs | 13 ----------- src/libcore/ops.rs | 17 -------------- src/libcore/prelude.rs | 3 --- src/libcore/slice.rs | 13 ----------- src/libcore/str/mod.rs | 10 -------- src/libfmt_macros/lib.rs | 1 - src/libstd/ffi/os_str.rs | 11 --------- src/libstd/fmt.rs | 4 ---- src/libstd/lib.rs | 2 +- src/libstd/path/mod.rs | 2 -- src/libstd/path/windows.rs | 2 -- src/libstd/prelude/v1.rs | 4 ---- src/libstd/rt/unwind.rs | 4 ++-- src/libstd/sys/common/wtf8.rs | 11 --------- src/snapshots.txt | 9 ++++++++ 21 files changed, 12 insertions(+), 195 deletions(-) (limited to 'src/libstd/rt') diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index d2f92d1c8db..affa4898010 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -98,9 +98,6 @@ use core::iter::{range_step, MultiplicativeIterator}; use core::marker::Sized; use core::mem::size_of; use core::mem; -#[cfg(stage0)] -use core::ops::{FnMut, FullRange}; -#[cfg(not(stage0))] use core::ops::FnMut; use core::option::Option::{self, Some, None}; use core::ptr::PtrExt; @@ -1512,9 +1509,6 @@ mod tests { use core::prelude::{Some, None, range, Clone}; use core::prelude::{Iterator, IteratorExt}; use core::prelude::{AsSlice}; - #[cfg(stage0)] - use core::prelude::{Ord, FullRange}; - #[cfg(not(stage0))] use core::prelude::Ord; use core::default::Default; use core::mem; diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index ded6385d293..43b5d14cc86 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -61,11 +61,6 @@ use core::clone::Clone; use core::iter::AdditiveIterator; use core::iter::{Iterator, IteratorExt}; use core::ops::Index; -#[cfg(stage0)] -use core::ops::FullRange as RangeFull; -#[cfg(stage0)] -use core::ops::FullRange; -#[cfg(not(stage0))] use core::ops::RangeFull; use core::option::Option::{self, Some, None}; use core::result::Result; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 4cb7b05f967..d0b89cfa2c3 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -877,16 +877,6 @@ impl ops::Index> for String { &self[][*index] } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index for String { - type Output = str; - #[inline] - fn index(&self, _index: &ops::FullRange) -> &str { - unsafe { mem::transmute(self.vec.as_slice()) } - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl ops::Index for String { type Output = str; @@ -1011,8 +1001,6 @@ mod tests { use str::Utf8Error; use core::iter::repeat; use super::{as_string, CowString}; - #[cfg(stage0)] - use core::ops::FullRange; #[test] fn test_as_string() { diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index c45879ae251..82c1c37ab6a 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1318,16 +1318,6 @@ impl ops::Index> for Vec { self.as_slice().index(index) } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index for Vec { - type Output = [T]; - #[inline] - fn index(&self, _index: &ops::FullRange) -> &[T] { - self.as_slice() - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl ops::Index for Vec { type Output = [T]; @@ -1361,16 +1351,6 @@ impl ops::IndexMut> for Vec { self.as_mut_slice().index_mut(index) } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl ops::IndexMut for Vec { - type Output = [T]; - #[inline] - fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] { - self.as_mut_slice() - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl ops::IndexMut for Vec { type Output = [T]; @@ -1934,8 +1914,6 @@ mod tests { use prelude::*; use core::mem::size_of; use core::iter::repeat; - #[cfg(stage0)] - use core::ops::FullRange; use test::Bencher; use super::as_vec; diff --git a/src/libcore/array.rs b/src/libcore/array.rs index ec3d9783255..5c4567e567b 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -20,9 +20,6 @@ use fmt; use hash::{Hash, Hasher, self}; use iter::IntoIterator; use marker::Copy; -#[cfg(stage0)] -use ops::{Deref, FullRange}; -#[cfg(not(stage0))] use ops::Deref; use option::Option; use slice::{Iter, IterMut, SliceExt}; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 2ff67ebd550..694888bb2bc 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -38,7 +38,6 @@ mod float; #[stable(feature = "rust1", since = "1.0.0")] #[doc(hidden)] pub mod rt { - #[cfg(stage0)] pub use self::v1::*; pub mod v1; } @@ -191,20 +190,6 @@ impl<'a> Arguments<'a> { } } - /// When using the format_args!() macro, this function is used to generate the - /// Arguments structure. - #[doc(hidden)] #[inline] - #[cfg(stage0)] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn new(pieces: &'a [&'a str], - args: &'a [ArgumentV1<'a>]) -> Arguments<'a> { - Arguments { - pieces: pieces, - fmt: None, - args: args - } - } - /// This function is used to specify nonstandard formatting parameters. /// The `pieces` array must be at least as long as `fmt` to construct /// a valid Arguments structure. Also, any `Count` within `fmt` that is @@ -212,25 +197,6 @@ impl<'a> Arguments<'a> { /// created with `argumentuint`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] - #[cfg(stage0)] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_placeholders(pieces: &'a [&'a str], - fmt: &'a [rt::v1::Argument], - args: &'a [ArgumentV1<'a>]) -> Arguments<'a> { - Arguments { - pieces: pieces, - fmt: Some(fmt), - args: args - } - } - /// This function is used to specify nonstandard formatting parameters. - /// The `pieces` array must be at least as long as `fmt` to construct - /// a valid Arguments structure. Also, any `Count` within `fmt` that is - /// `CountIsParam` or `CountIsNextParam` has to point to an argument - /// created with `argumentuint`. However, failing to do so doesn't cause - /// unsafety, but will ignore invalid . - #[doc(hidden)] #[inline] - #[cfg(not(stage0))] pub fn new_v1_formatted(pieces: &'a [&'a str], args: &'a [ArgumentV1<'a>], fmt: &'a [rt::v1::Argument]) -> Arguments<'a> { @@ -684,25 +650,6 @@ impl Display for Error { } } -/// This is a function which calls are emitted to by the compiler itself to -/// create the Argument structures that are passed into the `format` function. -#[doc(hidden)] #[inline] -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, - t: &'a T) -> ArgumentV1<'a> { - ArgumentV1::new(t, f) -} - -/// When the compiler determines that the type of an argument *must* be a uint -/// (such as for width and precision), then it invokes this method. -#[doc(hidden)] #[inline] -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -pub fn argumentuint<'a>(s: &'a uint) -> ArgumentV1<'a> { - ArgumentV1::from_uint(s) -} - // Implementations of the core formatting traits macro_rules! fmt_refs { diff --git a/src/libcore/fmt/rt/v1.rs b/src/libcore/fmt/rt/v1.rs index f0c82759b70..0c9bb6316e0 100644 --- a/src/libcore/fmt/rt/v1.rs +++ b/src/libcore/fmt/rt/v1.rs @@ -16,19 +16,6 @@ #![stable(feature = "rust1", since = "1.0.0")] -#[cfg(stage0)] pub use self::Position::*; - -#[cfg(stage0)] pub use self::Alignment::Left as AlignLeft; -#[cfg(stage0)] pub use self::Alignment::Right as AlignRight; -#[cfg(stage0)] pub use self::Alignment::Center as AlignCenter; -#[cfg(stage0)] pub use self::Alignment::Unknown as AlignUnknown; -#[cfg(stage0)] pub use self::Count::Is as CountIs; -#[cfg(stage0)] pub use self::Count::Implied as CountImplied; -#[cfg(stage0)] pub use self::Count::Param as CountIsParam; -#[cfg(stage0)] pub use self::Count::NextParam as CountIsNextParam; -#[cfg(stage0)] pub use self::Position::Next as ArgumentNext; -#[cfg(stage0)] pub use self::Position::At as ArgumentIs; - #[derive(Copy)] #[stable(feature = "rust1", since = "1.0.0")] pub struct Argument { diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index f656fd4b8b9..7af94c73f32 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -947,28 +947,11 @@ pub trait IndexMut { } /// An unbounded range. -#[cfg(stage0)] -#[derive(Copy, Clone, PartialEq, Eq)] -#[lang="full_range"] -#[unstable(feature = "core", reason = "may be renamed to RangeFull")] -pub struct FullRange; - -/// An unbounded range. -#[cfg(not(stage0))] #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range_full"] #[stable(feature = "rust1", since = "1.0.0")] pub struct RangeFull; -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for FullRange { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt("..", fmt) - } -} - -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for RangeFull { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index 9d253178664..f4b1a0633de 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -26,9 +26,6 @@ // Reexported core operators pub use marker::{Copy, Send, Sized, Sync}; -#[cfg(stage0)] -pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange}; -#[cfg(not(stage0))] pub use ops::{Drop, Fn, FnMut, FnOnce}; // Reexported functions diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index a368ddba9bc..a750e81bf59 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -43,9 +43,6 @@ use default::Default; use iter::*; use num::Int; use ops::{FnMut, self, Index}; -#[cfg(stage0)] -use ops::FullRange as RangeFull; -#[cfg(not(stage0))] use ops::RangeFull; use option::Option; use option::Option::{None, Some}; @@ -769,16 +766,6 @@ impl<'a, T> ops::Index> for Iter<'a, T> { } } -#[cfg(stage0)] -#[unstable(feature = "core")] -impl<'a, T> ops::Index for Iter<'a, T> { - type Output = [T]; - #[inline] - fn index(&self, _index: &ops::FullRange) -> &[T] { - self.as_slice() - } -} -#[cfg(not(stage0))] #[unstable(feature = "core")] impl<'a, T> ops::Index for Iter<'a, T> { type Output = [T]; diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index cb7af3b3d35..026f708b305 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -1266,16 +1266,6 @@ mod traits { } } - #[cfg(stage0)] - #[stable(feature = "rust1", since = "1.0.0")] - impl ops::Index for str { - type Output = str; - #[inline] - fn index(&self, _index: &ops::FullRange) -> &str { - self - } - } - #[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl ops::Index for str { type Output = str; diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 8a473ad43af..fc8d18df815 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -24,7 +24,6 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] -#![cfg_attr(stage0, feature(core))] #![feature(int_uint)] #![feature(slicing_syntax)] #![feature(staged_api)] diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs index 18e2aa8c098..61cc47375b2 100644 --- a/src/libstd/ffi/os_str.rs +++ b/src/libstd/ffi/os_str.rs @@ -82,17 +82,6 @@ impl OsString { } } -#[cfg(stage0)] -impl ops::Index for OsString { - type Output = OsStr; - - #[inline] - fn index(&self, _index: &ops::FullRange) -> &OsStr { - unsafe { mem::transmute(self.inner.as_slice()) } - } -} - -#[cfg(not(stage0))] impl ops::Index for OsString { type Output = OsStr; diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 8e86aa65196..47f5d64e260 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -413,10 +413,6 @@ pub use core::fmt::{LowerExp, UpperExp}; pub use core::fmt::Error; pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt}; -#[doc(hidden)] -#[cfg(stage0)] -pub use core::fmt::{argument, argumentuint}; - /// The format function takes a precompiled format string and a list of /// arguments, to return the resulting formatted string. /// diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 96aebb735ef..f0981145af7 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -120,7 +120,7 @@ #![feature(staged_api)] #![feature(unboxed_closures)] #![feature(unicode)] -#![cfg_attr(not(stage0), feature(macro_reexport))] +#![feature(macro_reexport)] #![cfg_attr(test, feature(test))] // Don't link to std. We are std. diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index b5409da9c9c..74b8757f6a9 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -68,8 +68,6 @@ use fmt; use iter::IteratorExt; use option::Option; use option::Option::{None, Some}; -#[cfg(stage0)] -use ops::FullRange; use str; use str::StrExt; use string::{String, CowString}; diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index b524b89ef9f..7ddd919c11e 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -25,8 +25,6 @@ use iter::{AdditiveIterator, Extend}; use iter::{Iterator, IteratorExt, Map, repeat}; use mem; use option::Option::{self, Some, None}; -#[cfg(stage0)] -use ops::FullRange; use result::Result::{self, Ok, Err}; use slice::{SliceExt, SliceConcatExt}; use str::{SplitTerminator, FromStr, StrExt}; diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index b3c4ffa5120..2398485afef 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -18,10 +18,6 @@ #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce}; -#[cfg(stage0)] -#[unstable(feature = "std_misc")] -#[doc(no_inline)] pub use ops::FullRange; - // Reexported functions #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use mem::drop; diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index fb40a6c8f60..757aecaaaff 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -160,7 +160,7 @@ pub fn panicking() -> bool { // An uninlined, unmangled function upon which to slap yer breakpoints #[inline(never)] #[no_mangle] -#[cfg_attr(not(stage0), allow(private_no_mangle_fns))] +#[allow(private_no_mangle_fns)] fn rust_panic(cause: Box) -> ! { rtdebug!("begin_unwind()"); @@ -238,7 +238,7 @@ pub mod eabi { #[lang="eh_personality"] #[no_mangle] // referenced from rust_try.ll - #[cfg_attr(not(stage0), allow(private_no_mangle_fns))] + #[allow(private_no_mangle_fns)] extern fn rust_eh_personality( version: c_int, actions: uw::_Unwind_Action, diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index fdcb0c19f30..1a898e73cda 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -680,17 +680,6 @@ impl ops::Index> for Wtf8 { } } -#[cfg(stage0)] -impl ops::Index for Wtf8 { - type Output = Wtf8; - - #[inline] - fn index(&self, _range: &ops::FullRange) -> &Wtf8 { - self - } -} - -#[cfg(not(stage0))] impl ops::Index for Wtf8 { type Output = Wtf8; diff --git a/src/snapshots.txt b/src/snapshots.txt index 3406a91e718..058e2e6bf7f 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,12 @@ +S 2015-01-31 474b324 + freebsd-x86_64 c5b55eb488790ff8425d74afa3b37c49517bc55f + linux-i386 319f2f3573c058cb2c4dfc75faaf8ea3ae86ef11 + linux-x86_64 7e71108be890adfecc7644ab6ad183e8a657dc97 + macos-i386 b0b2676681c6d8ec8cb85700428555761c7bdbb8 + macos-x86_64 381dd1587920388e2f71e120a1eabac2648d9672 + winnt-i386 5f99509f88355437824a746f7f90fc22233edb9b + winnt-x86_64 382aa20518b1a19d374f06a038025619ba00b77d + S 2015-01-28 a45e117 freebsd-x86_64 08a3ce7331fd1a52466acc0598cf745a009f86f6 linux-i386 66e36a3461c12e2102a7f7f241d1b0e242c704d0 -- cgit 1.4.1-3-g733a5 From d5d7e6565a4034b93d19be1edafd20730a4276bc Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sat, 31 Jan 2015 12:20:46 -0500 Subject: `for x in xs.iter()` -> `for x in &xs` --- src/compiletest/compiletest.rs | 6 +- src/compiletest/procsrv.rs | 4 +- src/compiletest/runtest.rs | 18 ++-- src/compiletest/util.rs | 2 +- src/libarena/lib.rs | 2 +- src/libcollections/bench.rs | 2 +- src/libcollections/binary_heap.rs | 4 +- src/libcollections/bit.rs | 16 ++-- src/libcollections/btree/map.rs | 4 +- src/libcollections/btree/node.rs | 6 +- src/libcollections/btree/set.rs | 6 +- src/libcollections/dlist.rs | 2 +- src/libcollections/enum_set.rs | 2 +- src/libcollections/ring_buf.rs | 4 +- src/libcollections/slice.rs | 12 +-- src/libcollections/str.rs | 10 +-- src/libcollections/string.rs | 2 +- src/libcollections/vec.rs | 4 +- src/libcollections/vec_map.rs | 4 +- src/libcore/fmt/mod.rs | 2 +- src/libcore/hash/mod.rs | 2 +- src/libcoretest/cmp.rs | 8 +- src/libcoretest/hash/mod.rs | 2 +- src/libcoretest/hash/sip.rs | 4 +- src/libgetopts/lib.rs | 10 +-- src/libgraphviz/lib.rs | 6 +- src/librand/distributions/mod.rs | 2 +- src/librand/distributions/range.rs | 4 +- src/librand/isaac.rs | 4 +- src/librand/reseeding.rs | 2 +- src/librustc/lint/builtin.rs | 26 +++--- src/librustc/lint/context.rs | 12 +-- src/librustc/metadata/creader.rs | 6 +- src/librustc/metadata/csearch.rs | 2 +- src/librustc/metadata/cstore.rs | 8 +- src/librustc/metadata/decoder.rs | 6 +- src/librustc/metadata/encoder.rs | 74 +++++++-------- src/librustc/metadata/filesearch.rs | 5 +- src/librustc/metadata/loader.rs | 2 +- src/librustc/metadata/tydecode.rs | 2 +- src/librustc/metadata/tyencode.rs | 16 ++-- src/librustc/middle/astencode.rs | 32 +++---- src/librustc/middle/cfg/construct.rs | 10 +-- src/librustc/middle/check_const.rs | 4 +- src/librustc/middle/check_match.rs | 12 +-- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dataflow.rs | 4 +- src/librustc/middle/dead.rs | 14 +-- src/librustc/middle/dependency_format.rs | 4 +- src/librustc/middle/entry.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 34 +++---- src/librustc/middle/infer/combine.rs | 6 +- src/librustc/middle/infer/error_reporting.rs | 28 +++--- src/librustc/middle/infer/higher_ranked/mod.rs | 10 +-- src/librustc/middle/infer/mod.rs | 4 +- src/librustc/middle/infer/region_inference/mod.rs | 16 ++-- src/librustc/middle/infer/type_variable.rs | 4 +- src/librustc/middle/lang_items.rs | 4 +- src/librustc/middle/liveness.rs | 24 ++--- src/librustc/middle/mem_categorization.rs | 10 +-- src/librustc/middle/reachable.rs | 4 +- src/librustc/middle/recursion_limit.rs | 2 +- src/librustc/middle/region.rs | 4 +- src/librustc/middle/resolve_lifetime.rs | 22 ++--- src/librustc/middle/stability.rs | 8 +- src/librustc/middle/subst.rs | 2 +- src/librustc/middle/traits/doc.rs | 2 +- src/librustc/middle/traits/error_reporting.rs | 4 +- src/librustc/middle/traits/object_safety.rs | 2 +- src/librustc/middle/traits/project.rs | 2 +- src/librustc/middle/traits/select.rs | 2 +- src/librustc/middle/traits/util.rs | 2 +- src/librustc/middle/ty.rs | 42 ++++----- src/librustc/middle/weak_lang_items.rs | 2 +- src/librustc/plugin/build.rs | 2 +- src/librustc/plugin/load.rs | 10 +-- src/librustc/session/config.rs | 12 +-- src/librustc/util/common.rs | 2 +- src/librustc/util/nodemap.rs | 2 +- src/librustc/util/ppaux.rs | 16 ++-- src/librustc_back/archive.rs | 6 +- src/librustc_back/rpath.rs | 8 +- src/librustc_back/sha2.rs | 4 +- src/librustc_back/svh.rs | 4 +- src/librustc_back/target/mod.rs | 2 +- src/librustc_borrowck/borrowck/check_loans.rs | 8 +- src/librustc_borrowck/borrowck/fragments.rs | 14 +-- .../borrowck/gather_loans/move_error.rs | 6 +- src/librustc_borrowck/borrowck/move_data.rs | 12 +-- src/librustc_borrowck/graphviz.rs | 2 +- src/librustc_driver/driver.rs | 6 +- src/librustc_driver/lib.rs | 10 +-- src/librustc_driver/test.rs | 4 +- src/librustc_llvm/lib.rs | 4 +- src/librustc_privacy/lib.rs | 54 +++++------ src/librustc_resolve/build_reduced_graph.rs | 18 ++-- src/librustc_resolve/check_unused.rs | 2 +- src/librustc_resolve/lib.rs | 66 +++++++------- src/librustc_resolve/record_exports.rs | 8 +- src/librustc_trans/back/link.rs | 14 +-- src/librustc_trans/back/lto.rs | 2 +- src/librustc_trans/back/write.rs | 10 +-- src/librustc_trans/save/mod.rs | 56 ++++++------ src/librustc_trans/trans/_match.rs | 24 ++--- src/librustc_trans/trans/adt.rs | 8 +- src/librustc_trans/trans/base.rs | 22 ++--- src/librustc_trans/trans/cabi_aarch64.rs | 2 +- src/librustc_trans/trans/cabi_arm.rs | 2 +- src/librustc_trans/trans/cabi_mips.rs | 2 +- src/librustc_trans/trans/cabi_powerpc.rs | 2 +- src/librustc_trans/trans/cabi_x86.rs | 2 +- src/librustc_trans/trans/cabi_x86_64.rs | 6 +- src/librustc_trans/trans/cabi_x86_win64.rs | 2 +- src/librustc_trans/trans/cleanup.rs | 2 +- src/librustc_trans/trans/common.rs | 2 +- src/librustc_trans/trans/controlflow.rs | 2 +- src/librustc_trans/trans/debuginfo.rs | 58 ++++++------ src/librustc_trans/trans/expr.rs | 8 +- src/librustc_trans/trans/foreign.rs | 8 +- src/librustc_trans/trans/glue.rs | 2 +- src/librustc_trans/trans/intrinsic.rs | 2 +- src/librustc_trans/trans/meth.rs | 4 +- src/librustc_trans/trans/tvec.rs | 2 +- src/librustc_trans/trans/type_of.rs | 2 +- src/librustc_typeck/astconv.rs | 8 +- src/librustc_typeck/check/_match.rs | 20 ++--- src/librustc_typeck/check/method/probe.rs | 16 ++-- src/librustc_typeck/check/mod.rs | 42 ++++----- src/librustc_typeck/check/regionck.rs | 34 +++---- src/librustc_typeck/check/regionmanip.rs | 10 +-- src/librustc_typeck/check/upvar.rs | 2 +- src/librustc_typeck/check/vtable.rs | 6 +- src/librustc_typeck/check/wf.rs | 8 +- src/librustc_typeck/check/writeback.rs | 10 +-- src/librustc_typeck/coherence/mod.rs | 20 ++--- src/librustc_typeck/coherence/overlap.rs | 4 +- src/librustc_typeck/collect.rs | 32 +++---- src/librustc_typeck/variance.rs | 20 ++--- src/librustdoc/clean/mod.rs | 28 +++--- src/librustdoc/externalfiles.rs | 2 +- src/librustdoc/html/format.rs | 18 ++-- src/librustdoc/html/render.rs | 66 +++++++------- src/librustdoc/html/toc.rs | 2 +- src/librustdoc/lib.rs | 14 +-- src/librustdoc/markdown.rs | 2 +- src/librustdoc/passes.rs | 4 +- src/librustdoc/plugins.rs | 2 +- src/librustdoc/visit_ast.rs | 4 +- src/libserialize/collection_impls.rs | 10 +-- src/libserialize/hex.rs | 2 +- src/libserialize/json.rs | 14 +-- src/libstd/ascii.rs | 2 +- src/libstd/collections/hash/map.rs | 4 +- src/libstd/collections/hash/set.rs | 6 +- src/libstd/old_io/extensions.rs | 12 +-- src/libstd/old_io/fs.rs | 2 +- src/libstd/old_io/net/addrinfo.rs | 2 +- src/libstd/old_io/process.rs | 6 +- src/libstd/old_io/test.rs | 2 +- src/libstd/os.rs | 14 +-- src/libstd/path/mod.rs | 4 +- src/libstd/rand/mod.rs | 2 +- src/libstd/rand/os.rs | 2 +- src/libstd/rt/unwind.rs | 2 +- src/libstd/sys/common/net.rs | 2 +- src/libstd/sys/unix/process.rs | 2 +- src/libstd/sys/windows/os.rs | 2 +- src/libstd/sys/windows/process.rs | 6 +- src/libstd/sys/windows/thread_local.rs | 2 +- src/libstd/thread_local/mod.rs | 2 +- src/libsyntax/ast_map/mod.rs | 12 +-- src/libsyntax/ast_util.rs | 12 +-- src/libsyntax/attr.rs | 6 +- src/libsyntax/codemap.rs | 4 +- src/libsyntax/diagnostic.rs | 4 +- src/libsyntax/ext/deriving/generic/mod.rs | 4 +- src/libsyntax/ext/deriving/hash.rs | 2 +- src/libsyntax/ext/deriving/primitive.rs | 2 +- src/libsyntax/ext/expand.rs | 12 +-- src/libsyntax/ext/format.rs | 4 +- src/libsyntax/ext/quote.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 6 +- src/libsyntax/ext/tt/macro_rules.rs | 2 +- src/libsyntax/feature_gate.rs | 6 +- src/libsyntax/parse/lexer/comments.rs | 4 +- src/libsyntax/parse/lexer/mod.rs | 2 +- src/libsyntax/parse/mod.rs | 2 +- src/libsyntax/parse/parser.rs | 4 +- src/libsyntax/print/pprust.rs | 82 ++++++++--------- src/libsyntax/util/interner.rs | 4 +- src/libsyntax/visit.rs | 100 ++++++++++----------- src/libterm/terminfo/parm.rs | 8 +- src/libterm/terminfo/searcher.rs | 2 +- src/libtest/lib.rs | 8 +- src/libtest/stats.rs | 4 +- src/libunicode/normalize.rs | 4 +- src/rustbook/book.rs | 2 +- src/test/auxiliary/cci_nested_lib.rs | 2 +- src/test/bench/shootout-chameneos-redux.rs | 6 +- src/test/bench/shootout-fasta-redux.rs | 4 +- src/test/bench/shootout-k-nucleotide-pipes.rs | 4 +- src/test/bench/shootout-k-nucleotide.rs | 2 +- src/test/bench/shootout-mandelbrot.rs | 2 +- src/test/bench/shootout-meteor.rs | 4 +- src/test/bench/shootout-nbody.rs | 2 +- .../borrowck-for-loop-correct-cmt-for-pattern.rs | 2 +- .../compile-fail/borrowck-for-loop-head-linkage.rs | 2 +- .../compile-fail/borrowck-insert-during-each.rs | 2 +- .../compile-fail/drop-with-active-borrows-1.rs | 2 +- src/test/compile-fail/issue-15480.rs | 2 +- src/test/compile-fail/issue-18400.rs | 2 +- src/test/compile-fail/issue-2149.rs | 2 +- src/test/compile-fail/issue-2150.rs | 2 +- src/test/compile-fail/issue-5100.rs | 2 +- src/test/compile-fail/issue-7573.rs | 4 +- .../debuginfo/destructured-for-loop-variable.rs | 4 +- src/test/debuginfo/lexical-scope-in-for-loop.rs | 2 +- src/test/debuginfo/unreachable-locals.rs | 10 +-- src/test/pretty/block-comment-wchar.pp | 2 +- src/test/pretty/block-comment-wchar.rs | 2 +- src/test/pretty/for-comment.rs | 2 +- src/test/run-pass/auto-loop.rs | 2 +- src/test/run-pass/block-arg.rs | 2 +- src/test/run-pass/block-iter-1.rs | 2 +- src/test/run-pass/block-iter-2.rs | 2 +- src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs | 2 +- src/test/run-pass/break.rs | 4 +- .../run-pass/capture-clauses-boxed-closures.rs | 2 +- .../run-pass/capture-clauses-unboxed-closures.rs | 2 +- src/test/run-pass/cleanup-rvalue-for-scope.rs | 2 +- src/test/run-pass/coerce-reborrow-imm-vec-arg.rs | 2 +- src/test/run-pass/const-vec-of-fns.rs | 2 +- src/test/run-pass/explicit-self-closures.rs | 2 +- src/test/run-pass/fn-pattern-expected-type-2.rs | 2 +- src/test/run-pass/for-destruct.rs | 2 +- src/test/run-pass/for-loop-goofiness.rs | 2 +- src/test/run-pass/for-loop-panic.rs | 2 +- .../run-pass/foreach-external-iterators-break.rs | 2 +- ...ach-external-iterators-hashmap-break-restart.rs | 2 +- .../run-pass/foreach-external-iterators-hashmap.rs | 4 +- .../run-pass/foreach-external-iterators-nested.rs | 4 +- src/test/run-pass/foreach-external-iterators.rs | 2 +- src/test/run-pass/generic-static-methods.rs | 2 +- src/test/run-pass/hashmap-memory.rs | 2 +- src/test/run-pass/issue-10396.rs | 2 +- src/test/run-pass/issue-17068.rs | 2 +- src/test/run-pass/issue-2904.rs | 4 +- src/test/run-pass/issue-3389.rs | 2 +- src/test/run-pass/issue-3563-2.rs | 2 +- src/test/run-pass/issue-3563-3.rs | 2 +- src/test/run-pass/issue-4241.rs | 2 +- src/test/run-pass/issue-4542.rs | 2 +- src/test/run-pass/issue-5666.rs | 2 +- src/test/run-pass/issue-5688.rs | 2 +- src/test/run-pass/linear-for-loop.rs | 2 +- src/test/run-pass/loop-label-shadowing.rs | 2 +- src/test/run-pass/loop-scope.rs | 2 +- src/test/run-pass/monad.rs | 2 +- ...mutability-inherits-through-fixed-length-vec.rs | 2 +- src/test/run-pass/overloaded-index-assoc-list.rs | 2 +- src/test/run-pass/packed-struct-vec.rs | 2 +- src/test/run-pass/regions-mock-tcx.rs | 2 +- src/test/run-pass/repeated-vector-syntax.rs | 2 +- src/test/run-pass/shadow.rs | 2 +- src/test/run-pass/static-impl.rs | 4 +- src/test/run-pass/task-comm-3.rs | 2 +- src/test/run-pass/trait-bounds-in-arc.rs | 6 +- src/test/run-pass/trait-generic.rs | 2 +- src/test/run-pass/vector-sort-panic-safe.rs | 2 +- 269 files changed, 1063 insertions(+), 1064 deletions(-) (limited to 'src/libstd/rt') diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index b73623223fd..b16e9dea03d 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -276,7 +276,7 @@ pub fn make_tests(config: &Config) -> Vec { config.src_base.display()); let mut tests = Vec::new(); let dirs = fs::readdir(&config.src_base).unwrap(); - for file in dirs.iter() { + for file in &dirs { let file = file.clone(); debug!("inspecting file {:?}", file.display()); if is_test(config, &file) { @@ -304,13 +304,13 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool { let mut valid = false; - for ext in valid_extensions.iter() { + for ext in &valid_extensions { if name.ends_with(ext.as_slice()) { valid = true; } } - for pre in invalid_prefixes.iter() { + for pre in &invalid_prefixes { if name.starts_with(pre.as_slice()) { valid = false; } diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 7f3865308da..57f4171f7c2 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -46,7 +46,7 @@ pub fn run(lib_path: &str, match cmd.spawn() { Ok(mut process) => { - for input in input.iter() { + if let Some(input) = input { process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap(); } let ProcessOutput { status, output, error } = @@ -78,7 +78,7 @@ pub fn run_background(lib_path: &str, match cmd.spawn() { Ok(mut process) => { - for input in input.iter() { + if let Some(input) = input { process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap(); } diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 18cb3d1d5b0..2143cf22e05 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -547,7 +547,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { exe_file.as_str().unwrap().replace("\\", "\\\\"))[]); // Add line breakpoints - for line in breakpoint_lines.iter() { + for line in &breakpoint_lines { script_str.push_str(&format!("break '{}':{}\n", testfile.filename_display(), *line)[]); @@ -683,13 +683,13 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) script_str.push_str("type category enable Rust\n"); // Set breakpoints on every line that contains the string "#break" - for line in breakpoint_lines.iter() { + for line in &breakpoint_lines { script_str.push_str(format!("breakpoint set --line {}\n", line).as_slice()); } // Append the other commands - for line in commands.iter() { + for line in &commands { script_str.push_str(line.as_slice()); script_str.push_str("\n"); } @@ -847,7 +847,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String]) let mut rest = line.trim(); let mut first = true; let mut failed = false; - for frag in check_fragments[i].iter() { + for frag in &check_fragments[i] { let found = if first { if rest.starts_with(frag.as_slice()) { Some(0) @@ -915,7 +915,7 @@ fn check_error_patterns(props: &TestProps, missing_patterns[0]).as_slice(), proc_res); } else { - for pattern in missing_patterns.iter() { + for pattern in missing_patterns { error(format!("error pattern '{}' not found!", *pattern).as_slice()); } @@ -935,7 +935,7 @@ fn check_no_compiler_crash(proc_res: &ProcRes) { fn check_forbid_output(props: &TestProps, output_to_check: &str, proc_res: &ProcRes) { - for pat in props.forbid_output.iter() { + for pat in &props.forbid_output { if output_to_check.contains(pat.as_slice()) { fatal_proc_rec("forbidden pattern found in compiler output", proc_res); } @@ -1173,7 +1173,7 @@ fn compose_and_run_compiler( // FIXME (#9639): This needs to handle non-utf8 paths let extra_link_args = vec!("-L".to_string(), aux_dir.as_str().unwrap().to_string()); - for rel_ab in props.aux_builds.iter() { + for rel_ab in &props.aux_builds { let abs_ab = config.aux_base.join(rel_ab.as_slice()); let aux_props = header::load_props(&abs_ab); let mut crate_type = if aux_props.no_prefer_dynamic { @@ -1510,7 +1510,7 @@ fn _arm_exec_compiled_test(config: &Config, runargs.push(format!("{}", config.adb_test_dir)); runargs.push(format!("{}", prog_short)); - for tv in args.args.iter() { + for tv in &args.args { runargs.push(tv.to_string()); } procsrv::run("", @@ -1591,7 +1591,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) { let tdir = aux_output_dir_name(config, testfile); let dirs = fs::readdir(&tdir).unwrap(); - for file in dirs.iter() { + for file in &dirs { if file.extension_str() == Some("so") { // FIXME (#9639): This needs to handle non-utf8 paths let copy_result = procsrv::run("", diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index a116cc33690..b1e44ef34fe 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -26,7 +26,7 @@ static OS_TABLE: &'static [(&'static str, &'static str)] = &[ ]; pub fn get_os(triple: &str) -> &'static str { - for &(triple_os, os) in OS_TABLE.iter() { + for &(triple_os, os) in OS_TABLE { if triple.contains(triple_os) { return os } diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 5ada51976ac..0ff6cf7b79a 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -127,7 +127,7 @@ impl Drop for Arena { fn drop(&mut self) { unsafe { destroy_chunk(&*self.head.borrow()); - for chunk in self.chunks.borrow().iter() { + for chunk in &*self.chunks.borrow() { if !chunk.is_copy.get() { destroy_chunk(chunk); } diff --git a/src/libcollections/bench.rs b/src/libcollections/bench.rs index d03fbf00847..9301bf5e4ab 100644 --- a/src/libcollections/bench.rs +++ b/src/libcollections/bench.rs @@ -73,7 +73,7 @@ pub fn find_rand_n(n: uint, let mut keys = (0..n).map(|_| rng.gen::() % n) .collect::>(); - for k in keys.iter() { + for k in &keys { insert(map, *k); } diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 8aa4c77f6f9..56bc573cbb4 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -696,7 +696,7 @@ mod tests { let iterout = [9, 5, 3]; let heap = BinaryHeap::from_vec(data); let mut i = 0; - for el in heap.iter() { + for el in &heap { assert_eq!(*el, iterout[i]); i += 1; } @@ -884,7 +884,7 @@ mod tests { let mut q: BinaryHeap = xs.iter().rev().map(|&x| x).collect(); - for &x in xs.iter() { + for &x in &xs { assert_eq!(q.pop().unwrap(), x); } } diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index ec2a274a45d..3d16dd4b166 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -976,7 +976,7 @@ impl Ord for Bitv { #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for Bitv { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - for bit in self.iter() { + for bit in self { try!(write!(fmt, "{}", if bit { 1u32 } else { 0u32 })); } Ok(()) @@ -1743,7 +1743,7 @@ impl fmt::Debug for BitvSet { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "BitvSet {{")); let mut first = true; - for n in self.iter() { + for n in self { if !first { try!(write!(fmt, ", ")); } @@ -1756,7 +1756,7 @@ impl fmt::Debug for BitvSet { impl hash::Hash for BitvSet { fn hash(&self, state: &mut S) { - for pos in self.iter() { + for pos in self { pos.hash(state); } } @@ -2600,7 +2600,7 @@ mod bitv_bench { b.iter(|| { let mut sum = 0u; for _ in 0u..10 { - for pres in bitv.iter() { + for pres in &bitv { sum += pres as uint; } } @@ -2613,7 +2613,7 @@ mod bitv_bench { let bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { let mut sum = 0u; - for pres in bitv.iter() { + for pres in &bitv { sum += pres as uint; } sum @@ -2674,8 +2674,8 @@ mod bitv_set_test { fn test_bitv_set_frombitv_init() { let bools = [true, false]; let lengths = [10, 64, 100]; - for &b in bools.iter() { - for &l in lengths.iter() { + for &b in &bools { + for &l in &lengths { let bitset = BitvSet::from_bitv(Bitv::from_elem(l, b)); assert_eq!(bitset.contains(&1u), b); assert_eq!(bitset.contains(&(l-1u)), b); @@ -3062,7 +3062,7 @@ mod bitv_set_bench { |idx| {idx % 3 == 0})); b.iter(|| { let mut sum = 0u; - for idx in bitv.iter() { + for idx in &bitv { sum += idx as uint; } sum diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index ce5e8f07be1..bc657a19d78 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -856,7 +856,7 @@ impl Extend<(K, V)> for BTreeMap { #[stable(feature = "rust1", since = "1.0.0")] impl, V: Hash> Hash for BTreeMap { fn hash(&self, state: &mut S) { - for elt in self.iter() { + for elt in self { elt.hash(state); } } @@ -1946,7 +1946,7 @@ mod bench { } b.iter(|| { - for entry in map.iter() { + for entry in &map { black_box(entry); } }); diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 8d6f06b25c5..8fdfe9ed56a 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -435,13 +435,13 @@ impl Clone for Node { let mut vals = RawItems::from_parts(ret.vals().as_ptr(), 0); let mut edges = RawItems::from_parts(ret.edges().as_ptr(), 0); - for key in self.keys().iter() { + for key in self.keys() { keys.push(key.clone()) } - for val in self.vals().iter() { + for val in self.vals() { vals.push(val.clone()) } - for edge in self.edges().iter() { + for edge in self.edges() { edges.push(edge.clone()) } diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 72d5bf6d799..a4e28d36a05 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -791,8 +791,8 @@ mod test { let mut set_a = BTreeSet::new(); let mut set_b = BTreeSet::new(); - for x in a.iter() { assert!(set_a.insert(*x)) } - for y in b.iter() { assert!(set_b.insert(*y)) } + for x in a { assert!(set_a.insert(*x)) } + for y in b { assert!(set_b.insert(*y)) } let mut i = 0; f(&set_a, &set_b, Counter { i: &mut i, expected: expected }); @@ -894,7 +894,7 @@ mod test { let set: BTreeSet = xs.iter().map(|&x| x).collect(); - for x in xs.iter() { + for x in &xs { assert!(set.contains(x)); } } diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index beb2973febc..e229cd8a961 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -917,7 +917,7 @@ impl fmt::Debug for DList { impl> Hash for DList { fn hash(&self, state: &mut S) { self.len().hash(state); - for elt in self.iter() { + for elt in self { elt.hash(state); } } diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 9765bb5875e..14a3a5a0990 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -36,7 +36,7 @@ impl fmt::Debug for EnumSet { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "EnumSet {{")); let mut first = true; - for e in self.iter() { + for e in self { if !first { try!(write!(fmt, ", ")); } diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 7032a3d9137..4b9f3980db2 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -1573,7 +1573,7 @@ impl Ord for RingBuf { impl> Hash for RingBuf { fn hash(&self, state: &mut S) { self.len().hash(state); - for elt in self.iter() { + for elt in self { elt.hash(state); } } @@ -1856,7 +1856,7 @@ mod tests { b.iter(|| { let mut sum = 0; - for &i in ring.iter() { + for &i in &ring { sum += i; } test::black_box(sum); diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index affa4898010..9be918dbe15 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1118,7 +1118,7 @@ impl> SliceConcatExt> for [V] { fn concat(&self) -> Vec { let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len()); let mut result = Vec::with_capacity(size); - for v in self.iter() { + for v in self { result.push_all(v.as_slice()) } result @@ -1128,7 +1128,7 @@ impl> SliceConcatExt> for [V] { let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len()); let mut result = Vec::with_capacity(size + self.len()); let mut first = true; - for v in self.iter() { + for v in self { if first { first = false } else { result.push(sep.clone()) } result.push_all(v.as_slice()) } @@ -2681,13 +2681,13 @@ mod tests { assert_eq!(v.len(), 3); let mut cnt = 0u; - for f in v.iter() { + for f in &v { assert!(*f == Foo); cnt += 1; } assert_eq!(cnt, 3); - for f in v[1..3].iter() { + for f in &v[1..3] { assert!(*f == Foo); cnt += 1; } @@ -2707,7 +2707,7 @@ mod tests { let xs: [Foo; 3] = [Foo, Foo, Foo]; cnt = 0; - for f in xs.iter() { + for f in &xs { assert!(*f == Foo); cnt += 1; } @@ -2858,7 +2858,7 @@ mod bench { b.iter(|| { let mut sum = 0; - for x in v.iter() { + for x in &v { sum += *x; } // sum == 11806, to stop dead code elimination. diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 43b5d14cc86..75f7b812974 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -99,7 +99,7 @@ impl SliceConcatExt for [S] { let len = s.iter().map(|s| s.as_slice().len()).sum(); let mut result = String::with_capacity(len); - for s in s.iter() { + for s in s { result.push_str(s.as_slice()) } @@ -125,7 +125,7 @@ impl SliceConcatExt for [S] { let mut result = String::with_capacity(len); let mut first = true; - for s in s.iter() { + for s in s { if first { first = false; } else { @@ -2005,7 +2005,7 @@ mod tests { let s = "ศไทย中华Việt Nam"; let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; - for ch in v.iter() { + for ch in &v { assert!(s.char_at(pos) == *ch); pos += ch.to_string().len(); } @@ -2703,7 +2703,7 @@ mod tests { &["\u{378}\u{308}\u{903}"], &["\u{378}\u{308}", "\u{903}"]), ]; - for &(s, g) in test_same.iter() { + for &(s, g) in &test_same[] { // test forward iterator assert!(order::equals(s.graphemes(true), g.iter().map(|&x| x))); assert!(order::equals(s.graphemes(false), g.iter().map(|&x| x))); @@ -2713,7 +2713,7 @@ mod tests { assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().map(|&x| x))); } - for &(s, gt, gf) in test_diff.iter() { + for &(s, gt, gf) in &test_diff { // test forward iterator assert!(order::equals(s.graphemes(true), gt.iter().map(|&x| x))); assert!(order::equals(s.graphemes(false), gf.iter().map(|&x| x))); diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index d0b89cfa2c3..b9857973946 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -1118,7 +1118,7 @@ mod tests { (String::from_str("\u{20000}"), vec![0xD840, 0xDC00])]; - for p in pairs.iter() { + for p in &pairs { let (s, u) = (*p).clone(); let s_as_utf16 = s.utf16_units().collect::>(); let u_as_string = String::from_utf16(u.as_slice()).unwrap(); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 82c1c37ab6a..e570d401609 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1547,7 +1547,7 @@ impl Drop for Vec { // zeroed (when moving out, because of #[unsafe_no_drop_flag]). if self.cap != 0 { unsafe { - for x in self.iter() { + for x in &*self { ptr::read(x); } dealloc(*self.ptr, self.cap) @@ -2129,7 +2129,7 @@ mod tests { v.push(()); assert_eq!(v.iter().count(), 2); - for &() in v.iter() {} + for &() in &v {} assert_eq!(v.iter_mut().count(), 2); v.push(()); diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index f2a9bb4392c..1adea45f630 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -90,7 +90,7 @@ impl> Hash for VecMap { // In order to not traverse the `VecMap` twice, count the elements // during iteration. let mut count: uint = 0; - for elt in self.iter() { + for elt in self { elt.hash(state); count += 1; } @@ -1112,7 +1112,7 @@ mod test_map { let map: VecMap = xs.iter().map(|&x| x).collect(); - for &(k, v) in xs.iter() { + for &(k, v) in &xs { assert_eq!(map.get(&k), Some(&v)); } } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 694888bb2bc..20ef30b0a3e 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -888,7 +888,7 @@ impl Debug for [T] { try!(write!(f, "[")); } let mut is_first = true; - for x in self.iter() { + for x in self { if is_first { is_first = false; } else { diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 5a4d2fffade..d73e6ed589f 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -205,7 +205,7 @@ impl> Hash for [T] { #[inline] fn hash(&self, state: &mut S) { self.len().hash(state); - for elt in self.iter() { + for elt in self { elt.hash(state); } } diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs index 6bc1f14cc5a..2e5c6fe5a2f 100644 --- a/src/libcoretest/cmp.rs +++ b/src/libcoretest/cmp.rs @@ -66,11 +66,11 @@ fn test_partial_min() { (1.0f64, NAN, None) ]; - for &(a, b, result) in data_integer.iter() { + for &(a, b, result) in &data_integer { assert!(partial_min(a, b) == result); } - for &(a, b, result) in data_float.iter() { + for &(a, b, result) in &data_float { assert!(partial_min(a, b) == result); } } @@ -99,11 +99,11 @@ fn test_partial_max() { (1.0f64, NAN, None) ]; - for &(a, b, result) in data_integer.iter() { + for &(a, b, result) in &data_integer { assert!(partial_max(a, b) == result); } - for &(a, b, result) in data_float.iter() { + for &(a, b, result) in &data_float { assert!(partial_max(a, b) == result); } } diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs index 07f3ab4a5a7..2da3f370b40 100644 --- a/src/libcoretest/hash/mod.rs +++ b/src/libcoretest/hash/mod.rs @@ -25,7 +25,7 @@ impl Default for MyHasher { impl Writer for MyHasher { // Most things we'll just add up the bytes. fn write(&mut self, buf: &[u8]) { - for byte in buf.iter() { + for byte in buf { self.hash += *byte as u64; } } diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs index 431f7e748f6..a493f71925e 100644 --- a/src/libcoretest/hash/sip.rs +++ b/src/libcoretest/hash/sip.rs @@ -109,7 +109,7 @@ fn test_siphash() { fn to_hex_str(r: &[u8; 8]) -> String { let mut s = String::new(); - for b in r.iter() { + for b in r { s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); } s @@ -130,7 +130,7 @@ fn test_siphash() { fn result_str(h: u64) -> String { let r = result_bytes(h); let mut s = String::new(); - for b in r.iter() { + for b in &r { s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); } s diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 055672df5d1..b4eb8e9902a 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -315,7 +315,7 @@ impl Matches { /// Returns true if any of several options were matched. pub fn opts_present(&self, names: &[String]) -> bool { - for nm in names.iter() { + for nm in names { match find_opt(self.opts.as_slice(), Name::from_str(&nm[])) { Some(id) if !self.vals[id].is_empty() => return true, _ => (), @@ -326,7 +326,7 @@ impl Matches { /// Returns the string argument supplied to one of several matching options or `None`. pub fn opts_str(&self, names: &[String]) -> Option { - for nm in names.iter() { + for nm in names { match self.opt_val(&nm[]) { Some(Val(ref s)) => return Some(s.clone()), _ => () @@ -342,7 +342,7 @@ impl Matches { pub fn opt_strs(&self, nm: &str) -> Vec { let mut acc: Vec = Vec::new(); let r = self.opt_vals(nm); - for v in r.iter() { + for v in &r { match *v { Val(ref s) => acc.push((*s).clone()), _ => () @@ -395,7 +395,7 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option { } // Search in aliases. - for candidate in opts.iter() { + for candidate in opts { if candidate.aliases.iter().position(|opt| opt.name == nm).is_some() { return opts.iter().position(|opt| opt.name == candidate.name); } @@ -648,7 +648,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { } } let mut name_pos = 0; - for nm in names.iter() { + for nm in &names { name_pos += 1; let optid = match find_opt(opts.as_slice(), (*nm).clone()) { Some(id) => id, diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 3606387ad23..e9c7f837014 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -548,7 +548,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N options: &[RenderOption]) -> old_io::IoResult<()> { fn writeln(w: &mut W, arg: &[&str]) -> old_io::IoResult<()> { - for &s in arg.iter() { try!(w.write_str(s)); } + for &s in arg { try!(w.write_str(s)); } w.write_char('\n') } @@ -557,7 +557,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N } try!(writeln(w, &["digraph ", g.graph_id().as_slice(), " {"])); - for n in g.nodes().iter() { + for n in &*g.nodes() { try!(indent(w)); let id = g.node_id(n); if options.contains(&RenderOption::NoNodeLabels) { @@ -569,7 +569,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N } } - for e in g.edges().iter() { + for e in &*g.edges() { let escaped_label = g.edge_label(e).escape(); try!(indent(w)); let source = g.source(e); diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 1b5e5ae8398..fb543e3d549 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -305,7 +305,7 @@ mod tests { let mut rng = CountingRng { i: 0 }; - for &val in expected.iter() { + for &val in &expected { assert_eq!(wc.ind_sample(&mut rng), val) } }} diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index 16830c84c46..ab0b45e7d32 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -188,7 +188,7 @@ mod tests { let v: &[($ty, $ty)] = &[(0, 10), (10, 127), (Int::min_value(), Int::max_value())]; - for &(low, high) in v.iter() { + for &(low, high) in v { let mut sampler: Range<$ty> = Range::new(low, high); for _ in 0u..1000 { let v = sampler.sample(&mut rng); @@ -214,7 +214,7 @@ mod tests { (-1e35, -1e25), (1e-35, 1e-25), (-1e35, 1e35)]; - for &(low, high) in v.iter() { + for &(low, high) in v { let mut sampler: Range<$ty> = Range::new(low, high); for _ in 0u..1000 { let v = sampler.sample(&mut rng); diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index a22ef704fa5..d0f4afdde72 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -134,7 +134,7 @@ impl IsaacRng { } let r = [(0, MIDPOINT), (MIDPOINT, 0)]; - for &(mr_offset, m2_offset) in r.iter() { + for &(mr_offset, m2_offset) in &r { macro_rules! rngstepp { ($j:expr, $shift:expr) => {{ @@ -373,7 +373,7 @@ impl Isaac64Rng { } } - for &(mr_offset, m2_offset) in MP_VEC.iter() { + for &(mr_offset, m2_offset) in &MP_VEC { for base in (0..MIDPOINT / 4).map(|i| i * 4) { macro_rules! rngstepp { diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 57e90139876..75ac1b2cf44 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -225,7 +225,7 @@ mod test { // To test that `fill_bytes` actually did something, check that the // average of `v` is not 0. let mut sum = 0.0; - for &x in v.iter() { + for &x in &v { sum += x as f64; } assert!(sum / v.len() as f64 != 0.0); diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 904c9c3adb5..57380ec2797 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -459,7 +459,7 @@ impl LintPass for ImproperCTypes { } fn check_foreign_fn(cx: &Context, decl: &ast::FnDecl) { - for input in decl.inputs.iter() { + for input in &decl.inputs { check_ty(cx, &*input.ty); } if let ast::Return(ref ret_ty) = decl.output { @@ -469,7 +469,7 @@ impl LintPass for ImproperCTypes { match it.node { ast::ItemForeignMod(ref nmod) if nmod.abi != abi::RustIntrinsic => { - for ni in nmod.items.iter() { + for ni in &nmod.items { match ni.node { ast::ForeignItemFn(ref decl, _) => check_foreign_fn(cx, &**decl), ast::ForeignItemStatic(ref t, _) => check_ty(cx, &**t) @@ -532,7 +532,7 @@ impl LintPass for BoxPointers { // If it's a struct, we also have to check the fields' types match it.node { ast::ItemStruct(ref struct_def, _) => { - for struct_field in struct_def.fields.iter() { + for struct_field in &struct_def.fields { self.check_heap_type(cx, struct_field.span, ty::node_id_to_type(cx.tcx, struct_field.node.id)); } @@ -683,7 +683,7 @@ impl LintPass for UnusedAttributes { "no_builtins", ]; - for &name in ATTRIBUTE_WHITELIST.iter() { + for &name in ATTRIBUTE_WHITELIST { if attr.check_name(name) { break; } @@ -785,7 +785,7 @@ impl LintPass for UnusedResults { } fn check_must_use(cx: &Context, attrs: &[ast::Attribute], sp: Span) -> bool { - for attr in attrs.iter() { + for attr in attrs { if attr.check_name("must_use") { let mut msg = "unused result which must be used".to_string(); // check for #[must_use="..."] @@ -869,7 +869,7 @@ impl LintPass for NonCamelCaseTypes { ast::ItemEnum(ref enum_definition, _) => { if has_extern_repr { return } self.check_case(cx, "type", it.ident, it.span); - for variant in enum_definition.variants.iter() { + for variant in &enum_definition.variants { self.check_case(cx, "variant", variant.node.name, variant.span); } } @@ -878,7 +878,7 @@ impl LintPass for NonCamelCaseTypes { } fn check_generics(&mut self, cx: &Context, it: &ast::Generics) { - for gen in it.ty_params.iter() { + for gen in &*it.ty_params { self.check_case(cx, "type parameter", gen.ident, gen.span); } } @@ -1048,7 +1048,7 @@ impl LintPass for NonSnakeCase { fn check_struct_def(&mut self, cx: &Context, s: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { - for sf in s.fields.iter() { + for sf in &s.fields { if let ast::StructField_ { kind: ast::NamedField(ident, _), .. } = sf.node { self.check_snake_case(cx, "structure field", ident, sf.span); } @@ -1346,7 +1346,7 @@ impl UnusedMut { // avoid false warnings in match arms with multiple patterns let mut mutables = FnvHashMap(); - for p in pats.iter() { + for p in pats { pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| { let ident = path1.node; if let ast::BindByValue(ast::MutMutable) = mode { @@ -1361,7 +1361,7 @@ impl UnusedMut { } let used_mutables = cx.tcx.used_mut_nodes.borrow(); - for (_, v) in mutables.iter() { + for (_, v) in &mutables { if !v.iter().any(|e| used_mutables.contains(e)) { cx.span_lint(UNUSED_MUT, cx.tcx.map.span(v[0]), "variable does not need to be mutable"); @@ -1377,7 +1377,7 @@ impl LintPass for UnusedMut { fn check_expr(&mut self, cx: &Context, e: &ast::Expr) { if let ast::ExprMatch(_, ref arms, _) = e.node { - for a in arms.iter() { + for a in arms { self.check_unused_mut_pat(cx, &a.pats[]) } } @@ -1394,7 +1394,7 @@ impl LintPass for UnusedMut { fn check_fn(&mut self, cx: &Context, _: visit::FnKind, decl: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { - for a in decl.inputs.iter() { + for a in &decl.inputs { self.check_unused_mut_pat(cx, slice::ref_slice(&a.pat)); } } @@ -1871,7 +1871,7 @@ impl LintPass for UnconditionalRecursion { if cx.current_level(UNCONDITIONAL_RECURSION) != Level::Allow { let sess = cx.sess(); // offer some help to the programmer. - for call in self_call_spans.iter() { + for call in &self_call_spans { sess.span_note(*call, "recursive call site") } sess.span_help(sp, "a `loop` may express intention better if this is on purpose") diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index c649ff2635b..4ed61c6ffa1 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -116,7 +116,7 @@ impl LintStore { pub fn register_pass(&mut self, sess: Option<&Session>, from_plugin: bool, pass: LintPassObject) { - for &lint in pass.get_lints().iter() { + for &lint in pass.get_lints() { self.lints.push((*lint, from_plugin)); let id = LintId::of(*lint); @@ -260,7 +260,7 @@ impl LintStore { } pub fn process_command_line(&mut self, sess: &Session) { - for &(ref lint_name, level) in sess.opts.lint_opts.iter() { + for &(ref lint_name, level) in &sess.opts.lint_opts { match self.find_lint(&lint_name[], sess, None) { Some(lint_id) => self.set_level(lint_id, (level, CommandLine)), None => { @@ -340,7 +340,7 @@ macro_rules! run_lints { ($cx:expr, $f:ident, $($args:expr),*) => ({ pub fn gather_attrs(attrs: &[ast::Attribute]) -> Vec> { let mut out = vec!(); - for attr in attrs.iter() { + for attr in attrs { let level = match Level::from_str(attr.name().get()) { None => continue, Some(lvl) => lvl, @@ -357,7 +357,7 @@ pub fn gather_attrs(attrs: &[ast::Attribute]) } }; - for meta in metas.iter() { + for meta in metas { out.push(match meta.node { ast::MetaWord(ref lint_name) => Ok((lint_name.clone(), level, meta.span)), _ => Err(meta.span), @@ -794,8 +794,8 @@ pub fn check_crate(tcx: &ty::ctxt, // If we missed any lints added to the session, then there's a bug somewhere // in the iteration code. - for (id, v) in tcx.sess.lints.borrow().iter() { - for &(lint, span, ref msg) in v.iter() { + for (id, v) in &*tcx.sess.lints.borrow() { + for &(lint, span, ref msg) in v { tcx.sess.span_bug(span, format!("unprocessed lint {} at {}: {}", lint.as_str(), tcx.map.node_to_string(*id), *msg).as_slice()) diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 7b71120ba64..15229b6618f 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -162,7 +162,7 @@ impl<'a> CrateReader<'a> { dump_crates(&self.sess.cstore); } - for &(ref name, kind) in self.sess.opts.libs.iter() { + for &(ref name, kind) in &self.sess.opts.libs { register_native_lib(self.sess, None, name.clone(), kind); } } @@ -235,7 +235,7 @@ impl<'a> CrateReader<'a> { None }) .collect::>(); - for m in link_args.iter() { + for m in &link_args { match m.value_str() { Some(linkarg) => self.sess.cstore.add_used_link_args(linkarg.get()), None => { /* fallthrough */ } @@ -250,7 +250,7 @@ impl<'a> CrateReader<'a> { None }) .collect::>(); - for m in link_args.iter() { + for m in &link_args { match m.meta_item_list() { Some(items) => { let kind = items.iter().find(|k| { diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 1295970d667..619cfc1b52c 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -382,7 +382,7 @@ pub fn get_stability(cstore: &cstore::CStore, pub fn is_staged_api(cstore: &cstore::CStore, def: ast::DefId) -> bool { let cdata = cstore.get_crate_data(def.krate); let attrs = decoder::get_crate_attributes(cdata.data()); - for attr in attrs.iter() { + for attr in &attrs { if attr.name().get() == "staged_api" { match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) } } diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 40242f52493..0a3e173b35e 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -113,7 +113,7 @@ impl CStore { pub fn iter_crate_data(&self, mut i: I) where I: FnMut(ast::CrateNum, &crate_metadata), { - for (&k, v) in self.metas.borrow().iter() { + for (&k, v) in &*self.metas.borrow() { i(k, &**v); } } @@ -122,7 +122,7 @@ impl CStore { pub fn iter_crate_data_origins(&self, mut i: I) where I: FnMut(ast::CrateNum, &crate_metadata, Option), { - for (&k, v) in self.metas.borrow().iter() { + for (&k, v) in &*self.metas.borrow() { let origin = self.get_used_crate_source(k); origin.as_ref().map(|cs| { assert!(k == cs.cnum); }); i(k, &**v, origin); @@ -167,12 +167,12 @@ impl CStore { ordering: &mut Vec) { if ordering.contains(&cnum) { return } let meta = cstore.get_crate_data(cnum); - for (_, &dep) in meta.cnum_map.iter() { + for (_, &dep) in &meta.cnum_map { visit(cstore, dep, ordering); } ordering.push(cnum); }; - for (&num, _) in self.metas.borrow().iter() { + for (&num, _) in &*self.metas.borrow() { visit(self, num, &mut ordering); } ordering.reverse(); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 94fe99ff07d..3a70490771e 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1022,7 +1022,7 @@ pub fn get_methods_if_impl(intr: Rc, }); let mut impl_methods = Vec::new(); - for impl_method_id in impl_method_ids.iter() { + for impl_method_id in &impl_method_ids { let impl_method_doc = lookup_item(impl_method_id.node, cdata.data()); let family = item_family(impl_method_doc); match family { @@ -1189,7 +1189,7 @@ fn list_crate_attributes(md: rbml::Doc, hash: &Svh, try!(write!(out, "=Crate Attributes ({})=\n", *hash)); let r = get_attributes(md); - for attr in r.iter() { + for attr in &r { try!(write!(out, "{}\n", pprust::attribute_to_string(attr))); } @@ -1232,7 +1232,7 @@ pub fn get_crate_deps(data: &[u8]) -> Vec { fn list_crate_deps(data: &[u8], out: &mut old_io::Writer) -> old_io::IoResult<()> { try!(write!(out, "=External Dependencies=\n")); - for dep in get_crate_deps(data).iter() { + for dep in &get_crate_deps(data) { try!(write!(out, "{} {}-{}\n", dep.cnum, dep.name, dep.hash)); } try!(write!(out, "\n")); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 7ad91d4d71c..117ab4c8a5a 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -288,7 +288,7 @@ fn encode_parent_item(rbml_w: &mut Encoder, id: DefId) { fn encode_struct_fields(rbml_w: &mut Encoder, fields: &[ty::field_ty], origin: DefId) { - for f in fields.iter() { + for f in fields { if f.name == special_idents::unnamed_field.name { rbml_w.start_tag(tag_item_unnamed_field); } else { @@ -316,7 +316,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let mut i = 0; let vi = ty::enum_variants(ecx.tcx, DefId { krate: ast::LOCAL_CRATE, node: id }); - for variant in variants.iter() { + for variant in variants { let def_id = local_def(variant.node.id); index.push(entry { val: variant.node.id as i64, @@ -367,7 +367,7 @@ fn encode_path>(rbml_w: &mut Encoder, path: PI) { let path = path.collect::>(); rbml_w.start_tag(tag_path); rbml_w.wr_tagged_u32(tag_path_len, path.len() as u32); - for pe in path.iter() { + for pe in &path { let tag = match *pe { ast_map::PathMod(_) => tag_path_elem_mod, ast_map::PathName(_) => tag_path_elem_name @@ -402,8 +402,8 @@ fn encode_reexported_static_base_methods(ecx: &EncodeContext, let impl_items = ecx.tcx.impl_items.borrow(); match ecx.tcx.inherent_impls.borrow().get(&exp.def_id) { Some(implementations) => { - for base_impl_did in implementations.iter() { - for &method_did in (*impl_items)[*base_impl_did].iter() { + for base_impl_did in &**implementations { + for &method_did in &*(*impl_items)[*base_impl_did] { let impl_item = ty::impl_or_trait_item( ecx.tcx, method_did.def_id()); @@ -431,7 +431,7 @@ fn encode_reexported_static_trait_methods(ecx: &EncodeContext, -> bool { match ecx.tcx.trait_items_cache.borrow().get(&exp.def_id) { Some(trait_items) => { - for trait_item in trait_items.iter() { + for trait_item in &**trait_items { if let ty::MethodTraitItem(ref m) = *trait_item { encode_reexported_static_method(rbml_w, exp, @@ -517,9 +517,9 @@ fn encode_reexports(ecx: &EncodeContext, path: PathElems) { debug!("(encoding info for module) encoding reexports for {}", id); match ecx.reexports.get(&id) { - Some(ref exports) => { + Some(exports) => { debug!("(encoding info for module) found reexports for {}", id); - for exp in exports.iter() { + for exp in exports { debug!("(encoding info for module) reexport '{}' ({}/{}) for \ {}", exp.name, @@ -559,7 +559,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, debug!("(encoding info for module) encoding info for module ID {}", id); // Encode info about all the module children. - for item in md.items.iter() { + for item in &md.items { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(&def_to_string(local_def(item.id))[]); rbml_w.end_tag(); @@ -665,9 +665,9 @@ fn encode_parent_sort(rbml_w: &mut Encoder, sort: char) { fn encode_provided_source(rbml_w: &mut Encoder, source_opt: Option) { - for source in source_opt.iter() { + if let Some(source) = source_opt { rbml_w.start_tag(tag_item_method_provided_source); - let s = def_to_string(*source); + let s = def_to_string(source); rbml_w.writer.write_all(s.as_bytes()); rbml_w.end_tag(); } @@ -684,7 +684,7 @@ fn encode_info_for_struct(ecx: &EncodeContext, let mut index = Vec::new(); /* We encode both private and public fields -- need to include private fields to get the offsets right */ - for field in fields.iter() { + for field in fields { let nm = field.name; let id = field.id.node; @@ -783,7 +783,7 @@ fn encode_generics<'a, 'tcx>(rbml_w: &mut Encoder, rbml_w.wr_tagged_u64(tag_region_param_def_index, param.index as u64); - for &bound_region in param.bounds.iter() { + for &bound_region in ¶m.bounds { encode_region(ecx, rbml_w, bound_region); } @@ -911,7 +911,7 @@ fn encode_info_for_associated_type(ecx: &EncodeContext, fn encode_method_argument_names(rbml_w: &mut Encoder, decl: &ast::FnDecl) { rbml_w.start_tag(tag_method_argument_names); - for arg in decl.inputs.iter() { + for arg in &decl.inputs { rbml_w.start_tag(tag_method_argument_name); if let ast::PatIdent(_, ref path1, _) = arg.pat.node { let name = token::get_ident(path1.node); @@ -926,7 +926,7 @@ fn encode_repr_attrs(rbml_w: &mut Encoder, ecx: &EncodeContext, attrs: &[ast::Attribute]) { let mut repr_attrs = Vec::new(); - for attr in attrs.iter() { + for attr in attrs { repr_attrs.extend(attr::find_repr_attrs(ecx.tcx.sess.diagnostic(), attr).into_iter()); } @@ -962,7 +962,7 @@ fn encode_inherent_implementations(ecx: &EncodeContext, match ecx.tcx.inherent_impls.borrow().get(&def_id) { None => {} Some(implementations) => { - for &impl_def_id in implementations.iter() { + for &impl_def_id in &**implementations { rbml_w.start_tag(tag_items_data_item_inherent_impl); encode_def_id(rbml_w, impl_def_id); rbml_w.end_tag(); @@ -978,7 +978,7 @@ fn encode_extension_implementations(ecx: &EncodeContext, match ecx.tcx.trait_impls.borrow().get(&trait_def_id) { None => {} Some(implementations) => { - for &impl_def_id in implementations.borrow().iter() { + for &impl_def_id in &*implementations.borrow() { rbml_w.start_tag(tag_items_data_item_extension_impl); encode_def_id(rbml_w, impl_def_id); rbml_w.end_tag(); @@ -1091,7 +1091,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_path(rbml_w, path); // Encode all the items in this module. - for foreign_item in fm.items.iter() { + for foreign_item in &fm.items { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(&def_to_string(local_def(foreign_item.id))[]); rbml_w.end_tag(); @@ -1123,7 +1123,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_name(rbml_w, item.ident.name); encode_attributes(rbml_w, &item.attrs[]); encode_repr_attrs(rbml_w, ecx, &item.attrs[]); - for v in (*enum_definition).variants.iter() { + for v in &enum_definition.variants { encode_variant_id(rbml_w, local_def(v.node.id)); } encode_inlined_item(ecx, rbml_w, IIItemRef(item)); @@ -1216,7 +1216,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } _ => {} } - for &item_def_id in items.iter() { + for &item_def_id in items { rbml_w.start_tag(tag_item_impl_item); match item_def_id { ty::MethodTraitItemId(item_def_id) => { @@ -1230,7 +1230,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } rbml_w.end_tag(); } - for ast_trait_ref in opt_trait.iter() { + if let Some(ref ast_trait_ref) = *opt_trait { let trait_ref = ty::node_id_to_trait_ref( tcx, ast_trait_ref.ref_id); encode_trait_ref(rbml_w, ecx, &*trait_ref, tag_item_trait_ref); @@ -1314,7 +1314,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_attributes(rbml_w, &item.attrs[]); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); - for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() { + for &method_def_id in &*ty::trait_item_def_ids(tcx, def_id) { rbml_w.start_tag(tag_item_trait_item); match method_def_id { ty::MethodTraitItemId(method_def_id) => { @@ -1599,10 +1599,10 @@ fn encode_index(rbml_w: &mut Encoder, index: Vec>, mut write_fn: rbml_w.start_tag(tag_index); let mut bucket_locs = Vec::new(); rbml_w.start_tag(tag_index_buckets); - for bucket in buckets.iter() { + for bucket in &buckets { bucket_locs.push(rbml_w.writer.tell().unwrap()); rbml_w.start_tag(tag_index_buckets_bucket); - for elt in bucket.iter() { + for elt in bucket { rbml_w.start_tag(tag_index_buckets_bucket_elt); assert!(elt.pos < 0xffff_ffff); { @@ -1616,7 +1616,7 @@ fn encode_index(rbml_w: &mut Encoder, index: Vec>, mut write_fn: } rbml_w.end_tag(); rbml_w.start_tag(tag_index_table); - for pos in bucket_locs.iter() { + for pos in &bucket_locs { assert!(*pos < 0xffff_ffff); let wr: &mut SeekableMemWriter = rbml_w.writer; wr.write_be_u32(*pos as u32); @@ -1660,7 +1660,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) { rbml_w.start_tag(tag_meta_item_name); rbml_w.writer.write_all(name.get().as_bytes()); rbml_w.end_tag(); - for inner_item in items.iter() { + for inner_item in items { encode_meta_item(rbml_w, &**inner_item); } rbml_w.end_tag(); @@ -1670,7 +1670,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) { fn encode_attributes(rbml_w: &mut Encoder, attrs: &[ast::Attribute]) { rbml_w.start_tag(tag_attributes); - for attr in attrs.iter() { + for attr in attrs { rbml_w.start_tag(tag_attribute); rbml_w.wr_tagged_u8(tag_attribute_is_sugared_doc, attr.node.is_sugared_doc as u8); encode_meta_item(rbml_w, &*attr.node.value); @@ -1694,7 +1694,7 @@ fn encode_paren_sugar(rbml_w: &mut Encoder, paren_sugar: bool) { fn encode_associated_type_names(rbml_w: &mut Encoder, names: &[ast::Name]) { rbml_w.start_tag(tag_associated_type_names); - for &name in names.iter() { + for &name in names { rbml_w.wr_tagged_str(tag_associated_type_name, token::get_name(name).get()); } rbml_w.end_tag(); @@ -1726,7 +1726,7 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { // Sanity-check the crate numbers let mut expected_cnum = 1; - for n in deps.iter() { + for n in &deps { assert_eq!(n.cnum, expected_cnum); expected_cnum += 1; } @@ -1740,7 +1740,7 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { // but is enough to get transitive crate dependencies working. rbml_w.start_tag(tag_crate_deps); let r = get_ordered_deps(cstore); - for dep in r.iter() { + for dep in &r { encode_crate_dep(rbml_w, (*dep).clone()); } rbml_w.end_tag(); @@ -1749,8 +1749,8 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_lang_items); - for (i, def_id) in ecx.tcx.lang_items.items() { - for id in def_id.iter() { + for (i, &def_id) in ecx.tcx.lang_items.items() { + if let Some(id) = def_id { if id.krate == ast::LOCAL_CRATE { rbml_w.start_tag(tag_lang_items_item); @@ -1773,7 +1773,7 @@ fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { } } - for i in ecx.tcx.lang_items.missing.iter() { + for i in &ecx.tcx.lang_items.missing { rbml_w.wr_tagged_u32(tag_lang_items_missing, *i as u32); } @@ -1817,7 +1817,7 @@ fn encode_plugin_registrar_fn(ecx: &EncodeContext, rbml_w: &mut Encoder) { fn encode_macro_defs(rbml_w: &mut Encoder, krate: &ast::Crate) { rbml_w.start_tag(tag_macro_defs); - for def in krate.exported_macros.iter() { + for def in &krate.exported_macros { rbml_w.start_tag(tag_macro_def); encode_name(rbml_w, def.ident.name); @@ -1911,7 +1911,7 @@ fn encode_misc_info(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_misc_info); rbml_w.start_tag(tag_misc_info_crate_items); - for item in krate.module.items.iter() { + for item in &krate.module.items { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(&def_to_string(local_def(item.id))[]); rbml_w.end_tag(); @@ -1935,7 +1935,7 @@ fn encode_misc_info(ecx: &EncodeContext, fn encode_reachable_extern_fns(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_reachable_extern_fns); - for id in ecx.reachable.iter() { + for id in ecx.reachable { if let Some(ast_map::NodeItem(i)) = ecx.tcx.map.find(*id) { if let ast::ItemFn(_, _, abi, ref generics, _) = i.node { if abi != abi::Rust && !generics.is_type_parameterized() { @@ -2150,7 +2150,7 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, stats.total_bytes = rbml_w.writer.tell().unwrap(); if tcx.sess.meta_stats() { - for e in rbml_w.writer.get_ref().iter() { + for e in rbml_w.writer.get_ref() { if *e == 0 { stats.zero_bytes += 1; } diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 26046cfb43d..6197846ec6f 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -66,7 +66,7 @@ impl<'a> FileSearch<'a> { // Try RUST_PATH if !found { let rustpath = rust_path(); - for path in rustpath.iter() { + for path in &rustpath { let tlib_path = make_rustpkg_lib_path( self.sysroot, path, self.triple); debug!("is {} in visited_dirs? {}", tlib_path.display(), @@ -243,8 +243,7 @@ pub fn rust_path() -> Vec { } cwd.pop(); } - let h = os::homedir(); - for h in h.iter() { + if let Some(h) = os::homedir() { let p = h.join(".rust"); if !env_rust_path.contains(&p) && p.exists() { env_rust_path.push(p); diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 09957f58bcc..f219bfffcb8 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -452,7 +452,7 @@ impl<'a> Context<'a> { &format!("multiple matching crates for `{}`", self.crate_name)[]); self.sess.note("candidates:"); - for lib in libraries.iter() { + for lib in &libraries { match lib.dylib { Some((ref p, _)) => { self.sess.note(&format!("path: {}", diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index ac6d2d0174c..4c0aefaf83d 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -249,7 +249,7 @@ fn parse_vec_per_param_space<'a, 'tcx, T, F>(st: &mut PState<'a, 'tcx>, F: FnMut(&mut PState<'a, 'tcx>) -> T, { let mut r = VecPerParamSpace::empty(); - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { assert_eq!(next(st), '['); while peek(st) != ']' { r.push(space, f(st)); diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 2dc334bfe95..f8081e2c309 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -97,7 +97,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t } ty::ty_tup(ref ts) => { mywrite!(w, "T["); - for t in ts.iter() { enc_ty(w, cx, *t); } + for t in ts { enc_ty(w, cx, *t); } mywrite!(w, "]"); } ty::ty_uniq(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); } @@ -206,9 +206,9 @@ fn enc_vec_per_param_space<'a, 'tcx, T, F>(w: &mut SeekableMemWriter, mut op: F) where F: FnMut(&mut SeekableMemWriter, &ctxt<'a, 'tcx>, &T), { - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { mywrite!(w, "["); - for t in v.get_slice(space).iter() { + for t in v.get_slice(space) { op(w, cx, t); } mywrite!(w, "]"); @@ -337,7 +337,7 @@ pub fn enc_closure_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, fn enc_fn_sig<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, fsig: &ty::PolyFnSig<'tcx>) { mywrite!(w, "["); - for ty in fsig.0.inputs.iter() { + for ty in &fsig.0.inputs { enc_ty(w, cx, *ty); } mywrite!(w, "]"); @@ -357,7 +357,7 @@ fn enc_fn_sig<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, } pub fn enc_builtin_bounds(w: &mut SeekableMemWriter, _cx: &ctxt, bs: &ty::BuiltinBounds) { - for bound in bs.iter() { + for bound in bs { match bound { ty::BoundSend => mywrite!(w, "S"), ty::BoundSized => mywrite!(w, "Z"), @@ -383,17 +383,17 @@ pub fn enc_bounds<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, bs: &ty::ParamBounds<'tcx>) { enc_builtin_bounds(w, cx, &bs.builtin_bounds); - for &r in bs.region_bounds.iter() { + for &r in &bs.region_bounds { mywrite!(w, "R"); enc_region(w, cx, r); } - for tp in bs.trait_bounds.iter() { + for tp in &bs.trait_bounds { mywrite!(w, "I"); enc_trait_ref(w, cx, &*tp.0); } - for tp in bs.projection_bounds.iter() { + for tp in &bs.projection_bounds { mywrite!(w, "P"); enc_projection_predicate(w, cx, &tp.0); } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 6d9b9c23504..4130195ae40 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -766,7 +766,7 @@ fn encode_vec_per_param_space(rbml_w: &mut Encoder, mut f: F) where F: FnMut(&mut Encoder, &T), { - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { rbml_w.emit_from_vec(v.get_slice(space), |rbml_w, n| Ok(f(rbml_w, n))).unwrap(); } @@ -1156,14 +1156,14 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, debug!("Encoding side tables for id {}", id); - for def in tcx.def_map.borrow().get(&id).iter() { + if let Some(def) = tcx.def_map.borrow().get(&id) { rbml_w.tag(c::tag_table_def, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| (*def).encode(rbml_w).unwrap()); }) } - for &ty in tcx.node_types.borrow().get(&id).iter() { + if let Some(ty) = tcx.node_types.borrow().get(&id) { rbml_w.tag(c::tag_table_node_type, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1172,7 +1172,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &item_substs in tcx.item_substs.borrow().get(&id).iter() { + if let Some(item_substs) = tcx.item_substs.borrow().get(&id) { rbml_w.tag(c::tag_table_item_subst, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1181,7 +1181,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &fv in tcx.freevars.borrow().get(&id).iter() { + if let Some(fv) = tcx.freevars.borrow().get(&id) { rbml_w.tag(c::tag_table_freevars, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1191,7 +1191,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) }); - for freevar in fv.iter() { + for freevar in fv { rbml_w.tag(c::tag_table_upvar_capture_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1209,7 +1209,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id }; - for &type_scheme in tcx.tcache.borrow().get(&lid).iter() { + if let Some(type_scheme) = tcx.tcache.borrow().get(&lid) { rbml_w.tag(c::tag_table_tcache, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1218,7 +1218,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &type_param_def in tcx.ty_param_defs.borrow().get(&id).iter() { + if let Some(type_param_def) = tcx.ty_param_defs.borrow().get(&id) { rbml_w.tag(c::tag_table_param_defs, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1228,7 +1228,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } let method_call = MethodCall::expr(id); - for &method in tcx.method_map.borrow().get(&method_call).iter() { + if let Some(method) = tcx.method_map.borrow().get(&method_call) { rbml_w.tag(c::tag_table_method_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1237,7 +1237,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &trait_ref in tcx.object_cast_map.borrow().get(&id).iter() { + if let Some(trait_ref) = tcx.object_cast_map.borrow().get(&id) { rbml_w.tag(c::tag_table_object_cast_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1246,11 +1246,11 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &adjustment in tcx.adjustments.borrow().get(&id).iter() { + if let Some(adjustment) = tcx.adjustments.borrow().get(&id) { match *adjustment { _ if ty::adjust_is_object(adjustment) => { let method_call = MethodCall::autoobject(id); - for &method in tcx.method_map.borrow().get(&method_call).iter() { + if let Some(method) = tcx.method_map.borrow().get(&method_call) { rbml_w.tag(c::tag_table_method_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1263,7 +1263,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, assert!(!ty::adjust_is_object(adjustment)); for autoderef in 0..adj.autoderefs { let method_call = MethodCall::autoderef(id, autoderef); - for &method in tcx.method_map.borrow().get(&method_call).iter() { + if let Some(method) = tcx.method_map.borrow().get(&method_call) { rbml_w.tag(c::tag_table_method_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1287,7 +1287,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &closure_type in tcx.closure_tys.borrow().get(&ast_util::local_def(id)).iter() { + if let Some(closure_type) = tcx.closure_tys.borrow().get(&ast_util::local_def(id)) { rbml_w.tag(c::tag_table_closure_tys, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1296,11 +1296,11 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &&closure_kind in tcx.closure_kinds.borrow().get(&ast_util::local_def(id)).iter() { + if let Some(closure_kind) = tcx.closure_kinds.borrow().get(&ast_util::local_def(id)) { rbml_w.tag(c::tag_table_closure_kinds, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { - encode_closure_kind(rbml_w, closure_kind) + encode_closure_kind(rbml_w, *closure_kind) }) }) } diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 0a575a31ead..d39b94a202e 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -68,7 +68,7 @@ fn add_initial_dummy_node(g: &mut CFGGraph) -> CFGIndex { impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { fn block(&mut self, blk: &ast::Block, pred: CFGIndex) -> CFGIndex { let mut stmts_exit = pred; - for stmt in blk.stmts.iter() { + for stmt in &blk.stmts { stmts_exit = self.stmt(&**stmt, stmts_exit); } @@ -166,7 +166,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.pat(&*pats[0], pred) } else { let collect = self.add_dummy_node(&[]); - for pat in pats.iter() { + for pat in pats { let pat_exit = self.pat(&**pat, pred); self.add_contained_edge(pat_exit, collect); } @@ -325,7 +325,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let expr_exit = self.add_node(expr.id, &[]); let mut cond_exit = discr_exit; - for arm in arms.iter() { + for arm in arms { cond_exit = self.add_dummy_node(&[cond_exit]); // 2 let pats_exit = self.pats_any(&arm.pats[], cond_exit); // 3 @@ -522,7 +522,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { assert!(!self.exit_map.contains_key(&id)); self.exit_map.insert(id, node); } - for &pred in preds.iter() { + for &pred in preds { self.add_contained_edge(pred, node); } node @@ -574,7 +574,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { Some(_) => { match self.tcx.def_map.borrow().get(&expr.id) { Some(&def::DefLabel(loop_id)) => { - for l in self.loop_scopes.iter() { + for l in &self.loop_scopes { if l.loop_id == loop_id { return *l; } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 202020a9033..925bd5b6395 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -46,7 +46,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { } ast::ItemEnum(ref enum_definition, _) => { self.inside_const(|v| { - for var in enum_definition.variants.iter() { + for var in &enum_definition.variants { if let Some(ref ex) = var.node.disr_expr { v.visit_expr(&**ex); } @@ -137,7 +137,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) { } ast::ExprBlock(ref block) => { // Check all statements in the block - for stmt in block.stmts.iter() { + for stmt in &block.stmts { let block_span_err = |&: span| span_err!(v.tcx.sess, span, E0016, "blocks in constants are limited to items and \ diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 6de517b2906..72551daa4e6 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -157,7 +157,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { visit::walk_expr(cx, ex); match ex.node { ast::ExprMatch(ref scrut, ref arms, source) => { - for arm in arms.iter() { + for arm in arms { // First, check legality of move bindings. check_legality_of_move_bindings(cx, arm.guard.is_some(), @@ -285,8 +285,8 @@ fn check_arms(cx: &MatchCheckCtxt, source: ast::MatchSource) { let mut seen = Matrix(vec![]); let mut printed_if_let_err = false; - for &(ref pats, guard) in arms.iter() { - for pat in pats.iter() { + for &(ref pats, guard) in arms { + for pat in pats { let v = vec![&**pat]; match is_useful(cx, &seen, &v[], LeaveOutWitness) { @@ -979,7 +979,7 @@ fn check_fn(cx: &mut MatchCheckCtxt, visit::walk_fn(cx, kind, decl, body, sp); - for input in decl.inputs.iter() { + for input in &decl.inputs { is_refutable(cx, &*input.pat, |pat| { span_err!(cx.tcx.sess, input.pat.span, E0006, "refutable pattern in function argument: `{}` not covered", @@ -1012,7 +1012,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, let tcx = cx.tcx; let def_map = &tcx.def_map; let mut by_ref_span = None; - for pat in pats.iter() { + for pat in pats { pat_bindings(def_map, &**pat, |bm, _, span, _path| { match bm { ast::BindByRef(_) => { @@ -1039,7 +1039,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, } }; - for pat in pats.iter() { + for pat in pats { walk_pat(&**pat, |p| { if pat_is_binding(def_map, &*p) { match p.node { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 00141903c7c..fa5d5227be5 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -104,7 +104,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, -> Option<&'a Expr> { fn variant_expr<'a>(variants: &'a [P], id: ast::NodeId) -> Option<&'a Expr> { - for variant in variants.iter() { + for variant in variants { if variant.node.id == id { return variant.node.disr_expr.as_ref().map(|e| &**e); } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 3e2e81077da..a06a57beb61 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -399,7 +399,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let mut orig_kills = self.kills[start.. end].to_vec(); let mut changed = false; - for &node_id in edge.data.exiting_scopes.iter() { + for &node_id in &edge.data.exiting_scopes { let opt_cfg_idx = self.nodeid_to_index.get(&node_id).map(|&i|i); match opt_cfg_idx { Some(cfg_idx) => { @@ -550,7 +550,7 @@ fn bits_to_string(words: &[uint]) -> String { // Note: this is a little endian printout of bytes. - for &word in words.iter() { + for &word in words { let mut v = word; for _ in 0..uint::BYTES { result.push(sep); diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 3db931002d2..6bad7f59441 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -173,7 +173,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } }; let fields = ty::lookup_struct_fields(self.tcx, id); - for pat in pats.iter() { + for pat in pats { let field_id = fields.iter() .find(|field| field.name == pat.node.ident.name).unwrap().id; self.live_symbols.insert(field_id.node); @@ -356,7 +356,7 @@ impl<'v> Visitor<'v> for LifeSeeder { self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.id)); } ast::ItemImpl(_, _, _, Some(ref _trait_ref), _, ref impl_items) => { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { self.worklist.push(method.id); @@ -397,10 +397,10 @@ fn create_and_seed_worklist(tcx: &ty::ctxt, // depending on whether a crate is built as bin or lib, and we want // the warning to be consistent, we also seed the worklist with // exported symbols. - for id in exported_items.iter() { + for id in exported_items { worklist.push(*id); } - for id in reachable_symbols.iter() { + for id in reachable_symbols { worklist.push(*id); } @@ -499,8 +499,8 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { match self.tcx.inherent_impls.borrow().get(&local_def(id)) { None => (), Some(impl_list) => { - for impl_did in impl_list.iter() { - for item_did in (*impl_items)[*impl_did].iter() { + for impl_did in &**impl_list { + for item_did in &(*impl_items)[*impl_did] { if self.live_symbols.contains(&item_did.def_id() .node) { return true; @@ -536,7 +536,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for DeadVisitor<'a, 'tcx> { } else { match item.node { ast::ItemEnum(ref enum_def, _) => { - for variant in enum_def.variants.iter() { + for variant in &enum_def.variants { if self.should_warn_about_variant(&variant.node) { self.warn_dead_code(variant.node.id, variant.span, variant.node.name, "variant"); diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 16b7d6134c3..6d35a82d153 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -85,7 +85,7 @@ pub type Dependencies = FnvHashMap; pub fn calculate(tcx: &ty::ctxt) { let mut fmts = tcx.dependency_formats.borrow_mut(); - for &ty in tcx.sess.crate_types.borrow().iter() { + for &ty in &*tcx.sess.crate_types.borrow() { fmts.insert(ty, calculate_type(&tcx.sess, ty)); } tcx.sess.abort_if_errors(); @@ -148,7 +148,7 @@ fn calculate_type(sess: &session::Session, debug!("adding dylib: {}", data.name); add_library(sess, cnum, cstore::RequireDynamic, &mut formats); let deps = csearch::get_dylib_dependency_formats(&sess.cstore, cnum); - for &(depnum, style) in deps.iter() { + for &(depnum, style) in &deps { debug!("adding {:?}: {}", style, sess.cstore.get_crate_data(depnum).name.clone()); add_library(sess, depnum, style, &mut formats); diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 417e5336249..24073848edf 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -139,7 +139,7 @@ fn configure_main(this: &mut EntryContext) { but you have one or more functions named 'main' that are not \ defined at the crate level. Either move the definition or \ attach the `#[main]` attribute to override this behavior."); - for &(_, span) in this.non_main_fns.iter() { + for &(_, span) in &this.non_main_fns { this.session.span_note(span, "here is a function named 'main'"); } this.session.abort_if_errors(); diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 4a0bed57433..44a816eb2f8 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -342,7 +342,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn walk_arg_patterns(&mut self, decl: &ast::FnDecl, body: &ast::Block) { - for arg in decl.inputs.iter() { + for arg in &decl.inputs { let arg_ty = return_if_err!(self.typer.node_ty(arg.pat.id)); let fn_body_scope = region::CodeExtent::from_node_id(body.id); @@ -372,7 +372,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } fn consume_exprs(&mut self, exprs: &Vec>) { - for expr in exprs.iter() { + for expr in exprs { self.consume_expr(&**expr); } } @@ -476,7 +476,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { ast::ExprIf(ref cond_expr, ref then_blk, ref opt_else_expr) => { self.consume_expr(&**cond_expr); self.walk_block(&**then_blk); - for else_expr in opt_else_expr.iter() { + if let Some(ref else_expr) = *opt_else_expr { self.consume_expr(&**else_expr); } } @@ -490,7 +490,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { self.borrow_expr(&**discr, ty::ReEmpty, ty::ImmBorrow, MatchDiscriminant); // treatment of the discriminant is handled while walking the arms. - for arm in arms.iter() { + for arm in arms { let mode = self.arm_move_mode(discr_cmt.clone(), arm); let mode = mode.match_mode(); self.walk_arm(discr_cmt.clone(), arm, mode); @@ -511,11 +511,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } ast::ExprInlineAsm(ref ia) => { - for &(_, ref input) in ia.inputs.iter() { + for &(_, ref input) in &ia.inputs { self.consume_expr(&**input); } - for &(_, ref output, is_rw) in ia.outputs.iter() { + for &(_, ref output, is_rw) in &ia.outputs { self.mutate_expr(expr, &**output, if is_rw { WriteAndRead } else { JustWrite }); } @@ -572,7 +572,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } ast::ExprRet(ref opt_expr) => { - for expr in opt_expr.iter() { + if let Some(ref expr) = *opt_expr { self.consume_expr(&**expr); } } @@ -715,11 +715,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn walk_block(&mut self, blk: &ast::Block) { debug!("walk_block(blk.id={})", blk.id); - for stmt in blk.stmts.iter() { + for stmt in &blk.stmts { self.walk_stmt(&**stmt); } - for tail_expr in blk.expr.iter() { + if let Some(ref tail_expr) = blk.expr { self.consume_expr(&**tail_expr); } } @@ -729,7 +729,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fields: &Vec, opt_with: &Option>) { // Consume the expressions supplying values for each field. - for field in fields.iter() { + for field in fields { self.consume_expr(&*field.expr); } @@ -762,7 +762,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { }; // Consume those fields of the with expression that are needed. - for with_field in with_fields.iter() { + for with_field in &with_fields { if !contains_field_named(with_field, fields) { let cmt_field = self.mc.cat_field(&*with_expr, with_cmt.clone(), @@ -908,7 +908,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { match pass_args { PassArgs::ByValue => { self.consume_expr(receiver); - for &arg in rhs.iter() { + for &arg in &rhs { self.consume_expr(arg); } @@ -926,7 +926,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { let r = ty::ReScope(region::CodeExtent::from_node_id(expr.id)); let bk = ty::ImmBorrow; - for &arg in rhs.iter() { + for &arg in &rhs { self.borrow_expr(arg, r, bk, OverloadedOperator); } return true; @@ -934,18 +934,18 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn arm_move_mode(&mut self, discr_cmt: mc::cmt<'tcx>, arm: &ast::Arm) -> TrackMatchMode { let mut mode = Unknown; - for pat in arm.pats.iter() { + for pat in &arm.pats { self.determine_pat_move_mode(discr_cmt.clone(), &**pat, &mut mode); } mode } fn walk_arm(&mut self, discr_cmt: mc::cmt<'tcx>, arm: &ast::Arm, mode: MatchMode) { - for pat in arm.pats.iter() { + for pat in &arm.pats { self.walk_pat(discr_cmt.clone(), &**pat, mode); } - for guard in arm.guard.iter() { + if let Some(ref guard) = arm.guard { self.consume_expr(&**guard); } @@ -1195,7 +1195,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { debug!("walk_captures({})", closure_expr.repr(self.tcx())); ty::with_freevars(self.tcx(), closure_expr.id, |freevars| { - for freevar in freevars.iter() { + for freevar in freevars { let id_var = freevar.def.def_id().node; let upvar_id = ty::UpvarId { var_id: id_var, closure_expr_id: closure_expr.id }; diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index 8b29ef9b880..8cb2774f7df 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -116,7 +116,7 @@ pub trait Combine<'tcx> : Sized { { let mut substs = subst::Substs::empty(); - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { let a_tps = a_subst.types.get_slice(space); let b_tps = b_subst.types.get_slice(space); let tps = try!(self.tps(space, a_tps, b_tps)); @@ -129,7 +129,7 @@ pub trait Combine<'tcx> : Sized { } (&NonerasedRegions(ref a), &NonerasedRegions(ref b)) => { - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { let a_regions = a.get_slice(space); let b_regions = b.get_slice(space); @@ -139,7 +139,7 @@ pub trait Combine<'tcx> : Sized { variances.regions.get_slice(space) } None => { - for _ in a_regions.iter() { + for _ in a_regions { invariance.push(ty::Invariant); } &invariance[] diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index f0174c5b0c6..2efc07a4023 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -170,7 +170,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { errors: &Vec>) { let p_errors = self.process_errors(errors); let errors = if p_errors.is_empty() { errors } else { &p_errors }; - for error in errors.iter() { + for error in errors { match error.clone() { ConcreteFailure(origin, sub, sup) => { self.report_concrete_failure(origin, sub, sup); @@ -222,7 +222,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { let mut trace_origins = Vec::new(); let mut same_regions = Vec::new(); let mut processed_errors = Vec::new(); - for error in errors.iter() { + for error in errors { match error.clone() { ConcreteFailure(origin, sub, sup) => { debug!("processing ConcreteFailure"); @@ -257,7 +257,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { } if !same_regions.is_empty() { let common_scope_id = same_regions[0].scope_id; - for sr in same_regions.iter() { + for sr in &same_regions { // Since ProcessedErrors is used to reconstruct the function // declaration, we want to make sure that they are, in fact, // from the same scope @@ -796,11 +796,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { var_origins: &[RegionVariableOrigin], trace_origins: &[(TypeTrace<'tcx>, ty::type_err<'tcx>)], same_regions: &[SameRegions]) { - for vo in var_origins.iter() { + for vo in var_origins { self.report_inference_failure(vo.clone()); } self.give_suggestion(same_regions); - for &(ref trace, terr) in trace_origins.iter() { + for &(ref trace, terr) in trace_origins { self.report_type_error(trace.clone(), &terr); } } @@ -916,7 +916,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { let mut ty_params = self.generics.ty_params.clone(); let where_clause = self.generics.where_clause.clone(); let mut kept_lifetimes = HashSet::new(); - for sr in self.same_regions.iter() { + for sr in self.same_regions { self.cur_anon.set(0); self.offset_cur_anon(); let (anon_nums, region_names) = @@ -958,7 +958,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { // vector of string and then sort them. However, it makes the // choice of lifetime name deterministic and thus easier to test. let mut names = Vec::new(); - for rn in region_names.iter() { + for rn in region_names { let lt_name = token::get_name(*rn).get().to_string(); names.push(lt_name); } @@ -973,7 +973,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { -> (HashSet, HashSet) { let mut anon_nums = HashSet::new(); let mut region_names = HashSet::new(); - for br in same_regions.regions.iter() { + for br in &same_regions.regions { match *br { ty::BrAnon(i) => { anon_nums.insert(i); @@ -989,8 +989,8 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { fn extract_all_region_names(&self) -> HashSet { let mut all_region_names = HashSet::new(); - for sr in self.same_regions.iter() { - for br in sr.regions.iter() { + for sr in self.same_regions { + for br in &sr.regions { match *br { ty::BrNamed(_, name) => { all_region_names.insert(name); @@ -1123,11 +1123,11 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { where_clause: ast::WhereClause) -> ast::Generics { let mut lifetimes = Vec::new(); - for lt in add.iter() { + for lt in add { lifetimes.push(ast::LifetimeDef { lifetime: *lt, bounds: Vec::new() }); } - for lt in generics.lifetimes.iter() { + for lt in &generics.lifetimes { if keep.contains(<.lifetime.name) || !remove.contains(<.lifetime.name) { lifetimes.push((*lt).clone()); @@ -1147,7 +1147,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { region_names: &HashSet) -> Vec { let mut new_inputs = Vec::new(); - for arg in inputs.iter() { + for arg in inputs { let new_ty = self.rebuild_arg_ty_or_output(&*arg.ty, lifetime, anon_nums, region_names); let possibly_new_arg = ast::Arg { @@ -1729,7 +1729,7 @@ struct LifeGiver { impl LifeGiver { fn with_taken(taken: &[ast::LifetimeDef]) -> LifeGiver { let mut taken_ = HashSet::new(); - for lt in taken.iter() { + for lt in taken { let lt_name = token::get_name(lt.lifetime.name).get().to_string(); taken_.insert(lt_name); } diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs index 0df84323ae5..e4eecd919c8 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -176,7 +176,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C // in both A and B. Replace the variable with the "first" // bound region from A that we find it to be associated // with. - for (a_br, a_r) in a_map.iter() { + for (a_br, a_r) in a_map { if tainted.iter().any(|x| x == a_r) { debug!("generalize_region(r0={:?}): \ replacing with {:?}, tainted={:?}", @@ -258,7 +258,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C let mut a_r = None; let mut b_r = None; let mut only_new_vars = true; - for r in tainted.iter() { + for r in &tainted { if is_var_in_set(a_vars, *r) { if a_r.is_some() { return fresh_bound_variable(infcx, debruijn); @@ -315,7 +315,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C a_map: &FnvHashMap, r: ty::Region) -> ty::Region { - for (a_br, a_r) in a_map.iter() { + for (a_br, a_r) in a_map { if *a_r == r { return ty::ReLateBound(ty::DebruijnIndex::new(1), *a_br); } @@ -497,9 +497,9 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, skol_map.repr(infcx.tcx)); let new_vars = infcx.region_vars_confined_to_snapshot(snapshot); - for (&skol_br, &skol) in skol_map.iter() { + for (&skol_br, &skol) in skol_map { let tainted = infcx.tainted_regions(snapshot, skol); - for &tainted_region in tainted.iter() { + for &tainted_region in &tainted { // Each skolemized should only be relatable to itself // or new variables: match tainted_region { diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 1665966a5e5..f8dae3e92da 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -998,8 +998,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty), error_str)[]); - for err in err.iter() { - ty::note_and_explain_type_err(self.tcx, *err) + if let Some(err) = err { + ty::note_and_explain_type_err(self.tcx, err) } } } diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 8952452cb4b..919ea0a2520 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -667,7 +667,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a, b); } VerifyGenericBound(_, _, a, ref bs) => { - for &b in bs.iter() { + for &b in bs { consider_adding_bidirectional_edges( &mut result_set, r, a, b); @@ -1200,7 +1200,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { errors: &mut Vec>) { let mut reg_reg_dups = FnvHashSet(); - for verify in self.verifys.borrow().iter() { + for verify in &*self.verifys.borrow() { match *verify { VerifyRegSubReg(ref origin, sub, sup) => { if self.is_subregion_of(sub, sup) { @@ -1333,7 +1333,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } let dummy_idx = graph.add_node(()); - for (constraint, _) in constraints.iter() { + for (constraint, _) in &*constraints { match *constraint { ConstrainVarSubVar(a_id, b_id) => { graph.add_edge(NodeIndex(a_id.index as uint), @@ -1393,8 +1393,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { lower_bounds.sort_by(|a, b| { free_regions_first(a, b) }); upper_bounds.sort_by(|a, b| { free_regions_first(a, b) }); - for lower_bound in lower_bounds.iter() { - for upper_bound in upper_bounds.iter() { + for lower_bound in &lower_bounds { + for upper_bound in &upper_bounds { if !self.is_subregion_of(lower_bound.region, upper_bound.region) { errors.push(SubSupConflict( @@ -1435,8 +1435,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { return; } - for upper_bound_1 in upper_bounds.iter() { - for upper_bound_2 in upper_bounds.iter() { + for upper_bound_1 in &upper_bounds { + for upper_bound_2 in &upper_bounds { match self.glb_concrete_regions(upper_bound_1.region, upper_bound_2.region) { Ok(_) => {} @@ -1554,7 +1554,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { changed = false; iteration += 1; debug!("---- {} Iteration {}{}", "#", tag, iteration); - for (constraint, _) in self.constraints.borrow().iter() { + for (constraint, _) in &*self.constraints.borrow() { let edge_changed = body(constraint); if edge_changed { debug!("Updated due to constraint {}", diff --git a/src/librustc/middle/infer/type_variable.rs b/src/librustc/middle/infer/type_variable.rs index 65061a29b78..9b8a4a84412 100644 --- a/src/librustc/middle/infer/type_variable.rs +++ b/src/librustc/middle/infer/type_variable.rs @@ -105,7 +105,7 @@ impl<'tcx> TypeVariableTable<'tcx> { already instantiated") }; - for &(dir, vid) in relations.iter() { + for &(dir, vid) in &relations { stack.push((ty, dir, vid)); } @@ -165,7 +165,7 @@ impl<'tcx> TypeVariableTable<'tcx> { let mut escaping_types = Vec::new(); let actions_since_snapshot = self.values.actions_since_snapshot(&s.snapshot); debug!("actions_since_snapshot.len() = {}", actions_since_snapshot.len()); - for action in actions_since_snapshot.iter() { + for action in actions_since_snapshot { match *action { sv::UndoLog::NewElem(index) => { // if any new variables were created during the diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 29a615f2b40..d9b90c1935a 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -120,7 +120,7 @@ impl LanguageItems { (self.fn_once_trait(), ty::FnOnceClosureKind), ]; - for &(opt_def_id, kind) in def_id_kinds.iter() { + for &(opt_def_id, kind) in &def_id_kinds { if Some(id) == opt_def_id { return Some(kind); } @@ -217,7 +217,7 @@ impl<'a> LanguageItemCollector<'a> { } pub fn extract(attrs: &[ast::Attribute]) -> Option { - for attribute in attrs.iter() { + for attribute in attrs { match attribute.value_str() { Some(ref value) if attribute.check_name("lang") => { return Some(value.clone()); diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index cb0157fed87..e40e04bdee8 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -378,7 +378,7 @@ fn visit_fn(ir: &mut IrMaps, debug!("creating fn_maps: {:?}", &fn_maps as *const IrMaps); - for arg in decl.inputs.iter() { + for arg in &decl.inputs { pat_util::pat_bindings(&ir.tcx.def_map, &*arg.pat, |_bm, arg_id, _x, path1| { @@ -427,7 +427,7 @@ fn visit_local(ir: &mut IrMaps, local: &ast::Local) { } fn visit_arm(ir: &mut IrMaps, arm: &ast::Arm) { - for pat in arm.pats.iter() { + for pat in &arm.pats { pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| { debug!("adding local variable {} from match with bm {:?}", p_id, bm); @@ -464,7 +464,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) { // construction site. let mut call_caps = Vec::new(); ty::with_freevars(ir.tcx, expr.id, |freevars| { - for fv in freevars.iter() { + for fv in freevars { if let DefLocal(rv) = fv.def { let fv_ln = ir.add_live_node(FreeVarNode(fv.span)); call_caps.push(CaptureInfo {ln: fv_ln, @@ -1049,7 +1049,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { let ln = self.live_node(expr.id, expr.span); self.init_empty(ln, succ); let mut first_merge = true; - for arm in arms.iter() { + for arm in arms { let body_succ = self.propagate_through_expr(&*arm.body, succ); let guard_succ = @@ -1445,12 +1445,12 @@ fn check_expr(this: &mut Liveness, expr: &Expr) { } ast::ExprInlineAsm(ref ia) => { - for &(_, ref input) in ia.inputs.iter() { + for &(_, ref input) in &ia.inputs { this.visit_expr(&**input); } // Output operands must be lvalues - for &(_, ref out, _) in ia.outputs.iter() { + for &(_, ref out, _) in &ia.outputs { this.check_lvalue(&**out); this.visit_expr(&**out); } @@ -1590,7 +1590,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } fn warn_about_unused_args(&self, decl: &ast::FnDecl, entry_ln: LiveNode) { - for arg in decl.inputs.iter() { + for arg in &decl.inputs { pat_util::pat_bindings(&self.ir.tcx.def_map, &*arg.pat, |_bm, p_id, sp, path1| { @@ -1620,7 +1620,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { -> bool { if !self.used_on_entry(ln, var) { let r = self.should_warn(var); - for name in r.iter() { + if let Some(name) = r { // annoying: for parameters in funcs like `fn(x: int) // {ret}`, there is only one node, so asking about @@ -1634,10 +1634,10 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { if is_assigned { self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_VARIABLES, id, sp, format!("variable `{}` is assigned to, but never used", - *name)); + name)); } else { self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_VARIABLES, id, sp, - format!("unused variable: `{}`", *name)); + format!("unused variable: `{}`", name)); } } true @@ -1653,9 +1653,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { var: Variable) { if self.live_on_exit(ln, var).is_none() { let r = self.should_warn(var); - for name in r.iter() { + if let Some(name) = r { self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_ASSIGNMENTS, id, sp, - format!("value assigned to `{}` is never read", *name)); + format!("value assigned to `{}` is never read", name)); } } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 93daaa72843..1ae483be269 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -1208,7 +1208,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { } } Some(&def::DefConst(..)) => { - for subpat in subpats.iter() { + for subpat in subpats { try!(self.cat_pattern_(cmt.clone(), &**subpat, op)); } } @@ -1230,7 +1230,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { ast::PatStruct(_, ref field_pats, _) => { // {f1: p1, ..., fN: pN} - for fp in field_pats.iter() { + for fp in field_pats { let field_ty = try!(self.pat_ty(&*fp.node.pat)); // see (*2) let cmt_field = self.cat_field(pat, cmt.clone(), fp.node.ident.name, field_ty); try!(self.cat_pattern_(cmt_field, &*fp.node.pat, op)); @@ -1259,15 +1259,15 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { ast::PatVec(ref before, ref slice, ref after) => { let elt_cmt = try!(self.cat_index(pat, try!(self.deref_vec(pat, cmt)))); - for before_pat in before.iter() { + for before_pat in before { try!(self.cat_pattern_(elt_cmt.clone(), &**before_pat, op)); } - for slice_pat in slice.iter() { + if let Some(ref slice_pat) = *slice { let slice_ty = try!(self.pat_ty(&**slice_pat)); let slice_cmt = self.cat_rvalue_node(pat.id(), pat.span(), slice_ty); try!(self.cat_pattern_(slice_cmt, &**slice_pat, op)); } - for after_pat in after.iter() { + for after_pat in after { try!(self.cat_pattern_(elt_cmt.clone(), &**after_pat, op)); } } diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index b93cde4bf64..0af226de251 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -353,7 +353,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { // this properly would result in the necessity of computing *type* // reachability, which might result in a compile time loss. fn mark_destructors_reachable(&mut self) { - for (_, destructor_def_id) in self.tcx.destructor_for_type.borrow().iter() { + for (_, destructor_def_id) in &*self.tcx.destructor_for_type.borrow() { if destructor_def_id.krate == ast::LOCAL_CRATE { self.reachable_symbols.insert(destructor_def_id.node); } @@ -371,7 +371,7 @@ pub fn find_reachable(tcx: &ty::ctxt, // other crates link to us, they're going to expect to be able to // use the lang items, so we need to be sure to mark them as // exported. - for id in exported_items.iter() { + for id in exported_items { reachable_context.worklist.push(*id); } for (_, item) in tcx.lang_items.items() { diff --git a/src/librustc/middle/recursion_limit.rs b/src/librustc/middle/recursion_limit.rs index da83833fba3..7dcd358165c 100644 --- a/src/librustc/middle/recursion_limit.rs +++ b/src/librustc/middle/recursion_limit.rs @@ -20,7 +20,7 @@ use syntax::ast; use syntax::attr::AttrMetaMethods; pub fn update_recursion_limit(sess: &Session, krate: &ast::Crate) { - for attr in krate.attrs.iter() { + for attr in &krate.attrs { if !attr.check_name("recursion_limit") { continue; } diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 3f8b7e5a7b3..87d386d94c9 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -888,14 +888,14 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) { record_rvalue_scope(visitor, &**subexpr, blk_id); } ast::ExprStruct(_, ref fields, _) => { - for field in fields.iter() { + for field in fields { record_rvalue_scope_if_borrow_expr( visitor, &*field.expr, blk_id); } } ast::ExprVec(ref subexprs) | ast::ExprTup(ref subexprs) => { - for subexpr in subexprs.iter() { + for subexpr in subexprs { record_rvalue_scope_if_borrow_expr( visitor, &**subexpr, blk_id); } diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 9433f7b0a70..365355c4a2a 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -187,14 +187,14 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { } fn visit_generics(&mut self, generics: &ast::Generics) { - for ty_param in generics.ty_params.iter() { + for ty_param in &*generics.ty_params { visit::walk_ty_param_bounds_helper(self, &ty_param.bounds); match ty_param.default { Some(ref ty) => self.visit_ty(&**ty), None => {} } } - for predicate in generics.where_clause.predicates.iter() { + for predicate in &generics.where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ ref bounded_ty, ref bounds, @@ -207,7 +207,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { .. }) => { self.visit_lifetime_ref(lifetime); - for bound in bounds.iter() { + for bound in bounds { self.visit_lifetime_ref(bound); } } @@ -229,7 +229,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| { this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes); - for lifetime in trait_ref.bound_lifetimes.iter() { + for lifetime in &trait_ref.bound_lifetimes { this.visit_lifetime_def(lifetime); } this.visit_trait_ref(&trait_ref.trait_ref) @@ -408,7 +408,7 @@ impl<'a> LifetimeContext<'a> { let lifetime_i = &lifetimes[i]; let special_idents = [special_idents::static_lifetime]; - for lifetime in lifetimes.iter() { + for lifetime in lifetimes { if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) { span_err!(self.sess, lifetime.lifetime.span, E0262, "illegal lifetime parameter name: `{}`", @@ -431,7 +431,7 @@ impl<'a> LifetimeContext<'a> { // It is a soft error to shadow a lifetime within a parent scope. self.check_lifetime_def_for_shadowing(old_scope, &lifetime_i.lifetime); - for bound in lifetime_i.bounds.iter() { + for bound in &lifetime_i.bounds { self.resolve_lifetime_ref(bound); } } @@ -535,10 +535,10 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { let mut collector = FreeLifetimeCollector { early_bound: &mut early_bound, late_bound: &mut late_bound }; - for ty_param in generics.ty_params.iter() { + for ty_param in &*generics.ty_params { visit::walk_ty_param_bounds_helper(&mut collector, &ty_param.bounds); } - for predicate in generics.where_clause.predicates.iter() { + for predicate in &generics.where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bounds, ref bounded_ty, @@ -551,7 +551,7 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { ..}) => { collector.visit_lifetime_ref(lifetime); - for bound in bounds.iter() { + for bound in bounds { collector.visit_lifetime_ref(bound); } } @@ -562,11 +562,11 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { // Any lifetime that either has a bound or is referenced by a // bound is early. - for lifetime_def in generics.lifetimes.iter() { + for lifetime_def in &generics.lifetimes { if !lifetime_def.bounds.is_empty() { shuffle(&mut early_bound, &mut late_bound, lifetime_def.lifetime.name); - for bound in lifetime_def.bounds.iter() { + for bound in &lifetime_def.bounds { shuffle(&mut early_bound, &mut late_bound, bound.name); } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 7b5af0ab1aa..5028a1322ca 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -148,7 +148,7 @@ impl Index { /// Construct the stability index for a crate being compiled. pub fn build(sess: &Session, krate: &Crate) -> Index { let mut staged_api = false; - for attr in krate.attrs.iter() { + for attr in &krate.attrs { if attr.name().get() == "staged_api" { match attr.node.value.node { ast::MetaWord(_) => { @@ -273,7 +273,7 @@ pub fn check_item(tcx: &ty::ctxt, item: &ast::Item, maybe_do_stability_check(tcx, id, item.span, cb); } ast::ItemTrait(_, _, ref supertraits, _) => { - for t in supertraits.iter() { + for t in &**supertraits { if let ast::TraitTyParamBound(ref t, _) = *t { let id = ty::trait_ref_to_def_id(tcx, &t.trait_ref); maybe_do_stability_check(tcx, id, t.trait_ref.path.span, cb); @@ -410,11 +410,11 @@ pub fn check_unused_features(sess: &Session, let mut active_lib_features: FnvHashMap = lib_features.clone().into_iter().collect(); - for used_feature in used_lib_features.iter() { + for used_feature in used_lib_features { active_lib_features.remove(used_feature); } - for (_, &span) in active_lib_features.iter() { + for (_, &span) in &active_lib_features { sess.add_lint(lint::builtin::UNUSED_FEATURES, ast::CRATE_NODE_ID, span, diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index cbf65080a86..2cf8a83db9b 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -241,7 +241,7 @@ pub struct SeparateVecsPerParamSpace { impl fmt::Debug for VecPerParamSpace { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "VecPerParamSpace {{")); - for space in ParamSpace::all().iter() { + for space in &ParamSpace::all() { try!(write!(fmt, "{:?}: {:?}, ", *space, self.get_slice(*space))); } try!(write!(fmt, "}}")); diff --git a/src/librustc/middle/traits/doc.rs b/src/librustc/middle/traits/doc.rs index 4a01e964fd2..8ce4e38896e 100644 --- a/src/librustc/middle/traits/doc.rs +++ b/src/librustc/middle/traits/doc.rs @@ -35,7 +35,7 @@ provide an impl. To see what I mean, consider the body of `clone_slice`: fn clone_slice(x: &[T]) -> Vec { let mut v = Vec::new(); - for e in x.iter() { + for e in &x { v.push((*e).clone()); // (*) } } diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index 5e7168b6735..b8886fa65ba 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -28,7 +28,7 @@ use util::ppaux::{Repr, UserString}; pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, errors: &Vec>) { - for error in errors.iter() { + for error in errors { report_fulfillment_error(infcx, error); } } @@ -68,7 +68,7 @@ fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, span: Span) -> Option { let def_id = trait_ref.def_id; let mut report = None; - for item in ty::get_attrs(infcx.tcx, def_id).iter() { + for item in &*ty::get_attrs(infcx.tcx, def_id) { if item.check_name("rustc_on_unimplemented") { let err_sp = if item.meta().span == DUMMY_SP { span diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index 530190ddfc1..c88e58266a0 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -176,7 +176,7 @@ fn object_safety_violations_for_method<'tcx>(tcx: &ty::ctxt<'tcx>, // The `Self` type is erased, so it should not appear in list of // arguments or return type apart from the receiver. let ref sig = method.fty.sig; - for &input_ty in sig.0.inputs[1..].iter() { + for &input_ty in &sig.0.inputs[1..] { if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) { return Some(MethodViolationCode::ReferencesSelf); } diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index ce66f4d5b35..3ede6bbb965 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -802,7 +802,7 @@ fn confirm_impl_candidate<'cx,'tcx>( let impl_items = &impl_items_map[impl_vtable.impl_def_id]; let mut impl_ty = None; - for impl_item in impl_items.iter() { + for impl_item in impl_items { let assoc_type = match impl_or_trait_items_map[impl_item.def_id()] { ty::TypeTraitItem(ref assoc_type) => assoc_type.clone(), ty::MethodTraitItem(..) => { continue; } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 106c07baaa7..91eec4e4c45 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1089,7 +1089,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { debug!("assemble_candidates_from_impls(self_ty={})", self_ty.repr(self.tcx())); let all_impls = self.all_impls(obligation.predicate.def_id()); - for &impl_def_id in all_impls.iter() { + for &impl_def_id in &all_impls { self.infcx.probe(|snapshot| { let (skol_obligation_trait_pred, skol_map) = self.infcx().skolemize_late_bound_regions(&obligation.predicate, snapshot); diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index edeca83d569..45ce692bb07 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -343,7 +343,7 @@ pub fn get_vtable_index_of_object_method<'tcx>(tcx: &ty::ctxt<'tcx>, } let trait_items = ty::trait_items(tcx, bound_ref.def_id()); - for trait_item in trait_items.iter() { + for trait_item in &**trait_items { match *trait_item { ty::MethodTraitItem(_) => method_count += 1, ty::TypeTraitItem(_) => {} diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 1544db8ce4a..ec331d8f4b9 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -872,7 +872,7 @@ macro_rules! sty_debug_print { $(let mut $variant = total;)* - for (_, t) in tcx.interner.borrow().iter() { + for (_, t) in &*tcx.interner.borrow() { let variant = match t.sty { ty::ty_bool | ty::ty_char | ty::ty_int(..) | ty::ty_uint(..) | ty::ty_float(..) | ty::ty_str => continue, @@ -2579,7 +2579,7 @@ impl FlagComputation { &ty_trait(box TyTrait { ref principal, ref bounds }) => { let mut computation = FlagComputation::new(); computation.add_substs(principal.0.substs); - for projection_bound in bounds.projection_bounds.iter() { + for projection_bound in &bounds.projection_bounds { let mut proj_computation = FlagComputation::new(); proj_computation.add_projection_predicate(&projection_bound.0); computation.add_bound_computation(&proj_computation); @@ -2618,7 +2618,7 @@ impl FlagComputation { } fn add_tys(&mut self, tys: &[Ty]) { - for &ty in tys.iter() { + for &ty in tys { self.add_ty(ty); } } @@ -3530,7 +3530,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { // make no assumptions (other than that it cannot have an // in-scope type parameter within, which makes no sense). let mut tc = TC::All - TC::InteriorParam; - for bound in bounds.builtin_bounds.iter() { + for bound in &bounds.builtin_bounds { tc = tc - match bound { BoundSync | BoundSend | BoundCopy => TC::None, BoundSized => TC::Nonsized, @@ -4644,7 +4644,7 @@ pub fn stmt_node_id(s: &ast::Stmt) -> ast::NodeId { pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) -> uint { let mut i = 0; - for f in fields.iter() { if f.name == name { return i; } i += 1; } + for f in fields { if f.name == name { return i; } i += 1; } tcx.sess.bug(&format!( "no field named `{}` found in the list of fields `{:?}`", token::get_name(name), @@ -5468,25 +5468,25 @@ pub fn predicates<'tcx>( { let mut vec = Vec::new(); - for builtin_bound in bounds.builtin_bounds.iter() { + for builtin_bound in &bounds.builtin_bounds { match traits::trait_ref_for_builtin_bound(tcx, builtin_bound, param_ty) { Ok(trait_ref) => { vec.push(trait_ref.as_predicate()); } Err(ErrorReported) => { } } } - for ®ion_bound in bounds.region_bounds.iter() { + for ®ion_bound in &bounds.region_bounds { // account for the binder being introduced below; no need to shift `param_ty` // because, at present at least, it can only refer to early-bound regions let region_bound = ty_fold::shift_region(region_bound, 1); vec.push(ty::Binder(ty::OutlivesPredicate(param_ty, region_bound)).as_predicate()); } - for bound_trait_ref in bounds.trait_bounds.iter() { + for bound_trait_ref in &bounds.trait_bounds { vec.push(bound_trait_ref.as_predicate()); } - for projection in bounds.projection_bounds.iter() { + for projection in &bounds.projection_bounds { vec.push(projection.as_predicate()); } @@ -5931,17 +5931,17 @@ pub fn populate_implementations_for_type_if_necessary(tcx: &ctxt, // Record the trait->implementation mappings, if applicable. let associated_traits = csearch::get_impl_trait(tcx, impl_def_id); - for trait_ref in associated_traits.iter() { + if let Some(ref trait_ref) = associated_traits { record_trait_implementation(tcx, trait_ref.def_id, impl_def_id); } // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. - for impl_item_def_id in impl_items.iter() { + for impl_item_def_id in &impl_items { let method_def_id = impl_item_def_id.def_id(); match impl_or_trait_item(tcx, method_def_id) { MethodTraitItem(method) => { - for &source in method.provided_source.iter() { + if let Some(source) = method.provided_source { tcx.provided_method_sources .borrow_mut() .insert(method_def_id, source); @@ -5985,11 +5985,11 @@ pub fn populate_implementations_for_trait_if_necessary( // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. - for impl_item_def_id in impl_items.iter() { + for impl_item_def_id in &impl_items { let method_def_id = impl_item_def_id.def_id(); match impl_or_trait_item(tcx, method_def_id) { MethodTraitItem(method) => { - for &source in method.provided_source.iter() { + if let Some(source) = method.provided_source { tcx.provided_method_sources .borrow_mut() .insert(method_def_id, source); @@ -6121,7 +6121,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - }; let fn_sig = |&: state: &mut SipHasher, sig: &Binder>| { let sig = anonymize_late_bound_regions(tcx, sig).0; - for a in sig.inputs.iter() { helper(tcx, *a, svh, state); } + for a in &sig.inputs { helper(tcx, *a, svh, state); } if let ty::FnConverging(output) = sig.output { helper(tcx, output, svh, state); } @@ -6270,7 +6270,7 @@ pub fn construct_free_substs<'a,'tcx>( free_id: ast::NodeId, region_params: &[RegionParameterDef]) { - for r in region_params.iter() { + for r in region_params { regions.push(r.space, ty::free_region_from_def(free_id, r)); } } @@ -6278,7 +6278,7 @@ pub fn construct_free_substs<'a,'tcx>( fn push_types_from_defs<'tcx>(tcx: &ty::ctxt<'tcx>, types: &mut VecPerParamSpace>, defs: &[TypeParameterDef<'tcx>]) { - for def in defs.iter() { + for def in defs { debug!("construct_parameter_environment(): push_types_from_defs: def={:?}", def.repr(tcx)); let ty = ty::mk_param_from_def(tcx, def); @@ -6351,7 +6351,7 @@ pub fn construct_parameter_environment<'a,'tcx>( fn record_region_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, predicates: &[ty::Predicate<'tcx>]) { debug!("record_region_bounds(predicates={:?})", predicates.repr(tcx)); - for predicate in predicates.iter() { + for predicate in predicates { match *predicate { Predicate::Projection(..) | Predicate::Trait(..) | @@ -6870,7 +6870,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc let did = match self_type.sty { ty::ty_struct(struct_did, substs) => { let fields = ty::struct_fields(tcx, struct_did, substs); - for field in fields.iter() { + for field in &fields { if type_moves_by_default(param_env, span, field.mt.ty) { return Err(FieldDoesNotImplementCopy(field.name)) } @@ -6879,8 +6879,8 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc } ty::ty_enum(enum_did, substs) => { let enum_variants = ty::enum_variants(tcx, enum_did); - for variant in enum_variants.iter() { - for variant_arg_type in variant.args.iter() { + for variant in &*enum_variants { + for variant_arg_type in &variant.args { let substd_arg_type = variant_arg_type.subst(tcx, substs); if type_moves_by_default(param_env, span, substd_arg_type) { diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index 25cca98c5fb..425c9a4c9f7 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -78,7 +78,7 @@ fn verify(sess: &Session, items: &lang_items::LanguageItems) { let mut missing = HashSet::new(); sess.cstore.iter_crate_data(|cnum, _| { - for item in csearch::get_missing_lang_items(&sess.cstore, cnum).iter() { + for item in &csearch::get_missing_lang_items(&sess.cstore, cnum) { missing.insert(*item); } }); diff --git a/src/librustc/plugin/build.rs b/src/librustc/plugin/build.rs index a8018662d29..110e672b70f 100644 --- a/src/librustc/plugin/build.rs +++ b/src/librustc/plugin/build.rs @@ -48,7 +48,7 @@ pub fn find_plugin_registrar(diagnostic: &diagnostic::SpanHandler, }, _ => { diagnostic.handler().err("multiple plugin registration functions found"); - for &(_, span) in finder.registrars.iter() { + for &(_, span) in &finder.registrars { diagnostic.span_note(span, "one is here"); } diagnostic.handler().abort_if_errors(); diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs index c420d1f15b4..22edd7c691a 100644 --- a/src/librustc/plugin/load.rs +++ b/src/librustc/plugin/load.rs @@ -73,7 +73,7 @@ pub fn load_plugins(sess: &Session, krate: &ast::Crate, // We need to error on `#[macro_use] extern crate` when it isn't at the // crate root, because `$crate` won't work properly. Identify these by // spans, because the crate map isn't set up yet. - for item in krate.module.items.iter() { + for item in &krate.module.items { if let ast::ItemExternCrate(_) = item.node { loader.span_whitelist.insert(item.span); } @@ -82,7 +82,7 @@ pub fn load_plugins(sess: &Session, krate: &ast::Crate, visit::walk_crate(&mut loader, krate); if let Some(plugins) = addl_plugins { - for plugin in plugins.iter() { + for plugin in &plugins { loader.load_plugin(CrateOrString::Str(plugin.as_slice()), None, None, None) } @@ -107,7 +107,7 @@ impl<'a, 'v> Visitor<'v> for PluginLoader<'a> { let mut plugin_attr = None; let mut macro_selection = Some(HashSet::new()); // None => load all let mut reexport = HashSet::new(); - for attr in item.attrs.iter() { + for attr in &item.attrs { let mut used = true; match attr.name().get() { "phase" => { @@ -127,7 +127,7 @@ impl<'a, 'v> Visitor<'v> for PluginLoader<'a> { macro_selection = None; } if let (Some(sel), Some(names)) = (macro_selection.as_mut(), names) { - for name in names.iter() { + for name in names { if let ast::MetaWord(ref name) = name.node { sel.insert(name.clone()); } else { @@ -145,7 +145,7 @@ impl<'a, 'v> Visitor<'v> for PluginLoader<'a> { } }; - for name in names.iter() { + for name in names { if let ast::MetaWord(ref name) = name.node { reexport.insert(name.clone()); } else { diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index ab182dd2256..afeb123b7a5 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -306,7 +306,7 @@ macro_rules! options { let value = iter.next(); let option_to_lookup = key.replace("-", "_"); let mut found = false; - for &(candidate, setter, opt_type_desc, _) in $stat.iter() { + for &(candidate, setter, opt_type_desc, _) in $stat { if option_to_lookup != candidate { continue } if !setter(&mut op, value) { match (value, opt_type_desc) { @@ -830,7 +830,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut lint_opts = vec!(); let mut describe_lints = false; - for &level in [lint::Allow, lint::Warn, lint::Deny, lint::Forbid].iter() { + for &level in &[lint::Allow, lint::Warn, lint::Deny, lint::Forbid] { for lint_name in matches.opt_strs(level.as_str()).into_iter() { if lint_name == "help" { describe_lints = true; @@ -853,7 +853,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut output_types = Vec::new(); if !debugging_opts.parse_only && !no_trans { let unparsed_output_types = matches.opt_strs("emit"); - for unparsed_output_type in unparsed_output_types.iter() { + for unparsed_output_type in &unparsed_output_types { for part in unparsed_output_type.split(',') { let output_type = match part.as_slice() { "asm" => OutputTypeAssembly, @@ -923,7 +923,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { }; let mut search_paths = SearchPaths::new(); - for s in matches.opt_strs("L").iter() { + for s in &matches.opt_strs("L") { search_paths.add_path(&s[]); } @@ -997,7 +997,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { }; let mut externs = HashMap::new(); - for arg in matches.opt_strs("extern").iter() { + for arg in &matches.opt_strs("extern") { let mut parts = arg.splitn(1, '='); let name = match parts.next() { Some(s) => s, @@ -1049,7 +1049,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { pub fn parse_crate_types_from_list(list_list: Vec) -> Result, String> { let mut crate_types: Vec = Vec::new(); - for unparsed_crate_type in list_list.iter() { + for unparsed_crate_type in &list_list { for part in unparsed_crate_type.split(',') { let new_part = match part { "lib" => default_lib_output(), diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index a433161d659..b77a70f1f5d 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -163,7 +163,7 @@ pub fn can_reach(edges_map: &HashMap, S>, source: T, while i < queue.len() { match edges_map.get(&queue[i]) { Some(edges) => { - for target in edges.iter() { + for target in edges { if *target == destination { return true; } diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index 7aa126371c4..8da06e63dae 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -62,7 +62,7 @@ impl Hasher for FnvHasher { impl Writer for FnvHasher { fn write(&mut self, bytes: &[u8]) { let FnvHasher(mut hash) = *self; - for byte in bytes.iter() { + for byte in bytes { hash = hash ^ (*byte as u64); hash = hash * 0x100000001b3; } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index eb73757bf6a..458701f2dd7 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -494,11 +494,11 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, 0 }; - for t in tps[..tps.len() - num_defaults].iter() { + for t in &tps[..tps.len() - num_defaults] { strs.push(ty_to_string(cx, *t)) } - for projection in projections.iter() { + for projection in projections { strs.push(format!("{}={}", projection.projection_ty.item_name.user_string(cx), projection.ty.user_string(cx))); @@ -665,7 +665,7 @@ impl<'tcx> UserString<'tcx> for ty::TyTrait<'tcx> { components.push(tap.user_string(tcx)); // Builtin bounds. - for bound in bounds.builtin_bounds.iter() { + for bound in &bounds.builtin_bounds { components.push(bound.user_string(tcx)); } @@ -748,7 +748,7 @@ impl<'tcx> Repr<'tcx> for subst::RegionSubsts { impl<'tcx> Repr<'tcx> for ty::BuiltinBounds { fn repr(&self, _tcx: &ctxt) -> String { let mut res = Vec::new(); - for b in self.iter() { + for b in self { res.push(match b { ty::BoundSend => "Send".to_string(), ty::BoundSized => "Sized".to_string(), @@ -764,7 +764,7 @@ impl<'tcx> Repr<'tcx> for ty::ParamBounds<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { let mut res = Vec::new(); res.push(self.builtin_bounds.repr(tcx)); - for t in self.trait_bounds.iter() { + for t in &self.trait_bounds { res.push(t.repr(tcx)); } res.connect("+") @@ -1157,7 +1157,7 @@ impl<'tcx> UserString<'tcx> for ty::ParamBounds<'tcx> { if !s.is_empty() { result.push(s); } - for n in self.trait_bounds.iter() { + for n in &self.trait_bounds { result.push(n.user_string(tcx)); } result.connect(" + ") @@ -1173,11 +1173,11 @@ impl<'tcx> Repr<'tcx> for ty::ExistentialBounds<'tcx> { res.push(region_str); } - for bound in self.builtin_bounds.iter() { + for bound in &self.builtin_bounds { res.push(bound.user_string(tcx)); } - for projection_bound in self.projection_bounds.iter() { + for projection_bound in &self.projection_bounds { res.push(projection_bound.user_string(tcx)); } diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index ee8bc71668b..eff11a80691 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -99,7 +99,7 @@ pub fn find_library(name: &str, osprefix: &str, ossuffix: &str, let oslibname = format!("{}{}{}", osprefix, name, ossuffix); let unixlibname = format!("lib{}.a", name); - for path in search_paths.iter() { + for path in search_paths { debug!("looking for {} inside {:?}", name, path.display()); let test = path.join(&oslibname[]); if test.exists() { return test } @@ -244,7 +244,7 @@ impl<'a> ArchiveBuilder<'a> { // 32,768, and we leave a bit of extra space for the program name. static ARG_LENGTH_LIMIT: uint = 32000; - for member_name in self.members.iter() { + for member_name in &self.members { let len = member_name.as_vec().len(); // `len + 1` to account for the space that's inserted before each @@ -297,7 +297,7 @@ impl<'a> ArchiveBuilder<'a> { // all SYMDEF files as these are just magical placeholders which get // re-created when we make a new archive anyway. let files = try!(fs::readdir(loc.path())); - for file in files.iter() { + for file in &files { let filename = file.filename_str().unwrap(); if skip(filename) { continue } if filename.contains(".SYMDEF") { continue } diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index 47b909df5e8..311b07fc26f 100644 --- a/src/librustc_back/rpath.rs +++ b/src/librustc_back/rpath.rs @@ -51,7 +51,7 @@ pub fn get_rpath_flags(config: RPathConfig) -> Vec where fn rpaths_to_flags(rpaths: &[String]) -> Vec { let mut ret = Vec::new(); - for rpath in rpaths.iter() { + for rpath in rpaths { ret.push(format!("-Wl,-rpath,{}", &(*rpath)[])); } return ret; @@ -63,7 +63,7 @@ fn get_rpaths(mut config: RPathConfig, libs: &[Path]) -> Vec { debug!("output: {:?}", config.out_filename.display()); debug!("libs:"); - for libpath in libs.iter() { + for libpath in libs { debug!(" {:?}", libpath.display()); } @@ -77,7 +77,7 @@ fn get_rpaths(mut config: RPathConfig, libs: &[Path]) -> Vec fn log_rpaths(desc: &str, rpaths: &[String]) { debug!("{} rpaths:", desc); - for rpath in rpaths.iter() { + for rpath in rpaths { debug!(" {}", *rpath); } } @@ -139,7 +139,7 @@ fn get_install_prefix_rpath(config: RPathConfig) -> String where fn minimize_rpaths(rpaths: &[String]) -> Vec { let mut set = HashSet::new(); let mut minimized = Vec::new(); - for rpath in rpaths.iter() { + for rpath in rpaths { if set.insert(&rpath[]) { minimized.push(rpath.clone()); } diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index d99ce8b64b0..c15b4114aa7 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -557,7 +557,7 @@ mod tests { fn test_hash(sh: &mut D, tests: &[Test]) { // Test that it works when accepting the message all at once - for t in tests.iter() { + for t in tests { sh.reset(); sh.input_str(t.input.as_slice()); let out_str = sh.result_str(); @@ -565,7 +565,7 @@ mod tests { } // Test that it works when accepting the message in pieces - for t in tests.iter() { + for t in tests { sh.reset(); let len = t.input.len(); let mut left = len; diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 3d7adc9934f..a14f4775ec1 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -79,7 +79,7 @@ impl Svh { // avoid collisions. let mut state = SipHasher::new(); - for data in metadata.iter() { + for data in metadata { data.hash(&mut state); } @@ -97,7 +97,7 @@ impl Svh { // // We hash only the MetaItems instead of the entire Attribute // to avoid hashing the AttrId - for attr in krate.attrs.iter() { + for attr in &krate.attrs { attr.node.value.hash(&mut state); } diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index 16adccfba57..697e8a75163 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -384,7 +384,7 @@ impl Target { let paths = os::split_paths(&target_path[]); // FIXME 16351: add a sane default search path? - for dir in paths.iter() { + for dir in &paths { let p = dir.join(path.clone()); if p.is_file() { return load_file(&p); diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index b66419420e9..b8d736ab9ca 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -279,7 +279,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { let loan_path = owned_ptr_base_path(loan_path); let cont = self.each_in_scope_loan(scope, |loan| { let mut ret = true; - for restr_path in loan.restricted_paths.iter() { + for restr_path in &loan.restricted_paths { if **restr_path == *loan_path { if !op(loan) { ret = false; @@ -361,7 +361,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { debug!("new_loan_indices = {:?}", new_loan_indices); self.each_issued_loan(scope, |issued_loan| { - for &new_loan_index in new_loan_indices.iter() { + for &new_loan_index in &new_loan_indices { let new_loan = &self.all_loans[new_loan_index]; self.report_error_if_loans_conflict(issued_loan, new_loan); } @@ -370,7 +370,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { for (i, &x) in new_loan_indices.iter().enumerate() { let old_loan = &self.all_loans[x]; - for &y in new_loan_indices[(i+1) ..].iter() { + for &y in &new_loan_indices[(i+1) ..] { let new_loan = &self.all_loans[y]; self.report_error_if_loans_conflict(old_loan, new_loan); } @@ -416,7 +416,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { } let loan2_base_path = owned_ptr_base_path_rc(&loan2.loan_path); - for restr_path in loan1.restricted_paths.iter() { + for restr_path in &loan1.restricted_paths { if *restr_path != loan2_base_path { continue; } // If new_loan is something like `x.a`, and old_loan is something like `x.b`, we would diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 6e71da198e3..6f51ba31182 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -204,14 +204,14 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { debug!("fragments 1 assigned: {:?}", path_lps(&assigned[])); // Second, build parents from the moved and assigned. - for m in moved.iter() { + for m in &moved { let mut p = this.path_parent(*m); while p != InvalidMovePathIndex { parents.push(p); p = this.path_parent(p); } } - for a in assigned.iter() { + for a in &assigned { let mut p = this.path_parent(*a); while p != InvalidMovePathIndex { parents.push(p); @@ -231,15 +231,15 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { debug!("fragments 3 assigned: {:?}", path_lps(&assigned[])); // Fourth, build the leftover from the moved, assigned, and parents. - for m in moved.iter() { + for m in &moved { let lp = this.path_loan_path(*m); add_fragment_siblings(this, tcx, &mut unmoved, lp, None); } - for a in assigned.iter() { + for a in &assigned { let lp = this.path_loan_path(*a); add_fragment_siblings(this, tcx, &mut unmoved, lp, None); } - for p in parents.iter() { + for p in &parents { let lp = this.path_loan_path(*p); add_fragment_siblings(this, tcx, &mut unmoved, lp, None); } @@ -369,7 +369,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, let fields = ty::lookup_struct_fields(tcx, def_id); match *origin_field_name { mc::NamedField(ast_name) => { - for f in fields.iter() { + for f in &fields { if f.name == ast_name { continue; } @@ -407,7 +407,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, match *origin_field_name { mc::NamedField(ast_name) => { let variant_arg_names = variant_info.arg_names.as_ref().unwrap(); - for variant_arg_ident in variant_arg_names.iter() { + for variant_arg_ident in variant_arg_names { if variant_arg_ident.name == ast_name { continue; } diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 28d02161eeb..2cd25de431e 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -67,10 +67,10 @@ pub struct GroupedMoveErrors<'tcx> { fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, errors: &Vec>) { let grouped_errors = group_errors_with_same_origin(errors); - for error in grouped_errors.iter() { + for error in &grouped_errors { report_cannot_move_out_of(bccx, error.move_from.clone()); let mut is_first_note = true; - for move_to in error.move_to_places.iter() { + for move_to in &error.move_to_places { note_move_destination(bccx, move_to.span, &move_to.ident, is_first_note); is_first_note = false; @@ -81,7 +81,7 @@ fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, fn group_errors_with_same_origin<'tcx>(errors: &Vec>) -> Vec> { let mut grouped_errors = Vec::new(); - for error in errors.iter() { + for error in errors { append_to_grouped_errors(&mut grouped_errors, error) } return grouped_errors; diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index ece9d61d7f2..76c431fa4c5 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -475,13 +475,13 @@ impl<'tcx> MoveData<'tcx> { self.kill_moves(assignment.path, assignment.id, dfcx_moves); } - for assignment in self.path_assignments.borrow().iter() { + for assignment in &*self.path_assignments.borrow() { self.kill_moves(assignment.path, assignment.id, dfcx_moves); } // Kill all moves related to a variable `x` when // it goes out of scope: - for path in self.paths.borrow().iter() { + for path in &*self.paths.borrow() { match path.loan_path.kind { LpVar(..) | LpUpvar(..) | LpDowncast(..) => { let kill_scope = path.loan_path.kill_scope(tcx); @@ -633,11 +633,11 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> { //! Returns the kind of a move of `loan_path` by `id`, if one exists. let mut ret = None; - for loan_path_index in self.move_data.path_map.borrow().get(&*loan_path).iter() { + if let Some(loan_path_index) = self.move_data.path_map.borrow().get(&*loan_path) { self.dfcx_moves.each_gen_bit(id, |move_index| { let the_move = self.move_data.moves.borrow(); let the_move = (*the_move)[move_index]; - if the_move.path == **loan_path_index { + if the_move.path == *loan_path_index { ret = Some(the_move.kind); false } else { @@ -688,7 +688,7 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> { ret = false; } } else { - for &loan_path_index in opt_loan_path_index.iter() { + if let Some(loan_path_index) = opt_loan_path_index { let cont = self.move_data.each_base_path(moved_path, |p| { if p == loan_path_index { // Scenario 3: some extension of `loan_path` @@ -699,7 +699,7 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> { true } }); - if !cont { ret = false; break } + if !cont { ret = false; } } } ret diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index 150e616b36c..8b1b156691a 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -56,7 +56,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { debug!("dataflow_for({:?}, id={}) {:?}", e, id, self.variants); let mut sets = "".to_string(); let mut seen_one = false; - for &variant in self.variants.iter() { + for &variant in &self.variants { if seen_one { sets.push_str(" "); } else { seen_one = true; } sets.push_str(variant.short_name()); sets.push_str(": "); diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 9e00844b7ee..e8ea349c3db 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -760,11 +760,11 @@ fn write_out_deps(sess: &Session, id: &str) { let mut out_filenames = Vec::new(); - for output_type in sess.opts.output_types.iter() { + for output_type in &sess.opts.output_types { let file = outputs.path(*output_type); match *output_type { config::OutputTypeExe => { - for output in sess.crate_types.borrow().iter() { + for output in &*sess.crate_types.borrow() { let p = link::filename_for_input(sess, *output, id, &file); out_filenames.push(p); @@ -800,7 +800,7 @@ fn write_out_deps(sess: &Session, .map(|fmap| escape_dep_filename(&fmap.name[])) .collect(); let mut file = try!(old_io::File::create(&deps_filename)); - for path in out_filenames.iter() { + for path in &out_filenames { try!(write!(&mut file as &mut Writer, "{}: {}\n\n", path.display(), files.connect(" "))); } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 2eada1ff174..a8f5cfa6b3f 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -435,7 +435,7 @@ Available lint options: fn describe_debug_flags() { println!("\nAvailable debug options:\n"); - for &(name, _, opt_type_desc, desc) in config::DB_OPTIONS.iter() { + for &(name, _, opt_type_desc, desc) in config::DB_OPTIONS { let (width, extra) = match opt_type_desc { Some(..) => (21, "=val"), None => (25, "") @@ -447,7 +447,7 @@ fn describe_debug_flags() { fn describe_codegen_flags() { println!("\nAvailable codegen options:\n"); - for &(name, _, opt_type_desc, desc) in config::CG_OPTIONS.iter() { + for &(name, _, opt_type_desc, desc) in config::CG_OPTIONS { let (width, extra) = match opt_type_desc { Some(..) => (21, "=val"), None => (25, "") @@ -542,7 +542,7 @@ fn print_crate_info(sess: &Session, if sess.opts.prints.len() == 0 { return false } let attrs = input.map(|input| parse_crate_attrs(sess, input)); - for req in sess.opts.prints.iter() { + for req in &sess.opts.prints { match *req { PrintRequest::Sysroot => println!("{}", sess.sysroot().display()), PrintRequest::FileNames | @@ -566,7 +566,7 @@ fn print_crate_info(sess: &Session, let crate_types = driver::collect_crate_types(sess, attrs); let metadata = driver::collect_crate_metadata(sess, attrs); *sess.crate_metadata.borrow_mut() = metadata; - for &style in crate_types.iter() { + for &style in &crate_types { let fname = link::filename_for_input(sess, style, id.as_slice(), &t_outputs.with_extension("")); @@ -645,7 +645,7 @@ pub fn monitor(f: F) { BUG_REPORT_URL), "run with `RUST_BACKTRACE=1` for a backtrace".to_string(), ]; - for note in xs.iter() { + for note in &xs { emitter.emit(None, ¬e[], None, diagnostic::Note) } diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 45ff1c4537c..20bf77190be 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -147,7 +147,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { } pub fn create_region_hierarchy(&self, rh: &RH) { - for child_rh in rh.sub.iter() { + for child_rh in rh.sub { self.create_region_hierarchy(child_rh); self.infcx.tcx.region_maps.record_encl_scope( CodeExtent::from_node_id(child_rh.id), @@ -181,7 +181,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { names: &[String]) -> Option { assert!(idx < names.len()); - for item in m.items.iter() { + for item in &m.items { if item.ident.user_string(this.infcx.tcx) == names[idx] { return search(this, &**item, idx+1, names); } diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index a24bc6eaec3..8ec1babd4da 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -261,13 +261,13 @@ impl AttrBuilder { } pub fn apply_llfn(&self, llfn: ValueRef) { - for &(idx, ref attr) in self.attrs.iter() { + for &(idx, ref attr) in &self.attrs { attr.apply_llfn(idx as c_uint, llfn); } } pub fn apply_callsite(&self, callsite: ValueRef) { - for &(idx, ref attr) in self.attrs.iter() { + for &(idx, ref attr) in &self.attrs { attr.apply_callsite(idx as c_uint, callsite); } } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 14e80c6c8ef..c398ff72f50 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -79,7 +79,7 @@ impl<'v> Visitor<'v> for ParentVisitor { // Enum variants are parented to the enum definition itself because // they inherit privacy ast::ItemEnum(ref def, _) => { - for variant in def.variants.iter() { + for variant in &def.variants { // The parent is considered the enclosing enum because the // enum will dictate the privacy visibility of this variant // instead. @@ -93,7 +93,7 @@ impl<'v> Visitor<'v> for ParentVisitor { // parent all the methods to the trait to indicate that they're // private. ast::ItemTrait(_, _, _, ref methods) if item.vis != ast::Public => { - for m in methods.iter() { + for m in methods { match *m { ast::ProvidedMethod(ref m) => { self.parents.insert(m.id, item.id); @@ -139,7 +139,7 @@ impl<'v> Visitor<'v> for ParentVisitor { // While we have the id of the struct definition, go ahead and parent // all the fields. - for field in s.fields.iter() { + for field in &s.fields { self.parents.insert(field.node.id, self.curparent); } visit::walk_struct_def(self, s) @@ -233,7 +233,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // Enum variants inherit from their parent, so if the enum is // public all variants are public unless they're explicitly priv ast::ItemEnum(ref def, _) if public_first => { - for variant in def.variants.iter() { + for variant in &def.variants { self.exported_items.insert(variant.node.id); } } @@ -278,7 +278,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { }); if public_ty || public_trait { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { let meth_public = @@ -299,7 +299,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // Default methods on traits are all public so long as the trait // is public ast::ItemTrait(_, _, _, ref methods) if public_first => { - for method in methods.iter() { + for method in methods { match *method { ast::ProvidedMethod(ref m) => { debug!("provided {}", m.id); @@ -359,7 +359,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // crate module gets processed as well. if self.prev_exported { assert!(self.export_map.contains_key(&id), "wut {}", id); - for export in self.export_map[id].iter() { + for export in &self.export_map[id] { if is_local(export.def_id) { self.reexports.insert(export.def_id.node); } @@ -837,7 +837,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { match vpath.node { ast::ViewPathSimple(..) | ast::ViewPathGlob(..) => {} ast::ViewPathList(ref prefix, ref list) => { - for pid in list.iter() { + for pid in list { match pid.node { ast::PathListIdent { id, name } => { debug!("privacy - ident item {}", id); @@ -898,7 +898,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ast::ExprStruct(_, ref fields, _) => { match ty::expr_ty(self.tcx, expr).sty { ty::ty_struct(id, _) => { - for field in (*fields).iter() { + for field in &(*fields) { self.check_field(expr.span, id, NamedField(field.ident.node)); } @@ -906,7 +906,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ty::ty_enum(_, _) => { match self.tcx.def_map.borrow()[expr.id].clone() { def::DefVariant(_, variant_id, _) => { - for field in fields.iter() { + for field in fields { self.check_field(expr.span, variant_id, NamedField(field.ident.node)); } @@ -971,7 +971,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ast::PatStruct(_, ref fields, _) => { match ty::pat_ty(self.tcx, pattern).sty { ty::ty_struct(id, _) => { - for field in fields.iter() { + for field in fields { self.check_field(pattern.span, id, NamedField(field.node.ident)); } @@ -979,7 +979,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ty::ty_enum(_, _) => { match self.tcx.def_map.borrow().get(&pattern.id) { Some(&def::DefVariant(_, variant_id, _)) => { - for field in fields.iter() { + for field in fields { self.check_field(pattern.span, variant_id, NamedField(field.node.ident)); } @@ -1091,7 +1091,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { check_inherited(item.span, item.vis, "visibility qualifiers have no effect on trait \ impls"); - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref m) => { check_inherited(m.span, m.pe_vis(), ""); @@ -1112,7 +1112,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } ast::ItemEnum(ref def, _) => { - for v in def.variants.iter() { + for v in &def.variants { match v.node.vis { ast::Public => { if item.vis == ast::Public { @@ -1126,7 +1126,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } ast::ItemTrait(_, _, _, ref methods) => { - for m in methods.iter() { + for m in methods { match *m { ast::ProvidedMethod(ref m) => { check_inherited(m.span, m.pe_vis(), @@ -1157,7 +1157,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } } let check_struct = |&: def: &ast::StructDef| { - for f in def.fields.iter() { + for f in &def.fields { match f.node.kind { ast::NamedField(_, p) => check_inherited(tcx, f.span, p), ast::UnnamedField(..) => {} @@ -1167,7 +1167,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { check_inherited(tcx, item.span, item.vis); match item.node { ast::ItemImpl(_, _, _, _, _, ref impl_items) => { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref m) => { check_inherited(tcx, m.span, m.pe_vis()); @@ -1177,12 +1177,12 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } } ast::ItemForeignMod(ref fm) => { - for i in fm.items.iter() { + for i in &fm.items { check_inherited(tcx, i.span, i.vis); } } ast::ItemEnum(ref def, _) => { - for v in def.variants.iter() { + for v in &def.variants { check_inherited(tcx, v.span, v.node.vis); } } @@ -1190,7 +1190,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { ast::ItemStruct(ref def, _) => check_struct(&**def), ast::ItemTrait(_, _, _, ref methods) => { - for m in methods.iter() { + for m in methods { match *m { ast::RequiredMethod(..) => {} ast::ProvidedMethod(ref m) => check_inherited(tcx, m.span, @@ -1302,7 +1302,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { return } - for bound in bounds.iter() { + for bound in &**bounds { self.check_ty_param_bound(bound) } } @@ -1371,7 +1371,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { match *trait_ref { None => { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { visit::walk_method_helper(self, &**method) @@ -1400,7 +1400,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { // impl Public { ... }. Any public static // methods will be visible as `Public::foo`. let mut found_pub_static = false; - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { if method.pe_explicit_self().node == @@ -1439,15 +1439,15 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { } fn visit_generics(&mut self, generics: &ast::Generics) { - for ty_param in generics.ty_params.iter() { - for bound in ty_param.bounds.iter() { + for ty_param in &*generics.ty_params { + for bound in &*ty_param.bounds { self.check_ty_param_bound(bound) } } - for predicate in generics.where_clause.predicates.iter() { + for predicate in &generics.where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ref bound_pred) => { - for bound in bound_pred.bounds.iter() { + for bound in &*bound_pred.bounds { self.check_ty_param_bound(bound) } } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 65bd83d7937..a503398d484 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -223,8 +223,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { token::get_name(name))[]); { let r = child.span_for_namespace(ns); - for sp in r.iter() { - self.session.span_note(*sp, + if let Some(sp) = r { + self.session.span_note(sp, &format!("first definition of {} `{}` here", namespace_error_to_string(duplicate_type), token::get_name(name))[]); @@ -238,7 +238,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { fn block_needs_anonymous_module(&mut self, block: &Block) -> bool { // Check each statement. - for statement in block.stmts.iter() { + for statement in &block.stmts { match statement.node { StmtDecl(ref declaration, _) => { match declaration.node { @@ -338,7 +338,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } } - for source_item in source_items.iter() { + for source_item in source_items { let (module_path, name) = match source_item.node { PathListIdent { name, .. } => (module_path.clone(), name.name), @@ -477,7 +477,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let module = name_bindings.get_module(); - for variant in (*enum_definition).variants.iter() { + for variant in &(*enum_definition).variants { self.build_reduced_graph_for_variant( &**variant, local_def(item.id), @@ -591,7 +591,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { }; // For each implementation item... - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { MethodImplItem(ref method) => { // Add the method to the module. @@ -675,7 +675,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let def_id = local_def(item.id); // Add the names of all the items to the trait info. - for trait_item in items.iter() { + for trait_item in items { let (name, kind) = match *trait_item { ast::RequiredMethod(_) | ast::ProvidedMethod(_) => { @@ -926,7 +926,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let trait_item_def_ids = csearch::get_trait_item_def_ids(&self.session.cstore, def_id); - for trait_item_def_id in trait_item_def_ids.iter() { + for trait_item_def_id in &trait_item_def_ids { let (trait_item_name, trait_item_kind) = csearch::get_trait_item_name_and_kind( &self.session.cstore, @@ -1082,7 +1082,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // Add each static method to the module. let new_parent = type_module; - for method_info in methods.iter() { + for method_info in methods { let name = method_info.name; debug!("(building reduced graph for \ external crate) creating \ diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 97370112ab4..a239c73c110 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -136,7 +136,7 @@ impl<'a, 'b, 'v, 'tcx> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b, 'tcx> { } ViewPathList(_, ref list) => { - for i in list.iter() { + for i in list { self.finalize_import(i.node.id(), i.span); } } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index f0711903579..c10b7124218 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1031,7 +1031,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.current_module = orig_module; build_reduced_graph::populate_module_if_necessary(self, &module_); - for (_, child_node) in module_.children.borrow().iter() { + for (_, child_node) in &*module_.children.borrow() { match child_node.get_module_if_available() { None => { // Nothing to do. @@ -1042,7 +1042,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - for (_, child_module) in module_.anonymous_children.borrow().iter() { + for (_, child_module) in &*module_.anonymous_children.borrow() { self.resolve_imports_for_module_subtree(child_module.clone()); } } @@ -1087,7 +1087,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn names_to_string(&self, names: &[Name]) -> String { let mut first = true; let mut result = String::new(); - for name in names.iter() { + for name in names { if first { first = false } else { @@ -1596,7 +1596,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Add all resolved imports from the containing module. let import_resolutions = containing_module.import_resolutions.borrow(); - for (ident, target_import_resolution) in import_resolutions.iter() { + for (ident, target_import_resolution) in &*import_resolutions { debug!("(resolving glob import) writing module resolution \ {} into `{}`", token::get_name(*ident), @@ -1657,7 +1657,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Add all children from the containing module. build_reduced_graph::populate_module_if_necessary(self, &containing_module); - for (&name, name_bindings) in containing_module.children.borrow().iter() { + for (&name, name_bindings) in &*containing_module.children.borrow() { self.merge_import_resolution(module_, containing_module.clone(), import_directive, @@ -1667,7 +1667,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } // Add external module children from the containing module. - for (&name, module) in containing_module.external_module_children.borrow().iter() { + for (&name, module) in &*containing_module.external_module_children.borrow() { let name_bindings = Rc::new(Resolver::create_name_bindings_from_module(module.clone())); self.merge_import_resolution(module_, @@ -2519,7 +2519,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Descend into children and anonymous children. build_reduced_graph::populate_module_if_necessary(self, &module_); - for (_, child_node) in module_.children.borrow().iter() { + for (_, child_node) in &*module_.children.borrow() { match child_node.get_module_if_available() { None => { // Continue. @@ -2530,7 +2530,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - for (_, module_) in module_.anonymous_children.borrow().iter() { + for (_, module_) in &*module_.anonymous_children.borrow() { self.report_unresolved_imports(module_.clone()); } } @@ -2609,7 +2609,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { DlDef(d @ DefLocal(_)) => { let node_id = d.def_id().node; let mut def = d; - for rib in ribs.iter() { + for rib in ribs { match rib.kind { NormalRibKind => { // Nothing to do. Continue. @@ -2680,7 +2680,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } DlDef(def @ DefTyParam(..)) | DlDef(def @ DefSelfTy(..)) => { - for rib in ribs.iter() { + for rib in ribs { match rib.kind { NormalRibKind | ClosureRibKind(..) => { // Nothing to do. Continue. @@ -2795,8 +2795,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // enum item: resolve all the variants' discrs, // then resolve the ty params ItemEnum(ref enum_def, ref generics) => { - for variant in (*enum_def).variants.iter() { - for dis_expr in variant.node.disr_expr.iter() { + for variant in &(*enum_def).variants { + if let Some(ref dis_expr) = variant.node.disr_expr { // resolve the discriminator expr // as a constant self.with_constant_rib(|this| { @@ -2863,7 +2863,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_type_parameter_bounds(item.id, bounds, TraitDerivation); - for trait_item in (*trait_items).iter() { + for trait_item in &(*trait_items) { // Create a new rib for the trait_item-specific type // parameters. // @@ -2885,7 +2885,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_where_clause(&ty_m.generics .where_clause); - for argument in ty_m.decl.inputs.iter() { + for argument in &ty_m.decl.inputs { this.resolve_type(&*argument.ty); } @@ -2929,7 +2929,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ItemForeignMod(ref foreign_module) => { self.with_scope(Some(name), |this| { - for foreign_item in foreign_module.items.iter() { + for foreign_item in &foreign_module.items { match foreign_item.node { ForeignItemFn(_, ref generics) => { this.with_type_parameter_rib( @@ -3075,7 +3075,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } Some(declaration) => { let mut bindings_list = HashMap::new(); - for argument in declaration.inputs.iter() { + for argument in &declaration.inputs { this.resolve_pattern(&*argument.pat, ArgumentIrrefutableMode, &mut bindings_list); @@ -3103,14 +3103,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn resolve_type_parameters(&mut self, type_parameters: &OwnedSlice) { - for type_parameter in type_parameters.iter() { + for type_parameter in &**type_parameters { self.resolve_type_parameter(type_parameter); } } fn resolve_type_parameter(&mut self, type_parameter: &TyParam) { - for bound in type_parameter.bounds.iter() { + for bound in &*type_parameter.bounds { self.resolve_type_parameter_bound(type_parameter.id, bound, TraitBoundingTypeParameter); } @@ -3124,7 +3124,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { id: NodeId, type_parameter_bounds: &OwnedSlice, reference_type: TraitReferenceType) { - for type_parameter_bound in type_parameter_bounds.iter() { + for type_parameter_bound in &**type_parameter_bounds { self.resolve_type_parameter_bound(id, type_parameter_bound, reference_type); } @@ -3193,12 +3193,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn resolve_where_clause(&mut self, where_clause: &ast::WhereClause) { - for predicate in where_clause.predicates.iter() { + for predicate in &where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ref bound_pred) => { self.resolve_type(&*bound_pred.bounded_ty); - for bound in bound_pred.bounds.iter() { + for bound in &*bound_pred.bounds { self.resolve_type_parameter_bound(bound_pred.bounded_ty.id, bound, TraitBoundingTypeParameter); } @@ -3236,7 +3236,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_where_clause(&generics.where_clause); // Resolve fields. - for field in fields.iter() { + for field in fields { this.resolve_type(&*field.node.ty); } }); @@ -3320,7 +3320,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_type(self_type); this.with_current_self_type(self_type, |this| { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { MethodImplItem(ref method) => { // If this is a trait impl, ensure the method @@ -3375,7 +3375,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn check_trait_item(&self, name: Name, span: Span) { // If there is a TraitRef in scope for an impl, then the method must be in the trait. - for &(did, ref trait_ref) in self.current_trait_ref.iter() { + if let Some((did, ref trait_ref)) = self.current_trait_ref { if self.trait_item_map.get(&(name, did)).is_none() { let path_str = self.path_names_to_string(&trait_ref.path); self.resolve_error(span, @@ -3442,7 +3442,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (i, p) in arm.pats.iter().enumerate() { let map_i = self.binding_mode_map(&**p); - for (&key, &binding_0) in map_0.iter() { + for (&key, &binding_0) in &map_0 { match map_i.get(&key) { None => { self.resolve_error( @@ -3465,7 +3465,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - for (&key, &binding) in map_i.iter() { + for (&key, &binding) in &map_i { if !map_0.contains_key(&key) { self.resolve_error( binding.span, @@ -3482,7 +3482,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.value_ribs.push(Rib::new(NormalRibKind)); let mut bindings_list = HashMap::new(); - for pattern in arm.pats.iter() { + for pattern in &arm.pats { self.resolve_pattern(&**pattern, RefutableMode, &mut bindings_list); } @@ -3513,7 +3513,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Check for imports appearing after non-item statements. let mut found_non_item = false; - for statement in block.stmts.iter() { + for statement in &block.stmts { if let ast::StmtDecl(ref declaration, _) = statement.node { if let ast::DeclItem(ref i) = declaration.node { match i.node { @@ -4365,7 +4365,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let mut values: Vec = Vec::new(); for rib in this.value_ribs.iter().rev() { - for (&k, _) in rib.bindings.iter() { + for (&k, _) in &rib.bindings { maybes.push(token::get_name(k)); values.push(uint::MAX); } @@ -4640,7 +4640,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { build_reduced_graph::populate_module_if_necessary(self, &search_module); { - for (_, child_names) in search_module.children.borrow().iter() { + for (_, child_names) in &*search_module.children.borrow() { let def = match child_names.def_for_namespace(TypeNS) { Some(def) => def, None => continue @@ -4656,7 +4656,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } // Look for imports. - for (_, import) in search_module.import_resolutions.borrow().iter() { + for (_, import) in &*search_module.import_resolutions.borrow() { let target = match import.target_for_namespace(TypeNS) { None => continue, Some(target) => target, @@ -4766,13 +4766,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { debug!("Children:"); build_reduced_graph::populate_module_if_necessary(self, &module_); - for (&name, _) in module_.children.borrow().iter() { + for (&name, _) in &*module_.children.borrow() { debug!("* {}", token::get_name(name)); } debug!("Import resolutions:"); let import_resolutions = module_.import_resolutions.borrow(); - for (&name, import_resolution) in import_resolutions.iter() { + for (&name, import_resolution) in &*import_resolutions { let value_repr; match import_resolution.target_for_namespace(ValueNS) { None => { value_repr = "".to_string(); } diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 67bcf152eb7..5d025f40d32 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -80,7 +80,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { self.record_exports_for_module(&*module_); build_reduced_graph::populate_module_if_necessary(self.resolver, &module_); - for (_, child_name_bindings) in module_.children.borrow().iter() { + for (_, child_name_bindings) in &*module_.children.borrow() { match child_name_bindings.get_module_if_available() { None => { // Nothing to do. @@ -91,7 +91,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { } } - for (_, child_module) in module_.anonymous_children.borrow().iter() { + for (_, child_module) in &*module_.anonymous_children.borrow() { self.record_exports_for_module_subtree(child_module.clone()); } } @@ -133,12 +133,12 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { fn add_exports_for_module(&mut self, exports: &mut Vec, module_: &Module) { - for (name, importresolution) in module_.import_resolutions.borrow().iter() { + for (name, importresolution) in &*module_.import_resolutions.borrow() { if !importresolution.is_public { continue } let xs = [TypeNS, ValueNS]; - for &ns in xs.iter() { + for &ns in &xs { match importresolution.target_for_namespace(ns) { Some(target) => { debug!("(computing exports) maybe export '{}'", diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index c97d9090441..eeb6d9fab5e 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -194,7 +194,7 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>, symbol_hasher.input_str(&link_meta.crate_name[]); symbol_hasher.input_str("-"); symbol_hasher.input_str(link_meta.crate_hash.as_str()); - for meta in tcx.sess.crate_metadata.borrow().iter() { + for meta in &*tcx.sess.crate_metadata.borrow() { symbol_hasher.input_str(&meta[]); } symbol_hasher.input_str("-"); @@ -370,7 +370,7 @@ pub fn link_binary(sess: &Session, outputs: &OutputFilenames, crate_name: &str) -> Vec { let mut out_filenames = Vec::new(); - for &crate_type in sess.crate_types.borrow().iter() { + for &crate_type in &*sess.crate_types.borrow() { if invalid_output_for_target(sess, crate_type) { sess.bug(&format!("invalid output type `{:?}` for target os `{}`", crate_type, sess.opts.target_triple)[]); @@ -535,7 +535,7 @@ fn link_rlib<'a>(sess: &'a Session, let mut ab = ArchiveBuilder::create(config); ab.add_file(obj_filename).unwrap(); - for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() { + for &(ref l, kind) in &*sess.cstore.get_used_libraries().borrow() { match kind { cstore::NativeStatic => { ab.add_native_library(&l[]).unwrap(); @@ -721,7 +721,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { let crates = sess.cstore.get_used_crates(cstore::RequireStatic); let mut all_native_libs = vec![]; - for &(cnum, ref path) in crates.iter() { + for &(cnum, ref path) in &crates { let ref name = sess.cstore.get_crate_data(cnum).name; let p = match *path { Some(ref p) => p.clone(), None => { @@ -746,7 +746,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { and so may need to be preserved"); } - for &(kind, ref lib) in all_native_libs.iter() { + for &(kind, ref lib) in &all_native_libs { let name = match kind { cstore::NativeStatic => "static library", cstore::NativeUnknown => "library", @@ -1133,7 +1133,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // crates. let deps = sess.cstore.get_used_crates(cstore::RequireDynamic); - for &(cnum, _) in deps.iter() { + for &(cnum, _) in &deps { // We may not pass all crates through to the linker. Some crates may // appear statically in an existing dylib, meaning we'll pick up all the // symbols from the dylib. @@ -1277,7 +1277,7 @@ fn add_upstream_native_libraries(cmd: &mut Command, sess: &Session) { let crates = sess.cstore.get_used_crates(cstore::RequireStatic); for (cnum, _) in crates.into_iter() { let libs = csearch::get_native_libraries(&sess.cstore, cnum); - for &(kind, ref lib) in libs.iter() { + for &(kind, ref lib) in &libs { match kind { cstore::NativeUnknown => { cmd.arg(format!("-l{}", *lib)); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index 5fcf0be4c67..1a5310bb0a8 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -34,7 +34,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, } // Make sure we actually can run LTO - for crate_type in sess.crate_types.borrow().iter() { + for crate_type in &*sess.crate_types.borrow() { match *crate_type { config::CrateTypeExecutable | config::CrateTypeStaticlib => {} _ => { diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index 9b195486d5d..c54e3e02d3c 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -100,7 +100,7 @@ impl SharedEmitter { fn dump(&mut self, handler: &Handler) { let mut buffer = self.buffer.lock().unwrap(); - for diag in buffer.iter() { + for diag in &*buffer { match diag.code { Some(ref code) => { handler.emit_with_code(None, @@ -452,7 +452,7 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext, config.no_builtins); } - for pass in config.passes.iter() { + for pass in &config.passes { let pass = CString::from_slice(pass.as_bytes()); if !llvm::LLVMRustAddPass(mpm, pass.as_ptr()) { cgcx.handler.warn(format!("unknown pass {:?}, ignoring", @@ -597,7 +597,7 @@ pub fn run_passes(sess: &Session, modules_config.emit_bc = true; } - for output_type in output_types.iter() { + for output_type in output_types { match *output_type { config::OutputTypeBitcode => { modules_config.emit_bc = true; }, config::OutputTypeLlvmAssembly => { modules_config.emit_ir = true; }, @@ -761,7 +761,7 @@ pub fn run_passes(sess: &Session, // Otherwise, we produced it only as a temporary output, and will need // to get rid of it. let mut user_wants_bitcode = false; - for output_type in output_types.iter() { + for output_type in output_types { match *output_type { config::OutputTypeBitcode => { user_wants_bitcode = true; @@ -1015,7 +1015,7 @@ unsafe fn configure_llvm(sess: &Session) { // FIXME #21627 disable faulty FastISel on AArch64 (even for -O0) if sess.target.target.arch.as_slice() == "aarch64" { add("-fast-isel=0"); } - for arg in sess.opts.cg.llvm_args.iter() { + for arg in &sess.opts.cg.llvm_args { add(&(*arg)[]); } } diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index fbeaae1d1df..e522b1f3671 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -113,7 +113,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { error!("Mis-calculated spans for path '{}'. \ Found {} spans, expected {}. Found spans:", path_to_string(path), spans.len(), path.segments.len()); - for s in spans.iter() { + for s in &spans { let loc = self.sess.codemap().lookup_char_pos(s.lo); error!(" '{}' in {}, line {}", self.span.snippet(*s), loc.file.name, loc.line); @@ -204,7 +204,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { return; } let sub_paths = &sub_paths[..len-2]; - for &(ref span, ref qualname) in sub_paths.iter() { + for &(ref span, ref qualname) in sub_paths { self.fmt.sub_mod_ref_str(path.span, *span, &qualname[], @@ -264,13 +264,13 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } fn process_formals(&mut self, formals: &Vec, qualname: &str) { - for arg in formals.iter() { + for arg in formals { assert!(self.collected_paths.len() == 0 && !self.collecting); self.collecting = true; self.visit_pat(&*arg.pat); self.collecting = false; let span_utils = self.span.clone(); - for &(id, ref p, _, _) in self.collected_paths.iter() { + for &(id, ref p, _, _) in &self.collected_paths { let typ = ppaux::ty_to_string(&self.analysis.ty_cx, (*self.analysis.ty_cx.node_types.borrow())[id]); // get the span only for the name of the variable (I hope the path is only ever a @@ -389,7 +389,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.process_formals(&method.pe_fn_decl().inputs, qualname); // walk arg and return types - for arg in method.pe_fn_decl().inputs.iter() { + for arg in &method.pe_fn_decl().inputs { self.visit_ty(&*arg.ty); } @@ -493,7 +493,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.process_formals(&decl.inputs, &qualname[]); // walk arg and return types - for arg in decl.inputs.iter() { + for arg in &decl.inputs { self.visit_ty(&*arg.ty); } @@ -580,7 +580,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &val[]); // fields - for field in def.fields.iter() { + for field in &def.fields { self.process_struct_field_def(field, &qualname[], item.id); self.visit_ty(&*field.node.ty); } @@ -605,7 +605,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &format!("Could not find subspan for enum {}", enum_name)[]), } - for variant in enum_definition.variants.iter() { + for variant in &enum_definition.variants { let name = get_ident(variant.node.name); let name = name.get(); let mut qualname = enum_name.clone(); @@ -623,7 +623,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &enum_name[], &val[], item.id); - for arg in args.iter() { + for arg in args { self.visit_ty(&*arg.ty); } } @@ -642,7 +642,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &val[], item.id); - for field in struct_def.fields.iter() { + for field in &struct_def.fields { self.process_struct_field_def(field, qualname.as_slice(), variant.node.id); self.visit_ty(&*field.node.ty); } @@ -701,7 +701,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } self.process_generic_params(type_parameters, item.span, "", item.id); - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { visit::walk_method_helper(self, &**method) @@ -729,7 +729,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &val[]); // super-traits - for super_bound in trait_refs.iter() { + for super_bound in &**trait_refs { let trait_ref = match *super_bound { ast::TraitTyParamBound(ref trait_ref, _) => { trait_ref @@ -759,7 +759,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // walk generics and methods self.process_generic_params(generics, item.span, &qualname[], item.id); - for method in methods.iter() { + for method in methods { self.visit_trait_item(method) } } @@ -912,11 +912,11 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { _ => None }; - for field in fields.iter() { + for field in fields { match struct_def { Some(struct_def) => { let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, struct_def); - for f in fields.iter() { + for f in &fields { if generated_code(field.ident.span) { continue; } @@ -1010,10 +1010,10 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.span.snippet(p.span))[]); } }; - for &Spanned { node: ref field, span } in fields.iter() { + for &Spanned { node: ref field, span } in fields { let sub_span = self.span.span_for_first_ident(span); let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, struct_def); - for f in fields.iter() { + for f in fields { if f.name == field.ident.name { self.fmt.ref_str(recorder::VarRef, span, @@ -1104,7 +1104,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { let glob_map = &self.analysis.glob_map; let glob_map = glob_map.as_ref().unwrap(); if glob_map.contains_key(&item.id) { - for n in glob_map[item.id].iter() { + for n in &glob_map[item.id] { if name_string.len() > 0 { name_string.push_str(", "); } @@ -1122,7 +1122,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.write_sub_paths(path, true); } ast::ViewPathList(ref path, ref list) => { - for plid in list.iter() { + for plid in list { match plid.node { ast::PathListIdent { id, .. } => { match self.lookup_type_ref(id) { @@ -1208,8 +1208,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { } fn visit_generics(&mut self, generics: &ast::Generics) { - for param in generics.ty_params.iter() { - for bound in param.bounds.iter() { + for param in &*generics.ty_params { + for bound in &*param.bounds { if let ast::TraitTyParamBound(ref trait_ref, _) = *bound { self.process_trait_ref(&trait_ref.trait_ref); } @@ -1270,7 +1270,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { scope_id); // walk arg and return types - for arg in method_type.decl.inputs.iter() { + for arg in &method_type.decl.inputs { self.visit_ty(&*arg.ty); } @@ -1349,7 +1349,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { match *ty { ty::ty_struct(def_id, _) => { let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, def_id); - for f in fields.iter() { + for f in &fields { if f.name == ident.node.name { let sub_span = self.span.span_for_last_ident(ex.span); self.fmt.ref_str(recorder::VarRef, @@ -1404,7 +1404,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.process_formals(&decl.inputs, &id[]); // walk arg and return types - for arg in decl.inputs.iter() { + for arg in &decl.inputs { self.visit_ty(&*arg.ty); } @@ -1435,7 +1435,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { fn visit_arm(&mut self, arm: &ast::Arm) { assert!(self.collected_paths.len() == 0 && !self.collecting); self.collecting = true; - for pattern in arm.pats.iter() { + for pattern in &arm.pats { // collect paths from the arm's patterns self.visit_pat(&**pattern); } @@ -1443,7 +1443,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { // This is to get around borrow checking, because we need mut self to call process_path. let mut paths_to_process = vec![]; // process collected paths - for &(id, ref p, ref immut, ref_kind) in self.collected_paths.iter() { + for &(id, ref p, ref immut, ref_kind) in &self.collected_paths { let def_map = self.analysis.ty_cx.def_map.borrow(); if !def_map.contains_key(&id) { self.sess.span_bug(p.span, @@ -1477,7 +1477,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { *def) } } - for &(id, ref path, ref_kind) in paths_to_process.iter() { + for &(id, ref path, ref_kind) in &paths_to_process { self.process_path(id, path.span, path, ref_kind); } self.collecting = false; @@ -1508,7 +1508,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { let value = self.span.snippet(l.span); - for &(id, ref p, ref immut, _) in self.collected_paths.iter() { + for &(id, ref p, ref immut, _) in &self.collected_paths { let value = if *immut { value.to_string() } else { "".to_string() }; let types = self.analysis.ty_cx.node_types.borrow(); let typ = ppaux::ty_to_string(&self.analysis.ty_cx, (*types)[id]); diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index b66e2770815..52fe8797592 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -366,7 +366,7 @@ impl<'a, 'p, 'blk, 'tcx> Repr<'tcx> for Match<'a, 'p, 'blk, 'tcx> { } fn has_nested_bindings(m: &[Match], col: uint) -> bool { - for br in m.iter() { + for br in m { match br.pats[col].node { ast::PatIdent(_, _, Some(_)) => return true, _ => () @@ -561,7 +561,7 @@ fn get_branches<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let tcx = bcx.tcx(); let mut found: Vec = vec![]; - for br in m.iter() { + for br in m { let cur = br.pats[col]; let opt = match cur.node { ast::PatLit(ref l) => ConstantValue(ConstantExpr(&**l)), @@ -827,7 +827,7 @@ fn insert_lllocals<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, bindings_map: &BindingsMap<'tcx>, cs: Option) -> Block<'blk, 'tcx> { - for (&ident, &binding_info) in bindings_map.iter() { + for (&ident, &binding_info) in bindings_map { let llval = match binding_info.trmode { // By value mut binding for a copy type: load from the ptr // into the matched value and copy to our alloca @@ -883,7 +883,7 @@ fn compile_guard<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let val = unpack_datum!(bcx, expr::trans(bcx, guard_expr)); let val = val.to_llbool(bcx); - for (_, &binding_info) in data.bindings_map.iter() { + for (_, &binding_info) in &data.bindings_map { if let TrByCopy(llbinding) = binding_info.trmode { call_lifetime_end(bcx, llbinding); } @@ -891,7 +891,7 @@ fn compile_guard<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, with_cond(bcx, Not(bcx, val, guard_expr.debug_loc()), |bcx| { // Guard does not match: remove all bindings from the lllocals table - for (_, &binding_info) in data.bindings_map.iter() { + for (_, &binding_info) in &data.bindings_map { call_lifetime_end(bcx, binding_info.llmatch); bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id); } @@ -949,7 +949,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } None => { let data = &m[0].data; - for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() { + for &(ref ident, ref value_ptr) in &m[0].bound_ptrs { let llmatch = data.bindings_map[*ident].llmatch; call_lifetime_start(bcx, llmatch); Store(bcx, *value_ptr, llmatch); @@ -1055,7 +1055,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, Variant(_, ref repr, _) => { let (the_kind, val_opt) = adt::trans_switch(bcx, &**repr, val); kind = the_kind; - for &tval in val_opt.iter() { test_val = tval; } + if let Some(tval) = val_opt { test_val = tval; } } SliceLengthEqual(_) | SliceLengthGreaterOrEqual(_, _) => { let (_, len) = tvec::get_base_and_len(bcx, val, left_ty); @@ -1064,7 +1064,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } } } - for o in opts.iter() { + for o in &opts { match *o { ConstantRange(_, _) => { kind = Compare; break }, SliceLengthGreaterOrEqual(_, _) => { kind = CompareSliceLength; break }, @@ -1410,7 +1410,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, compile_submatch(bcx, &matches[], &[discr_datum.val], &chk, has_default); let mut arm_cxs = Vec::new(); - for arm_data in arm_datas.iter() { + for arm_data in &arm_datas { let mut bcx = arm_data.bodycx; // insert bindings into the lllocals map and add cleanups @@ -1623,7 +1623,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }); } - for inner_pat in inner.iter() { + if let Some(ref inner_pat) = *inner { bcx = bind_irrefutable_pat(bcx, &**inner_pat, val, cleanup_scope); } } @@ -1639,7 +1639,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, &*repr, vinfo.disr_val, val); - for sub_pat in sub_pats.iter() { + if let Some(ref sub_pat) = *sub_pats { for (i, &argval) in args.vals.iter().enumerate() { bcx = bind_irrefutable_pat(bcx, &*sub_pat[i], argval, cleanup_scope); @@ -1673,7 +1673,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let pat_ty = node_id_type(bcx, pat.id); let pat_repr = adt::represent_type(bcx.ccx(), pat_ty); expr::with_field_tys(tcx, pat_ty, Some(pat.id), |discr, field_tys| { - for f in fields.iter() { + for f in fields { let ix = ty::field_idx_strict(tcx, f.node.ident.name, field_tys); let fldptr = adt::trans_field_ptr(bcx, &*pat_repr, val, discr, ix); diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 1deb07e1ba0..b99622ce911 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -285,7 +285,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // alignment of the type. let (_, align) = union_size_and_align(fields.as_slice()); let mut use_align = true; - for st in fields.iter() { + for st in &fields { // Get the first non-zero-sized field let field = st.fields.iter().skip(1).filter(|ty| { let t = type_of::sizing_type_of(cx, **ty); @@ -519,7 +519,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp cx.tcx().sess.bug("range_to_inttype: found ReprPacked on an enum"); } } - for &ity in attempts.iter() { + for &ity in attempts { if bounds_usable(cx, ity, bounds) { return ity; } @@ -563,7 +563,7 @@ fn ensure_struct_fits_in_address_space<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, packed: bool, scapegoat: Ty<'tcx>) { let mut offset = 0; - for &llty in fields.iter() { + for &llty in fields { // Invariant: offset < ccx.obj_size_bound() <= 1<<61 if !packed { let type_align = machine::llalign_of_min(ccx, llty); @@ -1097,7 +1097,7 @@ fn compute_struct_field_offsets<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let mut offsets = vec!(); let mut offset = 0; - for &ty in st.fields.iter() { + for &ty in &st.fields { let llty = type_of::sizing_type_of(ccx, ty); if !st.packed { let type_align = type_of::align_of(ccx, ty); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index a7afa17ab72..e4077f26ba8 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -350,7 +350,7 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId, // don't do this then linker errors can be generated where the linker // complains that one object files has a thread local version of the // symbol and another one doesn't. - for attr in ty::get_attrs(ccx.tcx(), did).iter() { + for attr in &*ty::get_attrs(ccx.tcx(), did) { if attr.check_name("thread_local") { llvm::set_thread_local(c, true); } @@ -442,7 +442,7 @@ pub fn set_llvm_fn_attrs(ccx: &CrateContext, attrs: &[ast::Attribute], llfn: Val InlineNone => { /* fallthrough */ } } - for attr in attrs.iter() { + for attr in attrs { let mut used = true; match attr.name().get() { "no_stack_check" => unset_split_stack(llfn), @@ -765,7 +765,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, n_variants); let next_cx = fcx.new_temp_block("enum-iter-next"); - for variant in (*variants).iter() { + for variant in &(*variants) { let variant_cx = fcx.new_temp_block( &format!("enum-iter-variant-{}", @@ -970,7 +970,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if need_invoke(bcx) { debug!("invoking {} at {:?}", bcx.val_to_string(llfn), bcx.llbb); - for &llarg in llargs.iter() { + for &llarg in llargs { debug!("arg: {}", bcx.val_to_string(llarg)); } let normal_bcx = bcx.fcx.new_temp_block("normal-return"); @@ -986,7 +986,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, return (llresult, normal_bcx); } else { debug!("calling {} at {:?}", bcx.val_to_string(llfn), bcx.llbb); - for &llarg in llargs.iter() { + for &llarg in llargs { debug!("arg: {}", bcx.val_to_string(llarg)); } @@ -1830,7 +1830,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, vec![ty::mk_tup(ccx.tcx(), monomorphized_arg_types)] } }; - for monomorphized_arg_type in monomorphized_arg_types.iter() { + for monomorphized_arg_type in &monomorphized_arg_types { debug!("trans_closure: monomorphized_arg_type: {}", ty_to_string(ccx.tcx(), *monomorphized_arg_type)); } @@ -1908,7 +1908,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // This somewhat improves single-stepping experience in debugger. unsafe { let llreturn = fcx.llreturn.get(); - for &llreturn in llreturn.iter() { + if let Some(llreturn) = llreturn { llvm::LLVMMoveBasicBlockAfter(llreturn, bcx.llbb); } } @@ -2109,7 +2109,7 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span, let avar = adt::represent_type(ccx, ty); match *avar { adt::General(_, ref variants, _) => { - for var in variants.iter() { + for var in variants { let mut size = 0; for field in var.fields.iter().skip(1) { // skip the discriminant @@ -2382,7 +2382,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { // and control visibility. pub fn trans_mod(ccx: &CrateContext, m: &ast::Mod) { let _icx = push_ctxt("trans_mod"); - for item in m.items.iter() { + for item in &m.items { trans_item(ccx, &**item); } } @@ -3161,7 +3161,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) stats.fn_stats.borrow_mut().sort_by(|&(_, insns_a), &(_, insns_b)| { insns_b.cmp(&insns_a) }); - for tuple in stats.fn_stats.borrow().iter() { + for tuple in &*stats.fn_stats.borrow() { match *tuple { (ref name, insns) => { println!("{} insns, {}", insns, *name); @@ -3170,7 +3170,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) } } if shared_ccx.sess().count_llvm_insns() { - for (k, v) in shared_ccx.stats().llvm_insns.borrow().iter() { + for (k, v) in &*shared_ccx.stats().llvm_insns.borrow() { println!("{:7} {}", *v, *k); } } diff --git a/src/librustc_trans/trans/cabi_aarch64.rs b/src/librustc_trans/trans/cabi_aarch64.rs index ce1cf54919c..5d1e6d2c9e8 100644 --- a/src/librustc_trans/trans/cabi_aarch64.rs +++ b/src/librustc_trans/trans/cabi_aarch64.rs @@ -150,7 +150,7 @@ pub fn compute_abi_info(ccx: &CrateContext, rty: Type, ret_def: bool) -> FnType { let mut arg_tys = Vec::new(); - for &aty in atys.iter() { + for &aty in atys { let ty = classify_arg_ty(ccx, aty); arg_tys.push(ty); } diff --git a/src/librustc_trans/trans/cabi_arm.rs b/src/librustc_trans/trans/cabi_arm.rs index ac32ce49511..50014230df6 100644 --- a/src/librustc_trans/trans/cabi_arm.rs +++ b/src/librustc_trans/trans/cabi_arm.rs @@ -186,7 +186,7 @@ pub fn compute_abi_info(ccx: &CrateContext, }; let mut arg_tys = Vec::new(); - for &aty in atys.iter() { + for &aty in atys { let ty = classify_arg_ty(ccx, aty, align_fn); arg_tys.push(ty); } diff --git a/src/librustc_trans/trans/cabi_mips.rs b/src/librustc_trans/trans/cabi_mips.rs index af7956b46be..fecd1a9013b 100644 --- a/src/librustc_trans/trans/cabi_mips.rs +++ b/src/librustc_trans/trans/cabi_mips.rs @@ -176,7 +176,7 @@ pub fn compute_abi_info(ccx: &CrateContext, let mut arg_tys = Vec::new(); let mut offset = if sret { 4 } else { 0 }; - for aty in atys.iter() { + for aty in atys { let ty = classify_arg_ty(ccx, *aty, &mut offset); arg_tys.push(ty); }; diff --git a/src/librustc_trans/trans/cabi_powerpc.rs b/src/librustc_trans/trans/cabi_powerpc.rs index c3b0026de98..9583158a0e2 100644 --- a/src/librustc_trans/trans/cabi_powerpc.rs +++ b/src/librustc_trans/trans/cabi_powerpc.rs @@ -171,7 +171,7 @@ pub fn compute_abi_info(ccx: &CrateContext, let mut arg_tys = Vec::new(); let mut offset = if sret { 4 } else { 0 }; - for aty in atys.iter() { + for aty in atys { let ty = classify_arg_ty(ccx, *aty, &mut offset); arg_tys.push(ty); }; diff --git a/src/librustc_trans/trans/cabi_x86.rs b/src/librustc_trans/trans/cabi_x86.rs index 32f6eb060c0..028d20f3084 100644 --- a/src/librustc_trans/trans/cabi_x86.rs +++ b/src/librustc_trans/trans/cabi_x86.rs @@ -60,7 +60,7 @@ pub fn compute_abi_info(ccx: &CrateContext, ret_ty = ArgType::direct(rty, None, None, attr); } - for &t in atys.iter() { + for &t in atys { let ty = match t.kind() { Struct => { let size = llsize_of_alloc(ccx, t); diff --git a/src/librustc_trans/trans/cabi_x86_64.rs b/src/librustc_trans/trans/cabi_x86_64.rs index c0ab0d24dab..22318fb6c14 100644 --- a/src/librustc_trans/trans/cabi_x86_64.rs +++ b/src/librustc_trans/trans/cabi_x86_64.rs @@ -195,7 +195,7 @@ fn classify_ty(ty: Type) -> Vec { off: uint, packed: bool) { let mut field_off = off; - for ty in tys.iter() { + for ty in tys { if !packed { field_off = align(field_off, *ty); } @@ -333,7 +333,7 @@ fn classify_ty(ty: Type) -> Vec { fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type { fn llvec_len(cls: &[RegClass]) -> uint { let mut len = 1; - for c in cls.iter() { + for c in cls { if *c != SSEUp { break; } @@ -413,7 +413,7 @@ pub fn compute_abi_info(ccx: &CrateContext, } let mut arg_tys = Vec::new(); - for t in atys.iter() { + for t in atys { let ty = x86_64_ty(ccx, *t, |cls| cls.is_pass_byval(), ByValAttribute); arg_tys.push(ty); } diff --git a/src/librustc_trans/trans/cabi_x86_win64.rs b/src/librustc_trans/trans/cabi_x86_win64.rs index 79e309dacaa..9b34c3bf262 100644 --- a/src/librustc_trans/trans/cabi_x86_win64.rs +++ b/src/librustc_trans/trans/cabi_x86_win64.rs @@ -38,7 +38,7 @@ pub fn compute_abi_info(ccx: &CrateContext, ret_ty = ArgType::direct(rty, None, None, attr); } - for &t in atys.iter() { + for &t in atys { let ty = match t.kind() { Struct => { match llsize_of_alloc(ccx, t) { diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index 096ea22eaac..ac76b52598d 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -72,7 +72,7 @@ impl<'blk, 'tcx: 'blk> fmt::Debug for CleanupScopeKind<'blk, 'tcx> { AstScopeKind(nid) => write!(f, "AstScopeKind({})", nid), LoopScopeKind(nid, ref blks) => { try!(write!(f, "LoopScopeKind({}, [", nid)); - for blk in blks.iter() { + for blk in blks { try!(write!(f, "{:p}, ", blk)); } write!(f, "])") diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 5782b3987cb..392d320f166 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -515,7 +515,7 @@ impl<'a, 'tcx> FunctionContext<'a, 'tcx> { -> Block<'a, 'tcx> { let out = self.new_id_block("join", id); let mut reachable = false; - for bcx in in_cxs.iter() { + for bcx in in_cxs { if !bcx.unreachable.get() { build::Br(*bcx, out.llbb, DebugLoc::None); reachable = true; diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs index c4388603145..651058a5674 100644 --- a/src/librustc_trans/trans/controlflow.rs +++ b/src/librustc_trans/trans/controlflow.rs @@ -96,7 +96,7 @@ pub fn trans_block<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debuginfo::get_cleanup_debug_loc_for_ast_node(bcx.ccx(), b.id, b.span, true); fcx.push_ast_cleanup_scope(cleanup_debug_loc); - for s in b.stmts.iter() { + for s in &b.stmts { bcx = trans_stmt(bcx, &**s); } diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 258a6fb958d..9032eaeae50 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -375,7 +375,7 @@ impl<'tcx> TypeMap<'tcx> { }, ty::ty_tup(ref component_types) => { unique_type_id.push_str("tuple "); - for &component_type in component_types.iter() { + for &component_type in component_types { let component_type_id = self.get_unique_type_id_of_type(cx, component_type); let component_type_id = @@ -447,7 +447,7 @@ impl<'tcx> TypeMap<'tcx> { let sig = ty::erase_late_bound_regions(cx.tcx(), sig); - for ¶meter_type in sig.inputs.iter() { + for ¶meter_type in &sig.inputs { let parameter_type_id = self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = @@ -533,7 +533,7 @@ impl<'tcx> TypeMap<'tcx> { if tps.len() > 0 { output.push('<'); - for &type_parameter in tps.iter() { + for &type_parameter in tps { let param_type_id = type_map.get_unique_type_id_of_type(cx, type_parameter); let param_type_id = @@ -563,7 +563,7 @@ impl<'tcx> TypeMap<'tcx> { let sig = ty::erase_late_bound_regions(cx.tcx(), sig); - for ¶meter_type in sig.inputs.iter() { + for ¶meter_type in &sig.inputs { let parameter_type_id = self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = @@ -1440,7 +1440,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } // Arguments types - for arg in fn_decl.inputs.iter() { + for arg in &fn_decl.inputs { assert_type_for_node_id(cx, arg.pat.id, arg.pat.span); let arg_type = ty::node_id_to_type(cx.tcx(), arg.pat.id); let arg_type = monomorphize::apply_param_substs(cx.tcx(), @@ -2838,7 +2838,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }); // regular arguments - for &argument_type in signature.inputs.iter() { + for &argument_type in &signature.inputs { signature_metadata.push(type_metadata(cx, argument_type, span)); } @@ -3226,7 +3226,7 @@ fn create_scope_map(cx: &CrateContext, // Push argument identifiers onto the stack so arguments integrate nicely // with variable shadowing. - for arg in args.iter() { + for arg in args { pat_util::pat_bindings(def_map, &*arg.pat, |_, node_id, _, path1| { scope_stack.push(ScopeStackEntry { scope_metadata: fn_metadata, ident: Some(path1.node) }); @@ -3292,7 +3292,7 @@ fn create_scope_map(cx: &CrateContext, scope_map.insert(block.id, scope_stack.last().unwrap().scope_metadata); // The interesting things here are statements and the concluding expression. - for statement in block.stmts.iter() { + for statement in &block.stmts { scope_map.insert(ast_util::stmt_id(&**statement), scope_stack.last().unwrap().scope_metadata); @@ -3306,7 +3306,7 @@ fn create_scope_map(cx: &CrateContext, } } - for exp in block.expr.iter() { + if let Some(ref exp) = block.expr { walk_expr(cx, &**exp, scope_stack, scope_map); } } @@ -3321,7 +3321,7 @@ fn create_scope_map(cx: &CrateContext, walk_pattern(cx, &*local.pat, scope_stack, scope_map); - for exp in local.init.iter() { + if let Some(ref exp) = local.init { walk_expr(cx, &**exp, scope_stack, scope_map); } } @@ -3407,7 +3407,7 @@ fn create_scope_map(cx: &CrateContext, scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pat in sub_pat_opt.iter() { + if let Some(ref sub_pat) = *sub_pat_opt { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } } @@ -3419,8 +3419,8 @@ fn create_scope_map(cx: &CrateContext, ast::PatEnum(_, ref sub_pats_opt) => { scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pats in sub_pats_opt.iter() { - for p in sub_pats.iter() { + if let Some(ref sub_pats) = *sub_pats_opt { + for p in sub_pats { walk_pattern(cx, &**p, scope_stack, scope_map); } } @@ -3440,7 +3440,7 @@ fn create_scope_map(cx: &CrateContext, ast::PatTup(ref sub_pats) => { scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pat in sub_pats.iter() { + for sub_pat in sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } } @@ -3464,15 +3464,15 @@ fn create_scope_map(cx: &CrateContext, ast::PatVec(ref front_sub_pats, ref middle_sub_pats, ref back_sub_pats) => { scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pat in front_sub_pats.iter() { + for sub_pat in front_sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } - for sub_pat in middle_sub_pats.iter() { + if let Some(ref sub_pat) = *middle_sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } - for sub_pat in back_sub_pats.iter() { + for sub_pat in back_sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } } @@ -3534,7 +3534,7 @@ fn create_scope_map(cx: &CrateContext, ast::ExprVec(ref init_expressions) | ast::ExprTup(ref init_expressions) => { - for ie in init_expressions.iter() { + for ie in init_expressions { walk_expr(cx, &**ie, scope_stack, scope_map); } } @@ -3612,7 +3612,7 @@ fn create_scope_map(cx: &CrateContext, scope_stack, scope_map, |cx, scope_stack, scope_map| { - for &ast::Arg { pat: ref pattern, .. } in decl.inputs.iter() { + for &ast::Arg { pat: ref pattern, .. } in &decl.inputs { walk_pattern(cx, &**pattern, scope_stack, scope_map); } @@ -3623,13 +3623,13 @@ fn create_scope_map(cx: &CrateContext, ast::ExprCall(ref fn_exp, ref args) => { walk_expr(cx, &**fn_exp, scope_stack, scope_map); - for arg_exp in args.iter() { + for arg_exp in args { walk_expr(cx, &**arg_exp, scope_stack, scope_map); } } ast::ExprMethodCall(_, _, ref args) => { - for arg_exp in args.iter() { + for arg_exp in args { walk_expr(cx, &**arg_exp, scope_stack, scope_map); } } @@ -3642,7 +3642,7 @@ fn create_scope_map(cx: &CrateContext, // walk only one pattern per arm, as they all must contain the // same binding names. - for arm_ref in arms.iter() { + for arm_ref in arms { let arm_span = arm_ref.pats[0].span; with_new_scope(cx, @@ -3650,11 +3650,11 @@ fn create_scope_map(cx: &CrateContext, scope_stack, scope_map, |cx, scope_stack, scope_map| { - for pat in arm_ref.pats.iter() { + for pat in &arm_ref.pats { walk_pattern(cx, &**pat, scope_stack, scope_map); } - for guard_exp in arm_ref.guard.iter() { + if let Some(ref guard_exp) = arm_ref.guard { walk_expr(cx, &**guard_exp, scope_stack, scope_map) } @@ -3664,7 +3664,7 @@ fn create_scope_map(cx: &CrateContext, } ast::ExprStruct(_, ref fields, ref base_exp) => { - for &ast::Field { expr: ref exp, .. } in fields.iter() { + for &ast::Field { expr: ref exp, .. } in fields { walk_expr(cx, &**exp, scope_stack, scope_map); } @@ -3678,11 +3678,11 @@ fn create_scope_map(cx: &CrateContext, ref outputs, .. }) => { // inputs, outputs: Vec<(String, P)> - for &(_, ref exp) in inputs.iter() { + for &(_, ref exp) in inputs { walk_expr(cx, &**exp, scope_stack, scope_map); } - for &(_, ref exp, _) in outputs.iter() { + for &(_, ref exp, _) in outputs { walk_expr(cx, &**exp, scope_stack, scope_map); } } @@ -3737,7 +3737,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }, ty::ty_tup(ref component_types) => { output.push('('); - for &component_type in component_types.iter() { + for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); output.push_str(", "); } @@ -3802,7 +3802,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let sig = ty::erase_late_bound_regions(cx.tcx(), sig); if sig.inputs.len() > 0 { - for ¶meter_type in sig.inputs.iter() { + for ¶meter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index cf85389cd5b..bed43a5c838 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -1451,7 +1451,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let custom_cleanup_scope = fcx.push_custom_cleanup_scope(); // First we trans the base, if we have one, to the dest - for base in optbase.iter() { + if let Some(base) = optbase { assert_eq!(discr, 0); match ty::expr_kind(bcx.tcx(), &*base.expr) { @@ -1461,7 +1461,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, ty::RvalueStmtExpr => bcx.tcx().sess.bug("unexpected expr kind for struct base expr"), _ => { let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &*base.expr, "base")); - for &(i, t) in base.fields.iter() { + for &(i, t) in &base.fields { let datum = base_datum.get_element( bcx, t, |srcval| adt::trans_field_ptr(bcx, &*repr, srcval, discr, i)); assert!(type_is_sized(bcx.tcx(), datum.ty)); @@ -1485,7 +1485,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, // (i.e. avoid GEPi and `store`s to an alloca) . let mut vec_val = C_undef(llty); - for &(i, ref e) in fields.iter() { + for &(i, ref e) in fields { let block_datum = trans(bcx, &**e); bcx = block_datum.bcx; let position = C_uint(bcx.ccx(), i); @@ -1495,7 +1495,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, Store(bcx, vec_val, addr); } else { // Now, we just overwrite the fields we've explicitly specified - for &(i, ref e) in fields.iter() { + for &(i, ref e) in fields { let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i); let e_ty = expr_ty_adjusted(bcx, &**e); bcx = trans_into(bcx, &**e, SaveIn(dest)); diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 6c017866ef0..00bb3036546 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -352,7 +352,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } arg_idx += 1; - for arg_ty in fn_type.arg_tys.iter() { + for arg_ty in &fn_type.arg_tys { if arg_ty.is_ignore() { continue; } @@ -453,7 +453,7 @@ fn gate_simd_ffi(tcx: &ty::ctxt, decl: &ast::FnDecl, ty: &ty::BareFnTy) { pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) { let _icx = push_ctxt("foreign::trans_foreign_mod"); - for foreign_item in foreign_mod.items.iter() { + for foreign_item in &foreign_mod.items { let lname = link_name(&**foreign_item); if let ast::ForeignItemFn(ref decl, _) = foreign_item.node { @@ -936,7 +936,7 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T } }; - for &arg_ty in tys.fn_ty.arg_tys.iter() { + for &arg_ty in &tys.fn_ty.arg_tys { if arg_ty.is_ignore() { continue; } @@ -987,7 +987,7 @@ fn add_argument_attributes(tys: &ForeignTypes, i += 1; - for &arg_ty in tys.fn_ty.arg_tys.iter() { + for &arg_ty in &tys.fn_ty.arg_tys { if arg_ty.is_ignore() { continue; } diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 497237da38c..5d26daab5cd 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -572,7 +572,7 @@ pub fn emit_tydescs(ccx: &CrateContext) { // As of this point, allow no more tydescs to be created. ccx.finished_tydescs().set(true); let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to(); - for (_, ti) in ccx.tydescs().borrow().iter() { + for (_, ti) in &*ccx.tydescs().borrow() { // Each of the glue functions needs to be cast to a generic type // before being put into the tydesc because we only have a singleton // tydesc type. Then we'll recast each function to its real type when diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 9bee2c5bbc6..340fcb76058 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -92,7 +92,7 @@ pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Opti /// the only intrinsic that needs such verification is `transmute`. pub fn check_intrinsics(ccx: &CrateContext) { let mut last_failing_id = None; - for transmute_restriction in ccx.tcx().transmute_restrictions.borrow().iter() { + for transmute_restriction in &*ccx.tcx().transmute_restrictions.borrow() { // Sometimes, a single call to transmute will push multiple // type pairs to test in order to exhaustively test the // possibility around a type parameter. If one of those fails, diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index 335c639df90..f522024c2e7 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -65,7 +65,7 @@ pub fn trans_impl(ccx: &CrateContext, // items that we need to translate. if !generics.ty_params.is_empty() { let mut v = TransItemVisitor{ ccx: ccx }; - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { visit::walk_method_helper(&mut v, &**method); @@ -75,7 +75,7 @@ pub fn trans_impl(ccx: &CrateContext, } return; } - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { if method.pe_generics().ty_params.len() == 0 { diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 844795b667b..66f603cbe07 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -263,7 +263,7 @@ pub fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ast::ExprVec(ref elements) => { match dest { Ignore => { - for element in elements.iter() { + for element in elements { bcx = expr::trans_into(bcx, &**element, Ignore); } } diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 6b6ca600a88..2243982c20d 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -84,7 +84,7 @@ pub fn untuple_arguments_if_necessary<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match inputs[inputs.len() - 1].sty { ty::ty_tup(ref tupled_arguments) => { debug!("untuple_arguments_if_necessary(): untupling arguments"); - for &tupled_argument in tupled_arguments.iter() { + for &tupled_argument in tupled_arguments { result.push(tupled_argument); } } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 350227c6662..d14945d1c9f 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -373,7 +373,7 @@ fn create_substs_for_ast_path<'tcx>( } } - for param in ty_param_defs[supplied_ty_param_count..].iter() { + for param in &ty_param_defs[supplied_ty_param_count..] { match param.default { Some(default) => { // This is a default type parameter. @@ -659,7 +659,7 @@ fn ast_path_to_trait_ref<'a,'tcx>( prohibit_projections(this.tcx(), assoc_bindings.as_slice()); } Some(ref mut v) => { - for binding in assoc_bindings.iter() { + for binding in &assoc_bindings { match ast_type_binding_to_projection_predicate(this, trait_ref.clone(), self_ty, binding) { Ok(pp) => { v.push(pp); } @@ -979,7 +979,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, token::get_name(assoc_name), token::get_name(ty_param_name)); - for suitable_bound in suitable_bounds.iter() { + for suitable_bound in &suitable_bounds { span_note!(this.tcx().sess, ast_ty.span, "associated type `{}` could derive from `{}`", token::get_name(ty_param_name), @@ -1710,7 +1710,7 @@ pub fn partition_bounds<'a>(tcx: &ty::ctxt, let mut region_bounds = Vec::new(); let mut trait_bounds = Vec::new(); let mut trait_def_ids = DefIdMap(); - for ast_bound in ast_bounds.iter() { + for ast_bound in ast_bounds { match *ast_bound { ast::TraitTyParamBound(ref b, ast::TraitBoundModifier::None) => { match ::lookup_def_tcx(tcx, b.trait_ref.path.span, b.trait_ref.ref_id) { diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index c4b7ffb8729..174a9029534 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -240,7 +240,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, // below for details. demand::eqtype(fcx, pat.span, expected, pat_ty); - for elt in before.iter() { + for elt in before { check_pat(pcx, &**elt, inner_ty); } if let Some(ref slice) = *slice { @@ -254,7 +254,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, }); check_pat(pcx, &**slice, slice_ty); } - for elt in after.iter() { + for elt in after { check_pat(pcx, &**elt, inner_ty); } } @@ -348,12 +348,12 @@ pub fn check_match<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Typecheck the patterns first, so that we get types for all the // bindings. - for arm in arms.iter() { + for arm in arms { let mut pcx = pat_ctxt { fcx: fcx, map: pat_id_map(&tcx.def_map, &*arm.pats[0]), }; - for p in arm.pats.iter() { + for p in &arm.pats { check_pat(&mut pcx, &**p, discrim_ty); } } @@ -439,7 +439,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, "use of trait `{}` in a struct pattern", name); fcx.write_error(pat.id); - for field in fields.iter() { + for field in fields { check_pat(pcx, &*field.node.pat, tcx.types.err); } return; @@ -458,7 +458,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, "`{}` does not name a struct or a struct variant", name); fcx.write_error(pat.id); - for field in fields.iter() { + for field in fields { check_pat(pcx, &*field.node.pat, tcx.types.err); } return; @@ -540,7 +540,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, fcx.write_error(pat.id); if let Some(subpats) = subpats { - for pat in subpats.iter() { + for pat in subpats { check_pat(pcx, &**pat, tcx.types.err); } } @@ -558,7 +558,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, "this pattern has {} field{}, but the corresponding {} has no fields", subpats.len(), if subpats.len() == 1 {""} else {"s"}, kind_name); - for pat in subpats.iter() { + for pat in subpats { check_pat(pcx, &**pat, tcx.types.err); } } else { @@ -568,7 +568,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, kind_name, arg_tys.len(), if arg_tys.len() == 1 {""} else {"s"}); - for pat in subpats.iter() { + for pat in subpats { check_pat(pcx, &**pat, tcx.types.err); } } @@ -598,7 +598,7 @@ pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let mut used_fields = FnvHashMap(); // Typecheck each field. - for &Spanned { node: ref field, span } in fields.iter() { + for &Spanned { node: ref field, span } in fields { let field_type = match used_fields.entry(field.ident.name) { Occupied(occupied) => { span_err!(tcx.sess, span, E0025, diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index e9ea0921bc9..8ad67b43178 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -134,7 +134,7 @@ pub fn probe<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Create a list of simplified self types, if we can. let mut simplified_steps = Vec::new(); - for step in steps.iter() { + for step in &steps { match fast_reject::simplify_type(fcx.tcx(), step.self_ty, true) { None => { break; } Some(simplified_type) => { simplified_steps.push(simplified_type); } @@ -236,7 +236,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { fn assemble_inherent_candidates(&mut self) { let steps = self.steps.clone(); - for step in steps.iter() { + for step in &*steps { self.assemble_probe(step.self_ty); } } @@ -268,8 +268,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // metadata if necessary. ty::populate_implementations_for_type_if_necessary(self.tcx(), def_id); - for impl_infos in self.tcx().inherent_impls.borrow().get(&def_id).iter() { - for &impl_def_id in impl_infos.iter() { + if let Some(impl_infos) = self.tcx().inherent_impls.borrow().get(&def_id) { + for &impl_def_id in &***impl_infos { self.assemble_inherent_impl_probe(impl_def_id); } } @@ -449,7 +449,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { let mut duplicates = HashSet::new(); let opt_applicable_traits = self.fcx.ccx.trait_map.get(&expr_id); for applicable_traits in opt_applicable_traits.into_iter() { - for &trait_did in applicable_traits.iter() { + for &trait_did in applicable_traits { if duplicates.insert(trait_did) { try!(self.assemble_extension_candidates_for_trait(trait_did)); } @@ -530,7 +530,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { Some(impls) => impls, }; - for &impl_def_id in impl_def_ids.borrow().iter() { + for &impl_def_id in &*impl_def_ids.borrow() { debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={} impl_def_id={}", trait_def_id.repr(self.tcx()), impl_def_id.repr(self.tcx())); @@ -601,7 +601,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // Check if there is an unboxed-closure self-type in the list of receivers. // If so, add "synthetic impls". let steps = self.steps.clone(); - for step in steps.iter() { + for step in &*steps { let (closure_def_id, _, _) = match step.self_ty.sty { ty::ty_closure(a, b, ref c) => (a, b, c), _ => continue, @@ -653,7 +653,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { method.repr(self.tcx()), method_index); - for step in self.steps.iter() { + for step in &*self.steps { debug!("assemble_projection_candidates: step={}", step.repr(self.tcx())); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index c193e1ef483..a704508e6fa 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -735,7 +735,7 @@ pub fn check_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { None => { } } - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref m) => { check_method_body(ccx, &impl_pty.generics, &**m); @@ -750,7 +750,7 @@ pub fn check_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { ast::ItemTrait(_, ref generics, _, ref trait_methods) => { check_trait_on_unimplemented(ccx, generics, it); let trait_def = ty::lookup_trait_def(ccx.tcx, local_def(it.id)); - for trait_method in trait_methods.iter() { + for trait_method in trait_methods { match *trait_method { RequiredMethod(..) => { // Nothing to do, since required methods don't have @@ -774,11 +774,11 @@ pub fn check_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { } ast::ItemForeignMod(ref m) => { if m.abi == abi::RustIntrinsic { - for item in m.items.iter() { + for item in &m.items { check_intrinsic_type(ccx, &**item); } } else { - for item in m.items.iter() { + for item in &m.items { let pty = ty::lookup_item_type(ccx.tcx, local_def(item.id)); if !pty.generics.types.is_empty() { span_err!(ccx.tcx.sess, item.span, E0044, @@ -879,7 +879,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // Check existing impl methods to see if they are both present in trait // and compatible with trait signature - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref impl_method) => { let impl_method_def_id = local_def(impl_method.id); @@ -969,7 +969,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // Check for missing items from trait let provided_methods = ty::provided_trait_methods(tcx, impl_trait_ref.def_id); let mut missing_methods = Vec::new(); - for trait_item in trait_items.iter() { + for trait_item in &*trait_items { match *trait_item { ty::MethodTraitItem(ref trait_method) => { let is_implemented = @@ -2321,7 +2321,7 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // of arguments when we typecheck the functions. This isn't really the // right way to do this. let xs = [false, true]; - for check_blocks in xs.iter() { + for check_blocks in &xs { let check_blocks = *check_blocks; debug!("check_blocks={}", check_blocks); @@ -3101,7 +3101,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let mut best_dist = name.len(); let fields = ty::lookup_struct_fields(tcx, id); let mut best = None; - for elem in fields.iter() { + for elem in &fields { let n = elem.name.as_str(); // ignore already set fields if skip.iter().any(|&x| x == n) { @@ -3199,14 +3199,14 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let mut class_field_map = FnvHashMap(); let mut fields_found = 0; - for field in field_types.iter() { + for field in field_types { class_field_map.insert(field.name, (field.id, false)); } let mut error_happened = false; // Typecheck each field. - for field in ast_fields.iter() { + for field in ast_fields { let mut expected_field_type = tcx.types.err; let pair = class_field_map.get(&field.ident.node.name).map(|x| *x); @@ -3273,7 +3273,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, assert!(fields_found <= field_types.len()); if fields_found < field_types.len() { let mut missing_fields = Vec::new(); - for class_field in field_types.iter() { + for class_field in field_types { let name = class_field.name; let (_, seen) = class_field_map[name]; if !seen { @@ -3374,7 +3374,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // Make sure to still write the types // otherwise we might ICE fcx.write_error(id); - for field in fields.iter() { + for field in fields { check_expr(fcx, &*field.expr); } match *base_expr { @@ -3628,10 +3628,10 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, constrain_path_type_parameters(fcx, expr); } ast::ExprInlineAsm(ref ia) => { - for &(_, ref input) in ia.inputs.iter() { + for &(_, ref input) in &ia.inputs { check_expr(fcx, &**input); } - for &(_, ref out, _) in ia.outputs.iter() { + for &(_, ref out, _) in &ia.outputs { check_expr(fcx, &**out); } fcx.write_nil(id); @@ -3764,14 +3764,14 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let typ = match uty { Some(uty) => { - for e in args.iter() { + for e in args { check_expr_coercable_to_type(fcx, &**e, uty); } uty } None => { let t: Ty = fcx.infcx().next_ty_var(); - for e in args.iter() { + for e in args { check_expr_has_type(fcx, &**e, t); } t @@ -4270,7 +4270,7 @@ fn check_block_with_expected<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let mut warned = false; let mut any_diverges = false; let mut any_err = false; - for s in blk.stmts.iter() { + for s in &blk.stmts { check_stmt(fcx, &**s); let s_id = ast_util::stmt_id(&**s); let s_ty = fcx.node_ty(s_id); @@ -4506,7 +4506,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, let mut disr_vals: Vec = Vec::new(); let mut prev_disr_val: Option = None; - for v in vs.iter() { + for v in vs { // If the discriminant value is specified explicitly in the enum check whether the // initialization expression is valid, otherwise use the last value plus one. @@ -4838,7 +4838,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // variables. If the user provided some types, we may still need // to add defaults. If the user provided *too many* types, that's // a problem. - for &space in ParamSpace::all().iter() { + for &space in &ParamSpace::all() { adjust_type_parameters(fcx, span, space, type_defs, &mut substs); assert_eq!(substs.types.len(space), type_defs.len(space)); @@ -4870,13 +4870,13 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, fcx: &FnCtxt, segment: &ast::PathSegment) { - for typ in segment.parameters.types().iter() { + for typ in &segment.parameters.types() { span_err!(fcx.tcx().sess, typ.span, E0085, "type parameters may not appear here"); break; } - for lifetime in segment.parameters.lifetimes().iter() { + for lifetime in &segment.parameters.lifetimes() { span_err!(fcx.tcx().sess, lifetime.span, E0086, "lifetime parameters may not appear here"); break; diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index f8c7055a003..816edd92bf9 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -148,7 +148,7 @@ pub fn regionck_ensure_component_tys_wf<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, span: Span, component_tys: &[Ty<'tcx>]) { let mut rcx = Rcx::new(fcx, Repeating(0), SubjectNode::None); - for &component_ty in component_tys.iter() { + for &component_ty in component_tys { // Check that each type outlives the empty region. Since the // empty region is a subregion of all others, this can't fail // unless the type does not meet the well-formedness @@ -298,7 +298,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { .region_obligations(node_id) .to_vec(); - for r_o in region_obligations.iter() { + for r_o in ®ion_obligations { debug!("visit_region_obligations: r_o={}", r_o.repr(self.tcx())); let sup_type = self.resolve_type(r_o.sup_type); @@ -327,7 +327,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { debug!("relate_free_regions >>"); let tcx = self.tcx(); - for &ty in fn_sig_tys.iter() { + for &ty in fn_sig_tys { let ty = self.resolve_type(ty); debug!("relate_free_regions(t={})", ty.repr(tcx)); let body_scope = CodeExtent::from_node_id(body_id); @@ -337,7 +337,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { tcx, ty, body_scope); - for constraint in constraints.iter() { + for constraint in &constraints { debug!("constraint: {}", constraint.repr(tcx)); match *constraint { regionmanip::RegionSubRegionConstraint(_, @@ -424,7 +424,7 @@ fn visit_block(rcx: &mut Rcx, b: &ast::Block) { fn visit_arm(rcx: &mut Rcx, arm: &ast::Arm) { // see above - for p in arm.pats.iter() { + for p in &arm.pats { constrain_bindings_in_pat(&**p, rcx); } @@ -487,13 +487,13 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { let has_method_map = rcx.fcx.inh.method_map.borrow().contains_key(&method_call); // Check any autoderefs or autorefs that appear. - for &adjustment in rcx.fcx.inh.adjustments.borrow().get(&expr.id).iter() { + if let Some(adjustment) = rcx.fcx.inh.adjustments.borrow().get(&expr.id) { debug!("adjustment={:?}", adjustment); match *adjustment { ty::AdjustDerefRef(ty::AutoDerefRef {autoderefs, autoref: ref opt_autoref}) => { let expr_ty = rcx.resolve_node_type(expr.id); constrain_autoderefs(rcx, expr, autoderefs, expr_ty); - for autoref in opt_autoref.iter() { + if let Some(ref autoref) = *opt_autoref { link_autoref(rcx, expr, autoderefs, autoref); // Require that the resulting region encompasses @@ -753,7 +753,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, debug!("ensure_free_variable_types_outlive_closure_bound({}, {})", bounds.region_bound.repr(tcx), expr.repr(tcx)); - for freevar in freevars.iter() { + for freevar in freevars { let var_node_id = { let def_id = freevar.def.def_id(); assert!(def_id.krate == ast::LOCAL_CRATE); @@ -779,7 +779,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, }; // Check that the type meets the criteria of the existential bounds: - for builtin_bound in bounds.builtin_bounds.iter() { + for builtin_bound in &bounds.builtin_bounds { let code = traits::ClosureCapture(var_node_id, expr.span, builtin_bound); let cause = traits::ObligationCause::new(freevar.span, rcx.fcx.body_id, code); rcx.fcx.register_builtin_bound(var_ty, builtin_bound, cause); @@ -802,7 +802,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, let tcx = rcx.fcx.ccx.tcx; debug!("constrain_captured_variables({}, {})", region_bound.repr(tcx), expr.repr(tcx)); - for freevar in freevars.iter() { + for freevar in freevars { debug!("constrain_captured_variables: freevar.def={:?}", freevar.def); // Identify the variable being closed over and its node-id. @@ -897,13 +897,13 @@ fn constrain_call<'a, I: Iterator>(rcx: &mut Rcx, } // as loop above, but for receiver - for r in receiver.iter() { + if let Some(r) = receiver { debug!("receiver: {}", r.repr(tcx)); type_of_node_must_outlive( rcx, infer::CallRcvr(r.span), r.id, callee_region); if implicitly_ref_args { - link_by_ref(rcx, &**r, callee_scope); + link_by_ref(rcx, &*r, callee_scope); } } } @@ -1079,8 +1079,8 @@ fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { let mc = mc::MemCategorizationContext::new(rcx.fcx); let discr_cmt = ignore_err!(mc.cat_expr(discr)); debug!("discr_cmt={}", discr_cmt.repr(rcx.tcx())); - for arm in arms.iter() { - for root_pat in arm.pats.iter() { + for arm in arms { + for root_pat in &arm.pats { link_pattern(rcx, mc, discr_cmt.clone(), &**root_pat); } } @@ -1092,7 +1092,7 @@ fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { fn link_fn_args(rcx: &Rcx, body_scope: CodeExtent, args: &[ast::Arg]) { debug!("regionck::link_fn_args(body_scope={:?})", body_scope); let mc = mc::MemCategorizationContext::new(rcx.fcx); - for arg in args.iter() { + for arg in args { let arg_ty = rcx.fcx.node_ty(arg.id); let re_scope = ty::ReScope(body_scope); let arg_cmt = mc.cat_rvalue(arg.id, arg.ty.span, re_scope, arg_ty); @@ -1418,7 +1418,7 @@ fn type_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, rcx.tcx(), ty, region); - for constraint in constraints.iter() { + for constraint in &constraints { debug!("constraint: {}", constraint.repr(rcx.tcx())); match *constraint { regionmanip::RegionSubRegionConstraint(None, r_a, r_b) => { @@ -1479,7 +1479,7 @@ fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, // The problem is that the type of `x` is `&'a A`. To be // well-formed, then, A must be lower-generic by `'a`, but we // don't know that this holds from first principles. - for &(ref r, ref p) in rcx.region_bound_pairs.iter() { + for &(ref r, ref p) in &rcx.region_bound_pairs { debug!("generic={} p={}", generic.repr(rcx.tcx()), p.repr(rcx.tcx())); diff --git a/src/librustc_typeck/check/regionmanip.rs b/src/librustc_typeck/check/regionmanip.rs index cbd51a880ce..4a0e2acc854 100644 --- a/src/librustc_typeck/check/regionmanip.rs +++ b/src/librustc_typeck/check/regionmanip.rs @@ -126,7 +126,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { } ty::ty_tup(ref tuptys) => { - for &tupty in tuptys.iter() { + for &tupty in tuptys { self.accumulate_from_ty(tupty); } } @@ -236,7 +236,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { // Variance of each type/region parameter. let variances = ty::item_variances(self.tcx, def_id); - for &space in ParamSpace::all().iter() { + for &space in &ParamSpace::all() { let region_params = substs.regions().get_slice(space); let region_variances = variances.regions.get_slice(space); let region_param_defs = generics.regions.get_slice(space); @@ -272,7 +272,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { } } - for ®ion_bound in region_param_def.bounds.iter() { + for ®ion_bound in ®ion_param_def.bounds { // The type declared a constraint like // // 'b : 'a @@ -314,7 +314,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { // Inspect bounds on this type parameter for any // region bounds. - for &r in type_param_def.bounds.region_bounds.iter() { + for &r in &type_param_def.bounds.region_bounds { self.stack.push((r, Some(ty))); self.accumulate_from_ty(type_param_ty); self.stack.pop().unwrap(); @@ -368,7 +368,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { // And then, in turn, to be well-formed, the // `region_bound` that user specified must imply the // region bounds required from all of the trait types: - for &r_d in required_region_bounds.iter() { + for &r_d in &required_region_bounds { // Each of these is an instance of the `'c <= 'b` // constraint above self.out.push(RegionSubRegionConstraint(Some(ty), r_d, r_c)); diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index f7babadd41f..b52e01f9a7a 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -138,7 +138,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { } ty::with_freevars(self.tcx(), expr.id, |freevars| { - for freevar in freevars.iter() { + for freevar in freevars { let var_node_id = freevar.def.local_node_id(); let upvar_id = ty::UpvarId { var_id: var_node_id, closure_expr_id: expr.id }; diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs index 5cf71a9be6a..43910a937e8 100644 --- a/src/librustc_typeck/check/vtable.rs +++ b/src/librustc_typeck/check/vtable.rs @@ -221,7 +221,7 @@ pub fn register_object_cast_obligations<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // bounds attached to the object cast. (In other words, if the // object type is Foo+Send, this would create an obligation // for the Send check.) - for builtin_bound in object_trait.bounds.builtin_bounds.iter() { + for builtin_bound in &object_trait.bounds.builtin_bounds { fcx.register_builtin_bound( referent_ty, builtin_bound, @@ -231,7 +231,7 @@ pub fn register_object_cast_obligations<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Create obligations for the projection predicates. let projection_bounds = object_trait.projection_bounds_with_self_ty(fcx.tcx(), referent_ty); - for projection_bound in projection_bounds.iter() { + for projection_bound in &projection_bounds { let projection_obligation = Obligation::new(cause.clone(), projection_bound.as_predicate()); fcx.register_predicate(projection_obligation); @@ -263,7 +263,7 @@ fn check_object_type_binds_all_associated_types<'tcx>(tcx: &ty::ctxt<'tcx>, }) .collect(); - for projection_bound in object_trait.bounds.projection_bounds.iter() { + for projection_bound in &object_trait.bounds.projection_bounds { let pair = (projection_bound.0.projection_ty.trait_ref.def_id, projection_bound.0.projection_ty.item_name); associated_types.remove(&pair); diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index db226295cd9..24153fd94ea 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -147,15 +147,15 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { item.span, region::CodeExtent::from_node_id(item.id), Some(&mut this.cache)); - for variant in variants.iter() { - for field in variant.fields.iter() { + for variant in &variants { + for field in &variant.fields { // Regions are checked below. bounds_checker.check_traits_in_ty(field.ty); } // For DST, all intermediate types must be sized. if variant.fields.len() > 0 { - for field in variant.fields.init().iter() { + for field in variant.fields.init() { fcx.register_builtin_bound( field.ty, ty::BoundSized, @@ -323,7 +323,7 @@ fn reject_shadowing_type_parameters<'tcx>(tcx: &ty::ctxt<'tcx>, let impl_params = generics.types.get_slice(subst::TypeSpace).iter() .map(|tp| tp.name).collect::>(); - for method_param in generics.types.get_slice(subst::FnSpace).iter() { + for method_param in generics.types.get_slice(subst::FnSpace) { if impl_params.contains(&method_param.name) { span_err!(tcx.sess, span, E0194, "type parameter `{}` shadows another type parameter of the same name", diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 0eaecf8ac05..52b1eb490cc 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -49,7 +49,7 @@ pub fn resolve_type_vars_in_fn(fcx: &FnCtxt, assert_eq!(fcx.writeback_errors.get(), false); let mut wbcx = WritebackCx::new(fcx); wbcx.visit_block(blk); - for arg in decl.inputs.iter() { + for arg in &decl.inputs { wbcx.visit_node_id(ResolvingPattern(arg.pat.span), arg.id); wbcx.visit_pat(&*arg.pat); @@ -119,7 +119,7 @@ impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> { match e.node { ast::ExprClosure(_, _, ref decl, _) => { - for input in decl.inputs.iter() { + for input in &decl.inputs { let _ = self.visit_node_id(ResolvingExpr(e.span), input.id); } @@ -182,7 +182,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { return; } - for (upvar_id, upvar_capture) in self.fcx.inh.upvar_capture_map.borrow().iter() { + for (upvar_id, upvar_capture) in &*self.fcx.inh.upvar_capture_map.borrow() { let new_upvar_capture = match *upvar_capture { ty::UpvarCapture::ByValue => ty::UpvarCapture::ByValue, ty::UpvarCapture::ByRef(ref upvar_borrow) => { @@ -204,12 +204,12 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { return } - for (def_id, closure_ty) in self.fcx.inh.closure_tys.borrow().iter() { + for (def_id, closure_ty) in &*self.fcx.inh.closure_tys.borrow() { let closure_ty = self.resolve(closure_ty, ResolvingClosure(*def_id)); self.fcx.tcx().closure_tys.borrow_mut().insert(*def_id, closure_ty); } - for (def_id, &closure_kind) in self.fcx.inh.closure_kinds.borrow().iter() { + for (def_id, &closure_kind) in &*self.fcx.inh.closure_kinds.borrow() { self.fcx.tcx().closure_kinds.borrow_mut().insert(*def_id, closure_kind); } } diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 9760d5f05df..ed340b0882c 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -136,7 +136,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { // the tcx. let mut tcx_inherent_impls = self.crate_context.tcx.inherent_impls.borrow_mut(); - for (k, v) in self.inherent_impls.borrow().iter() { + for (k, v) in &*self.inherent_impls.borrow() { tcx_inherent_impls.insert((*k).clone(), Rc::new((*v.borrow()).clone())); } @@ -167,7 +167,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let impl_items = self.create_impl_from_item(item); - for associated_trait in associated_traits.iter() { + for associated_trait in associated_traits { let trait_ref = ty::node_id_to_trait_ref(self.crate_context.tcx, associated_trait.ref_id); debug!("(checking implementation) adding impl for trait '{}', item '{}'", @@ -215,7 +215,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let impl_type_scheme = ty::lookup_item_type(tcx, impl_id); let prov = ty::provided_trait_methods(tcx, trait_ref.def_id); - for trait_method in prov.iter() { + for trait_method in &prov { // Synthesize an ID. let new_id = tcx.sess.next_node_id(); let new_did = local_def(new_id); @@ -303,7 +303,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } }).collect(); - for trait_ref in trait_refs.iter() { + if let Some(ref trait_ref) = *trait_refs { let ty_trait_ref = ty::node_id_to_trait_ref( self.crate_context.tcx, trait_ref.ref_id); @@ -345,17 +345,17 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { assert!(associated_traits.is_some()); // Record all the trait items. - for trait_ref in associated_traits.iter() { + if let Some(trait_ref) = associated_traits { self.add_trait_impl(trait_ref.def_id, impl_def_id); } // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. - for item_def_id in impl_items.iter() { + for item_def_id in &impl_items { let impl_item = ty::impl_or_trait_item(tcx, item_def_id.def_id()); match impl_item { ty::MethodTraitItem(ref method) => { - for &source in method.provided_source.iter() { + if let Some(source) = method.provided_source { tcx.provided_method_sources .borrow_mut() .insert(item_def_id.def_id(), source); @@ -398,7 +398,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { Some(found_impls) => found_impls }; - for &impl_did in trait_impls.borrow().iter() { + for &impl_did in &*trait_impls.borrow() { let items = &(*impl_items)[impl_did]; if items.len() < 1 { // We'll error out later. For now, just don't ICE. @@ -465,7 +465,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { // Clone first to avoid a double borrow error. let trait_impls = trait_impls.borrow().clone(); - for &impl_did in trait_impls.iter() { + for &impl_did in &trait_impls { debug!("check_implementations_of_copy: impl_did={}", impl_did.repr(tcx)); @@ -559,7 +559,7 @@ fn subst_receiver_types_in_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>, // replace the type parameters declared on the trait with those // from the impl - for &space in [subst::TypeSpace, subst::SelfSpace].iter() { + for &space in &[subst::TypeSpace, subst::SelfSpace] { method_generics.types.replace( space, impl_type_scheme.generics.types.get_slice(space).to_vec()); diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index a7bad3dc789..403dcf1e25a 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -46,7 +46,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { (k, v.borrow().clone()) }).collect(); - for &(trait_def_id, ref impls) in trait_def_ids.iter() { + for &(trait_def_id, ref impls) in &trait_def_ids { self.check_for_overlapping_impls_of_trait(trait_def_id, impls); } } @@ -65,7 +65,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { continue; } - for &impl2_def_id in trait_impls[(i+1)..].iter() { + for &impl2_def_id in &trait_impls[(i+1)..] { self.check_if_impls_overlap(trait_def_id, impl1_def_id, impl2_def_id); diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index ed33ddd458a..6d92343d332 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -203,7 +203,7 @@ fn get_enum_variant_types<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, let tcx = ccx.tcx; // Create a set of parameter types shared among all the variants. - for variant in variants.iter() { + for variant in variants { let variant_def_id = local_def(variant.node.id); // Nullary enum constructors get turned into constants; n-ary enum @@ -249,7 +249,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, if let ast::ItemTrait(_, _, _, ref trait_items) = item.node { // For each method, construct a suitable ty::Method and // store it into the `tcx.impl_or_trait_items` table: - for trait_item in trait_items.iter() { + for trait_item in trait_items { match *trait_item { ast::RequiredMethod(_) | ast::ProvidedMethod(_) => { @@ -527,8 +527,8 @@ fn ensure_no_ty_param_bounds(ccx: &CollectCtxt, thing: &'static str) { let mut warn = false; - for ty_param in generics.ty_params.iter() { - for bound in ty_param.bounds.iter() { + for ty_param in &*generics.ty_params { + for bound in &*ty_param.bounds { match *bound { ast::TraitTyParamBound(..) => { warn = true; @@ -596,7 +596,7 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { }; let mut methods = Vec::new(); - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { let body_id = method.pe_body().id; @@ -644,7 +644,7 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { &ty_generics, parent_visibility); - for trait_ref in opt_trait_ref.iter() { + if let Some(ref trait_ref) = *opt_trait_ref { astconv::instantiate_trait_ref(ccx, &ExplicitRscope, trait_ref, @@ -663,7 +663,7 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { it.ident.repr(ccx.tcx), trait_def.repr(ccx.tcx)); - for trait_method in trait_methods.iter() { + for trait_method in trait_methods { let self_type = ty::mk_self_type(tcx); match *trait_method { ast::RequiredMethod(ref type_method) => { @@ -1168,7 +1168,7 @@ fn add_unsized_bound<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, { // Try to find an unbound in bounds. let mut unbound = None; - for ab in ast_bounds.iter() { + for ab in ast_bounds { if let &ast::TraitTyParamBound(ref ptr, ast::TraitBoundModifier::Maybe) = ab { if unbound.is_none() { assert!(ptr.bound_lifetimes.is_empty()); @@ -1249,12 +1249,12 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, create_predicates(ccx.tcx, &mut result, space); // Add the bounds not associated with a type parameter - for predicate in where_clause.predicates.iter() { + for predicate in &where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ref bound_pred) => { let ty = ast_ty_to_ty(ccx, &ExplicitRscope, &*bound_pred.bounded_ty); - for bound in bound_pred.bounds.iter() { + for bound in &*bound_pred.bounds { match bound { &ast::TyParamBound::TraitTyParamBound(ref poly_trait_ref, _) => { let mut projections = Vec::new(); @@ -1269,7 +1269,7 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, result.predicates.push(space, trait_ref.as_predicate()); - for projection in projections.iter() { + for projection in &projections { result.predicates.push(space, projection.as_predicate()); } } @@ -1285,7 +1285,7 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, &ast::WherePredicate::RegionPredicate(ref region_pred) => { let r1 = ast_region_to_region(ccx.tcx, ®ion_pred.lifetime); - for bound in region_pred.bounds.iter() { + for bound in ®ion_pred.bounds { let r2 = ast_region_to_region(ccx.tcx, bound); let pred = ty::Binder(ty::OutlivesPredicate(r1, r2)); result.predicates.push(space, ty::Predicate::RegionOutlives(pred)) @@ -1308,16 +1308,16 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, result: &mut ty::Generics<'tcx>, space: subst::ParamSpace) { - for type_param_def in result.types.get_slice(space).iter() { + for type_param_def in result.types.get_slice(space) { let param_ty = ty::mk_param_from_def(tcx, type_param_def); for predicate in ty::predicates(tcx, param_ty, &type_param_def.bounds).into_iter() { result.predicates.push(space, predicate); } } - for region_param_def in result.regions.get_slice(space).iter() { + for region_param_def in result.regions.get_slice(space) { let region = region_param_def.to_early_bound_region(); - for &bound_region in region_param_def.bounds.iter() { + for &bound_region in ®ion_param_def.bounds { // account for new binder introduced in the predicate below; no need // to shift `region` because it is never a late-bound region let bound_region = ty_fold::shift_region(bound_region, 1); @@ -1480,7 +1480,7 @@ fn ty_of_foreign_fn_decl<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ast_generics: &ast::Generics, abi: abi::Abi) -> ty::TypeScheme<'tcx> { - for i in decl.inputs.iter() { + for i in &decl.inputs { match (*i).pat.node { ast::PatIdent(_, _, _) => (), ast::PatWild(ast::PatWildSingle) => (), diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 6c5950e4df5..40197ee2c49 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -499,12 +499,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { // `ty::VariantInfo::from_ast_variant()` ourselves // here, mainly so as to mask the differences between // struct-like enums and so forth. - for ast_variant in enum_definition.variants.iter() { + for ast_variant in &enum_definition.variants { let variant = ty::VariantInfo::from_ast_variant(tcx, &**ast_variant, /*discriminant*/ 0); - for arg_ty in variant.args.iter() { + for arg_ty in &variant.args { self.add_constraints_from_ty(generics, *arg_ty, self.covariant); } } @@ -513,7 +513,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { ast::ItemStruct(..) => { let generics = &ty::lookup_item_type(tcx, did).generics; let struct_fields = ty::lookup_struct_fields(tcx, did); - for field_info in struct_fields.iter() { + for field_info in &struct_fields { assert_eq!(field_info.id.krate, ast::LOCAL_CRATE); let field_ty = ty::node_id_to_type(tcx, field_info.id.node); self.add_constraints_from_ty(generics, field_ty, self.covariant); @@ -522,7 +522,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { ast::ItemTrait(..) => { let trait_items = ty::trait_items(tcx, did); - for trait_item in trait_items.iter() { + for trait_item in &*trait_items { match *trait_item { ty::MethodTraitItem(ref method) => { self.add_constraints_from_sig(&method.generics, @@ -759,7 +759,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } ty::ty_tup(ref subtys) => { - for &subty in subtys.iter() { + for &subty in subtys { self.add_constraints_from_ty(generics, subty, variance); } } @@ -821,7 +821,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { let projections = data.projection_bounds_with_self_ty(self.tcx(), self.tcx().types.err); - for projection in projections.iter() { + for projection in &projections { self.add_constraints_from_ty(generics, projection.0.ty, self.invariant); } } @@ -866,7 +866,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance: VarianceTermPtr<'a>) { debug!("add_constraints_from_substs(def_id={:?})", def_id); - for p in type_param_defs.iter() { + for p in type_param_defs { let variance_decl = self.declared_variance(p.def_id, def_id, TypeParam, p.space, p.index as uint); @@ -875,7 +875,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.add_constraints_from_ty(generics, substs_ty, variance_i); } - for p in region_param_defs.iter() { + for p in region_param_defs { let variance_decl = self.declared_variance(p.def_id, def_id, RegionParam, p.space, p.index as uint); @@ -892,7 +892,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { sig: &ty::PolyFnSig<'tcx>, variance: VarianceTermPtr<'a>) { let contra = self.contravariant(variance); - for &input in sig.0.inputs.iter() { + for &input in &sig.0.inputs { self.add_constraints_from_ty(generics, input, contra); } if let ty::FnConverging(result_type) = sig.0.output { @@ -990,7 +990,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { while changed { changed = false; - for constraint in self.constraints.iter() { + for constraint in &self.constraints { let Constraint { inferred, variance: term } = *constraint; let InferredIndex(inferred) = inferred; let variance = self.evaluate(term); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index d5c03879438..b140e26e037 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -254,7 +254,7 @@ impl Item { /// Finds the `doc` attribute as a List and returns the list of attributes /// nested inside. pub fn doc_list<'a>(&'a self) -> Option<&'a [Attribute]> { - for attr in self.attrs.iter() { + for attr in &self.attrs { match *attr { List(ref x, ref list) if "doc" == *x => { return Some(list.as_slice()); @@ -268,7 +268,7 @@ impl Item { /// Finds the `doc` attribute as a NameValue and returns the corresponding /// value found. pub fn doc_value<'a>(&'a self) -> Option<&'a str> { - for attr in self.attrs.iter() { + for attr in &self.attrs { match *attr { NameValue(ref x, ref v) if "doc" == *x => { return Some(v.as_slice()); @@ -281,8 +281,8 @@ impl Item { pub fn is_hidden_from_doc(&self) -> bool { match self.doc_list() { - Some(ref l) => { - for innerattr in l.iter() { + Some(l) => { + for innerattr in l { match *innerattr { Word(ref s) if "hidden" == *s => { return true @@ -508,12 +508,12 @@ impl<'tcx> Clean<(Vec, Vec)> for ty::ExistentialBound fn clean(&self, cx: &DocContext) -> (Vec, Vec) { let mut tp_bounds = vec![]; self.region_bound.clean(cx).map(|b| tp_bounds.push(RegionBound(b))); - for bb in self.builtin_bounds.iter() { + for bb in &self.builtin_bounds { tp_bounds.push(bb.clean(cx)); } let mut bindings = vec![]; - for &ty::Binder(ref pb) in self.projection_bounds.iter() { + for &ty::Binder(ref pb) in &self.projection_bounds { bindings.push(TypeBinding { name: pb.projection_ty.item_name.clean(cx), ty: pb.ty.clean(cx) @@ -636,10 +636,10 @@ impl<'tcx> Clean for ty::TraitRef<'tcx> { // collect any late bound regions let mut late_bounds = vec![]; - for &ty_s in self.substs.types.get_slice(ParamSpace::TypeSpace).iter() { + for &ty_s in self.substs.types.get_slice(ParamSpace::TypeSpace) { use rustc::middle::ty::{Region, sty}; if let sty::ty_tup(ref ts) = ty_s.sty { - for &ty_s in ts.iter() { + for &ty_s in ts { if let sty::ty_rptr(ref reg, _) = ty_s.sty { if let &Region::ReLateBound(_, _) = *reg { debug!(" hit an ReLateBound {:?}", reg); @@ -662,7 +662,7 @@ impl<'tcx> Clean for ty::TraitRef<'tcx> { impl<'tcx> Clean> for ty::ParamBounds<'tcx> { fn clean(&self, cx: &DocContext) -> Vec { let mut v = Vec::new(); - for t in self.trait_bounds.iter() { + for t in &self.trait_bounds { v.push(t.clean(cx)); } for r in self.region_bounds.iter().filter_map(|r| r.clean(cx)) { @@ -872,7 +872,7 @@ impl<'a, 'tcx> Clean for (&'a ty::Generics<'tcx>, subst::ParamSpace) { Some(did) => did, None => return false }; - for bound in bounds.iter() { + for bound in bounds { if let TyParamBound::TraitBound(PolyTrait { trait_: Type::ResolvedPath { did, .. }, .. }, TBM::None) = *bound { @@ -915,7 +915,7 @@ impl<'a, 'tcx> Clean for (&'a ty::Generics<'tcx>, subst::ParamSpace) { }).collect::>(); // Finally, run through the type parameters again and insert a ?Sized unbound for // any we didn't find to be Sized. - for tp in stripped_typarams.iter() { + for tp in &stripped_typarams { if !sized_params.contains(&tp.name) { let mut sized_bound = ty::BuiltinBound::BoundSized.clean(cx); if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound { @@ -1420,12 +1420,12 @@ impl PrimitiveType { } fn find(attrs: &[Attribute]) -> Option { - for attr in attrs.iter() { + for attr in attrs { let list = match *attr { List(ref k, ref l) if *k == "doc" => l, _ => continue, }; - for sub_attr in list.iter() { + for sub_attr in list { let value = match *sub_attr { NameValue(ref k, ref v) if *k == "primitive" => v.as_slice(), @@ -2175,7 +2175,7 @@ impl Clean> for doctree::Import { let mut ret = vec![]; let remaining = if !denied { let mut remaining = vec![]; - for path in list.iter() { + for path in list { match inline::try_inline(cx, path.node.id(), None) { Some(items) => { ret.extend(items.into_iter()); diff --git a/src/librustdoc/externalfiles.rs b/src/librustdoc/externalfiles.rs index 79ca24a18d4..84e88158219 100644 --- a/src/librustdoc/externalfiles.rs +++ b/src/librustdoc/externalfiles.rs @@ -62,7 +62,7 @@ macro_rules! load_or_return { pub fn load_external_files(names: &[String]) -> Option { let mut out = String::new(); - for name in names.iter() { + for name in names { out.push_str(load_or_return!(name.as_slice(), None, None).as_slice()); out.push('\n'); } diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index eb7402b67c4..e86c0e39714 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -212,21 +212,21 @@ impl fmt::Display for clean::PathParameters { if lifetimes.len() > 0 || types.len() > 0 || bindings.len() > 0 { try!(f.write_str("<")); let mut comma = false; - for lifetime in lifetimes.iter() { + for lifetime in lifetimes { if comma { try!(f.write_str(", ")); } comma = true; try!(write!(f, "{}", *lifetime)); } - for ty in types.iter() { + for ty in types { if comma { try!(f.write_str(", ")); } comma = true; try!(write!(f, "{}", *ty)); } - for binding in bindings.iter() { + for binding in bindings { if comma { try!(f.write_str(", ")); } @@ -239,7 +239,7 @@ impl fmt::Display for clean::PathParameters { clean::PathParameters::Parenthesized { ref inputs, ref output } => { try!(f.write_str("(")); let mut comma = false; - for ty in inputs.iter() { + for ty in inputs { if comma { try!(f.write_str(", ")); } @@ -332,7 +332,7 @@ fn path(w: &mut fmt::Formatter, match rel_root { Some(root) => { let mut root = String::from_str(root.as_slice()); - for seg in path.segments[..amt].iter() { + for seg in &path.segments[..amt] { if "super" == seg.name || "self" == seg.name { try!(write!(w, "{}::", seg.name)); @@ -347,7 +347,7 @@ fn path(w: &mut fmt::Formatter, } } None => { - for seg in path.segments[..amt].iter() { + for seg in &path.segments[..amt] { try!(write!(w, "{}::", seg.name)); } } @@ -359,7 +359,7 @@ fn path(w: &mut fmt::Formatter, Some((ref fqp, shortty)) if abs_root.is_some() => { let mut url = String::from_str(abs_root.unwrap().as_slice()); let to_link = &fqp[..fqp.len() - 1]; - for component in to_link.iter() { + for component in to_link { url.push_str(component.as_slice()); url.push_str("/"); } @@ -440,7 +440,7 @@ fn tybounds(w: &mut fmt::Formatter, typarams: &Option >) -> fmt::Result { match *typarams { Some(ref params) => { - for param in params.iter() { + for param in params { try!(write!(w, " + ")); try!(write!(w, "{}", *param)); } @@ -770,7 +770,7 @@ impl fmt::Display for ModuleSummary { (100 * cnt.unmarked) as f64/tot as f64)); try!(write!(f, "")); - for submodule in m.submodules.iter() { + for submodule in &m.submodules { try!(fmt_inner(f, context, submodule)); } context.pop(); diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 8a007fb035e..20ba0bb9e90 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -283,7 +283,7 @@ pub fn run(mut krate: clean::Crate, let default: &[_] = &[]; match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(default)) { Some(attrs) => { - for attr in attrs.iter() { + for attr in attrs { match *attr { clean::NameValue(ref x, ref s) if "html_favicon_url" == *x => { @@ -353,7 +353,7 @@ pub fn run(mut krate: clean::Crate, krate = cache.fold_crate(krate); // Cache where all our extern crates are located - for &(n, ref e) in krate.externs.iter() { + for &(n, ref e) in &krate.externs { cache.extern_locations.insert(n, extern_location(e, &cx.dst)); let did = ast::DefId { krate: n, node: ast::CRATE_NODE_ID }; cache.paths.insert(did, (vec![e.name.to_string()], ItemType::Module)); @@ -364,11 +364,11 @@ pub fn run(mut krate: clean::Crate, // Favor linking to as local extern as possible, so iterate all crates in // reverse topological order. for &(n, ref e) in krate.externs.iter().rev() { - for &prim in e.primitives.iter() { + for &prim in &e.primitives { cache.primitive_locations.insert(prim, n); } } - for &prim in krate.primitives.iter() { + for &prim in &krate.primitives { cache.primitive_locations.insert(prim, ast::LOCAL_CRATE); } @@ -402,7 +402,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> old_io::IoResult { @@ -420,7 +420,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> old_io::IoResult { if !nodeid_to_pathid.contains_key(&nodeid) { @@ -542,7 +542,7 @@ fn write_shared(cx: &Context, let mut w = try!(File::create(&dst)); try!(writeln!(&mut w, "var searchIndex = {{}};")); try!(writeln!(&mut w, "{}", search_index)); - for index in all_indexes.iter() { + for index in &all_indexes { try!(writeln!(&mut w, "{}", *index)); } try!(writeln!(&mut w, "initSearch(searchIndex);")); @@ -550,7 +550,7 @@ fn write_shared(cx: &Context, // Update the list of all implementors for traits let dst = cx.dst.join("implementors"); try!(mkdir(&dst)); - for (&did, imps) in cache.implementors.iter() { + for (&did, imps) in &cache.implementors { // Private modules can leak through to this phase of rustdoc, which // could contain implementations for otherwise private types. In some // rare cases we could find an implementation for an item which wasn't @@ -564,7 +564,7 @@ fn write_shared(cx: &Context, }; let mut mydst = dst.clone(); - for part in remote_path[..remote_path.len() - 1].iter() { + for part in &remote_path[..remote_path.len() - 1] { mydst.push(part.as_slice()); try!(mkdir(&mydst)); } @@ -578,12 +578,12 @@ fn write_shared(cx: &Context, let mut f = BufferedWriter::new(try!(File::create(&mydst))); try!(writeln!(&mut f, "(function() {{var implementors = {{}};")); - for implementor in all_implementors.iter() { + for implementor in &all_implementors { try!(write!(&mut f, "{}", *implementor)); } try!(write!(&mut f, r"implementors['{}'] = [", krate.name)); - for imp in imps.iter() { + for imp in imps { // If the trait and implementation are in the same crate, then // there's no need to emit information about it (there's inlining // going on). If they're in different crates then the crate defining @@ -679,10 +679,10 @@ fn extern_location(e: &clean::ExternalCrate, dst: &Path) -> ExternalLocation { // Failing that, see if there's an attribute specifying where to find this // external crate - for attr in e.attrs.iter() { + for attr in &e.attrs { match *attr { clean::List(ref x, ref list) if "doc" == *x => { - for attr in list.iter() { + for attr in list { match *attr { clean::NameValue(ref x, ref s) if "html_root_url" == *x => { @@ -1043,7 +1043,7 @@ impl DocFolder for Cache { impl<'a> Cache { fn generics(&mut self, generics: &clean::Generics) { - for typ in generics.type_params.iter() { + for typ in &generics.type_params { self.typarams.insert(typ.did, typ.name.clone()); } } @@ -1190,7 +1190,7 @@ impl Context { .collect::(); match cache().paths.get(&it.def_id) { Some(&(ref names, _)) => { - for name in (&names[..names.len() - 1]).iter() { + for name in &names[..names.len() - 1] { url.push_str(name.as_slice()); url.push_str("/"); } @@ -1252,7 +1252,7 @@ impl Context { fn build_sidebar(&self, m: &clean::Module) -> HashMap> { let mut map = HashMap::new(); - for item in m.items.iter() { + for item in &m.items { if self.ignore_private_item(item) { continue } // avoid putting foreign items to the sidebar. @@ -1536,7 +1536,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, debug!("{:?}", indices); let mut curty = None; - for &idx in indices.iter() { + for &idx in &indices { let myitem = &items[idx]; let myty = Some(shortty(myitem)); @@ -1696,7 +1696,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, try!(write!(w, "{{ }}")); } else { try!(write!(w, "{{\n")); - for t in types.iter() { + for t in &types { try!(write!(w, " ")); try!(render_method(w, t.item())); try!(write!(w, ";\n")); @@ -1704,7 +1704,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, if types.len() > 0 && required.len() > 0 { try!(w.write_str("\n")); } - for m in required.iter() { + for m in &required { try!(write!(w, " ")); try!(render_method(w, m.item())); try!(write!(w, ";\n")); @@ -1712,7 +1712,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, if required.len() > 0 && provided.len() > 0 { try!(w.write_str("\n")); } - for m in provided.iter() { + for m in &provided { try!(write!(w, " ")); try!(render_method(w, m.item())); try!(write!(w, " {{ ... }}\n")); @@ -1741,7 +1741,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,

Associated Types

")); - for t in types.iter() { + for t in &types { try!(trait_item(w, *t)); } try!(write!(w, "
")); @@ -1753,7 +1753,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,

Required Methods

")); - for m in required.iter() { + for m in &required { try!(trait_item(w, *m)); } try!(write!(w, "
")); @@ -1763,7 +1763,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,

Provided Methods

")); - for m in provided.iter() { + for m in &provided { try!(trait_item(w, *m)); } try!(write!(w, "
")); @@ -1776,7 +1776,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, ")); match cache.implementors.get(&it.def_id) { Some(implementors) => { - for i in implementors.iter() { + for i in implementors { try!(writeln!(w, "
  • {}impl{} {} for {}{}
    • ", ConciseStability(&i.stability), i.generics, i.trait_, i.for_, WhereClause(&i.generics))); @@ -1890,7 +1890,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, try!(write!(w, " {{}}")); } else { try!(write!(w, " {{\n")); - for v in e.variants.iter() { + for v in &e.variants { try!(write!(w, " ")); let name = v.name.as_ref().unwrap().as_slice(); match v.inner { @@ -1933,7 +1933,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, try!(document(w, it)); if e.variants.len() > 0 { try!(write!(w, "

    Variants

    \n")); - for variant in e.variants.iter() { + for variant in &e.variants { try!(write!(w, "
    {stab}{name}", stab = ConciseStability(&variant.stability), name = variant.name.as_ref().unwrap().as_slice())); @@ -1996,7 +1996,7 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item, doctree::Plain => { try!(write!(w, " {{\n{}", tab)); let mut fields_stripped = false; - for field in fields.iter() { + for field in fields { match field.inner { clean::StructFieldItem(clean::HiddenStructField) => { fields_stripped = true; @@ -2049,7 +2049,7 @@ fn render_methods(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result { .partition(|i| i.impl_.trait_.is_none()); if non_trait.len() > 0 { try!(write!(w, "

    Methods

    ")); - for i in non_trait.iter() { + for i in &non_trait { try!(render_impl(w, i)); } } @@ -2058,13 +2058,13 @@ fn render_methods(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result { Implementations")); let (derived, manual): (Vec<_>, _) = traits.into_iter() .partition(|i| i.impl_.derived); - for i in manual.iter() { + for i in &manual { try!(render_impl(w, i)); } if derived.len() > 0 { try!(write!(w, "

    Derived Implementations \

    ")); - for i in derived.iter() { + for i in &derived { try!(render_impl(w, i)); } } @@ -2137,14 +2137,14 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result { } try!(write!(w, "
    ")); - for trait_item in i.impl_.items.iter() { + for trait_item in &i.impl_.items { try!(doctraititem(w, trait_item, true)); } fn render_default_methods(w: &mut fmt::Formatter, t: &clean::Trait, i: &clean::Impl) -> fmt::Result { - for trait_item in t.items.iter() { + for trait_item in &t.items { let n = trait_item.item().name.clone(); match i.items.iter().find(|m| { m.name == n }) { Some(..) => continue, @@ -2209,7 +2209,7 @@ impl<'a> fmt::Display for Sidebar<'a> { None => return Ok(()) }; try!(write!(w, "

    {}

    ", short, longty)); - for &NameDoc(ref name, ref doc) in items.iter() { + for &NameDoc(ref name, ref doc) in items { let curty = shortty(cur).to_static_str(); let class = if cur.name.as_ref().unwrap() == name && short == curty { "current" } else { "" }; diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs index 9143baf9ed9..7790c7d6a50 100644 --- a/src/librustdoc/html/toc.rs +++ b/src/librustdoc/html/toc.rs @@ -185,7 +185,7 @@ impl fmt::Debug for Toc { impl fmt::Display for Toc { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "