---

yaml
---
r: 152199
b: refs/heads/try2
c: 87ecd4f
h: refs/heads/master
i:
  152197: be1a673
  152195: 2dd3f94
  152191: f215946
v: v3

Author: bnoordhuis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 4e0b936900275bcee7ba61894857030c39faec7d
+refs/heads/try2: 87ecd4f75b0441e986c6cda4cc8a0db07c61ca71
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/complement-cheatsheet.md

@@ -4,7 +4,7 @@
 
 **Int to string**
 
-Use [`ToStr`](std/to_str/trait.ToStr.html).
+Use [`ToStr`](../std/to_str/trait.ToStr.html).
 
 ~~~
 let x: int = 42;
@@ -13,8 +13,8 @@ let y: String = x.to_str().to_string();
 
 **String to int**
 
-Use [`FromStr`](std/from_str/trait.FromStr.html), and its helper function,
-[`from_str`](std/from_str/fn.from_str.html).
+Use [`FromStr`](../std/from_str/trait.FromStr.html), and its helper function,
+[`from_str`](../std/from_str/fn.from_str.html).
 
 ~~~
 let x: Option<int> = from_str("42");
@@ -35,8 +35,8 @@ let y: String = format!("{:X}", x);   // uppercase hexadecimal
 
 **String to int, in non-base-10**
 
-Use [`FromStrRadix`](std/num/trait.FromStrRadix.html), and its helper
-function, [`from_str_radix`](std/num/fn.from_str_radix.html).
+Use [`FromStrRadix`](../std/num/trait.FromStrRadix.html), and its helper
+function, [`from_str_radix`](../std/num/fn.from_str_radix.html).
 
 ~~~
 use std::num;
@@ -48,7 +48,7 @@ let y: i64 = x.unwrap();
 **Vector of Bytes to String**
 
 To return a Borrowed String Slice (&str) use the str helper function
-[`from_utf8`](std/str/fn.from_utf8.html).
+[`from_utf8`](../std/str/fn.from_utf8.html).
 
 ~~~
 use std::str;
@@ -58,7 +58,7 @@ let x: &str = str::from_utf8(bytes).unwrap();
 ~~~
 
 To return an Owned String use the str helper function
-[`from_utf8_owned`](std/str/fn.from_utf8_owned.html).
+[`from_utf8_owned`](../std/str/fn.from_utf8_owned.html).
 
 ~~~
 use std::str;
@@ -68,8 +68,8 @@ let x: Option<String> =
 let y: String = x.unwrap();
 ~~~
 
-To return a [`MaybeOwned`](std/str/type.MaybeOwned.html) use the str helper
-function [`from_utf8_lossy`](std/str/fn.from_utf8_owned.html).
+To return a [`MaybeOwned`](../std/str/enum.MaybeOwned.html) use the str helper
+function [`from_utf8_lossy`](../std/str/fn.from_utf8_owned.html).
 This function also replaces non-valid utf-8 sequences with U+FFFD replacement
 character.
 
@@ -85,11 +85,11 @@ let y = str::from_utf8_lossy(x);
 ## How do I read from a file?
 
 Use
-[`File::open`](std/io/fs/struct.File.html#method.open)
+[`File::open`](../std/io/fs/struct.File.html#method.open)
 to create a
-[`File`](std/io/fs/struct.File.html)
+[`File`](../std/io/fs/struct.File.html)
 struct, which implements the
-[`Reader`](std/io/trait.Reader.html)
+[`Reader`](../std/io/trait.Reader.html)
 trait.
 
 ~~~ {.ignore}
@@ -103,8 +103,7 @@ let reader : File = File::open(&path).unwrap_or_else(on_error);
 
 ## How do I iterate over the lines in a file?
 
-Use the [`lines`](std/io/trait.Buffer.html#method.lines) method on a
-[`BufferedReader`](std/io/struct.BufferedReader.html).
+Use the [`lines`](../std/io/trait.Buffer.html#method.lines) method on a [`BufferedReader`](../std/io/buffered/struct.BufferedReader.html).
 
 ~~~
 use std::io::BufferedReader;
@@ -122,7 +121,7 @@ for line in reader.lines() {
 
 ## How do I search for a substring?
 
-Use the [`find_str`](std/str/trait.StrSlice.html#tymethod.find_str) method.
+Use the [`find_str`](../std/str/trait.StrSlice.html#tymethod.find_str) method.
 
 ~~~
 let str = "Hello, this is some random string";
@@ -133,7 +132,7 @@ let index: Option<uint> = str.find_str("rand");
 
 ## How do I get the length of a vector?
 
-The [`Container`](std/container/trait.Container.html) trait provides the `len` method.
+The [`Container`](../std/container/trait.Container.html) trait provides the `len` method.
 
 ~~~
 let u: Vec<u32> = vec![0, 1, 2];
@@ -145,7 +144,7 @@ println!("u: {}, v: {}, w: {}", u.len(), v.len(), w.len()); // 3, 4, 5
 
 ## How do I iterate over a vector?
 
-Use the [`iter`](std/slice/trait.ImmutableVector.html#tymethod.iter) method.
+Use the [`iter`](../std/vec/trait.ImmutableVector.html#tymethod.iter) method.
 
 ~~~
 let values: Vec<int> = vec![1, 2, 3, 4, 5];
@@ -154,9 +153,9 @@ for value in values.iter() {  // value: &int
 }
 ~~~
 
-(See also [`mut_iter`](std/slice/trait.MutableVector.html#tymethod.mut_iter)
+(See also [`mut_iter`](../std/vec/trait.MutableVector.html#tymethod.mut_iter)
 which yields `&mut int` and
-[`move_iter`](std/slice/trait.OwnedVector.html#tymethod.move_iter) which yields
+[`move_iter`](../std/vec/trait.OwnedVector.html#tymethod.move_iter) which yields
 `int` while consuming the `values` vector.)
 
 # Type system

branches/try2/src/doc/complement-lang-faq.md

@@ -21,7 +21,7 @@ Some examples that demonstrate different aspects of the language:
 * The extra library's [json] module. Enums and pattern matching
 
 [sprocketnes]: https://github.com/pcwalton/sprocketnes
-[hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash/mod.rs
+[hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash.rs
 [HashMap]: https://github.com/mozilla/rust/blob/master/src/libcollections/hashmap.rs
 [json]: https://github.com/mozilla/rust/blob/master/src/libserialize/json.rs
 
@@ -149,6 +149,6 @@ example we were setting RUST_LOG to the name of the hello crate. Multiple paths
 can be combined to control the exact logging you want to see. For example, when
 debugging linking in the compiler you might set
 `RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
-For a full description see [the logging crate][1].
+For a full description see [the language reference][1].
 
-[1]:log/index.html
+[1]:http://doc.rust-lang.org/doc/master/rust.html#logging-system

branches/try2/src/doc/guide-lifetimes.md

@@ -67,7 +67,7 @@ Now we can call `compute_distance()`:
 # let on_the_stack :     Point  =     Point{x: 3.0, y: 4.0};
 # let on_the_heap  : Box<Point> = box Point{x: 7.0, y: 9.0};
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
-compute_distance(&on_the_stack, on_the_heap);
+compute_distance(&on_the_stack, &*on_the_heap);
 ~~~
 
 Here, the `&` operator takes the address of the variable
@@ -77,10 +77,9 @@ value. We also call this _borrowing_ the local variable
 `on_the_stack`, because we have created an alias: that is, another
 name for the same data.
 
-In the case of `on_the_heap`, however, no explicit action is necessary. 
-The compiler will automatically convert a box box point to a reference like &point. 
-This is another form of borrowing; in this case, the contents of the owned box 
-are being lent out.
+For the second argument, we need to extract the contents of `on_the_heap`
+by derefercing with the `*` symbol. Now that we have the data, we need
+to create a reference with the `&` symbol.
 
 Whenever a caller lends data to a callee, there are some limitations on what
 the caller can do with the original. For example, if the contents of a

branches/try2/src/doc/guide-unsafe.md

@@ -499,9 +499,9 @@ shouldn't get triggered.
 
 The second of these two functions, `eh_personality`, is used by the failure
 mechanisms of the compiler. This is often mapped to GCC's personality function
-(see the [libstd implementation](std/rt/unwind/index.html) for more
-information), but crates which do not trigger failure can be assured that this
-function is never called.
+(see the [libstd implementation](../std/rt/unwind/) for more information), but
+crates which do not trigger failure can be assured that this function is never
+called.
 
 ## Using libcore
 
@@ -511,8 +511,7 @@ function is never called.
 With the above techniques, we've got a bare-metal executable running some Rust
 code. There is a good deal of functionality provided by the standard library,
 however, that is necessary to be productive in Rust. If the standard library is
-not sufficient, then [libcore](core/index.html) is designed to be used
-instead.
+not sufficient, then [libcore](../core/) is designed to be used instead.
 
 The core library has very few dependencies and is much more portable than the
 standard library itself. Additionally, the core library has most of the

branches/try2/src/doc/tutorial.md

@@ -1429,7 +1429,7 @@ contains a point, but allocated in a different location:
 ~~~
 # struct Point { x: f64, y: f64 }
 let on_the_stack :     Point  =     Point { x: 3.0, y: 4.0 };
-let on_the_heap  : Box<Point> = box Point { x: 7.0, y: 9.0 };
+let owned_box    : Box<Point> = box Point { x: 7.0, y: 9.0 };
 ~~~
 
 Suppose we want to write a procedure that computes the distance
@@ -1454,9 +1454,9 @@ Now we can call `compute_distance()` in various ways:
 ~~~
 # struct Point{ x: f64, y: f64 };
 # let on_the_stack :     Point  =     Point { x: 3.0, y: 4.0 };
-# let on_the_heap  : Box<Point> = box Point { x: 7.0, y: 9.0 };
+# let owned_box    : Box<Point> = box Point { x: 7.0, y: 9.0 };
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
-compute_distance(&on_the_stack, on_the_heap);
+compute_distance(&on_the_stack, owned_box);
 ~~~
 
 Here the `&` operator is used to take the address of the variable

branches/try2/src/liballoc/lib.rs

@@ -97,7 +97,6 @@ pub mod arc;
 pub mod rc;
 
 #[cfg(not(test))]
-#[doc(hidden)]
 mod std {
     pub use core::fmt;
     pub use core::option;

branches/try2/src/libcore/bool.rs

@@ -12,8 +12,6 @@
 //!
 //! A `to_bit` conversion function.
 
-#![doc(primitive = "bool")]
-
 use num::{Int, one, zero};
 
 /////////////////////////////////////////////////////////////////////////////

branches/try2/src/libcore/char.rs

@@ -24,7 +24,6 @@
 //! and, as such, should be performed via the `from_u32` function..
 
 #![allow(non_snake_case_functions)]
-#![doc(primitive = "char")]
 
 use mem::transmute;
 use option::{None, Option, Some};

branches/try2/src/libcore/lib.rs

@@ -134,12 +134,10 @@ pub mod fmt;
 //        crate.
 mod should_not_exist;
 
-#[doc(hidden)]
 mod core {
     pub use failure;
 }
 
-#[doc(hidden)]
 mod std {
     pub use clone;
     pub use cmp;

branches/try2/src/libcore/num/f32.rs

@@ -10,8 +10,6 @@
 
 //! Operations and constants for 32-bits floats (`f32` type)
 
-#![doc(primitive = "f32")]
-
 use intrinsics;
 use mem;
 use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};

branches/try2/src/libcore/num/f64.rs

@@ -10,8 +10,6 @@
 
 //! Operations and constants for 64-bits floats (`f64` type)
 
-#![doc(primitive = "f64")]
-
 use intrinsics;
 use mem;
 use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};

branches/try2/src/libcore/num/i16.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for signed 16-bits integers (`i16` type)
 
-#![doc(primitive = "i16")]
-
 int_module!(i16, 16)
 

branches/try2/src/libcore/num/i32.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for signed 32-bits integers (`i32` type)
 
-#![doc(primitive = "i32")]
-
 int_module!(i32, 32)
 

branches/try2/src/libcore/num/i64.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for signed 64-bits integers (`i64` type)
 
-#![doc(primitive = "i64")]
-
 int_module!(i64, 64)
 

branches/try2/src/libcore/num/i8.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for signed 8-bits integers (`i8` type)
 
-#![doc(primitive = "i8")]
-
 int_module!(i8, 8)
 

branches/try2/src/libcore/num/int.rs

@@ -10,8 +10,6 @@
 
 //! Operations and constants for architecture-sized signed integers (`int` type)
 
-#![doc(primitive = "int")]
-
 #[cfg(target_word_size = "32")] int_module!(int, 32)
 #[cfg(target_word_size = "64")] int_module!(int, 64)
 

branches/try2/src/libcore/num/u16.rs

@@ -10,6 +10,4 @@
 
 //! Operations and constants for unsigned 16-bits integers (`u16` type)
 
-#![doc(primitive = "u16")]
-
 uint_module!(u16, i16, 16)

branches/try2/src/libcore/num/u32.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for unsigned 32-bits integers (`u32` type)
 
-#![doc(primitive = "u32")]
-
 uint_module!(u32, i32, 32)
 

branches/try2/src/libcore/num/u64.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for unsigned 64-bits integer (`u64` type)
 
-#![doc(primitive = "u64")]
-
 uint_module!(u64, i64, 64)
 

branches/try2/src/libcore/num/u8.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for unsigned 8-bits integers (`u8` type)
 
-#![doc(primitive = "u8")]
-
 uint_module!(u8, i8, 8)
 

branches/try2/src/libcore/num/uint.rs

@@ -10,7 +10,5 @@
 
 //! Operations and constants for architecture-sized unsigned integers (`uint` type)
 
-#![doc(primitive = "uint")]
-
 uint_module!(uint, int, ::int::BITS)
 

branches/try2/src/libcore/result.rs

@@ -234,8 +234,8 @@
 //! similar and complementary: they are often employed to indicate a
 //! lack of a return value; and they are trivially converted between
 //! each other, so `Result`s are often handled by first converting to
-//! `Option` with the [`ok`](type.Result.html#method.ok) and
-//! [`err`](type.Result.html#method.ok) methods.
+//! `Option` with the [`ok`](enum.Result.html#method.ok) and
+//! [`err`](enum.Result.html#method.ok) methods.
 //!
 //! Whereas `Option` only indicates the lack of a value, `Result` is
 //! specifically for error reporting, and carries with it an error

branches/try2/src/libcore/slice.rs

@@ -12,8 +12,6 @@
 //!
 //! For more details `std::slice`.
 
-#![doc(primitive = "slice")]
-
 use mem::transmute;
 use clone::Clone;
 use container::Container;

branches/try2/src/libcore/str.rs

@@ -12,8 +12,6 @@
 //!
 //! For more details, see std::str
 
-#![doc(primitive = "str")]
-
 use mem;
 use char;
 use clone::Clone;

branches/try2/src/libcore/tuple.rs

@@ -59,8 +59,6 @@
 //! assert_eq!(d, (0u32, 0.0f32));
 //! ```
 
-#![doc(primitive = "tuple")]
-
 use clone::Clone;
 #[cfg(not(test))] use cmp::*;
 #[cfg(not(test))] use default::Default;