---

yaml
---
r: 235233
b: refs/heads/stable
c: f29b565
h: refs/heads/master
i:
  235231: 169a667
v: v3

Author: steveklabnik

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: c69663caf6001e7681336cd0fe7f50c5211e8016
+refs/heads/stable: f29b565e2d73cd0d5e732d6b04bcbb19ce4363b4
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

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

@@ -101,6 +101,8 @@ 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
@@ -137,6 +139,33 @@ 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/stable/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/stable/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
@@ -2058,8 +1978,11 @@ register_diagnostics! {
     E0122,
     E0123,
     E0127,
+    E0128,
     E0129,
+    E0130,
     E0141,
+    E0159,
     E0163,
     E0164,
     E0167,

branches/stable/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/stable/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]

branches/stable/src/libsyntax/std_inject.rs

@@ -10,35 +10,16 @@
 
 use ast;
 use attr;
-use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute};
+use codemap::DUMMY_SP;
 use codemap;
 use fold::Folder;
 use fold;
 use parse::token::InternedString;
 use parse::token::special_idents;
-use parse::{token, ParseSess};
+use parse::token;
 use ptr::P;
 use util::small_vector::SmallVector;
 
-/// Craft a span that will be ignored by the stability lint's
-/// call to codemap's is_internal check.
-/// The expanded code uses the unstable `#[prelude_import]` attribute.
-fn ignored_span(sess: &ParseSess, sp: Span) -> Span {
-    let info = ExpnInfo {
-        call_site: DUMMY_SP,
-        callee: NameAndSpan {
-            name: "std_inject".to_string(),
-            format: MacroAttribute,
-            span: None,
-            allow_internal_unstable: true,
-        }
-    };
-    let expn_id = sess.codemap().record_expansion(info);
-    let mut sp = sp;
-    sp.expn_id = expn_id;
-    return sp;
-}
-
 pub fn maybe_inject_crates_ref(krate: ast::Crate, alt_std_name: Option<String>)
                                -> ast::Crate {
     if use_std(&krate) {
@@ -48,12 +29,9 @@ pub fn maybe_inject_crates_ref(krate: ast::Crate, alt_std_name: Option<String>)
     }
 }
 
-pub fn maybe_inject_prelude(sess: &ParseSess, krate: ast::Crate) -> ast::Crate {
+pub fn maybe_inject_prelude(krate: ast::Crate) -> ast::Crate {
     if use_std(&krate) {
-        let mut fold = PreludeInjector {
-            span: ignored_span(sess, DUMMY_SP)
-        };
-        fold.fold_crate(krate)
+        inject_prelude(krate)
     } else {
         krate
     }
@@ -102,9 +80,8 @@ fn inject_crates_ref(krate: ast::Crate, alt_std_name: Option<String>) -> ast::Cr
     fold.fold_crate(krate)
 }
 
-struct PreludeInjector {
-    span: Span
-}
+struct PreludeInjector;
+
 
 impl fold::Folder for PreludeInjector {
     fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
@@ -130,7 +107,7 @@ impl fold::Folder for PreludeInjector {
 
     fn fold_mod(&mut self, mut mod_: ast::Mod) -> ast::Mod {
         let prelude_path = ast::Path {
-            span: self.span,
+            span: DUMMY_SP,
             global: false,
             segments: vec![
                 ast::PathSegment {
@@ -154,22 +131,27 @@ impl fold::Folder for PreludeInjector {
             ident: special_idents::invalid,
             node: ast::ItemUse(vp),
             attrs: vec![ast::Attribute {
-                span: self.span,
+                span: DUMMY_SP,
                 node: ast::Attribute_ {
                     id: attr::mk_attr_id(),
                     style: ast::AttrOuter,
                     value: P(ast::MetaItem {
-                        span: self.span,
+                        span: DUMMY_SP,
                         node: ast::MetaWord(token::get_name(
                                 special_idents::prelude_import.name)),
                     }),
                     is_sugared_doc: false,
                 },
             }],
             vis: ast::Inherited,
-            span: self.span,
+            span: DUMMY_SP,
         }));
 
         fold::noop_fold_mod(mod_, self)
     }
 }
+
+fn inject_prelude(krate: ast::Crate) -> ast::Crate {
+    let mut fold = PreludeInjector;
+    fold.fold_crate(krate)
+}

branches/stable/src/test/compile-fail/feature-gate-prelude_import.rs

@@ -1,4 +1,4 @@
-#![feature(no_std, prelude_import)]
+#![feature(no_std)]
 #![no_std]
 #[prelude_import]
 use std::prelude::v1::*;