---

yaml
---
r: 221079
b: refs/heads/tmp
c: 58fb9b5
h: refs/heads/master
i:
  221077: 3afb5b8
  221075: f49b842
  221071: f44cd0d
v: v3

Author: bors

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: c8bab9d06a179028a0d5129aa62f09d694d9cc49
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: ef2f4cd40a5eeb729699cf9e06bfe43d3d147fb9
+refs/heads/tmp: 58fb9b5c2d2f45b95866171720244edc1d06cde2
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: e58601ab085591c71a27ae82137fc313222c2270
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/src/libcollections/borrow.rs

@@ -215,7 +215,7 @@ impl<'a, B: ?Sized> Clone for Cow<'a, B> where B: ToOwned {
 impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
     /// Acquires a mutable reference to the owned form of the data.
     ///
-    /// Copies the data if it is not already owned.
+    /// Clones the data if it is not already owned.
     ///
     /// # Examples
     ///
@@ -241,7 +241,7 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
 
     /// Extracts the owned data.
     ///
-    /// Copies the data if it is not already owned.
+    /// Clones the data if it is not already owned.
     ///
     /// # Examples
     ///

branches/tmp/src/libcore/cell.rs

@@ -36,16 +36,16 @@
 //! would otherwise be disallowed though, there are occasions when interior mutability might be
 //! appropriate, or even *must* be used, e.g.
 //!
-//! * Introducing inherited mutability roots to shared types.
+//! * Introducing mutability 'inside' of something immutable
 //! * Implementation details of logically-immutable methods.
 //! * Mutating implementations of `Clone`.
 //!
-//! ## Introducing inherited mutability roots to shared types
+//! ## Introducing mutability 'inside' of something immutable
 //!
-//! Shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be
+//! Many shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be
 //! cloned and shared between multiple parties. Because the contained values may be
-//! multiply-aliased, they can only be borrowed as shared references, not mutable references.
-//! Without cells it would be impossible to mutate data inside of shared boxes at all!
+//! multiply-aliased, they can only be borrowed with `&`, not `&mut`. Without cells it would be
+//! impossible to mutate data inside of these smart pointers at all.
 //!
 //! It's very common then to put a `RefCell<T>` inside shared pointer types to reintroduce
 //! mutability:
@@ -65,8 +65,8 @@
 //! ```
 //!
 //! Note that this example uses `Rc<T>` and not `Arc<T>`. `RefCell<T>`s are for single-threaded
-//! scenarios. Consider using `Mutex<T>` if you need shared mutability in a multi-threaded
-//! situation.
+//! scenarios. Consider using `RwLock<T>` or `Mutex<T>` if you need shared mutability in a
+//! multi-threaded situation.
 //!
 //! ## Implementation details of logically-immutable methods
 //!

branches/tmp/src/librustc/session/mod.rs

@@ -301,7 +301,8 @@ fn split_msg_into_multilines(msg: &str) -> Option<String> {
         !msg.contains("if and else have incompatible types") &&
         !msg.contains("if may be missing an else clause") &&
         !msg.contains("match arms have incompatible types") &&
-        !msg.contains("structure constructor specifies a structure of type") {
+        !msg.contains("structure constructor specifies a structure of type") &&
+        !msg.contains("has an incompatible type for trait") {
             return None
     }
     let first = msg.match_indices("expected").filter(|s| {

branches/tmp/src/librustc_resolve/diagnostics.rs

@@ -93,6 +93,23 @@ mod bar {
 ```
 "##,
 
+E0253: r##"
+Attempt was made to import an unimportable value. This can happen when
+trying to import a method from a trait. An example of this error:
+
+```
+mod foo {
+    pub trait MyTrait {
+        fn do_something();
+    }
+}
+use foo::MyTrait::do_something;
+```
+
+In general, it's not legal to directly import methods belonging to a
+trait or concrete type.
+"##,
+
 E0255: r##"
 You can't import a value whose name is the same as another value defined in the
 module.
@@ -262,7 +279,6 @@ http://doc.rust-lang.org/reference.html#use-declarations
 register_diagnostics! {
     E0153, // called no where
     E0157, // called from no where
-    E0253, // not directly importable
     E0254, // import conflicts with imported crate in this module
     E0257,
     E0258,

branches/tmp/src/librustc_typeck/diagnostics.rs

@@ -2109,6 +2109,66 @@ E0380: r##"
 Default impls are only allowed for traits with no methods or associated items.
 For more information see the [opt-in builtin traits RFC](https://github.com/rust
 -lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
+"##,
+
+E0392: r##"
+This error indicates that a type or lifetime parameter has been declared
+but not actually used.  Here is an example that demonstrates the error:
+
+```
+enum Foo<T> {
+    Bar
+}
+```
+
+If the type parameter was included by mistake, this error can be fixed
+by simply removing the type parameter, as shown below:
+
+```
+enum Foo {
+    Bar
+}
+```
+
+Alternatively, if the type parameter was intentionally inserted, it must be
+used. A simple fix is shown below:
+
+```
+enum Foo<T> {
+    Bar(T)
+}
+```
+
+This error may also commonly be found when working with unsafe code. For
+example, when using raw pointers one may wish to specify the lifetime for
+which the pointed-at data is valid. An initial attempt (below) causes this
+error:
+
+```
+struct Foo<'a, T> {
+    x: *const T
+}
+```
+
+We want to express the constraint that Foo should not outlive `'a`, because
+the data pointed to by `T` is only valid for that lifetime. The problem is
+that there are no actual uses of `'a`. It's possible to work around this
+by adding a PhantomData type to the struct, using it to tell the compiler
+to act as if the struct contained a borrowed reference `&'a T`:
+
+```
+use std::marker::PhantomData;
+
+struct Foo<'a, T: 'a> {
+    x: *const T,
+    phantom: PhantomData<&'a T>
+}
+```
+
+PhantomData can also be used to express information about unused type
+parameters. You can read more about it in the API documentation:
+
+https://doc.rust-lang.org/std/marker/struct.PhantomData.html
 "##
 
 }
@@ -2211,7 +2271,6 @@ register_diagnostics! {
     E0390, // only a single inherent implementation marked with
            // `#[lang = \"{}\"]` is allowed for the `{}` primitive
     E0391, // unsupported cyclic reference between types/traits detected
-    E0392, // parameter `{}` is never used
     E0393, // the type parameter `{}` must be explicitly specified in an object
            // type because its default value `{}` references the type `Self`"
     E0399, // trait items need to be implemented because the associated

branches/tmp/src/test/compile-fail/associated-const-impl-wrong-type.rs

@@ -18,7 +18,9 @@ struct SignedBar;
 
 impl Foo for SignedBar {
     const BAR: i32 = -1;
-    //~^ ERROR E0326
+    //~^ ERROR implemented const `BAR` has an incompatible type for trait
+    //~| expected u32,
+    //~| found i32 [E0326]
 }
 
 fn main() {}

branches/tmp/src/test/compile-fail/issue-15094.rs

@@ -19,7 +19,9 @@ struct Debuger<T> {
 impl<T: fmt::Debug> ops::FnOnce<(),> for Debuger<T> {
     type Output = ();
     fn call_once(self, _args: ()) {
-//~^ ERROR `call_once` has an incompatible type for trait: expected "rust-call" fn, found "Rust" fn
+    //~^ ERROR `call_once` has an incompatible type for trait
+    //~| expected "rust-call" fn,
+    //~| found "Rust" fn
         println!("{:?}", self.x);
     }
 }

branches/tmp/src/test/compile-fail/issue-20225.rs

@@ -14,19 +14,22 @@ struct Foo;
 
 impl<'a, T> Fn<(&'a T,)> for Foo {
   extern "rust-call" fn call(&self, (_,): (T,)) {}
-  //~^ ERROR: has an incompatible type for trait: expected &-ptr
+  //~^ ERROR: has an incompatible type for trait
+  //~| expected &-ptr
 }
 
 impl<'a, T> FnMut<(&'a T,)> for Foo {
   extern "rust-call" fn call_mut(&mut self, (_,): (T,)) {}
-  //~^ ERROR: has an incompatible type for trait: expected &-ptr
+  //~^ ERROR: has an incompatible type for trait
+  //~| expected &-ptr
 }
 
 impl<'a, T> FnOnce<(&'a T,)> for Foo {
   type Output = ();
 
   extern "rust-call" fn call_once(self, (_,): (T,)) {}
-  //~^ ERROR: has an incompatible type for trait: expected &-ptr
+  //~^ ERROR: has an incompatible type for trait
+  //~| expected &-ptr
 }
 
 fn main() {}

branches/tmp/src/test/compile-fail/issue-21332.rs

@@ -0,0 +1,21 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct S;
+
+impl Iterator for S {
+    type Item = i32;
+    fn next(&mut self) -> Result<i32, i32> { Ok(7) }
+    //~^ ERROR method `next` has an incompatible type for trait
+    //~| expected enum `core::option::Option`
+    //~|    found enum `core::result::Result` [E0053]
+}
+
+fn main() {}

branches/tmp/src/test/compile-fail/issue-24356.rs

@@ -30,7 +30,9 @@ fn main() {
         impl Deref for Thing {
             //~^ ERROR not all trait items implemented, missing: `Target` [E0046]
             fn deref(&self) -> i8 { self.0 }
-            //~^ ERROR method `deref` has an incompatible type for trait: expected &-ptr, found i8 [E0053]
+            //~^ ERROR method `deref` has an incompatible type for trait
+            //~| expected &-ptr
+            //~| found i8 [E0053]
         }
 
         let thing = Thing(72);

branches/tmp/src/test/compile-fail/trait-impl-method-mismatch.rs

@@ -16,7 +16,9 @@ trait Mumbo {
 impl Mumbo for usize {
     // Cannot have a larger effect than the trait:
     unsafe fn jumbo(&self, x: &usize) { *self + *x; }
-    //~^ ERROR expected normal fn, found unsafe fn
+    //~^ ERROR method `jumbo` has an incompatible type for trait
+    //~| expected normal fn,
+    //~| found unsafe fn
 }
 
 fn main() {}

branches/tmp/src/test/compile-fail/unsafe-trait-impl.rs

@@ -16,7 +16,9 @@ trait Foo {
 
 impl Foo for u32 {
     fn len(&self) -> u32 { *self }
-    //~^ ERROR incompatible type for trait: expected unsafe fn, found normal fn
+    //~^ ERROR method `len` has an incompatible type for trait
+    //~| expected unsafe fn,
+    //~| found normal fn
 }
 
 fn main() { }