---

yaml
---
r: 209591
b: refs/heads/try
c: e8fbd1c
h: refs/heads/master
i:
  209589: b0a453d
  209587: 12f608d
  209583: f742959
v: v3

Author: oh-its-jimjam

[refs]

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

branches/try/mk/crates.mk

@@ -52,19 +52,18 @@
 TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test rand \
                  log graphviz core rbml alloc \
-                 rustc_unicode rustc_bitflags
+                 unicode rustc_bitflags
 RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
-                rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
-                rustc_data_structures
+                rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc rustbook
 
 DEPS_core :=
 DEPS_libc := core
-DEPS_rustc_unicode := core
+DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
-DEPS_std := core libc rand alloc collections rustc_unicode \
+DEPS_std := core libc rand alloc collections unicode \
 	native:rust_builtin native:backtrace native:rustrt_native \
 	rustc_bitflags
 DEPS_graphviz := std
@@ -81,10 +80,9 @@ DEPS_rustc_resolve := rustc log syntax
 DEPS_rustc_privacy := rustc log syntax
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
-              log graphviz rustc_llvm rustc_back rustc_data_structures
+              log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
-DEPS_rustc_data_structures := std log serialize
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint
 DEPS_rustc_bitflags := core
@@ -96,7 +94,7 @@ DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
 DEPS_getopts := std
-DEPS_collections := core alloc rustc_unicode
+DEPS_collections := core alloc unicode
 DEPS_num := std
 DEPS_test := std getopts serialize rbml term native:rust_test_helpers
 DEPS_rand := core
@@ -117,11 +115,11 @@ ONLY_RLIB_libc := 1
 ONLY_RLIB_alloc := 1
 ONLY_RLIB_rand := 1
 ONLY_RLIB_collections := 1
-ONLY_RLIB_rustc_unicode := 1
+ONLY_RLIB_unicode := 1
 ONLY_RLIB_rustc_bitflags := 1
 
 # Documented-by-default crates
-DOC_CRATES := std alloc collections core libc rustc_unicode
+DOC_CRATES := std alloc collections core libc unicode
 
 ################################################################################
 # You should not need to edit below this line

branches/try/mk/tests.mk

@@ -15,14 +15,14 @@
 
 # The names of crates that must be tested
 
-# libcore/librustc_unicode tests are in a separate crate
+# libcore/libunicode tests are in a separate crate
 DEPS_coretest :=
 $(eval $(call RUST_CRATE,coretest))
 
 DEPS_collectionstest :=
 $(eval $(call RUST_CRATE,collectionstest))
 
-TEST_TARGET_CRATES = $(filter-out core rustc_unicode,$(TARGET_CRATES)) \
+TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) \
 			collectionstest coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
 TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve \

branches/try/src/compiletest/compiletest.rs

@@ -368,7 +368,7 @@ pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::Test
 fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
     match full_version_line {
         Some(ref full_version_line)
-          if !full_version_line.trim().is_empty() => {
+          if full_version_line.trim().len() > 0 => {
             let full_version_line = full_version_line.trim();
 
             // used to be a regex "(^|[^0-9])([0-9]\.[0-9])([^0-9]|$)"
@@ -408,7 +408,7 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
 
     match full_version_line {
         Some(ref full_version_line)
-          if !full_version_line.trim().is_empty() => {
+          if full_version_line.trim().len() > 0 => {
             let full_version_line = full_version_line.trim();
 
             for (pos, l) in full_version_line.char_indices() {
@@ -426,7 +426,7 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
                 let vers = full_version_line[pos + 5..].chars().take_while(|c| {
                     c.is_digit(10)
                 }).collect::<String>();
-                if !vers.is_empty() { return Some(vers) }
+                if vers.len() > 0 { return Some(vers) }
             }
             println!("Could not extract LLDB version from line '{}'",
                      full_version_line);

branches/try/src/compiletest/runtest.rs

@@ -864,7 +864,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                 }
                 first = false;
             }
-            if !failed && rest.is_empty() {
+            if !failed && rest.len() == 0 {
                 i += 1;
             }
             if i == num_check_lines {
@@ -1662,7 +1662,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
 // codegen tests (vs. clang)
 
 fn append_suffix_to_stem(p: &Path, suffix: &str) -> PathBuf {
-    if suffix.is_empty() {
+    if suffix.len() == 0 {
         p.to_path_buf()
     } else {
         let mut stem = p.file_stem().unwrap().to_os_string();

branches/try/src/doc/complement-design-faq.md

@@ -56,7 +56,7 @@ Types which are [`Sync`][sync] are thread-safe when multiple shared
 references to them are used concurrently. Types which are not `Sync` are not
 thread-safe, and thus when used in a global require unsafe code to use.
 
-[sync]: core/marker/trait.Sync.html
+[sync]: core/kinds/trait.Sync.html
 
 ### If mutable static items that implement `Sync` are safe, why is taking &mut SHARABLE unsafe?
 
@@ -139,7 +139,7 @@ and explicitly calling the `clone` method. Making user-defined copy operators
 explicit surfaces the underlying complexity, forcing the developer to opt-in
 to potentially expensive operations.
 
-[copy]: core/marker/trait.Copy.html
+[copy]: core/kinds/trait.Copy.html
 [clone]: core/clone/trait.Clone.html
 
 ## No move constructors

branches/try/src/doc/index.md

@@ -19,7 +19,7 @@ ideas behind Rust.
 donated to the Rust project. As the name implies, it teaches you Rust through a
 series of small examples.
 
-[rbe]: http://rustbyexample.com/
+[rbe]: rustbyexample.com
 
 # Community & Getting Help
 

branches/try/src/doc/reference.md

@@ -2177,14 +2177,6 @@ The following configurations must be defined by the implementation:
 * `unix`. See `target_family`.
 * `windows`. See `target_family`.
 
-You can also set another attribute based on a `cfg` variable with `cfg_attr`:
-
-```rust,ignore
-#[cfg_attr(a, b)]
-```
-
-Will be the same as `#[b]` if `a` is set by `cfg`, and nothing otherwise.
-
 ### Lint check attributes
 
 A lint check names a potentially undesirable coding pattern, such as
@@ -2376,7 +2368,7 @@ The currently implemented features of the reference compiler are:
                     removed entirely for something more wholesome.
 
 * `custom_attribute` - Allows the usage of attributes unknown to the compiler
-                       so that new attributes can be added in a backwards compatible
+                       so that new attributes can be added in a bacwards compatible
                        manner (RFC 572).
 
 * `custom_derive` - Allows the use of `#[derive(Foo,Bar)]` as sugar for
@@ -2405,7 +2397,7 @@ The currently implemented features of the reference compiler are:
                  nasty hack that will certainly be removed.
 
 * `main` - Allows use of the `#[main]` attribute, which changes the entry point
-           into a Rust program. This capability is subject to change.
+           into a Rust program. This capabiilty is subject to change.
 
 * `macro_reexport` - Allows macros to be re-exported from one crate after being imported
                      from another. This feature was originally designed with the sole
@@ -2452,9 +2444,7 @@ The currently implemented features of the reference compiler are:
 * `simd_ffi` - Allows use of SIMD vectors in signatures for foreign functions.
                The SIMD interface is subject to change.
 
-* `staged_api` - Allows usage of stability markers and `#![staged_api]` in a
-                 crate. Stability markers are also attributes: `#[stable]`,
-                 `#[unstable]`, and `#[deprecated]` are the three levels.
+* `staged_api` - Allows usage of stability markers and `#![staged_api]` in a crate
 
 * `static_assert` - The `#[static_assert]` functionality is experimental and
                     unstable. The attribute can be attached to a `static` of
@@ -2463,7 +2453,7 @@ The currently implemented features of the reference compiler are:
                     is unintuitive and suboptimal.
 
 * `start` - Allows use of the `#[start]` attribute, which changes the entry point
-            into a Rust program. This capability, especially the signature for the
+            into a Rust program. This capabiilty, especially the signature for the
             annotated function, is subject to change.
 
 * `struct_inherit` - Allows using struct inheritance, which is barely
@@ -3798,7 +3788,7 @@ its type parameters are types:
 
 ```ignore
 fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
-    if xs.is_empty() {
+    if xs.len() == 0 {
        return vec![];
     }
     let first: B = f(xs[0].clone());

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

@@ -205,11 +205,11 @@ you tons of control over what your code does, and closures are no different.
 
 Rust's implementation of closures is a bit different than other languages. They
 are effectively syntax sugar for traits. You'll want to make sure to have read
-the [traits chapter][traits] before this one, as well as the chapter on [trait
-objects][trait-objects].
+the [traits chapter][traits] before this one, as well as the chapter on [static
+and dynamic dispatch][dispatch], which talks about trait objects.
 
 [traits]: traits.html
-[trait-objects]: trait-objects.html
+[dispatch]: static-and-dynamic-dispatch.html
 
 Got all that? Good.
 

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

@@ -176,8 +176,8 @@ Here's the error:
                   ^~~~~~~~~~~~~
 ```
 
-You see, [`Mutex`](../std/sync/struct.Mutex.html) has a
-[`lock`](../std/sync/struct.Mutex.html#method.lock)
+You see, [`Mutex`](std/sync/struct.Mutex.html) has a
+[`lock`](http://doc.rust-lang.org/nightly/std/sync/struct.Mutex.html#method.lock)
 method which has this signature:
 
 ```ignore

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

@@ -380,10 +380,7 @@ $ rustdoc --test path/to/my/crate/root.rs
 $ cargo test
 ```
 
-That's right, `cargo test` tests embedded documentation too. However, 
-`cargo test` will not test binary crates, only library ones. This is
-due to the way `rustdoc` works: it links against the library to be tested,
-but with a binary, there’s nothing to link to.
+That's right, `cargo test` tests embedded documentation too.
 
 There are a few more annotations that are useful to help `rustdoc` do the right
 thing when testing your code:
@@ -563,13 +560,3 @@ This sets a few different options, with a logo, favicon, and a root URL.
 - `--html-before-content FILE`: includes the contents of FILE directly after
   `<body>`, before the rendered content (including the search bar).
 - `--html-after-content FILE`: includes the contents of FILE after all the rendered content.
-
-## Security note
-
-The Markdown in documentation comments is placed without processing into
-the final webpage. Be careful with literal HTML:
-
-```rust
-/// <script>alert(document.cookie)</script>
-# fn foo() {}
-```

branches/try/src/doc/trpl/error-handling.md

@@ -20,18 +20,18 @@ panic. A *failure* is an error that can be recovered from in some way. A
 *panic* is an error that cannot be recovered from.
 
 What do we mean by "recover"? Well, in most cases, the possibility of an error
-is expected. For example, consider the `parse` function:
+is expected. For example, consider the `from_str` function:
 
-```ignore
-"5".parse();
+```{rust,ignore}
+from_str("5");
 ```
 
-This method converts a string into another type. But because it's a string, you
-can't be sure that the conversion actually works. For example, what should this
-convert to?
+This function takes a string argument and converts it into another type. But
+because it's a string, you can't be sure that the conversion actually works.
+For example, what should this convert to?
 
-```ignore
-"hello5world".parse();
+```{rust,ignore}
+from_str("hello5world");
 ```
 
 This won't work. So we know that this function will only work properly for some
@@ -40,8 +40,7 @@ inputs. It's expected behavior. We call this kind of error a *failure*.
 On the other hand, sometimes, there are errors that are unexpected, or which
 we cannot recover from. A classic example is an `assert!`:
 
-```rust
-# let x = 5;
+```{rust,ignore}
 assert!(x == 5);
 ```
 
@@ -120,19 +119,17 @@ Rust calls these sorts of errors *panics*.
 # Handling errors with `Option` and `Result`
 
 The simplest way to indicate that a function may fail is to use the `Option<T>`
-type. For example, the `find` method on strings attempts to find a pattern
-in a string, and returns an `Option`:
+type. Remember our `from_str()` example? Here's its type signature:
 
-```rust
-let s = "foo";
-
-assert_eq!(s.find('f'), Some(0));
-assert_eq!(s.find('z'), None);
+```{rust,ignore}
+pub fn from_str<A: FromStr>(s: &str) -> Option<A>
 ```
 
+`from_str()` returns an `Option<A>`. If the conversion succeeds, it will return
+`Some(value)`, and if it fails, it will return `None`.
 
 This is appropriate for the simplest of cases, but doesn't give us a lot of
-information in the failure case. What if we wanted to know _why_ the function
+information in the failure case. What if we wanted to know _why_ the conversion
 failed? For this, we can use the `Result<T, E>` type. It looks like this:
 
 ```rust
@@ -300,5 +297,5 @@ It's worth noting that you can only use `try!` from a function that returns a
 `Result`, which means that you cannot use `try!` inside of `main()`, because
 `main()` doesn't return anything.
 
-`try!` makes use of [`From<Error>`](../std/convert/trait.From.html) to determine
+`try!` makes use of [`From<Error>`](../std/convert/trait.From.hml) to determine
 what to return in the error case.

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

@@ -166,7 +166,7 @@ pub fn uncompress(src: &[u8]) -> Option<Vec<u8>> {
 }
 ```
 
-For reference, the examples used here are also available as a [library on
+For reference, the examples used here are also available as an [library on
 GitHub](https://github.com/thestinger/rust-snappy).
 
 # Destructors

branches/try/src/doc/trpl/hello-cargo.md

@@ -89,7 +89,7 @@ we hadn’t changed the source file, and so it just ran the binary. If we had
 made a modification, we would have seen it do both:
 
 ```bash
-$ cargo run
+$ cargo build
    Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world)
      Running `target/debug/hello_world`
 Hello, world!

branches/try/src/doc/trpl/hello-world.md

@@ -104,10 +104,10 @@ We’ll get to the details eventually, you’ll just have to trust us for now.
 
 Next, `"Hello, world!"` is a ‘string’. Strings are a surprisingly complicated
 topic in a systems programming language, and this is a ‘statically allocated’
-string. If you want to read further about allocation, check out
-[the stack and the heap][allocation], but you don’t need to right now if you
-don’t want to. We pass this string as an argument to `println!`, which prints the
-string to the screen. Easy enough!
+string. If you want to read further about allocation, check out [the stack and
+the heap], but you don’t need to right now if you don’t want to. We pass this
+string as an argument to `println!`, which prints the string to the screen.
+Easy enough!
 
 [allocation]: the-stack-and-the-heap.html
 

branches/try/src/doc/trpl/installing-rust.md

@@ -90,10 +90,10 @@ If not, there are a number of places where you can get help. The easiest is
 [the #rust IRC channel on irc.mozilla.org][irc], which you can access through
 [Mibbit][mibbit]. Click that link, and you'll be chatting with other Rustaceans
 (a silly nickname we call ourselves), and we can help you out. Other great
-resources include [the user’s forum][users], and
-[Stack Overflow][stackoverflow].
+resources include [the user’s forum][users], and [Stack Overflow][stack
+overflow].
 
 [irc]: irc://irc.mozilla.org/#rust
 [mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
 [users]: http://users.rust-lang.org/ 
-[stackoverflow]: http://stackoverflow.com/questions/tagged/rust
+[stack overflow]: http://stackoverflow.com/questions/tagged/rust

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

@@ -33,7 +33,7 @@ mind.
 You may have seen the `vec!` macro, used to initialize a [vector][] with any
 number of elements.
 
-[vector]: vectors.html
+[vector]: arrays-vectors-and-slices.html
 
 ```rust
 let x: Vec<u32> = vec![1, 2, 3];