auto merge of #17629 : alexcrichton/rust/rollup, r=alexcrichton

Author: bors

configure

@@ -453,12 +453,12 @@ valopt datadir "${CFG_PREFIX}/share" "install data"
 valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
 valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 
-valopt release-channel "source" "the name of the release channel to build"
+valopt release-channel "dev" "the name of the release channel to build"
 
 # On windows we just store the libraries in the bin directory because
 # there's no rpath. This is where the build system itself puts libraries;
 # --libdir is used to configure the installation directory.
-# FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
+# FIXME: This needs to parameterized over target triples. Do it in platform.mk
 CFG_LIBDIR_RELATIVE=lib
 if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
 then
@@ -479,10 +479,10 @@ validate_opt
 
 # Validate the release channel
 case "$CFG_RELEASE_CHANNEL" in
-    (source | nightly | beta | stable)
+    (dev | nightly | beta | stable)
 	;;
     (*)
-        err "release channel must be 'source', 'nightly', 'beta' or 'stable'"
+        err "release channel must be 'dev', 'nightly', 'beta' or 'stable'"
         ;;
 esac
 

mk/crates.mk

@@ -71,7 +71,7 @@ DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std term serialize log fmt_macros debug arena
+DEPS_syntax := std term serialize log fmt_macros debug arena libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz debug rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std

mk/main.mk

@@ -35,9 +35,9 @@ ifeq ($(CFG_RELEASE_CHANNEL),nightly)
 CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly
 CFG_PACKAGE_VERS=nightly
 endif
-ifeq ($(CFG_RELEASE_CHANNEL),source)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-pre
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-pre
+ifeq ($(CFG_RELEASE_CHANNEL),dev)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-dev
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-dev
 endif
 
 # The name of the package to use for creating tarballs, installers etc.

src/doc/guide.md

@@ -4325,8 +4325,6 @@ and so we tell it that we want a vector of integers.
 is one:
 
 ```{rust}
-let one_to_one_hundred = range(0i, 100i);
-
 let greater_than_forty_two = range(0i, 100i)
                              .find(|x| *x >= 42);
 

src/etc/pkg/rust.iss

@@ -8,7 +8,7 @@
 SetupIconFile=rust-logo.ico
 AppName=Rust
 AppVersion={#CFG_RELEASE}
-AppCopyright=Copyright (C) 2006-2013 Mozilla Foundation, MIT license
+AppCopyright=Copyright (C) 2006-2014 Mozilla Foundation, MIT license
 AppPublisher=Mozilla Foundation
 AppPublisherURL=http://www.rust-lang.org
 VersionInfoVersion={#CFG_VERSION_WIN}
@@ -43,7 +43,7 @@ Source: "tmp/dist/win/*.*" ; DestDir: "{app}"; Flags: ignoreversion recursesubdi
 [Code]
 const
 	ModPathName = 'modifypath';
-	ModPathType = 'user';
+	ModPathType = 'system';
 
 function ModPathDir(): TArrayOfString;
 begin

src/grammar/RustLexer.g4

@@ -120,10 +120,9 @@ LIT_INTEGER
   | '0x' [0-9a-fA-F][0-9a-fA-F_]* INT_SUFFIX?
   ;
 
-FLOAT_SUFFIX
+fragment FLOAT_SUFFIX
   : 'f32'
   | 'f64'
-  | 'f128'
   ;
 
 LIT_FLOAT

src/liballoc/boxed.rs

@@ -96,12 +96,6 @@ pub trait BoxAny {
     /// `Err(Self)` if it isn't.
     #[unstable = "naming conventions around accessing innards may change"]
     fn downcast<T: 'static>(self) -> Result<Box<T>, Self>;
-
-    /// Deprecated; this method has been renamed to `downcast`.
-    #[deprecated = "use downcast instead"]
-    fn move<T: 'static>(self) -> Result<Box<T>, Self> {
-        self.downcast::<T>()
-    }
 }
 
 #[stable]

src/liballoc/util.rs

@@ -16,7 +16,7 @@ use core::raw;
 #[inline]
 #[deprecated]
 pub fn get_box_size(body_size: uint, body_align: uint) -> uint {
-    let header_size = mem::size_of::<raw::Box<()>>();
+    let header_size = mem::size_of::<raw::GcBox<()>>();
     let total_size = align_to(header_size, body_align) + body_size;
     total_size
 }

src/libcollections/enum_set.rs

@@ -16,7 +16,7 @@
 use core::prelude::*;
 use core::fmt;
 
-#[deriving(Clone, PartialEq, Eq, Hash)]
+#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 /// A specialized `Set` implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set

src/libcollections/string.rs

@@ -18,6 +18,7 @@ use core::default::Default;
 use core::fmt;
 use core::mem;
 use core::ptr;
+use core::ops;
 // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
 use core::raw::Slice as RawSlice;
 
@@ -530,7 +531,7 @@ impl String {
     /// assert_eq!(s.as_slice(), "abc123");
     /// ```
     #[inline]
-    #[stable = "function just renamed from push"]
+    #[stable = "function just renamed from push_char"]
     pub fn push(&mut self, ch: char) {
         let cur_len = self.len();
         // This may use up to 4 bytes.
@@ -926,6 +927,28 @@ impl<S: Str> Add<S, String> for String {
     }
 }
 
+impl ops::Slice<uint, str> for String {
+    #[inline]
+    fn as_slice_<'a>(&'a self) -> &'a str {
+        self.as_slice()
+    }
+
+    #[inline]
+    fn slice_from_<'a>(&'a self, from: &uint) -> &'a str {
+        self[][*from..]
+    }
+
+    #[inline]
+    fn slice_to_<'a>(&'a self, to: &uint) -> &'a str {
+        self[][..*to]
+    }
+
+    #[inline]
+    fn slice_<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
+        self[][*from..*to]
+    }
+}
+
 /// Unsafe operations
 #[unstable = "waiting on raw module conventions"]
 pub mod raw {
@@ -1290,6 +1313,15 @@ mod tests {
     #[test] #[should_fail] fn insert_bad1() { "".to_string().insert(1, 't'); }
     #[test] #[should_fail] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
 
+    #[test]
+    fn test_slicing() {
+        let s = "foobar".to_string();
+        assert_eq!("foobar", s[]);
+        assert_eq!("foo", s[..3]);
+        assert_eq!("bar", s[3..]);
+        assert_eq!("oob", s[1..4]);
+    }
+
     #[bench]
     fn bench_with_capacity(b: &mut Bencher) {
         b.iter(|| {

src/libcollections/vec.rs

@@ -2393,8 +2393,6 @@ mod tests {
         let _ = vec[3];
     }
 
-    // NOTE uncomment after snapshot
-    /*
     #[test]
     #[should_fail]
     fn test_slice_out_of_bounds_1() {
@@ -2429,7 +2427,6 @@ mod tests {
         let x: Vec<int> = vec![1, 2, 3, 4, 5];
         x[3..2];
     }
-    */
 
     #[test]
     fn test_swap_remove_empty() {

src/libcore/failure.rs

@@ -33,24 +33,9 @@
 use fmt;
 use intrinsics;
 
-// NOTE: remove after next snapshot
-#[cfg(stage0)]
-#[cold] #[inline(never)] // this is the slow path, always
-#[lang="fail_"]
-fn fail_(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
-    let (expr, file, line) = *expr_file_line;
-    let ref file_line = (file, line);
-    format_args!(|args| -> () {
-        fail_fmt(args, file_line);
-    }, "{}", expr);
-
-    unsafe { intrinsics::abort() }
-}
-
-#[cfg(not(stage0))]
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail"]
-fn fail(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
+pub fn fail(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
     let (expr, file, line) = *expr_file_line;
     let ref file_line = (file, line);
     format_args!(|args| -> () {
@@ -70,23 +55,10 @@ fn fail_bounds_check(file_line: &(&'static str, uint),
     unsafe { intrinsics::abort() }
 }
 
-#[cold] #[inline(never)]
-pub fn fail_str(msg: &str, file: &(&'static str, uint)) -> ! {
-    format_args!(|fmt| fail_fmt(fmt, file), "{}", msg)
-}
-
 #[cold] #[inline(never)]
 pub fn fail_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
     #[allow(ctypes)]
     extern {
-
-        // NOTE: remove after next snapshot
-        #[cfg(stage0)]
-        #[lang = "begin_unwind"]
-        fn fail_impl(fmt: &fmt::Arguments, file: &'static str,
-                        line: uint) -> !;
-
-        #[cfg(not(stage0))]
         #[lang = "fail_fmt"]
         fn fail_impl(fmt: &fmt::Arguments, file: &'static str,
                         line: uint) -> !;

src/libcore/iter.rs

@@ -366,7 +366,7 @@ pub trait Iterator<A> {
     ///     let mut sum = 0;
     ///     for x in it {
     ///         if x > 5 {
-    ///             continue;
+    ///             break;
     ///         }
     ///         sum += x;
     ///     }
@@ -377,6 +377,8 @@ pub trait Iterator<A> {
     ///     sum
     /// }
     /// let x = vec![1i,2,3,7,8,9];
+    /// assert_eq!(process(x.into_iter()), 6);
+    /// let x = vec![1i,2,3];
     /// assert_eq!(process(x.into_iter()), 1006);
     /// ```
     #[inline]

src/libcore/macros.rs

@@ -17,8 +17,8 @@ macro_rules! fail(
         fail!("{}", "explicit failure")
     );
     ($msg:expr) => ({
-        static _FILE_LINE: (&'static str, uint) = (file!(), line!());
-        ::core::failure::fail_str($msg, &_FILE_LINE)
+        static _MSG_FILE_LINE: (&'static str, &'static str, uint) = ($msg, file!(), line!());
+        ::core::failure::fail(&_MSG_FILE_LINE)
     });
     ($fmt:expr, $($arg:tt)*) => ({
         // a closure can't have return type !, so we need a full

src/libcore/ops.rs

@@ -764,13 +764,13 @@ pub trait Slice<Idx, Sized? Result> for Sized? {
 // FIXME(#17273) remove the postscript _s
 #[lang="slice_mut"]
 pub trait SliceMut<Idx, Sized? Result> for Sized? {
-    /// The method for the slicing operation foo[]
+    /// The method for the slicing operation foo[mut]
     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Result;
-    /// The method for the slicing operation foo[from..]
+    /// The method for the slicing operation foo[mut from..]
     fn slice_from_mut_<'a>(&'a mut self, from: &Idx) -> &'a mut Result;
-    /// The method for the slicing operation foo[..to]
+    /// The method for the slicing operation foo[mut ..to]
     fn slice_to_mut_<'a>(&'a mut self, to: &Idx) -> &'a mut Result;
-    /// The method for the slicing operation foo[from..to]
+    /// The method for the slicing operation foo[mut from..to]
     fn slice_mut_<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
 }
 /**

src/libcore/option.rs

@@ -312,7 +312,7 @@ impl<T> Option<T> {
     pub fn expect(self, msg: &str) -> T {
         match self {
             Some(val) => val,
-            None => fail!(msg),
+            None => fail!("{}", msg),
         }
     }
 

src/libcore/raw.rs

@@ -20,12 +20,12 @@
 
 use mem;
 
-/// The representation of a Rust managed box
-pub struct Box<T> {
+/// The representation of `std::gc::Gc`.
+pub struct GcBox<T> {
     pub ref_count: uint,
     pub drop_glue: fn(ptr: *mut u8),
-    pub prev: *mut Box<T>,
-    pub next: *mut Box<T>,
+    pub prev: *mut GcBox<T>,
+    pub next: *mut GcBox<T>,
     pub data: T,
 }
 

src/libcore/str.rs

@@ -1123,6 +1123,7 @@ pub mod traits {
     use collections::Collection;
     use iter::Iterator;
     use option::{Option, Some};
+    use ops;
     use str::{Str, StrSlice, eq_slice};
 
     impl<'a> Ord for &'a str {
@@ -1162,6 +1163,28 @@ pub mod traits {
         #[inline]
         fn equiv(&self, other: &S) -> bool { eq_slice(*self, other.as_slice()) }
     }
+
+    impl ops::Slice<uint, str> for str {
+        #[inline]
+        fn as_slice_<'a>(&'a self) -> &'a str {
+            self
+        }
+
+        #[inline]
+        fn slice_from_<'a>(&'a self, from: &uint) -> &'a str {
+            self.slice_from(*from)
+        }
+
+        #[inline]
+        fn slice_to_<'a>(&'a self, to: &uint) -> &'a str {
+            self.slice_to(*to)
+        }
+
+        #[inline]
+        fn slice_<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
+            self.slice(*from, *to)
+        }
+    }
 }
 
 /// Any string that can be represented as a slice

src/libdebug/repr.rs

@@ -277,7 +277,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
     fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
         try!(self, self.writer.write("box(GC) ".as_bytes()));
         self.write_mut_qualifier(mtbl);
-        self.get::<&raw::Box<()>>(|this, b| {
+        self.get::<&raw::GcBox<()>>(|this, b| {
             let p = &b.data as *const () as *const u8;
             this.visit_ptr_inner(p, inner)
         })

src/librustc/back/link.rs

@@ -1319,6 +1319,18 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
                         sess.abort_if_errors();
                     }
                 }
+                // Fix up permissions of the copy, as fs::copy() preserves
+                // permissions, but the original file may have been installed
+                // by a package manager and may be read-only.
+                match fs::chmod(&dst, io::UserRead | io::UserWrite) {
+                    Ok(..) => {}
+                    Err(e) => {
+                        sess.err(format!("failed to chmod {} when preparing \
+                                          for LTO: {}", dst.display(),
+                                         e).as_slice());
+                        sess.abort_if_errors();
+                    }
+                }
                 let handler = &sess.diagnostic().handler;
                 let config = ArchiveConfig {
                     handler: handler,