---

yaml
---
r: 130231
b: refs/heads/master
c: 9e82fc7
h: refs/heads/master
i:
  130229: f214537
  130227: 0477602
  130223: 2fb5c3e
v: v3

Author: nodakai

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6eabd85265e18b47942dac7cf3f258e38d9d9f2e
+refs/heads/master: 9e82fc7ef9b6c8a344dd27583990b02a661af78c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
 refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0

trunk/src/compiletest/runtest.rs

@@ -1577,6 +1577,10 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
 
 // codegen tests (vs. clang)
 
+fn make_o_name(config: &Config, testfile: &Path) -> Path {
+    output_base_name(config, testfile).with_extension("o")
+}
+
 fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
     if suffix.len() == 0 {
         (*p).clone()
@@ -1592,13 +1596,14 @@ fn compile_test_and_save_bitcode(config: &Config, props: &TestProps,
     // FIXME (#9639): This needs to handle non-utf8 paths
     let link_args = vec!("-L".to_string(),
                          aux_dir.as_str().unwrap().to_string());
-    let llvm_args = vec!("--emit=bc,obj".to_string(),
-                         "--crate-type=lib".to_string());
+    let llvm_args = vec!("--emit=obj".to_string(),
+                         "--crate-type=lib".to_string(),
+                         "-C".to_string(),
+                         "save-temps".to_string());
     let args = make_compile_args(config,
                                  props,
                                  link_args.append(llvm_args.as_slice()),
-                                 |a, b| ThisDirectory(output_base_name(a, b).dir_path()),
-                                 testfile);
+                                 |a, b| ThisFile(make_o_name(a, b)), testfile);
     compose_and_run_compiler(config, props, testfile, args, None)
 }
 

trunk/src/doc/rust.md

@@ -2221,8 +2221,8 @@ These types help drive the compiler's analysis
   : This type does not implement "copy", even if eligible
 * `no_send_bound`
   : This type does not implement "send", even if eligible
-* `no_sync_bound`
-  : This type does not implement "sync", even if eligible
+* `no_share_bound`
+  : This type does not implement "share", even if eligible
 * `eh_personality`
   : ___Needs filling in___
 * `exchange_free`

trunk/src/driver/driver.rs

@@ -9,9 +9,9 @@
 // except according to those terms.
 
 #[cfg(rustdoc)]
-extern crate "rustdoc" as this;
+extern crate this = "rustdoc";
 
 #[cfg(rustc)]
-extern crate "rustc" as this;
+extern crate this = "rustc";
 
 fn main() { this::main() }

trunk/src/libcollections/lib.rs

@@ -289,7 +289,7 @@ pub trait Set<T>: Collection {
 }
 
 /// A mutable collection of values which are distinct from one another that
-/// can be mutated.
+/// can be mutaed.
 pub trait MutableSet<T>: Set<T> + Mutable {
     /// Adds a value to the set. Returns `true` if the value was not already
     /// present in the set.

trunk/src/libcollections/ringbuf.rs

@@ -132,7 +132,7 @@ impl<T> RingBuf<T> {
               elts: Vec::from_fn(cmp::max(MINIMUM_CAPACITY, n), |_| None)}
     }
 
-    /// Retrieve an element in the `RingBuf` by index.
+    /// Retrieva an element in the `RingBuf` by index.
     ///
     /// Fails if there is no element with the given index.
     ///

trunk/src/libcollections/slice.rs

@@ -96,7 +96,7 @@ use vec::Vec;
 pub use core::slice::{Chunks, Slice, ImmutableSlice, ImmutablePartialEqSlice};
 pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
 pub use core::slice::{MutSplits, MutChunks, Splits};
-pub use core::slice::{bytes, mut_ref_slice, ref_slice, MutableCloneableSlice};
+pub use core::slice::{bytes, ref_slice, MutableCloneableSlice};
 pub use core::slice::{Found, NotFound};
 
 // Functional utilities

trunk/src/libcollections/smallintmap.rs

@@ -324,7 +324,7 @@ impl<V:Clone> SmallIntMap<V> {
     /// Updates a value in the map. If the key already exists in the map,
     /// modifies the value with `ff` taking `oldval, newval`.
     /// Otherwise, sets the value to `newval`.
-    /// Returns `true` if the key did not already exist in the map.
+    /// Returasn `true` if the key did not already exist in the map.
     ///
     /// # Example
     ///

trunk/src/libcollections/str.rs

@@ -44,7 +44,7 @@
 //!
 //! # Representation
 //!
-//! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as a
+//! Rust's string type, `str`, is a sequence of unicode scalar values encoded as a
 //! stream of UTF-8 bytes. All strings are guaranteed to be validly encoded UTF-8
 //! sequences. Additionally, strings are not null-terminated and can contain null
 //! bytes.

trunk/src/libcore/char.rs

@@ -201,7 +201,7 @@ pub fn escape_unicode(c: char, f: |char|) {
 /// - Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
 /// - Single-quote, double-quote and backslash chars are backslash-escaped.
 /// - Any other chars in the range [0x20,0x7e] are not escaped.
-/// - Any other chars are given hex Unicode escapes; see `escape_unicode`.
+/// - Any other chars are given hex unicode escapes; see `escape_unicode`.
 ///
 pub fn escape_default(c: char, f: |char|) {
     match c {
@@ -290,7 +290,7 @@ pub trait Char {
     /// * Single-quote, double-quote and backslash chars are backslash-
     ///   escaped.
     /// * Any other chars in the range [0x20,0x7e] are not escaped.
-    /// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
+    /// * Any other chars are given hex unicode escapes; see `escape_unicode`.
     fn escape_default(&self, f: |char|);
 
     /// Returns the amount of bytes this character would need if encoded in

trunk/src/libcore/fmt/mod.rs

@@ -461,28 +461,19 @@ impl<'a> Formatter<'a> {
         use char::Char;
         let align = match self.align {
             rt::AlignUnknown => default,
-            _ => self.align
+            rt::AlignLeft | rt::AlignRight => self.align
         };
-
-        let (pre_pad, post_pad) = match align {
-            rt::AlignLeft => (0u, padding),
-            rt::AlignRight | rt::AlignUnknown => (padding, 0u),
-            rt::AlignCenter => (padding / 2, (padding + 1) / 2),
-        };
-
+        if align == rt::AlignLeft {
+            try!(f(self));
+        }
         let mut fill = [0u8, ..4];
         let len = self.fill.encode_utf8(fill).unwrap_or(0);
-
-        for _ in range(0, pre_pad) {
+        for _ in range(0, padding) {
             try!(self.buf.write(fill.slice_to(len)));
         }
-
-        try!(f(self));
-
-        for _ in range(0, post_pad) {
-            try!(self.buf.write(fill.slice_to(len)));
+        if align == rt::AlignRight {
+            try!(f(self));
         }
-
         Ok(())
     }
 

trunk/src/libcore/fmt/rt.rs

@@ -43,8 +43,6 @@ pub enum Alignment {
     AlignLeft,
     /// Indication that contents should be right-aligned.
     AlignRight,
-    /// Indication that contents should be center-aligned.
-    AlignCenter,
     /// No alignment was requested.
     AlignUnknown,
 }

trunk/src/libcore/intrinsics.rs

@@ -311,7 +311,7 @@ extern "rust-intrinsic" {
 
     /// Gives the address for the return value of the enclosing function.
     ///
-    /// Using this intrinsic in a function that does not use an out pointer
+    /// Using this instrinsic in a function that does not use an out pointer
     /// will trigger a compiler error.
     pub fn return_address() -> *const u8;
 

trunk/src/libcore/kinds.rs

@@ -271,7 +271,7 @@ pub mod marker {
     /// A type which is considered "not sync", meaning that
     /// its contents are not threadsafe, hence they cannot be
     /// shared between tasks.
-    #[lang="no_sync_bound"]
+    #[lang="no_share_bound"]
     #[deriving(PartialEq,Clone)]
     pub struct NoSync;
 

trunk/src/libcore/str.rs

@@ -1128,7 +1128,7 @@ pub trait StrSlice<'a> {
     fn contains_char(&self, needle: char) -> bool;
 
     /// An iterator over the characters of `self`. Note, this iterates
-    /// over Unicode code-points, not Unicode graphemes.
+    /// over unicode code-points, not unicode graphemes.
     ///
     /// # Example
     ///
@@ -1505,7 +1505,7 @@ pub trait StrSlice<'a> {
     /// Pluck a character out of a string and return the index of the next
     /// character.
     ///
-    /// This function can be used to iterate over the Unicode characters of a
+    /// This function can be used to iterate over the unicode characters of a
     /// string.
     ///
     /// # Example
@@ -1549,7 +1549,7 @@ pub trait StrSlice<'a> {
     /// # Return value
     ///
     /// A record {ch: char, next: uint} containing the char value and the byte
-    /// index of the next Unicode character.
+    /// index of the next unicode character.
     ///
     /// # Failure
     ///
@@ -1559,7 +1559,7 @@ pub trait StrSlice<'a> {
 
     /// Given a byte position and a str, return the previous char and its position.
     ///
-    /// This function can be used to iterate over a Unicode string in reverse.
+    /// This function can be used to iterate over a unicode string in reverse.
     ///
     /// Returns 0 for next index if called on start index 0.
     ///

trunk/src/libfmt_macros/lib.rs

@@ -81,8 +81,6 @@ pub enum Alignment {
     AlignLeft,
     /// The value will be aligned to the right.
     AlignRight,
-    /// The value will be aligned in the center.
-    AlignCenter,
     /// The value will take on a default alignment.
     AlignUnknown,
 }
@@ -281,7 +279,7 @@ impl<'a> Parser<'a> {
         match self.cur.clone().next() {
             Some((_, c)) => {
                 match self.cur.clone().skip(1).next() {
-                    Some((_, '>')) | Some((_, '<')) | Some((_, '^')) => {
+                    Some((_, '>')) | Some((_, '<')) => {
                         spec.fill = Some(c);
                         self.cur.next();
                     }
@@ -295,8 +293,6 @@ impl<'a> Parser<'a> {
             spec.align = AlignLeft;
         } else if self.consume('>') {
             spec.align = AlignRight;
-        } else if self.consume('^') {
-            spec.align = AlignCenter;
         }
         // Sign flags
         if self.consume('+') {

trunk/src/libglob/lib.rs

@@ -680,7 +680,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME (#9406)
     fn test_lots_of_files() {
         // this is a good test because it touches lots of differently named files
         glob("/*/*/*/*").skip(10000).next();

trunk/src/liblibc/lib.rs

@@ -65,7 +65,7 @@
 * definitions common-to-all (held in modules named c95, c99, posix88, posix01
 * and posix08) and definitions that appear only on *some* platforms (named
 * 'extra'). This would be things like significant OSX foundation kit, or Windows
-* library kernel32.dll, or various fancy glibc, Linux or BSD extensions.
+* library kernel32.dll, or various fancy glibc, linux or BSD extensions.
 *
 * In addition to the per-platform 'extra' modules, we define a module of
 * 'common BSD' libc routines that never quite made it into POSIX but show up
@@ -4542,7 +4542,7 @@ pub mod funcs {
                 pub fn glob(pattern: *const c_char,
                             flags: c_int,
                             errfunc: ::Nullable<extern "C" fn(epath: *const c_char,
-                                                              errno: c_int) -> c_int>,
+                                                              errno: c_int) -> int>,
                             pglob: *mut glob_t);
                 pub fn globfree(pglob: *mut glob_t);
             }

trunk/src/libnative/io/file_unix.rs

@@ -154,7 +154,7 @@ impl rtio::RtioFileStream for FileDesc {
 
     fn fstat(&mut self) -> IoResult<rtio::FileStat> {
         let mut stat: libc::stat = unsafe { mem::zeroed() };
-        match unsafe { libc::fstat(self.fd(), &mut stat) } {
+        match retry(|| unsafe { libc::fstat(self.fd(), &mut stat) }) {
             0 => Ok(mkstat(&stat)),
             _ => Err(super::last_error()),
         }
@@ -346,7 +346,9 @@ pub fn open(path: &CString, fm: rtio::FileMode, fa: rtio::FileAccess)
 }
 
 pub fn mkdir(p: &CString, mode: uint) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::mkdir(p.as_ptr(), mode as libc::mode_t) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::mkdir(p.as_ptr(), mode as libc::mode_t)
+    }))
 }
 
 pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
@@ -391,11 +393,13 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
 }
 
 pub fn unlink(p: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::unlink(p.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe { libc::unlink(p.as_ptr()) }))
 }
 
 pub fn rename(old: &CString, new: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::rename(old.as_ptr(), new.as_ptr())
+    }))
 }
 
 pub fn chmod(p: &CString, mode: uint) -> IoResult<()> {
@@ -405,7 +409,9 @@ pub fn chmod(p: &CString, mode: uint) -> IoResult<()> {
 }
 
 pub fn rmdir(p: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::rmdir(p.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::rmdir(p.as_ptr())
+    }))
 }
 
 pub fn chown(p: &CString, uid: int, gid: int) -> IoResult<()> {
@@ -422,10 +428,10 @@ pub fn readlink(p: &CString) -> IoResult<CString> {
         len = 1024; // FIXME: read PATH_MAX from C ffi?
     }
     let mut buf: Vec<u8> = Vec::with_capacity(len as uint);
-    match unsafe {
+    match retry(|| unsafe {
         libc::readlink(p, buf.as_ptr() as *mut libc::c_char,
                        len as libc::size_t) as libc::c_int
-    } {
+    }) {
         -1 => Err(super::last_error()),
         n => {
             assert!(n > 0);
@@ -436,11 +442,15 @@ pub fn readlink(p: &CString) -> IoResult<CString> {
 }
 
 pub fn symlink(src: &CString, dst: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::symlink(src.as_ptr(), dst.as_ptr())
+    }))
 }
 
 pub fn link(src: &CString, dst: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::link(src.as_ptr(), dst.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::link(src.as_ptr(), dst.as_ptr())
+    }))
 }
 
 fn mkstat(stat: &libc::stat) -> rtio::FileStat {
@@ -479,15 +489,15 @@ fn mkstat(stat: &libc::stat) -> rtio::FileStat {
 
 pub fn stat(p: &CString) -> IoResult<rtio::FileStat> {
     let mut stat: libc::stat = unsafe { mem::zeroed() };
-    match unsafe { libc::stat(p.as_ptr(), &mut stat) } {
+    match retry(|| unsafe { libc::stat(p.as_ptr(), &mut stat) }) {
         0 => Ok(mkstat(&stat)),
         _ => Err(super::last_error()),
     }
 }
 
 pub fn lstat(p: &CString) -> IoResult<rtio::FileStat> {
     let mut stat: libc::stat = unsafe { mem::zeroed() };
-    match unsafe { libc::lstat(p.as_ptr(), &mut stat) } {
+    match retry(|| unsafe { libc::lstat(p.as_ptr(), &mut stat) }) {
         0 => Ok(mkstat(&stat)),
         _ => Err(super::last_error()),
     }
@@ -498,7 +508,9 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
         actime: (atime / 1000) as libc::time_t,
         modtime: (mtime / 1000) as libc::time_t,
     };
-    super::mkerr_libc(unsafe { libc::utime(p.as_ptr(), &buf) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::utime(p.as_ptr(), &buf)
+    }))
 }
 
 #[cfg(test)]