Update error messages in compile-fail tests

Author: nikomatsakis

src/test/compile-fail/bad-method-typaram-kind.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn foo<T:'static>() {
-    1u.bar::<T>(); //~ ERROR: does not fulfill `Send`
+    1u.bar::<T>(); //~ ERROR `core::kinds::Send` is not implemented
 }
 
 trait bar {

src/test/compile-fail/bad-sized.rs

@@ -16,10 +16,8 @@ trait Trait {}
 
 pub fn main() {
     let x: Vec<Trait + Sized> = Vec::new();
-    //~^ ERROR instantiating a type parameter with an incompatible type `Trait+Sized`, which does not fulfill `Sized`
-    //~^^ ERROR instantiating a type parameter with an incompatible type `Trait+Sized`, which does not fulfill `Sized`
-    //~^^^ ERROR instantiating a type parameter with an incompatible type `Trait+Sized`, which does not fulfill `Sized`
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^^ ERROR the trait `core::kinds::Sized` is not implemented
     let x: Vec<Box<RefCell<Trait + Sized>>> = Vec::new();
-    //~^ ERROR instantiating a type parameter with an incompatible type `Trait+Sized`, which does not fulfill `Sized`
-    //~^^ ERROR instantiating a type parameter with an incompatible type `Trait+Sized`, which does not fulfill `Sized`
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented
 }

src/test/compile-fail/builtin-superkinds-double-superkind.rs

@@ -13,9 +13,9 @@
 
 trait Foo : Send+Sync { }
 
-impl <T: Sync> Foo for (T,) { } //~ ERROR cannot implement this trait
+impl <T: Sync+'static> Foo for (T,) { } //~ ERROR the trait `core::kinds::Send` is not implemented
 
-impl <T: Send> Foo for (T,T) { } //~ ERROR cannot implement this trait
+impl <T: Send> Foo for (T,T) { } //~ ERROR the trait `core::kinds::Sync` is not implemented
 
 impl <T: Send+Sync> Foo for (T,T,T) { } // (ok)
 

src/test/compile-fail/builtin-superkinds-in-metadata.rs

@@ -21,6 +21,7 @@ struct X<T>(T);
 
 impl <T:Sync> RequiresShare for X<T> { }
 
-impl <T:Sync> RequiresRequiresShareAndSend for X<T> { } //~ ERROR cannot implement this trait
+impl <T:Sync+'static> RequiresRequiresShareAndSend for X<T> { }
+//~^ ERROR the trait `core::kinds::Send` is not implemented
 
 fn main() { }

src/test/compile-fail/builtin-superkinds-self-type.rs

@@ -12,12 +12,12 @@
 // to use capabilities granted by builtin kinds as supertraits.
 
 trait Foo : Sync+'static {
-    fn foo(self, mut chan: Sender<Self>) {
-        chan.send(self); //~ ERROR does not fulfill `Send`
-    }
+    fn foo(self, mut chan: Sender<Self>) { }
 }
 
 impl <T: Sync> Foo for T { }
+//~^ ERROR the parameter type `T` may not live long enough
+//~^^ ERROR the parameter type `T` may not live long enough
 
 fn main() {
     let (tx, rx) = channel();

src/test/compile-fail/builtin-superkinds-simple.rs

@@ -14,6 +14,6 @@
 trait Foo : Send { }
 
 impl <'a> Foo for &'a mut () { }
-//~^ ERROR which does not fulfill `Send`, cannot implement this trait
+//~^ ERROR does not fulfill the required lifetime
 
 fn main() { }

src/test/compile-fail/builtin-superkinds-typaram-not-send.rs

@@ -12,6 +12,6 @@
 
 trait Foo : Send { }
 
-impl <T: Sync> Foo for T { } //~ ERROR cannot implement this trait
+impl <T: Sync+'static> Foo for T { } //~ ERROR the trait `core::kinds::Send` is not implemented
 
 fn main() { }

src/test/compile-fail/comm-not-freeze.rs

@@ -11,7 +11,7 @@
 fn test<T: Sync>() {}
 
 fn main() {
-    test::<Sender<int>>();        //~ ERROR: does not fulfill `Sync`
-    test::<Receiver<int>>();        //~ ERROR: does not fulfill `Sync`
-    test::<Sender<int>>();  //~ ERROR: does not fulfill `Sync`
+    test::<Sender<int>>();        //~ ERROR: `core::kinds::Sync` is not implemented
+    test::<Receiver<int>>();        //~ ERROR: `core::kinds::Sync` is not implemented
+    test::<Sender<int>>();  //~ ERROR: `core::kinds::Sync` is not implemented
 }

src/test/compile-fail/conflicting-implementations-aux.rs

@@ -15,10 +15,7 @@
 extern crate trait_impl_conflict;
 use trait_impl_conflict::Foo;
 
-impl<A> Foo for A {
-//~^ ERROR conflicting implementations for trait `trait_impl_conflict::Foo`
-//~^^ ERROR cannot provide an extension implementation where both trait and type
-//          are not defined in this crate
+impl<A> Foo for A { //~ ERROR E0117
 }
 
 fn main() {

src/test/compile-fail/conflicting-implementations.rs

@@ -8,15 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern: conflicting implementations for trait `Foo`
 trait Foo {
 }
 
-impl Foo for int {
+impl Foo for int { //~ ERROR conflicting implementations
 
 }
 
-impl<A> Foo for A {
+impl<A> Foo for A { //~ NOTE conflicting implementation here
 
 }
 

src/test/compile-fail/deriving-span-Default-struct.rs

@@ -18,7 +18,7 @@ struct Error;
 
 #[deriving(Default)]
 struct Struct {
-    x: Error //~ ERROR
+    x: Error //~ ERROR `core::default::Default` is not implemented
 }
 
 fn main() {}

src/test/compile-fail/deriving-span-Zero-struct.rs

@@ -16,11 +16,9 @@ extern crate rand;
 
 struct Error;
 
-#[deriving(Zero)]   //~ ERROR failed to find an implementation
+#[deriving(Zero)]   //~ ERROR not implemented
 struct Struct {
-    x: Error //~ ERROR failed to find an implementation
-    //~^ ERROR failed to find an implementation
-    //~^^ ERROR type `Error` does not implement any method in scope
+    x: Error
 }
 
 fn main() {}

src/test/compile-fail/deriving-span-Zero-tuple-struct.rs

@@ -16,11 +16,9 @@ extern crate rand;
 
 struct Error;
 
-#[deriving(Zero)]   //~ ERROR failed to find an implementation
+#[deriving(Zero)]   //~ ERROR not implemented
 struct Struct(
-    Error //~ ERROR
-    //~^ ERROR failed to find an implementation
-    //~^^ ERROR type `Error` does not implement any method in scope
+    Error
 );
 
 fn main() {}

src/test/compile-fail/drop-on-non-struct.rs

@@ -8,12 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
-
-type Foo = Vec<u8>;
-
-impl Drop for Foo {
-//~^ ERROR cannot provide an extension implementation
+impl Drop for int {
+    //~^ ERROR the Drop trait may only be implemented on structures
+    //~^^ ERROR cannot provide an extension implementation
     fn drop(&mut self) {
         println!("kaboom");
     }

src/test/compile-fail/dst-bad-assign-2.rs

@@ -42,6 +42,6 @@ pub fn main() {
     // Assignment.
     let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
     let z: Box<ToBar> = box Bar1 {f: 36};
-    f5.ptr = *z;  //~ ERROR dynamically sized type on lhs of assignment
-    //~^ ERROR E0161
+    f5.ptr = *z;
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented
 }

src/test/compile-fail/dst-bad-assign.rs

@@ -43,4 +43,5 @@ pub fn main() {
     let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
     let z: Box<ToBar> = box Bar1 {f: 36};
     f5.ptr = Bar1 {f: 36}; //~ ERROR mismatched types: expected `ToBar`, found `Bar1`
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `ToBar`
 }

src/test/compile-fail/dst-bad-coerce1.rs

@@ -28,5 +28,5 @@ pub fn main() {
     let f1 = Fat { ptr: Foo };
     let f2: &Fat<Foo> = &f1;
     let f3: &Fat<Bar> = f2;
-    //~^ ERROR failed to find an implementation of trait Bar for Foo
+    //~^ ERROR the trait `Bar` is not implemented for the type `Foo`
 }

src/test/compile-fail/dst-bad-coerce2.rs

@@ -22,10 +22,10 @@ pub fn main() {
     // With a vec of ints.
     let f1 = Fat { ptr: [1, 2, 3] };
     let f2: &Fat<[int, ..3]> = &f1;
-    let f3: &mut Fat<[int]> = f2; //~ ERROR cannot borrow immutable dereference
+    let f3: &mut Fat<[int]> = f2; //~ ERROR mismatched types
 
     // With a trait.
     let f1 = Fat { ptr: Foo };
     let f2: &Fat<Foo> = &f1;
-    let f3: &mut Fat<Bar> = f2; //~ ERROR cannot borrow immutable dereference
+    let f3: &mut Fat<Bar> = f2; //~ ERROR mismatched types
 }

src/test/compile-fail/dst-bad-coercions.rs

@@ -30,10 +30,9 @@ pub fn main() {
     let y: &T = x; //~ ERROR mismatched types
 
     // Test that we cannot convert an immutable ptr to a mutable one using *-ptrs
-    let x: &mut T = &S; //~ ERROR types differ in mutability
-    let x: *mut T = &S; //~ ERROR types differ in mutability
-    let x: *mut S = &S;
-    //~^ ERROR mismatched types
+    let x: &mut T = &S; //~ ERROR mismatched types
+    let x: *mut T = &S; //~ ERROR mismatched types
+    let x: *mut S = &S; //~ ERROR mismatched types
 
     // The below four sets of tests test that we cannot implicitly deref a *-ptr
     // during a coercion.

src/test/compile-fail/dst-bad-deep.rs

@@ -21,6 +21,5 @@ pub fn main() {
     let f: Fat<[int, ..3]> = Fat { ptr: [5i, 6, 7] };
     let g: &Fat<[int]> = &f;
     let h: &Fat<Fat<[int]>> = &Fat { ptr: *g };
-    //~^ ERROR trying to initialise a dynamically sized struct
-    //~^^ ERROR E0161
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented
 }

src/test/compile-fail/dst-sized-trait-param.rs

@@ -0,0 +1,23 @@
+// Copyright 2014 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.
+
+// Check that when you implement a trait that has a sized type
+// parameter, the corresponding value must be sized. Also that the
+// self type must be sized if appropriate.
+
+trait Foo<T> { fn take(self, x: &T) { } } // Note: T is sized
+
+impl Foo<[int]> for uint { }
+//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[int]`
+
+impl Foo<int> for [uint] { }
+//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[uint]`
+
+pub fn main() { }

src/test/compile-fail/error-should-say-copy-not-pod.rs

@@ -13,5 +13,5 @@
 fn check_bound<T:Copy>(_: T) {}
 
 fn main() {
-    check_bound("nocopy".to_string()); //~ ERROR does not fulfill `Copy`
+    check_bound("nocopy".to_string()); //~ ERROR the trait `core::kinds::Copy` is not implemented
 }

src/test/compile-fail/ifmt-unimpl.rs

@@ -10,5 +10,5 @@
 
 fn main() {
     format!("{:d}", "3");
-    //~^ ERROR: failed to find an implementation of trait core::fmt::Signed
+    //~^ ERROR: the trait `core::fmt::Signed` is not implemented
 }

src/test/compile-fail/impl-bounds-checking.rs

@@ -17,7 +17,7 @@ trait Getter<T: Clone2> {
     fn get(&self) -> T;
 }
 
-impl Getter<int> for int { //~ ERROR failed to find an implementation of trait Clone2 for int
+impl Getter<int> for int { //~ ERROR the trait `Clone2` is not implemented
     fn get(&self) -> int { *self }
 }
 

src/test/compile-fail/issue-14915.rs

@@ -15,8 +15,8 @@ fn main() {
     let y: Gc<int> = box (GC) 0;
 
     println!("{}", x + 1); //~ ERROR binary operation `+` cannot be applied to type `Box<int>`
-    //~^ ERROR cannot determine a type for this bounded type parameter: unconstrained type
+    //~^ ERROR unable to infer enough type information
     println!("{}", y + 1);
     //~^ ERROR binary operation `+` cannot be applied to type `Gc<int>`
-    //~^^ ERROR cannot determine a type for this bounded type parameter: unconstrained type
+    //~^^ ERROR unable to infer enough type information
 }

src/test/compile-fail/issue-3907-2.rs

@@ -17,6 +17,6 @@ struct S {
     name: int
 }
 
-fn bar(_x: Foo) {} //~ ERROR variable `_x` has dynamically sized type
+fn bar(_x: Foo) {} //~ ERROR the trait `core::kinds::Sized` is not implemented
 
 fn main() {}

src/test/compile-fail/issue-5035-2.rs

@@ -11,6 +11,6 @@
 trait I {}
 type K = I+'static;
 
-fn foo(_x: K) {} //~ ERROR: variable `_x` has dynamically sized type
+fn foo(_x: K) {} //~ ERROR: the trait `core::kinds::Sized` is not implemented
 
 fn main() {}

src/test/compile-fail/issue-5883.rs

@@ -15,10 +15,9 @@ struct Struct {
 }
 
 fn new_struct(r: A+'static) -> Struct {
-    //~^ ERROR variable `r` has dynamically sized type
-    Struct { r: r } //~ ERROR trying to initialise a dynamically sized struct
-    //~^ ERROR E0161
-    //~^^ ERROR E0161
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    Struct { r: r }
+    //~^ ERROR the trait `core::kinds::Sized` is not implemented
 }
 
 trait Curve {}

src/test/compile-fail/issue-6458-2.rs

@@ -11,5 +11,6 @@
 extern crate debug;
 
 fn main() {
-    format!("{:?}", None); //~ ERROR: cannot determine a type for this bounded
+    // Unconstrained type:
+    format!("{:?}", None); //~ ERROR: E0101
 }

src/test/compile-fail/issue-7013.rs

@@ -32,10 +32,5 @@ struct A {
 
 fn main() {
     let a = A {v: box B{v: None} as Box<Foo+Send>};
-    //~^ ERROR cannot pack type `Box<B>`, which does not fulfill `Send`, as a trait bounded by Send
-    let v = Rc::new(RefCell::new(a));
-    let w = v.clone();
-    let b = &*v;
-    let mut b = b.borrow_mut();
-    b.v.set(w.clone());
+    //~^ ERROR the trait `core::kinds::Send` is not implemented for the type `B`
 }

src/test/compile-fail/kindck-copy.rs

@@ -34,29 +34,29 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<&'a [int]>();
 
     // ...unless they are mutable
-    assert_copy::<&'static mut int>(); //~ ERROR does not fulfill
-    assert_copy::<&'a mut int>();  //~ ERROR does not fulfill
+    assert_copy::<&'static mut int>(); //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<&'a mut int>();  //~ ERROR `core::kinds::Copy` is not implemented
 
     // ~ pointers are not ok
-    assert_copy::<Box<int>>();   //~ ERROR does not fulfill
-    assert_copy::<String>();   //~ ERROR does not fulfill
-    assert_copy::<Vec<int> >(); //~ ERROR does not fulfill
-    assert_copy::<Box<&'a mut int>>(); //~ ERROR does not fulfill
+    assert_copy::<Box<int>>();   //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<String>();   //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Vec<int> >(); //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::kinds::Copy` is not implemented
 
     // borrowed object types are generally ok
     assert_copy::<&'a Dummy>();
     assert_copy::<&'a Dummy+Copy>();
     assert_copy::<&'static Dummy+Copy>();
 
     // owned object types are not ok
-    assert_copy::<Box<Dummy>>(); //~ ERROR does not fulfill
-    assert_copy::<Box<Dummy+Copy>>(); //~ ERROR does not fulfill
+    assert_copy::<Box<Dummy>>(); //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Box<Dummy+Copy>>(); //~ ERROR `core::kinds::Copy` is not implemented
 
     // mutable object types are not ok
-    assert_copy::<&'a mut Dummy+Copy>();  //~ ERROR does not fulfill
+    assert_copy::<&'a mut Dummy+Copy>();  //~ ERROR `core::kinds::Copy` is not implemented
 
     // closures are like an `&mut` object
-    assert_copy::<||>(); //~ ERROR does not fulfill
+    assert_copy::<||>(); //~ ERROR `core::kinds::Copy` is not implemented
 
     // unsafe ptrs are ok
     assert_copy::<*const int>();
@@ -74,11 +74,11 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<MyStruct>();
 
     // structs containing non-POD are not ok
-    assert_copy::<MyNoncopyStruct>(); //~ ERROR does not fulfill
+    assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::kinds::Copy` is not implemented
 
     // managed or ref counted types are not ok
-    assert_copy::<Gc<int>>();   //~ ERROR does not fulfill
-    assert_copy::<Rc<int>>();   //~ ERROR does not fulfill
+    assert_copy::<Gc<int>>();   //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Rc<int>>();   //~ ERROR `core::kinds::Copy` is not implemented
 }
 
 pub fn main() {

src/test/compile-fail/kindck-impl-type-params-2.rs

@@ -19,5 +19,5 @@ fn take_param<T:Foo>(foo: &T) { }
 fn main() {
     let x = box 3i;
     take_param(&x);
-    //~^ ERROR instantiating a type parameter with an incompatible type
+    //~^ ERROR the trait `core::kinds::Copy` is not implemented
 }