---

yaml
---
r: 127965
b: refs/heads/master
c: 8f16aa7
h: refs/heads/master
i:
  127963: 4edb27c
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 17bcc1b08cdfea4db272c377eca65c1155076783
+refs/heads/master: 8f16aa748c63fe86730aaa68b7e21ec05ef7b70d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: aa98b25c4f0c10729dff37c699904ad57b8fbda8
 refs/heads/try: f1778314378f8951328206626b5ddf725898e0e6

trunk/src/etc/vim/ftplugin/rust.vim

@@ -56,16 +56,6 @@ if exists("g:loaded_delimitMate")
 	let b:delimitMate_excluded_regions = delimitMate#Get("excluded_regions") . ',rustLifetimeCandidate,rustGenericLifetimeCandidate'
 endif
 
-if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
-	let b:rust_set_foldmethod=1
-	setlocal foldmethod=syntax
-	if g:rust_fold == 2
-		setlocal foldlevel<
-	else
-		setlocal foldlevel=99
-	endif
-endif
-
 if has('conceal') && exists('g:rust_conceal')
 	let b:rust_set_conceallevel=1
 	setlocal conceallevel=2
@@ -118,10 +108,6 @@ let b:undo_ftplugin = "
 		\|else
 		  \|unlet! b:delimitMate_excluded_regions
 		\|endif
-		\|if exists('b:rust_set_foldmethod')
-		  \|setlocal foldmethod< foldlevel<
-		  \|unlet b:rust_set_foldmethod
-		\|endif
 		\|if exists('b:rust_set_conceallevel')
 		  \|setlocal conceallevel<
 		  \|unlet b:rust_set_conceallevel

trunk/src/etc/vim/syntax/rust.vim

@@ -11,6 +11,17 @@ elseif exists("b:current_syntax")
   finish
 endif
 
+" Fold settings {{{1
+
+if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
+  setlocal foldmethod=syntax
+  if g:rust_fold == 2
+    setlocal foldlevel<
+  else
+    setlocal foldlevel=99
+  endif
+endif
+
 " Syntax definitions {{{1
 " Basic keywords {{{2
 syn keyword   rustConditional match if else

trunk/src/libcore/intrinsics.rs

@@ -314,7 +314,6 @@ extern "rust-intrinsic" {
     ///
     /// Using this instrinsic in a function that does not use an out pointer
     /// will trigger a compiler error.
-    #[cfg(not(stage0))]
     pub fn return_address() -> *const u8;
 
     /// Returns `true` if a type requires drop glue.

trunk/src/libcore/kinds.rs

@@ -87,13 +87,6 @@ pub trait Copy {
 /// reference; not doing this is undefined behaviour (for example,
 /// `transmute`-ing from `&T` to `&mut T` is illegal).
 #[lang="sync"]
-#[cfg(not(stage0))]
-pub trait Sync {
-    // Empty
-}
-/// dox
-#[lang="share"]
-#[cfg(stage0)]
 pub trait Sync {
     // Empty
 }

trunk/src/libnum/complex.rs

@@ -257,14 +257,6 @@ mod test {
         assert_eq!(_1_0i.inv(), _1_0i.inv());
     }
 
-    #[test]
-    #[should_fail]
-    fn test_divide_by_zero_natural() {
-        let n = Complex::new(2i, 3i);
-        let d = Complex::new(0, 0);
-        let _x = n / d;
-    }
-
     #[test]
     #[should_fail]
     #[ignore]

trunk/src/librustc/back/link.rs

@@ -1472,9 +1472,6 @@ fn link_args(cmd: &mut Command,
         // [1] - https://sourceware.org/bugzilla/show_bug.cgi?id=13130
         // [2] - https://code.google.com/p/go/issues/detail?id=2139
         cmd.arg("-Wl,--enable-long-section-names");
-
-        // Always enable DEP (NX bit) when it is available
-        cmd.arg("-Wl,--nxcompat");
     }
 
     if sess.targ_cfg.os == abi::OsAndroid {

trunk/src/librustc/metadata/creader.rs

@@ -33,7 +33,6 @@ use syntax::diagnostic::SpanHandler;
 use syntax::parse::token::InternedString;
 use syntax::parse::token;
 use syntax::visit;
-use util::fs;
 
 struct Env<'a> {
     sess: &'a Session,
@@ -302,7 +301,7 @@ fn existing_match(e: &Env, name: &str,
         match e.sess.opts.externs.find_equiv(&name) {
             Some(locs) => {
                 let found = locs.iter().any(|l| {
-                    let l = fs::realpath(&Path::new(l.as_slice())).ok();
+                    let l = Some(Path::new(l.as_slice()));
                     l == source.dylib || l == source.rlib
                 });
                 if found {

trunk/src/librustc/metadata/loader.rs

@@ -666,9 +666,9 @@ impl<'a> Context<'a> {
         let mut dylibs = HashSet::new();
         for loc in locs {
             if loc.filename_str().unwrap().ends_with(".rlib") {
-                rlibs.insert(fs::realpath(&loc).unwrap());
+                rlibs.insert(loc.clone());
             } else {
-                dylibs.insert(fs::realpath(&loc).unwrap());
+                dylibs.insert(loc.clone());
             }
         }
 

trunk/src/librustc/middle/trans/base.rs

@@ -2278,7 +2278,7 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
         match ty::get(ret_ty).sty {
             // `~` pointer return values never alias because ownership
             // is transferred
-            ty::ty_uniq(it) if match ty::get(it).sty {
+            ty::ty_uniq(it)  if match ty::get(it).sty {
                 ty::ty_str | ty::ty_vec(..) | ty::ty_trait(..) => true, _ => false
             } => {}
             ty::ty_uniq(_) => {
@@ -2354,21 +2354,15 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
             }
 
             // `&mut` pointer parameters never alias other parameters, or mutable global data
-            //
-            // `&T` where `T` contains no `UnsafeCell<U>` is immutable, and can be marked as both
-            // `readonly` and `noalias`, as LLVM's definition of `noalias` is based solely on
-            // memory dependencies rather than pointer equality
+            // `&` pointer parameters never alias either (for LLVM's purposes) as long as the
+            // interior is safe
             ty::ty_rptr(b, mt) if mt.mutbl == ast::MutMutable ||
                                   !ty::type_contents(ccx.tcx(), mt.ty).interior_unsafe() => {
 
                 let llsz = llsize_of_real(ccx, type_of::type_of(ccx, mt.ty));
                 attrs.arg(idx, llvm::NoAliasAttribute)
                      .arg(idx, llvm::DereferenceableAttribute(llsz));
 
-                if mt.mutbl == ast::MutImmutable {
-                    attrs.arg(idx, llvm::ReadOnlyAttribute);
-                }
-
                 match b {
                     ReLateBound(_, BrAnon(_)) => {
                         attrs.arg(idx, llvm::NoCaptureAttribute);

trunk/src/libstd/io/util.rs

@@ -48,12 +48,10 @@ impl<R: Reader> Reader for LimitReader<R> {
         }
 
         let len = cmp::min(self.limit, buf.len());
-        let res = self.inner.read(buf.mut_slice_to(len));
-        match res {
-            Ok(len) => self.limit -= len,
-            _ => {}
-        }
-        res
+        self.inner.read(buf.mut_slice_to(len)).map(|len| {
+            self.limit -= len;
+            len
+        })
     }
 }
 
@@ -69,8 +67,6 @@ impl<R: Buffer> Buffer for LimitReader<R> {
     }
 
     fn consume(&mut self, amt: uint) {
-        // Don't let callers reset the limit by passing an overlarge value
-        let amt = cmp::min(amt, self.limit);
         self.limit -= amt;
         self.inner.consume(amt);
     }
@@ -101,7 +97,6 @@ impl Buffer for ZeroReader {
         static DATA: [u8, ..64] = [0, ..64];
         Ok(DATA.as_slice())
     }
-
     fn consume(&mut self, _amt: uint) {}
 }
 
@@ -122,10 +117,7 @@ impl Buffer for NullReader {
     fn consume(&mut self, _amt: uint) {}
 }
 
-/// A `Writer` which multiplexes writes to a set of `Writer`s.
-///
-/// The `Writer`s are delegated to in order. If any `Writer` returns an error,
-/// that error is returned immediately and remaining `Writer`s are not called.
+/// A `Writer` which multiplexes writes to a set of `Writers`.
 pub struct MultiWriter {
     writers: Vec<Box<Writer>>
 }
@@ -140,22 +132,24 @@ impl MultiWriter {
 impl Writer for MultiWriter {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
+        let mut ret = Ok(());
         for writer in self.writers.mut_iter() {
-            try!(writer.write(buf));
+            ret = ret.and(writer.write(buf));
         }
-        Ok(())
+        return ret;
     }
 
     #[inline]
     fn flush(&mut self) -> io::IoResult<()> {
+        let mut ret = Ok(());
         for writer in self.writers.mut_iter() {
-            try!(writer.flush());
+            ret = ret.and(writer.flush());
         }
-        Ok(())
+        return ret;
     }
 }
 
-/// A `Reader` which chains input from multiple `Reader`s, reading each to
+/// A `Reader` which chains input from multiple `Readers`, reading each to
 /// completion before moving onto the next.
 pub struct ChainedReader<I, R> {
     readers: I,
@@ -235,16 +229,17 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
     }
 }
 
-/// An adaptor converting an `Iterator<u8>` to a `Reader`.
+/// A `Reader` which converts an `Iterator<u8>` into a `Reader`.
 pub struct IterReader<T> {
     iter: T,
 }
 
 impl<T: Iterator<u8>> IterReader<T> {
-    /// Creates a new `IterReader` which will read from the specified
-    /// `Iterator`.
+    /// Create a new `IterReader` which will read from the specified `Iterator`.
     pub fn new(iter: T) -> IterReader<T> {
-        IterReader { iter: iter }
+        IterReader {
+            iter: iter,
+        }
     }
 }
 
@@ -256,7 +251,7 @@ impl<T: Iterator<u8>> Reader for IterReader<T> {
             *slot = elt;
             len += 1;
         }
-        if len == 0 && buf.len() != 0 {
+        if len == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
             Ok(len)
@@ -302,14 +297,6 @@ mod test {
         assert_eq!(0, r.limit());
     }
 
-    #[test]
-    fn test_limit_reader_overlong_consume() {
-        let mut r = MemReader::new(vec![0, 1, 2, 3, 4, 5]);
-        let mut r = LimitReader::new(r.by_ref(), 1);
-        r.consume(2);
-        assert_eq!(vec![], r.read_to_end().unwrap());
-    }
-
     #[test]
     fn test_null_writer() {
         let mut s = NullWriter;
@@ -428,11 +415,4 @@ mod test {
 
         assert_eq!(r.read(buf).unwrap_err().kind, io::EndOfFile);
     }
-
-    #[test]
-    fn iter_reader_zero_length() {
-        let mut r = IterReader::new(range(0u8, 8));
-        let mut buf = [];
-        assert_eq!(Ok(0), r.read(buf));
-    }
 }

trunk/src/rustllvm/RustWrapper.cpp

@@ -282,11 +282,7 @@ extern "C" LLVMValueRef LLVMDIBuilderCreateSubroutineType(
     LLVMValueRef ParameterTypes) {
     return wrap(Builder->createSubroutineType(
         unwrapDI<DIFile>(File),
-#if LLVM_VERSION_MINOR >= 6
         unwrapDI<DITypeArray>(ParameterTypes)));
-#else
-        unwrapDI<DIArray>(ParameterTypes)));
-#endif
 }
 
 extern "C" LLVMValueRef LLVMDIBuilderCreateFunction(
@@ -638,11 +634,7 @@ extern "C" void LLVMDICompositeTypeSetTypeArray(
     LLVMValueRef CompositeType,
     LLVMValueRef TypeArray)
 {
-#if LLVM_VERSION_MINOR >= 6
     unwrapDI<DICompositeType>(CompositeType).setArrays(unwrapDI<DIArray>(TypeArray));
-#else
-    unwrapDI<DICompositeType>(CompositeType).setTypeArray(unwrapDI<DIArray>(TypeArray));
-#endif
 }
 
 extern "C" char *LLVMTypeToString(LLVMTypeRef Type) {

trunk/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2014-08-14 aa98b25
+  freebsd-x86_64 6a84283dfd8600fca6ec08144228f405ad9fe333
+  linux-i386 6aeac588b086a99f81b53cfadd15617c82c540aa
+  linux-x86_64 0efd0a8516affe0b1c6bf2e02e08ceff0f9c3a1d
+  macos-i386 4b2535d247d24869ef00942f80a5a1bd17cafedb
+  macos-x86_64 7b88a4aa4e424a5cb3b6d978132591ea54e9589d
+  winnt-i386 19b86f3c413f07363726fb6bf086307ed14fdae2
+
 S 2014-08-07 12e0f72
   freebsd-x86_64 e55055a876ebbde0d3ed3bcb97579afab9264def
   linux-i386 2665e45879f2ef77ce0c9015f971642fe424ac33