---

yaml
---
r: 135903
b: refs/heads/try
c: 40ce87f
h: refs/heads/master
i:
  135901: 030cd96
  135899: d1f5f0e
  135895: 3def2a8
  135887: 28c2604
  135871: 8b09624
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 8794107f74682607f368776cc8b78820629778e6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ae81c89f34f1ac2cdb596cf216612e94822a8466
-refs/heads/try: fa6b2d4c3b81e6adcfae87dac25fb7d50b2dd39f
+refs/heads/try: 40ce87f6ede1d3963258bf35c882a895b02a82b7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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 "dev" "the name of the release channel to build"
+valopt release-channel "source" "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: This needs to parameterized over target triples. Do it in platform.mk
+# FIXME: Thise 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
-    (dev | nightly | beta | stable)
+    (source | nightly | beta | stable)
 	;;
     (*)
-        err "release channel must be 'dev', 'nightly', 'beta' or 'stable'"
+        err "release channel must be 'source', 'nightly', 'beta' or 'stable'"
         ;;
 esac
 

branches/try/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 libc
+DEPS_syntax := std term serialize log fmt_macros debug arena
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz debug rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std

branches/try/mk/dist.mk

@@ -283,7 +283,7 @@ distcheck-docs: dist-docs
 
 ifdef CFG_WINDOWSY_$(CFG_BUILD)
 
-dist: dist-win dist-tar-bins
+dist: dist-win
 
 distcheck: distcheck-win
 	$(Q)rm -Rf tmp/distcheck

branches/try/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),dev)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-dev
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-dev
+ifeq ($(CFG_RELEASE_CHANNEL),source)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-pre
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-pre
 endif
 
 # The name of the package to use for creating tarballs, installers etc.

branches/try/src/doc/guide.md

@@ -4325,6 +4325,8 @@ 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);
 

branches/try/src/etc/install.sh

@@ -325,7 +325,7 @@ then
     if [ -z "${CFG_UNINSTALL}" ]
     then
         msg "verifying platform can run binaries"
-        export $CFG_LD_PATH_VAR="${CFG_SRC_DIR}/lib:$CFG_OLD_LD_PATH_VAR"
+        export $CFG_LD_PATH_VAR="${CFG_SRC_DIR}/lib":$CFG_OLD_LD_PATH_VAR
         "${CFG_SRC_DIR}/bin/rustc" --version > /dev/null
         if [ $? -ne 0 ]
         then
@@ -489,7 +489,7 @@ then
     "${CFG_PREFIX}/bin/rustc" --version 2> /dev/null 1> /dev/null
     if [ $? -ne 0 ]
     then
-        export $CFG_LD_PATH_VAR="${CFG_PREFIX}/lib:$CFG_OLD_LD_PATH_VAR"
+        export $CFG_LD_PATH_VAR="${CFG_PREFIX}/lib":$CFG_OLD_LD_PATH_VAR
         "${CFG_PREFIX}/bin/rustc" --version > /dev/null
         if [ $? -ne 0 ]
         then

branches/try/src/etc/pkg/rust.iss

@@ -8,7 +8,7 @@
 SetupIconFile=rust-logo.ico
 AppName=Rust
 AppVersion={#CFG_RELEASE}
-AppCopyright=Copyright (C) 2006-2014 Mozilla Foundation, MIT license
+AppCopyright=Copyright (C) 2006-2013 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 = 'system';
+	ModPathType = 'user';
 
 function ModPathDir(): TArrayOfString;
 begin

branches/try/src/grammar/RustLexer.g4

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

branches/try/src/liballoc/boxed.rs

@@ -96,6 +96,12 @@ 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]

branches/try/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::GcBox<()>>();
+    let header_size = mem::size_of::<raw::Box<()>>();
     let total_size = align_to(header_size, body_align) + body_size;
     total_size
 }

branches/try/src/libcollections/enum_set.rs

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

branches/try/src/libcollections/string.rs

@@ -18,7 +18,6 @@ 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;
 
@@ -531,7 +530,7 @@ impl String {
     /// assert_eq!(s.as_slice(), "abc123");
     /// ```
     #[inline]
-    #[stable = "function just renamed from push_char"]
+    #[stable = "function just renamed from push"]
     pub fn push(&mut self, ch: char) {
         let cur_len = self.len();
         // This may use up to 4 bytes.
@@ -927,28 +926,6 @@ 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 {
@@ -1313,15 +1290,6 @@ 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(|| {

branches/try/src/libcollections/vec.rs

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

branches/try/src/libcore/failure.rs

@@ -33,9 +33,24 @@
 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"]
-pub fn fail(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
+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| -> () {
@@ -55,10 +70,23 @@ 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) -> !;

branches/try/src/libcore/iter.rs

@@ -366,7 +366,7 @@ pub trait Iterator<A> {
     ///     let mut sum = 0;
     ///     for x in it {
     ///         if x > 5 {
-    ///             break;
+    ///             continue;
     ///         }
     ///         sum += x;
     ///     }
@@ -377,8 +377,6 @@ 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]

branches/try/src/libcore/macros.rs

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

branches/try/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[mut]
+    /// The method for the slicing operation foo[]
     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Result;
-    /// The method for the slicing operation foo[mut from..]
+    /// The method for the slicing operation foo[from..]
     fn slice_from_mut_<'a>(&'a mut self, from: &Idx) -> &'a mut Result;
-    /// The method for the slicing operation foo[mut ..to]
+    /// The method for the slicing operation foo[..to]
     fn slice_to_mut_<'a>(&'a mut self, to: &Idx) -> &'a mut Result;
-    /// The method for the slicing operation foo[mut from..to]
+    /// The method for the slicing operation foo[from..to]
     fn slice_mut_<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
 }
 /**

branches/try/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),
         }
     }
 

branches/try/src/libcore/raw.rs

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

branches/try/src/libcore/str.rs

@@ -1123,7 +1123,6 @@ 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 {
@@ -1163,28 +1162,6 @@ 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