---

yaml
---
r: 218190
b: refs/heads/tmp
c: 3c76163
h: refs/heads/master
v: v3

Author: GuillaumeGomez

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: 18adf6230e2e229d4d73391cebff060afc5e5aaa
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: b6c7dff72864f91e5256f7d50b6d0a3f03ee3733
+refs/heads/tmp: 3c76163e1dc410db525bfaa7157726bd7a8a7dfe
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: e6596d0052e79e6393bbee3538bb122930d89887
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

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

@@ -10,12 +10,11 @@ system is up to the task, 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
-to understand something: Rust is low-level enough that the vast majority of
-this is provided by the standard library, not by the language. This means that
-if you don't like some aspect of the way Rust handles concurrency, you can
-implement an alternative way of doing things.
-[mio](https://github.com/carllerche/mio) is a real-world example of this
-principle in action.
+to understand something: Rust is low-level enough that all of this is provided
+by the standard library, not by the language. This means that if you don't like
+some aspect of the way Rust handles concurrency, you can implement an alternative
+way of doing things. [mio](https://github.com/carllerche/mio) is a real-world
+example of this principle in action.
 
 ## Background: `Send` and `Sync`
 

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

@@ -101,8 +101,6 @@ the lifetime `'a` has snuck in between the `&` and the `mut i32`. We read `&mut
 i32` as ‘a mutable reference to an i32’ and `&'a mut i32` as ‘a mutable
 reference to an `i32` with the lifetime `'a`’.
 
-# In `struct`s
-
 You’ll also need explicit lifetimes when working with [`struct`][structs]s:
 
 ```rust
@@ -139,33 +137,6 @@ x: &'a i32,
 uses it. So why do we need a lifetime here? We need to ensure that any reference
 to a `Foo` cannot outlive the reference to an `i32` it contains.
 
-## `impl` blocks
-
-Let’s implement a method on `Foo`:
-
-```rust
-struct Foo<'a> {
-    x: &'a i32,
-}
-
-impl<'a> Foo<'a> {
-    fn x(&self) -> &'a i32 { self.x }
-}
-
-fn main() {
-    let y = &5; // this is the same as `let _y = 5; let y = &_y;`
-    let f = Foo { x: y };
-
-    println!("x is: {}", f.x());
-}
-```
-
-As you can see, we need to declare a lifetime for `Foo` in the `impl` line. We repeat
-`'a` twice, just like on functions: `impl<'a>` defines a lifetime `'a`, and `Foo<'a>`
-uses it.
-
-## Multiple lifetimes
-
 If you have multiple references, you can use the same lifetime multiple times:
 
 ```rust

branches/tmp/src/doc/trpl/unsafe.md

@@ -8,7 +8,7 @@ this, Rust has a keyword, `unsafe`. Code using `unsafe` has less restrictions
 than normal code does.
 
 Let’s go over the syntax, and then we’ll talk semantics. `unsafe` is used in
-four contexts. The first one is to mark a function as unsafe:
+two contexts. The first one is to mark a function as unsafe:
 
 ```rust
 unsafe fn danger_will_robinson() {
@@ -27,40 +27,15 @@ unsafe {
 }
 ```
 
-The third is for unsafe traits:
-
-```rust
-unsafe trait Scary { }
-```
-
-And the fourth is for `impl`ementing one of those traits:
-
-```rust
-# unsafe trait Scary { }
-unsafe impl Scary for i32 {}
-```
-
 It’s important to be able to explicitly delineate code that may have bugs that
 cause big problems. If a Rust program segfaults, you can be sure it’s somewhere
 in the sections marked `unsafe`.
 
 # What does ‘safe’ mean?
 
-Safe, in the context of Rust, means ‘doesn’t do anything unsafe’. It’s also
-important to know that there are certain behaviors that are probably not
-desirable in your code, but are expressly _not_ unsafe:
+Safe, in the context of Rust, means “doesn’t do anything unsafe.” Easy!
 
-* Deadlocks
-* Leaks of memory or other resources
-* Exiting without calling destructors
-* Integer overflow
-
-Rust cannot prevent all kinds of software problems. Buggy code can and will be
-written in Rust. These things aren’t great, but they don’t qualify as `unsafe`
-specifically.
-
-In addition, the following are all undefined behaviors in Rust, and must be
-avoided, even when writing `unsafe` code:
+Okay, let’s try again: what is not safe to do? Here’s a list:
 
 * Data races
 * Dereferencing a null/dangling raw pointer
@@ -89,6 +64,18 @@ avoided, even when writing `unsafe` code:
 [undef]: http://llvm.org/docs/LangRef.html#undefined-values
 [aliasing]: http://llvm.org/docs/LangRef.html#pointer-aliasing-rules
 
+Whew! That’s a bunch of stuff. It’s also important to notice all kinds of
+behaviors that are certainly bad, but are expressly _not_ unsafe:
+
+* Deadlocks
+* Leaks of memory or other resources
+* Exiting without calling destructors
+* Integer overflow
+
+Rust cannot prevent all kinds of software problems. Buggy code can and will be
+written in Rust. These things aren’t great, but they don’t qualify as `unsafe`
+specifically.
+
 # Unsafe Superpowers
 
 In both unsafe functions and unsafe blocks, Rust will let you do three things

branches/tmp/src/librustc_driver/driver.rs

@@ -547,7 +547,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
                                                   sess.diagnostic()));
 
     krate = time(time_passes, "prelude injection", krate, |krate|
-                 syntax::std_inject::maybe_inject_prelude(&sess.parse_sess, krate));
+                 syntax::std_inject::maybe_inject_prelude(krate));
 
     time(time_passes, "checking that all macro invocations are gone", &krate, |krate|
          syntax::ext::expand::check_for_macros(&sess.parse_sess, krate));

branches/tmp/src/librustc_typeck/diagnostics.rs

@@ -1368,62 +1368,6 @@ struct Foo {
 ```
 "##,
 
-E0128: r##"
-Type parameter defaults can only use parameters that occur before them.
-Erroneous code example:
-
-```
-pub struct Foo<T=U, U=()> {
-    field1: T,
-    filed2: U,
-}
-// error: type parameters with a default cannot use forward declared
-// identifiers
-```
-
-Since type parameters are evaluated in-order, you may be able to fix this issue
-by doing:
-
-```
-pub struct Foo<U=(), T=U> {
-    field1: T,
-    filed2: U,
-}
-```
-
-Please also verify that this wasn't because of a name-clash and rename the type
-parameter if so.
-"##,
-
-E0130: r##"
-You declared a pattern as an argument in a foreign function declaration.
-Erroneous code example:
-
-```
-extern {
-    fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign
-                                //        function declarations
-}
-```
-
-Please replace the pattern argument with a regular one. Example:
-
-```
-struct SomeStruct {
-    a: u32,
-    b: u32,
-}
-
-extern {
-    fn foo(s: SomeStruct); // ok!
-}
-// or
-extern {
-    fn foo(a: (u32, u32)); // ok!
-}
-```
-"##,
-
 E0131: r##"
 It is not possible to define `main` with type parameters, or even with function
 parameters. When `main` is present, it must take no arguments and return `()`.
@@ -1438,30 +1382,6 @@ fn(isize, *const *const u8) -> isize
 ```
 "##,
 
-E0159: r##"
-You tried to use a trait as a struct constructor. Erroneous code example:
-
-```
-trait TraitNotAStruct {}
-
-TraitNotAStruct{ value: 0 }; // error: use of trait `TraitNotAStruct` as a
-                             //        struct constructor
-```
-
-Please verify you used the correct type name or please implement the trait
-on a struct and use this struct constructor. Example:
-
-```
-trait TraitNotAStruct {}
-
-struct Foo {
-    value: i32
-}
-
-Foo{ value: 0 }; // ok!
-```
-"##,
-
 E0166: r##"
 This error means that the compiler found a return expression in a function
 marked as diverging. A function diverges if it has `!` in the place of the
@@ -1547,6 +1467,7 @@ impl Foo for Bar {
     // the impl
     fn foo() {}
 }
+```
 "##,
 
 E0192: r##"
@@ -2058,8 +1979,11 @@ register_diagnostics! {
     E0122,
     E0123,
     E0127,
+    E0128,
     E0129,
+    E0130,
     E0141,
+    E0159,
     E0163,
     E0164,
     E0167,

branches/tmp/src/libsyntax/feature_gate.rs

@@ -155,9 +155,6 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[
 
     // Allows the definition of `const fn` functions.
     ("const_fn", "1.2.0", Active),
-
-    // Allows using #[prelude_import] on glob `use` items.
-    ("prelude_import", "1.2.0", Active),
 ];
 // (changing above list without updating src/doc/reference.md makes @cmr sad)
 
@@ -268,8 +265,7 @@ pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[
                                    and may be removed in the future")),
 
     // used in resolve
-    ("prelude_import", Gated("prelude_import",
-                             "`#[prelude_import]` is for use by rustc only")),
+    ("prelude_import", Whitelisted),
 
     // FIXME: #14407 these are only looked at on-demand so we can't
     // guarantee they'll have already been checked

branches/tmp/src/libsyntax/print/pprust.rs

@@ -120,13 +120,11 @@ pub fn print_crate<'a>(cm: &'a CodeMap,
         // of the feature gate, so we fake them up here.
 
         let no_std_meta = attr::mk_word_item(InternedString::new("no_std"));
-        let prelude_import_meta = attr::mk_word_item(InternedString::new("prelude_import"));
 
         // #![feature(no_std)]
         let fake_attr = attr::mk_attr_inner(attr::mk_attr_id(),
                                             attr::mk_list_item(InternedString::new("feature"),
-                                                               vec![no_std_meta.clone(),
-                                                                    prelude_import_meta]));
+                                                               vec![no_std_meta.clone()]));
         try!(s.print_attribute(&fake_attr));
 
         // #![no_std]