---

yaml
---
r: 210801
b: refs/heads/try
c: 785cbe3
h: refs/heads/master
i:
  210799: cfa9d06
v: v3

Author: Paul Faria

[refs]

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

branches/try/src/doc/reference.md

@@ -3529,9 +3529,7 @@ The actual implementation for each vtable entry can vary on an object-by-object
 basis.
 
 Note that for a trait object to be instantiated, the trait must be
-_object-safe_. Object safety rules are defined in [RFC 255].
-
-[RFC 255]: https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md
+_object-safe_. Object safety rules are defined in [RFC 255][rfc255].
 
 Given a pointer-typed expression `E` of type `&T` or `Box<T>`, where `T`
 implements trait `R`, casting `E` to the corresponding pointer type `&R` or

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

@@ -6,7 +6,7 @@ and more cores, yet many programmers aren't prepared to fully utilize them.
 
 Rust's memory safety features also apply to its concurrency story too. Even
 concurrent Rust programs must be memory safe, having no data races. Rust's type
-system is up to the task, and gives you powerful ways to reason about
+system is up to the thread, and gives you powerful ways to reason about
 concurrent code at compile time.
 
 Before we talk about the concurrency features that come with Rust, it's important

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

@@ -42,7 +42,7 @@ loop is just a handy way to write this `loop`/`match`/`break` construct.
 `for` loops aren't the only thing that uses iterators, however. Writing your
 own iterator involves implementing the `Iterator` trait. While doing that is
 outside of the scope of this guide, Rust provides a number of useful iterators
-to accomplish various tasks. Before we talk about those, we should talk about a
+to accomplish various threads. Before we talk about those, we should talk about a
 Rust anti-pattern. And that's using ranges like this.
 
 Yes, we just talked about how ranges are cool. But ranges are also very

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

@@ -35,7 +35,7 @@ let y = &mut x;
 
 `y` is an immutable binding to a mutable reference, which means that you can’t
 bind `y` to something else (`y = &mut z`), but you can mutate the thing that’s
-bound to `y` (`*y = 5`). A subtle distinction.
+bound to `y`. (`*y = 5`) A subtle distinction.
 
 Of course, if you need both:
 

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

@@ -66,7 +66,7 @@ match x {
 }
 ```
 
-This prints `something else`.
+This prints `something else`
 
 # Bindings
 
@@ -152,7 +152,7 @@ match x {
 }
 ```
 
-This prints `Got an int!`.
+This prints `Got an int!`
 
 # ref and ref mut
 

branches/try/src/doc/trpl/the-stack-and-the-heap.md

@@ -430,7 +430,7 @@ Next, `foo()` calls `bar()` with `x` and `z`:
 |  2<sup>30</sup>      |      | 20                   |
 | (2<sup>30</sup>) - 1 |      | 5                    |
 | ...                  | ...  | ...                  |
-| 10                   | e    | 4                    |
+| 10                   | e    | 9                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |
 | 7                    | b    | 4                    |
@@ -455,7 +455,7 @@ At the end of `bar()`, it calls `baz()`:
 | ...                  | ...  | ...                  |
 | 12                   | g    | 100                  |
 | 11                   | f    | 4                    |
-| 10                   | e    | 4                    |
+| 10                   | e    | 9                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |
 | 7                    | b    | 4                    |
@@ -477,7 +477,7 @@ After `baz()` is over, we get rid of `f` and `g`:
 |  2<sup>30</sup>      |      | 20                   |
 | (2<sup>30</sup>) - 1 |      | 5                    |
 | ...                  | ...  | ...                  |
-| 10                   | e    | 4                    |
+| 10                   | e    | 9                    |
 | 9                    | d    | (2<sup>30</sup>) - 1 |
 | 8                    | c    | 5                    |
 | 7                    | b    | 4                    |

branches/try/src/doc/trpl/while-loops.md

@@ -3,7 +3,7 @@
 Rust also has a `while` loop. It looks like this:
 
 ```{rust}
-let mut x = 5; // mut x: i32
+let mut x = 5; // mut x: u32
 let mut done = false; // mut done: bool
 
 while !done {

branches/try/src/librustc/lib.rs

@@ -30,8 +30,6 @@
 #![feature(box_syntax)]
 #![feature(collections)]
 #![feature(core)]
-#![feature(duration)]
-#![feature(duration_span)]
 #![feature(fs_canonicalize)]
 #![feature(hash)]
 #![feature(into_cow)]

branches/try/src/librustc/metadata/loader.rs

@@ -720,7 +720,8 @@ fn get_metadata_section(is_osx: bool, filename: &Path) -> Result<MetadataBlob, S
     let dur = Duration::span(|| {
         ret = Some(get_metadata_section_imp(is_osx, filename));
     });
-    info!("reading {:?} => {}", filename.file_name().unwrap(), dur);
+    info!("reading {:?} => {}ms", filename.file_name().unwrap(),
+          dur.num_milliseconds());
     return ret.unwrap();;
 }
 

branches/try/src/librustc/util/common.rs

@@ -55,8 +55,8 @@ pub fn time<T, U, F>(do_it: bool, what: &str, u: U, f: F) -> T where
     };
     let rv = rv.unwrap();
 
-    println!("{}time: {} \t{}", repeat("  ").take(old).collect::<String>(),
-             dur, what);
+    println!("{}time: {}.{:03} \t{}", repeat("  ").take(old).collect::<String>(),
+             dur.num_seconds(), dur.num_milliseconds() % 1000, what);
     DEPTH.with(|slot| slot.set(old));
 
     rv

branches/try/src/librustc_resolve/diagnostics.rs

@@ -49,88 +49,6 @@ about what constitutes an Item declaration and what does not:
 http://doc.rust-lang.org/reference.html#statements
 "##,
 
-E0251: r##"
-Two items of the same name cannot be imported without rebinding one of the
-items under a new local name.
-
-An example of this error:
-
-```
-use foo::baz;
-use bar::*; // error, do `use foo::baz as quux` instead on the previous line
-
-fn main() {}
-
-mod foo {
-    pub struct baz;
-}
-
-mod bar {
-    pub mod baz {}
-}
-```
-"##,
-
-E0252: r##"
-Two items of the same name cannot be imported without rebinding one of the
-items under a new local name.
-
-An example of this error:
-
-```
-use foo::baz;
-use bar::baz; // error, do `use bar::baz as quux` instead
-
-fn main() {}
-
-mod foo {
-    pub struct baz;
-}
-
-mod bar {
-    pub mod baz {}
-}
-```
-"##,
-
-E0255: r##"
-You can't import a value whose name is the same as another value defined in the
-module.
-
-An example of this error:
-
-```
-use bar::foo; // error, do `use bar::foo as baz` instead
-
-fn foo() {}
-
-mod bar {
-     pub fn foo() {}
-}
-
-fn main() {}
-```
-"##,
-
-E0256: r##"
-You can't import a type or module when the name of the item being imported is
-the same as another type or submodule defined in the module.
-
-An example of this error:
-
-```
-use foo::Bar; // error
-
-type Bar = u32;
-
-mod foo {
-    pub mod Bar { }
-}
-
-fn main() {}
-```
-"##,
-
 E0259: r##"
 The name chosen for an external crate conflicts with another external crate that
 has been imported into the current module.
@@ -204,10 +122,14 @@ http://doc.rust-lang.org/reference.html#types
 register_diagnostics! {
     E0157,
     E0153,
+    E0251, // a named type or value has already been imported in this module
+    E0252, // a named type or value has already been imported in this module
     E0253, // not directly importable
     E0254, // import conflicts with imported crate in this module
-    E0257,
-    E0258,
+    E0255, // import conflicts with value in this module
+    E0256, // import conflicts with type in this module
+    E0257, // inherent implementations are only allowed on types defined in the current module
+    E0258, // import conflicts with existing submodule
     E0364, // item is private
     E0365  // item is private
 }

branches/try/src/librustc_typeck/check/mod.rs

@@ -3082,8 +3082,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
           let mut checked = false;
           opt_place.as_ref().map(|place| match place.node {
               ast::ExprPath(None, ref path) => {
-                  // FIXME(pcwalton): For now we hardcode the only permissible
-                  // place: the exchange heap.
+                  // FIXME(pcwalton): For now we hardcode the two permissible
+                  // places: the exchange heap and the managed heap.
                   let definition = lookup_full_def(tcx, path.span, place.id);
                   let def_id = definition.def_id();
                   let referent_ty = fcx.expr_ty(&**subexpr);
@@ -3097,7 +3097,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
 
           if !checked {
               span_err!(tcx.sess, expr.span, E0066,
-                  "only the exchange heap is currently supported");
+                  "only the managed heap and exchange heap are currently supported");
               fcx.write_ty(id, tcx.types.err);
           }
       }
@@ -3317,8 +3317,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                         if let Err(_) = fcx.mk_eqty(false, infer::Misc(expr.span),
                                                     result_type, ty::mk_nil(fcx.tcx())) {
                             span_err!(tcx.sess, expr.span, E0069,
-                                "`return;` in a function whose return type is \
-                                 not `()`");
+                                "`return;` in function returning non-nil");
                         },
                     Some(ref e) => {
                         check_expr_coercable_to_type(fcx, &**e, result_type);