---

yaml
---
r: 130844
b: refs/heads/auto
c: 61414a9
h: refs/heads/master
v: v3

Author: inrustwetrust

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: d7502ac2d6c64958be672991c33a1404ea5f040e
+refs/heads/auto: 61414a985004a8948be8d01de11f4e55ef0dbad4
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libcore/num/mod.rs

@@ -406,7 +406,7 @@ pub trait Int: Primitive
     ///
     /// assert_eq!(n.count_ones(), 3);
     /// ```
-    fn count_ones(self) -> uint;
+    fn count_ones(self) -> Self;
 
     /// Returns the number of zeros in the binary representation of the integer.
     ///
@@ -418,7 +418,7 @@ pub trait Int: Primitive
     /// assert_eq!(n.count_zeros(), 5);
     /// ```
     #[inline]
-    fn count_zeros(self) -> uint {
+    fn count_zeros(self) -> Self {
         (!self).count_ones()
     }
 
@@ -432,7 +432,7 @@ pub trait Int: Primitive
     ///
     /// assert_eq!(n.leading_zeros(), 10);
     /// ```
-    fn leading_zeros(self) -> uint;
+    fn leading_zeros(self) -> Self;
 
     /// Returns the number of trailing zeros in the binary representation
     /// of the integer.
@@ -444,7 +444,7 @@ pub trait Int: Primitive
     ///
     /// assert_eq!(n.trailing_zeros(), 3);
     /// ```
-    fn trailing_zeros(self) -> uint;
+    fn trailing_zeros(self) -> Self;
 
     /// Shifts the bits to the left by a specified amount amount, `n`, wrapping
     /// the truncated bits to the end of the resulting integer.
@@ -569,13 +569,13 @@ macro_rules! int_impl {
     ($T:ty, $BITS:expr, $ctpop:path, $ctlz:path, $cttz:path, $bswap:path) => {
         impl Int for $T {
             #[inline]
-            fn count_ones(self) -> uint { unsafe { $ctpop(self) as uint } }
+            fn count_ones(self) -> $T { unsafe { $ctpop(self) } }
 
             #[inline]
-            fn leading_zeros(self) -> uint { unsafe { $ctlz(self) as uint } }
+            fn leading_zeros(self) -> $T { unsafe { $ctlz(self) } }
 
             #[inline]
-            fn trailing_zeros(self) -> uint { unsafe { $cttz(self) as uint } }
+            fn trailing_zeros(self) -> $T { unsafe { $cttz(self) } }
 
             #[inline]
             fn rotate_left(self, n: uint) -> $T {
@@ -629,13 +629,13 @@ macro_rules! int_cast_impl {
     ($T:ty, $U:ty) => {
         impl Int for $T {
             #[inline]
-            fn count_ones(self) -> uint { (self as $U).count_ones() }
+            fn count_ones(self) -> $T { (self as $U).count_ones() as $T }
 
             #[inline]
-            fn leading_zeros(self) -> uint { (self as $U).leading_zeros() }
+            fn leading_zeros(self) -> $T { (self as $U).leading_zeros() as $T }
 
             #[inline]
-            fn trailing_zeros(self) -> uint { (self as $U).trailing_zeros() }
+            fn trailing_zeros(self) -> $T { (self as $U).trailing_zeros() as $T }
 
             #[inline]
             fn rotate_left(self, n: uint) -> $T { (self as $U).rotate_left(n) as $T }

branches/auto/src/libcoretest/num/int_macros.rs

@@ -95,9 +95,9 @@ mod tests {
 
     #[test]
     fn test_count_zeros() {
-        assert!(A.count_zeros() == BITS - 3);
-        assert!(B.count_zeros() == BITS - 2);
-        assert!(C.count_zeros() == BITS - 5);
+        assert!(A.count_zeros() == BITS as $T - 3);
+        assert!(B.count_zeros() == BITS as $T - 2);
+        assert!(C.count_zeros() == BITS as $T - 5);
     }
 
     #[test]

branches/auto/src/libcoretest/num/uint_macros.rs

@@ -55,9 +55,9 @@ mod tests {
 
     #[test]
     fn test_count_zeros() {
-        assert!(A.count_zeros() == BITS - 3);
-        assert!(B.count_zeros() == BITS - 2);
-        assert!(C.count_zeros() == BITS - 5);
+        assert!(A.count_zeros() == BITS as $T - 3);
+        assert!(B.count_zeros() == BITS as $T - 2);
+        assert!(C.count_zeros() == BITS as $T - 5);
     }
 
     #[test]

branches/auto/src/liblibc/lib.rs

@@ -249,7 +249,7 @@ pub use funcs::bsd43::{shutdown};
 #[cfg(windows)] pub use types::os::arch::extra::{LARGE_INTEGER, LPVOID, LONG};
 #[cfg(windows)] pub use types::os::arch::extra::{time64_t, OVERLAPPED, LPCWSTR};
 #[cfg(windows)] pub use types::os::arch::extra::{LPOVERLAPPED, SIZE_T, LPDWORD};
-#[cfg(windows)] pub use types::os::arch::extra::{SECURITY_ATTRIBUTES, WIN32_FIND_DATAW};
+#[cfg(windows)] pub use types::os::arch::extra::{SECURITY_ATTRIBUTES};
 #[cfg(windows)] pub use funcs::c95::string::{wcslen};
 #[cfg(windows)] pub use funcs::posix88::stat_::{wstat, wutime, wchmod, wrmdir};
 #[cfg(windows)] pub use funcs::bsd43::{closesocket};
@@ -1638,22 +1638,6 @@ pub mod types {
                 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;
 
                 pub type GROUP = c_uint;
-
-                #[repr(C)]
-                pub struct WIN32_FIND_DATAW {
-                    pub dwFileAttributes: DWORD,
-                    pub ftCreationTime: FILETIME,
-                    pub ftLastAccessTime: FILETIME,
-                    pub ftLastWriteTime: FILETIME,
-                    pub nFileSizeHigh: DWORD,
-                    pub nFileSizeLow: DWORD,
-                    pub dwReserved0: DWORD,
-                    pub dwReserved1: DWORD,
-                    pub cFileName: [wchar_t, ..260], // #define MAX_PATH 260
-                    pub cAlternateFileName: [wchar_t, ..14],
-                }
-
-                pub type LPWIN32_FIND_DATAW = *mut WIN32_FIND_DATAW;
             }
         }
     }
@@ -4779,7 +4763,7 @@ pub mod funcs {
                                                LPMEMORY_BASIC_INFORMATION,
                                                LPSYSTEM_INFO, HANDLE, LPHANDLE,
                                                LARGE_INTEGER, PLARGE_INTEGER,
-                                               LPFILETIME, LPWIN32_FIND_DATAW};
+                                               LPFILETIME};
 
             extern "system" {
                 pub fn GetEnvironmentVariableW(n: LPCWSTR,
@@ -4809,9 +4793,9 @@ pub mod funcs {
                                             -> DWORD;
                 pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
                 pub fn GetLastError() -> DWORD;
-                pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW)
+                pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: HANDLE)
                                       -> HANDLE;
-                pub fn FindNextFileW(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW)
+                pub fn FindNextFileW(findFile: HANDLE, findFileData: HANDLE)
                                      -> BOOL;
                 pub fn FindClose(findFile: HANDLE) -> BOOL;
                 pub fn DuplicateHandle(hSourceProcessHandle: HANDLE,

branches/auto/src/libnative/io/file_windows.rs

@@ -11,14 +11,16 @@
 //! Blocking Windows-based file I/O
 
 use alloc::arc::Arc;
-use libc::{mod, c_int};
+use libc::{c_int, c_void};
+use libc;
 use std::c_str::CString;
 use std::mem;
 use std::os::windows::fill_utf16_buf_and_decode;
 use std::ptr;
 use std::rt::rtio;
 use std::rt::rtio::{IoResult, IoError};
 use std::str;
+use std::vec;
 
 pub type fd_t = libc::c_int;
 
@@ -342,6 +344,8 @@ pub fn mkdir(p: &CString, _mode: uint) -> IoResult<()> {
 }
 
 pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
+    use std::rt::libc_heap::malloc_raw;
+
     fn prune(root: &CString, dirs: Vec<Path>) -> Vec<CString> {
         let root = unsafe { CString::new(root.as_ptr(), false) };
         let root = Path::new(root);
@@ -351,35 +355,38 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
         }).map(|path| root.join(path).to_c_str()).collect()
     }
 
+    extern {
+        fn rust_list_dir_wfd_size() -> libc::size_t;
+        fn rust_list_dir_wfd_fp_buf(wfd: *mut libc::c_void) -> *const u16;
+    }
     let star = Path::new(unsafe {
         CString::new(p.as_ptr(), false)
     }).join("*");
     let path = try!(to_utf16(&star.to_c_str()));
 
     unsafe {
-        let mut wfd = mem::zeroed();
-        let find_handle = libc::FindFirstFileW(path.as_ptr(), &mut wfd);
+        let wfd_ptr = malloc_raw(rust_list_dir_wfd_size() as uint);
+        let find_handle = libc::FindFirstFileW(path.as_ptr(),
+                                               wfd_ptr as libc::HANDLE);
         if find_handle != libc::INVALID_HANDLE_VALUE {
-            let mut paths = vec![];
-            let mut more_files = 1 as libc::BOOL;
+            let mut paths = vec!();
+            let mut more_files = 1 as libc::c_int;
             while more_files != 0 {
-                {
-                    let filename = str::truncate_utf16_at_nul(wfd.cFileName);
-                    match String::from_utf16(filename) {
-                        Some(filename) => paths.push(Path::new(filename)),
-                        None => {
-                            assert!(libc::FindClose(find_handle) != 0);
-                            return Err(IoError {
-                                code: super::c::ERROR_ILLEGAL_CHARACTER as uint,
-                                extra: 0,
-                                detail: Some(format!("path was not valid UTF-16: {}", filename)),
-                            })
-                        }, // FIXME #12056: Convert the UCS-2 to invalid utf-8 instead of erroring
-                    }
+                let fp_buf = rust_list_dir_wfd_fp_buf(wfd_ptr as *mut c_void);
+                if fp_buf as uint == 0 {
+                    fail!("os::list_dir() failure: got null ptr from wfd");
+                } else {
+                    let fp_vec = vec::raw::from_buf(fp_buf, libc::wcslen(fp_buf) as uint);
+                    let fp_trimmed = str::truncate_utf16_at_nul(fp_vec.as_slice());
+                    let fp_str = String::from_utf16(fp_trimmed)
+                            .expect("rust_list_dir_wfd_fp_buf returned invalid UTF-16");
+                    paths.push(Path::new(fp_str));
                 }
-                more_files = libc::FindNextFileW(find_handle, &mut wfd);
+                more_files = libc::FindNextFileW(find_handle,
+                                                 wfd_ptr as libc::HANDLE);
             }
             assert!(libc::FindClose(find_handle) != 0);
+            libc::free(wfd_ptr as *mut c_void);
             Ok(prune(p, paths))
         } else {
             Err(super::last_error())

branches/auto/src/libnum/bigint.rs

@@ -807,7 +807,7 @@ impl BigUint {
     pub fn bits(&self) -> uint {
         if self.is_zero() { return 0; }
         let zeros = self.data.last().unwrap().leading_zeros();
-        return self.data.len()*BigDigit::bits - zeros;
+        return self.data.len()*BigDigit::bits - (zeros as uint);
     }
 }
 

branches/auto/src/librustc/back/link.rs

@@ -28,7 +28,6 @@ use util::ppaux;
 use util::sha2::{Digest, Sha256};
 
 use std::char;
-use std::collections::HashSet;
 use std::io::{fs, TempDir, Command};
 use std::io;
 use std::mem;
@@ -570,10 +569,7 @@ fn link_binary_output(sess: &Session,
 fn archive_search_paths(sess: &Session) -> Vec<Path> {
     let mut rustpath = filesearch::rust_path();
     rustpath.push(sess.target_filesearch().get_lib_path());
-    // FIXME: Addl lib search paths are an unordered HashSet?
-    // Shouldn't this search be done in some order?
-    let addl_lib_paths: HashSet<Path> = sess.opts.addl_lib_search_paths.borrow().clone();
-    let mut search: Vec<Path> = addl_lib_paths.move_iter().collect();
+    let mut search: Vec<Path> = sess.opts.addl_lib_search_paths.borrow().clone();
     search.push_all(rustpath.as_slice());
     return search;
 }

branches/auto/src/librustc/driver/config.rs

@@ -30,7 +30,7 @@ use syntax::diagnostic::{ColorConfig, Auto, Always, Never};
 use syntax::parse;
 use syntax::parse::token::InternedString;
 
-use std::collections::{HashSet, HashMap};
+use std::collections::HashMap;
 use getopts::{optopt, optmulti, optflag, optflagopt};
 use getopts;
 use std::cell::{RefCell};
@@ -76,7 +76,7 @@ pub struct Options {
     // This was mutable for rustpkg, which updates search paths based on the
     // parsed code. It remains mutable in case its replacements wants to use
     // this.
-    pub addl_lib_search_paths: RefCell<HashSet<Path>>,
+    pub addl_lib_search_paths: RefCell<Vec<Path>>,
     pub maybe_sysroot: Option<Path>,
     pub target_triple: String,
     // User-specified cfg meta items. The compiler itself will add additional
@@ -113,7 +113,7 @@ pub fn basic_options() -> Options {
         lint_opts: Vec::new(),
         describe_lints: false,
         output_types: Vec::new(),
-        addl_lib_search_paths: RefCell::new(HashSet::new()),
+        addl_lib_search_paths: RefCell::new(Vec::new()),
         maybe_sysroot: None,
         target_triple: driver::host_triple().to_string(),
         cfg: Vec::new(),

branches/auto/src/librustc/metadata/filesearch.rs

@@ -30,7 +30,7 @@ pub type pick<'a> = |path: &Path|: 'a -> FileMatch;
 
 pub struct FileSearch<'a> {
     pub sysroot: &'a Path,
-    pub addl_lib_search_paths: &'a RefCell<HashSet<Path>>,
+    pub addl_lib_search_paths: &'a RefCell<Vec<Path>>,
     pub triple: &'a str,
 }
 
@@ -125,7 +125,7 @@ impl<'a> FileSearch<'a> {
 
     pub fn new(sysroot: &'a Path,
                triple: &'a str,
-               addl_lib_search_paths: &'a RefCell<HashSet<Path>>) -> FileSearch<'a> {
+               addl_lib_search_paths: &'a RefCell<Vec<Path>>) -> FileSearch<'a> {
         debug!("using sysroot = {}, triple = {}", sysroot.display(), triple);
         FileSearch {
             sysroot: sysroot,

branches/auto/src/librustdoc/core.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -80,7 +80,7 @@ pub struct CrateAnalysis {
 pub type Externs = HashMap<String, Vec<String>>;
 
 /// Parses, resolves, and typechecks the given crate
-fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<String>,
+fn get_ast_and_resolve(cpath: &Path, libs: Vec<Path>, cfgs: Vec<String>,
                        externs: Externs, triple: Option<String>)
                        -> (DocContext, CrateAnalysis) {
     use syntax::codemap::dummy_spanned;
@@ -153,7 +153,7 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<String>,
     })
 }
 
-pub fn run_core(libs: HashSet<Path>, cfgs: Vec<String>, externs: Externs,
+pub fn run_core(libs: Vec<Path>, cfgs: Vec<String>, externs: Externs,
                 path: &Path, triple: Option<String>)
                 -> (clean::Crate, CrateAnalysis) {
     let (ctxt, analysis) = get_ast_and_resolve(path, libs, cfgs, externs, triple);

branches/auto/src/librustdoc/lib.rs

@@ -369,11 +369,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche
     info!("starting to run rustc");
     let (mut krate, analysis) = std::task::try(proc() {
         let cr = cr;
-        core::run_core(libs.move_iter().collect(),
-                       cfgs,
-                       externs,
-                       &cr,
-                       triple)
+        core::run_core(libs, cfgs, externs, &cr, triple)
     }).map_err(|boxed_any|format!("{:?}", boxed_any)).unwrap();
     info!("finished with rustc");
     analysiskey.replace(Some(analysis));

branches/auto/src/librustdoc/markdown.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::HashSet;
 use std::io;
 use std::string::String;
 
@@ -136,7 +135,7 @@ pub fn render(input: &str, mut output: Path, matches: &getopts::Matches,
 }
 
 /// Run any tests/code examples in the markdown file `input`.
-pub fn test(input: &str, libs: HashSet<Path>, externs: core::Externs,
+pub fn test(input: &str, libs: Vec<Path>, externs: core::Externs,
             mut test_args: Vec<String>) -> int {
     let input_str = load_or_return!(input, 1, 2);