---

yaml
---
r: 210459
b: refs/heads/try
c: 00204e8
h: refs/heads/master
i:
  210457: a333428
  210455: a0fc35a
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: b210aea1d446dcc9d05d0072c439575f9649d9f9
+refs/heads/try: 00204e8a83c097d7a5ad4643ee6b138a1bb0de1a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/AUTHORS.txt

@@ -518,7 +518,6 @@ Luke Francl <[email protected]>
 Luke Metz <[email protected]>
 Luke Steensen <[email protected]>
 Luqman Aden <[email protected]>
-Łukasz Niemier <[email protected]>
 Magnus Auvinen <[email protected]>
 Mahmut Bulut <[email protected]>
 Makoto Nakashima <[email protected]>
@@ -998,4 +997,5 @@ xales <[email protected]>
 zofrex <[email protected]>
 zslayton <[email protected]>
 zzmp <[email protected]>
+Łukasz Niemier <[email protected]>
 克雷 <[email protected]>

branches/try/configure

@@ -844,7 +844,7 @@ then
     CFG_OSX_GCC_VERSION=$("$CFG_GCC" --version 2>&1 | grep "Apple LLVM version")
     if [ $? -eq 0 ]
     then
-        step_msg "on OS X >=10.9, forcing use of clang"
+        step_msg "on OS X 10.9, forcing use of clang"
         CFG_ENABLE_CLANG=1
     else
         if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then

branches/try/mk/dist.mk

@@ -52,6 +52,7 @@ PKG_FILES := \
       doc                                      \
       driver                                   \
       etc                                      \
+      error-index-generator                    \
       $(foreach crate,$(CRATES),lib$(crate))   \
       libcollectionstest                       \
       libcoretest                              \

branches/try/src/doc/trpl/guessing-game.md

@@ -358,10 +358,11 @@ rand="0.3.0"
 The `[dependencies]` section of `Cargo.toml` is like the `[package]` section:
 everything that follows it is part of it, until the next section starts.
 Cargo uses the dependencies section to know what dependencies on external
-crates you have, and what versions you require. In this case, we’ve used version `0.3.0`.
-Cargo understands [Semantic Versioning][semver], which is a standard for writing version
-numbers. If we wanted to use the latest version we could use `*` or we could use a range 
-of versions. [Cargo’s documentation][cargodoc] contains more details.
+crates you have, and what versions you require. In this case, we’ve used `*`,
+which means that we’ll use the latest version of `rand`. Cargo understands
+[Semantic Versioning][semver], which is a standard for writing version
+numbers. If we wanted a specific version or range of versions, we could be
+more specific here. [Cargo’s documentation][cargodoc] contains more details.
 
 [semver]: http://semver.org
 [cargodoc]: http://doc.crates.io/crates-io.html
@@ -409,7 +410,7 @@ $ cargo build
    Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
 ```
 
-So, we told Cargo we wanted any `0.3.x` version of `rand`, and so it fetched the latest
+So, we told Cargo we wanted any version of `rand`, and so it fetched the latest
 version at the time this was written, `v0.3.8`. But what happens when next
 week, version `v0.3.9` comes out, with an important bugfix? While getting
 bugfixes is important, what if `0.3.9` contains a regression that breaks our

branches/try/src/doc/trpl/lifetimes.md

@@ -116,7 +116,7 @@ fn main() {
 }
 ```
 
-[structs]: structs.html
+[struct]: structs.html
 
 As you can see, `struct`s can also have lifetimes. In a similar way to functions,
 

branches/try/src/doc/trpl/method-syntax.md

@@ -188,7 +188,7 @@ struct CircleBuilder {
 
 impl CircleBuilder {
     fn new() -> CircleBuilder {
-        CircleBuilder { x: 0.0, y: 0.0, radius: 1.0, }
+        CircleBuilder { x: 0.0, y: 0.0, radius: 0.0, }
     }
 
     fn x(&mut self, coordinate: f64) -> &mut CircleBuilder {

branches/try/src/doc/trpl/mutability.md

@@ -85,7 +85,7 @@ safety, and the mechanism by which Rust guarantees it, the
 > You may have one or the other of these two kinds of borrows, but not both at
 > the same time:
 > 
-> * one or more references (`&T`) to a resource.
+> * 0 to N references (`&T`) to a resource.
 > * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html

branches/try/src/doc/trpl/ownership.md

@@ -3,7 +3,7 @@
 This guide is one of three presenting Rust’s ownership system. This is one of
 Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
-memory safety. There are a few distinct concepts, each with its own
+memory safety. The there are a few distinct concepts, each with its own
 chapter:
 
 * ownership, which you’re reading now.
@@ -59,7 +59,6 @@ deterministically, at the end of the scope.
 
 [vect]: ../std/vec/struct.Vec.html
 [heap]: the-stack-and-the-heap.html
-[bindings]: variable-bindings.html
 
 # Move semantics
 
@@ -123,7 +122,7 @@ let v2 = v;
 
 The first line creates some data for the vector on the [stack][sh], `v`. The
 vector’s data, however, is stored on the [heap][sh], and so it contains a
-pointer to that data. When we move `v` to `v2`, it creates a copy of that pointer,
+pointer to that data. When we move `v` to `v2`, it creates a copy of that data,
 for `v2`. Which would mean two pointers to the contents of the vector on the
 heap. That would be a problem: it would violate Rust’s safety guarantees by
 introducing a data race. Therefore, Rust forbids using `v` after we’ve done the

branches/try/src/doc/trpl/references-and-borrowing.md

@@ -3,7 +3,7 @@
 This guide is one of three presenting Rust’s ownership system. This is one of
 Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
-memory safety. There are a few distinct concepts, each with its own
+memory safety. The there are a few distinct concepts, each with its own
 chapter:
 
 * [ownership][ownership], ownership, the key concept

branches/try/src/doc/trpl/traits.md

@@ -192,7 +192,7 @@ Here’s the error:
 ```text
 error: type `std::fs::File` does not implement any method in scope named `write`
 
-let result = f.write(b"whatever");
+let result = f.write(b”whatever”);
                ^~~~~~~~~~~~~~~~~~
 ```
 

branches/try/src/libcollections/vec.rs

@@ -647,7 +647,7 @@ impl<T> Vec<T> {
             // zero-size types consume no memory, so we can't rely on the
             // address space running out
             self.len = self.len.checked_add(1).expect("length overflow");
-            mem::forget(value);
+            unsafe { mem::forget(value); }
             return
         }
 
@@ -994,7 +994,7 @@ impl<T> Vec<T> {
                 num_u: 0,
                 marker: PhantomData,
             };
-            mem::forget(vec);
+            unsafe { mem::forget(vec); }
 
             while pv.num_t != 0 {
                 unsafe {

branches/try/src/libcore/intrinsics.rs

@@ -232,6 +232,10 @@ extern "rust-intrinsic" {
     pub fn uninit<T>() -> T;
 
     /// Moves a value out of scope without running drop glue.
+    ///
+    /// `forget` is unsafe because the caller is responsible for
+    /// ensuring the argument is deallocated already.
+    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn forget<T>(_: T) -> ();
 
     /// Unsafely transforms a value of one type into a value of another type.

branches/try/src/libcore/iter.rs

@@ -137,7 +137,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().last().unwrap(), &5);
+    /// assert!(a.iter().last().unwrap() == &5);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -155,8 +155,8 @@ pub trait Iterator {
     /// ```
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
-    /// assert_eq!(it.nth(2).unwrap(), &3);
-    /// assert_eq!(it.nth(2), None);
+    /// assert!(it.nth(2).unwrap() == &3);
+    /// assert!(it.nth(2) == None);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -545,8 +545,8 @@ pub trait Iterator {
     /// let mut it = 0..10;
     /// // sum the first five values
     /// let partial_sum = it.by_ref().take(5).fold(0, |a, b| a + b);
-    /// assert_eq!(partial_sum, 10);
-    /// assert_eq!(it.next(), Some(5));
+    /// assert!(partial_sum == 10);
+    /// assert!(it.next() == Some(5));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
@@ -608,7 +608,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().fold(0, |acc, &item| acc + item), 15);
+    /// assert!(a.iter().fold(0, |acc, &item| acc + item) == 15);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -773,7 +773,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().max().unwrap(), &5);
+    /// assert!(a.iter().max().unwrap() == &5);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -796,7 +796,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().min().unwrap(), &1);
+    /// assert!(a.iter().min().unwrap() == &1);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -834,13 +834,13 @@ pub trait Iterator {
     /// assert_eq!(a.iter().min_max(), NoElements);
     ///
     /// let a = [1];
-    /// assert_eq!(a.iter().min_max(), OneElement(&1));
+    /// assert!(a.iter().min_max() == OneElement(&1));
     ///
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().min_max(), MinMax(&1, &5));
+    /// assert!(a.iter().min_max() == MinMax(&1, &5));
     ///
     /// let a = [1, 1, 1, 1];
-    /// assert_eq!(a.iter().min_max(), MinMax(&1, &1));
+    /// assert!(a.iter().min_max() == MinMax(&1, &1));
     /// ```
     #[unstable(feature = "core", reason = "return type may change")]
     fn min_max(mut self) -> MinMaxResult<Self::Item> where Self: Sized, Self::Item: Ord
@@ -1058,7 +1058,7 @@ pub trait Iterator {
     ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().cloned();
-    /// assert_eq!(it.sum::<i32>(), 15);
+    /// assert!(it.sum::<i32>() == 15);
     /// ```
     #[unstable(feature="core")]
     fn sum<S=<Self as Iterator>::Item>(self) -> S where
@@ -1078,9 +1078,9 @@ pub trait Iterator {
     /// fn factorial(n: u32) -> u32 {
     ///     (1..).take_while(|&i| i <= n).product()
     /// }
-    /// assert_eq!(factorial(0), 1);
-    /// assert_eq!(factorial(1), 1);
-    /// assert_eq!(factorial(5), 120);
+    /// assert!(factorial(0) == 1);
+    /// assert!(factorial(1) == 1);
+    /// assert!(factorial(5) == 120);
     /// ```
     #[unstable(feature="core")]
     fn product<P=<Self as Iterator>::Item>(self) -> P where

branches/try/src/libcore/marker.rs

@@ -313,7 +313,7 @@ macro_rules! impls{
 /// mismatches by enforcing types in the method implementations:
 ///
 /// ```
-/// # trait ResType { fn foo(&self); }
+/// # trait ResType { fn foo(&self); };
 /// # struct ParamType;
 /// # mod foreign_lib {
 /// # pub fn new(_: usize) -> *mut () { 42 as *mut () }

branches/try/src/libcore/mem.rs

@@ -22,54 +22,15 @@ use ptr;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use intrinsics::transmute;
 
-/// Leaks a value into the void, consuming ownership and never running its
-/// destructor.
+/// Moves a thing into the void.
 ///
-/// This function will take ownership of its argument, but is distinct from the
-/// `mem::drop` function in that it **does not run the destructor**, leaking the
-/// value and any resources that it owns.
+/// The forget function will take ownership of the provided value but neglect
+/// to run any required cleanup or memory management operations on it.
 ///
-/// # Safety
-///
-/// This function is not marked as `unsafe` as Rust does not guarantee that the
-/// `Drop` implementation for a value will always run. Note, however, that
-/// leaking resources such as memory or I/O objects is likely not desired, so
-/// this function is only recommended for specialized use cases.
-///
-/// The safety of this function implies that when writing `unsafe` code
-/// yourself care must be taken when leveraging a destructor that is required to
-/// run to preserve memory safety. There are known situations where the
-/// destructor may not run (such as if ownership of the object with the
-/// destructor is returned) which must be taken into account.
-///
-/// # Other forms of Leakage
-///
-/// It's important to point out that this function is not the only method by
-/// which a value can be leaked in safe Rust code. Other known sources of
-/// leakage are:
-///
-/// * `Rc` and `Arc` cycles
-/// * `mpsc::{Sender, Receiver}` cycles (they use `Arc` internally)
-/// * Panicking destructors are likely to leak local resources
-///
-/// # Example
-///
-/// ```rust,no_run
-/// use std::mem;
-/// use std::fs::File;
-///
-/// // Leak some heap memory by never deallocating it
-/// let heap_memory = Box::new(3);
-/// mem::forget(heap_memory);
-///
-/// // Leak an I/O object, never closing the file
-/// let file = File::open("foo.txt").unwrap();
-/// mem::forget(file);
-/// ```
+/// This function is the unsafe version of the `drop` function because it does
+/// not run any destructors.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn forget<T>(t: T) {
-    unsafe { intrinsics::forget(t) }
-}
+pub use intrinsics::forget;
 
 /// Returns the size of a type in bytes.
 ///

branches/try/src/liblibc/lib.rs

@@ -12,8 +12,7 @@
 #![cfg_attr(stage0, feature(custom_attribute))]
 #![crate_name = "libc"]
 #![crate_type = "rlib"]
-#![cfg_attr(not(feature = "cargo-build"), unstable(feature = "libc",
-                                                   reason = "use `libc` from crates.io"))]
+#![cfg_attr(not(feature = "cargo-build"), unstable(feature = "libc"))]
 #![cfg_attr(not(feature = "cargo-build"), feature(staged_api, core, no_std))]
 #![cfg_attr(not(feature = "cargo-build"), staged_api)]
 #![cfg_attr(not(feature = "cargo-build"), no_std)]
@@ -3625,30 +3624,6 @@ pub mod consts {
             pub const IPV6_DROP_MEMBERSHIP: c_int = 21;
 
             pub const TCP_NODELAY: c_int = 1;
-            pub const TCP_MAXSEG: c_int = 2;
-            pub const TCP_CORK: c_int = 3;
-            pub const TCP_KEEPIDLE: c_int = 4;
-            pub const TCP_KEEPINTVL: c_int = 5;
-            pub const TCP_KEEPCNT: c_int = 6;
-            pub const TCP_SYNCNT: c_int = 7;
-            pub const TCP_LINGER2: c_int = 8;
-            pub const TCP_DEFER_ACCEPT: c_int = 9;
-            pub const TCP_WINDOW_CLAMP: c_int = 10;
-            pub const TCP_INFO: c_int = 11;
-            pub const TCP_QUICKACK: c_int = 12;
-            pub const TCP_CONGESTION: c_int = 13;
-            pub const TCP_MD5SIG: c_int = 14;
-            pub const TCP_COOKIE_TRANSACTIONS: c_int = 15;
-            pub const TCP_THIN_LINEAR_TIMEOUTS: c_int = 16;
-            pub const TCP_THIN_DUPACK: c_int = 17;
-            pub const TCP_USER_TIMEOUT: c_int = 18;
-            pub const TCP_REPAIR: c_int = 19;
-            pub const TCP_REPAIR_QUEUE: c_int = 20;
-            pub const TCP_QUEUE_SEQ: c_int = 21;
-            pub const TCP_REPAIR_OPTIONS: c_int = 22;
-            pub const TCP_FASTOPEN: c_int = 23;
-            pub const TCP_TIMESTAMP: c_int = 24;
-
             pub const SOL_SOCKET: c_int = 65535;
 
             pub const SO_DEBUG: c_int = 0x0001;

branches/try/src/librand/lib.rs

@@ -26,8 +26,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![no_std]
 #![staged_api]
-#![unstable(feature = "rand",
-            reason = "use `rand` from crates.io")]
+#![unstable(feature = "rand")]
 #![feature(core)]
 #![feature(no_std)]
 #![feature(staged_api)]