---

yaml
---
r: 220875
b: refs/heads/auto
c: 6c74779
h: refs/heads/master
i:
  220873: 0b995b4
  220871: 7c88280
v: v3

Author: AlisdairO

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 3b8acb73869a6a0224cb39d16f2de25468e1bf28
+refs/heads/auto: 6c74779a5c4fb1c0bf5d395c8b0c27d296f7ca48
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/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.
     ///
-    /// Clones the data if it is not already owned.
+    /// Copies 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.
     ///
-    /// Clones the data if it is not already owned.
+    /// Copies the data if it is not already owned.
     ///
     /// # Examples
     ///

branches/auto/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 mutability 'inside' of something immutable
+//! * Introducing inherited mutability roots to shared types.
 //! * Implementation details of logically-immutable methods.
 //! * Mutating implementations of `Clone`.
 //!
-//! ## Introducing mutability 'inside' of something immutable
+//! ## Introducing inherited mutability roots to shared types
 //!
-//! Many shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be
+//! 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 with `&`, not `&mut`. Without cells it would be
-//! impossible to mutate data inside of these smart pointers at all.
+//! 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!
 //!
 //! 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 `RwLock<T>` or `Mutex<T>` if you need shared mutability in a
-//! multi-threaded situation.
+//! scenarios. Consider using `Mutex<T>` if you need shared mutability in a multi-threaded
+//! situation.
 //!
 //! ## Implementation details of logically-immutable methods
 //!

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

@@ -301,8 +301,7 @@ 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("has an incompatible type for trait") {
+        !msg.contains("structure constructor specifies a structure of type") {
             return None
     }
     let first = msg.match_indices("expected").filter(|s| {

branches/auto/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 function from a trait.  An example of this error:
+
+```
+mod foo {
+    pub trait MyTrait {
+        fn doSomething();
+    }
+}
+use foo::MyTrait::doSomething;
+```
+
+In general, it's not legal to directly import functions from a crate 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/auto/src/librustc_typeck/diagnostics.rs

@@ -2109,66 +2109,6 @@ 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
 "##
 
 }
@@ -2271,6 +2211,7 @@ 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/auto/src/test/compile-fail/associated-const-impl-wrong-type.rs

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

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

@@ -19,9 +19,7 @@ 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/auto/src/test/compile-fail/issue-20225.rs

@@ -14,22 +14,19 @@ 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/auto/src/test/compile-fail/issue-21332.rs

@@ -30,9 +30,7 @@ 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/auto/src/test/compile-fail/issue-24356.rs

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

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

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