Update message for `!Sized` types

64 files changed, 209 insertions, 207 deletions

diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 9c0508f1234..5db5d88d4a5 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -92,8 +92,8 @@ impl<T: ?Sized> !Send for *mut T { }
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "sized"]
 #[rustc_on_unimplemented(
-    message="`{Self}` does not have a constant size known at compile-time",
-    label="`{Self}` does not have a constant size known at compile-time",
+    message="the size for value values of type `{Self}` cannot be known at compilation time",
+    label="doesn't have a size known at compile-time",
     note="to learn more, visit <https://doc.rust-lang.org/book/second-edition/\
           ch19-04-advanced-types.html#dynamically-sized-types--sized>",
 )]
diff --git a/src/test/compile-fail/associated-types-unsized.rs b/src/test/compile-fail/associated-types-unsized.rs
index 29aa9614745..3bb0382ef03 100644
--- a/src/test/compile-fail/associated-types-unsized.rs
+++ b/src/test/compile-fail/associated-types-unsized.rs
@@ -14,7 +14,7 @@ trait Get {
 }
 
 fn foo<T:Get>(t: T) {
-    let x = t.get(); //~ ERROR `<T as Get>::Value` does not have a constant size known at
+    let x = t.get(); //~ ERROR the size for value values of type
 }
 
 fn main() {
diff --git a/src/test/compile-fail/bad-sized.rs b/src/test/compile-fail/bad-sized.rs
index 55b009aef4f..9b87ec4d446 100644
--- a/src/test/compile-fail/bad-sized.rs
+++ b/src/test/compile-fail/bad-sized.rs
@@ -13,6 +13,6 @@ trait Trait {}
 pub fn main() {
     let x: Vec<Trait + Sized> = Vec::new();
     //~^ ERROR only auto traits can be used as additional traits in a trait object
-    //~| ERROR `Trait` does not have a constant size known at compile-time
-    //~| ERROR `Trait` does not have a constant size known at compile-time
+    //~| ERROR the size for value values of type
+    //~| ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs
index c3cbc904842..1dbdd42ca36 100644
--- a/src/test/compile-fail/dst-bad-assign-2.rs
+++ b/src/test/compile-fail/dst-bad-assign-2.rs
@@ -43,5 +43,6 @@ pub fn main() {
     let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
     let z: Box<ToBar> = Box::new(Bar1 {f: 36});
     f5.ptr = *z;
-    //~^ ERROR `ToBar` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
+
 }
diff --git a/src/test/compile-fail/dst-bad-assign-3.rs b/src/test/compile-fail/dst-bad-assign-3.rs
index 1cd5b51fe34..5bc6c6cda26 100644
--- a/src/test/compile-fail/dst-bad-assign-3.rs
+++ b/src/test/compile-fail/dst-bad-assign-3.rs
@@ -45,5 +45,5 @@ pub fn main() {
     //~| expected type `ToBar`
     //~| found type `Bar1`
     //~| expected trait ToBar, found struct `Bar1`
-    //~| ERROR `ToBar` does not have a constant size known at compile-time
+    //~| ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs
index dcd78ac044c..37b6056d1a7 100644
--- a/src/test/compile-fail/dst-bad-assign.rs
+++ b/src/test/compile-fail/dst-bad-assign.rs
@@ -47,5 +47,5 @@ pub fn main() {
     //~| expected type `ToBar`
     //~| found type `Bar1`
     //~| expected trait ToBar, found struct `Bar1`
-    //~| ERROR `ToBar` does not have a constant size known at compile-time
+    //~| ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/dst-bad-deep-2.rs b/src/test/compile-fail/dst-bad-deep-2.rs
index 9ed2ec8d98d..82d81913cd3 100644
--- a/src/test/compile-fail/dst-bad-deep-2.rs
+++ b/src/test/compile-fail/dst-bad-deep-2.rs
@@ -19,5 +19,5 @@ pub fn main() {
     let f: ([isize; 3],) = ([5, 6, 7],);
     let g: &([isize],) = &f;
     let h: &(([isize],),) = &(*g,);
-    //~^ ERROR `[isize]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/dst-bad-deep.rs b/src/test/compile-fail/dst-bad-deep.rs
index 9b575ae4aad..b8ca22185bc 100644
--- a/src/test/compile-fail/dst-bad-deep.rs
+++ b/src/test/compile-fail/dst-bad-deep.rs
@@ -21,5 +21,5 @@ pub fn main() {
     let f: Fat<[isize; 3]> = Fat { ptr: [5, 6, 7] };
     let g: &Fat<[isize]> = &f;
     let h: &Fat<Fat<[isize]>> = &Fat { ptr: *g };
-    //~^ ERROR `[isize]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/dst-object-from-unsized-type.rs b/src/test/compile-fail/dst-object-from-unsized-type.rs
index 678eef76fde..4a892753595 100644
--- a/src/test/compile-fail/dst-object-from-unsized-type.rs
+++ b/src/test/compile-fail/dst-object-from-unsized-type.rs
@@ -16,22 +16,22 @@ impl Foo for [u8] {}
 
 fn test1<T: ?Sized + Foo>(t: &T) {
     let u: &Foo = t;
-    //~^ ERROR `T` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn test2<T: ?Sized + Foo>(t: &T) {
     let v: &Foo = t as &Foo;
-    //~^ ERROR `T` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn test3() {
     let _: &[&Foo] = &["hi"];
-    //~^ ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn test4(x: &[u8]) {
     let _: &Foo = x as &Foo;
-    //~^ ERROR `[u8]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/dst-sized-trait-param.rs b/src/test/compile-fail/dst-sized-trait-param.rs
index cafd67809f8..06795567432 100644
--- a/src/test/compile-fail/dst-sized-trait-param.rs
+++ b/src/test/compile-fail/dst-sized-trait-param.rs
@@ -15,9 +15,9 @@
 trait Foo<T> : Sized { fn take(self, x: &T) { } } // Note: T is sized
 
 impl Foo<[isize]> for usize { }
-//~^ ERROR `[isize]` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 impl Foo<isize> for [usize] { }
-//~^ ERROR `[usize]` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 pub fn main() { }
diff --git a/src/test/compile-fail/extern-types-unsized.rs b/src/test/compile-fail/extern-types-unsized.rs
index b3e19899a67..135b466161d 100644
--- a/src/test/compile-fail/extern-types-unsized.rs
+++ b/src/test/compile-fail/extern-types-unsized.rs
@@ -30,14 +30,14 @@ fn assert_sized<T>() { }
 
 fn main() {
     assert_sized::<A>();
-    //~^ ERROR `A` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     assert_sized::<Foo>();
-    //~^ ERROR `A` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     assert_sized::<Bar<A>>();
-    //~^ ERROR `A` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     assert_sized::<Bar<Bar<A>>>();
-    //~^ ERROR `A` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/issue-14366.rs b/src/test/compile-fail/issue-14366.rs
index 7b4954a2d4e..5212cbb004e 100644
--- a/src/test/compile-fail/issue-14366.rs
+++ b/src/test/compile-fail/issue-14366.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     let _x = "test" as &::std::any::Any;
-    //~^ ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/issue-15756.rs b/src/test/compile-fail/issue-15756.rs
index 0df82de8338..4756099ab95 100644
--- a/src/test/compile-fail/issue-15756.rs
+++ b/src/test/compile-fail/issue-15756.rs
@@ -15,7 +15,7 @@ fn dft_iter<'a, T>(arg1: Chunks<'a,T>, arg2: ChunksMut<'a,T>)
 {
     for
     &mut something
-    //~^ ERROR `[T]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     in arg2
     {
     }
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index 13548b06ea1..e7019ff7c0d 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -13,5 +13,5 @@
 
 fn main() {
     (|| Box::new(*(&[0][..])))();
-    //~^ ERROR `[{integer}]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/issue-18107.rs b/src/test/compile-fail/issue-18107.rs
index 5faa8885e73..9239ceb341f 100644
--- a/src/test/compile-fail/issue-18107.rs
+++ b/src/test/compile-fail/issue-18107.rs
@@ -12,7 +12,7 @@ pub trait AbstractRenderer {}
 
 fn _create_render(_: &()) ->
     AbstractRenderer
-//~^ ERROR: `AbstractRenderer + 'static` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 {
     match 0 {
         _ => unimplemented!()
diff --git a/src/test/compile-fail/issue-18919.rs b/src/test/compile-fail/issue-18919.rs
index 14b776cb1ff..0b717ec6413 100644
--- a/src/test/compile-fail/issue-18919.rs
+++ b/src/test/compile-fail/issue-18919.rs
@@ -11,7 +11,7 @@
 type FuncType<'f> = Fn(&isize) -> isize + 'f;
 
 fn ho_func(f: Option<FuncType>) {
-    //~^ ERROR: `for<'r> std::ops::Fn(&'r isize) -> isize` does not have a constant size known at
+    //~^ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-20005.rs b/src/test/compile-fail/issue-20005.rs
index ab47f687fc2..426657ac92e 100644
--- a/src/test/compile-fail/issue-20005.rs
+++ b/src/test/compile-fail/issue-20005.rs
@@ -15,7 +15,7 @@ trait From<Src> {
 }
 
 trait To {
-    fn to<Dst>(  //~ ERROR `Self` does not have a constant size known at compile-time
+    fn to<Dst>(  //~ ERROR the size for value values of type
         self
     ) -> <Dst as From<Self>>::Result where Dst: From<Self> {
         From::from(self)
diff --git a/src/test/compile-fail/issue-20433.rs b/src/test/compile-fail/issue-20433.rs
index d8ca00d313f..8b7f2d5a458 100644
--- a/src/test/compile-fail/issue-20433.rs
+++ b/src/test/compile-fail/issue-20433.rs
@@ -14,5 +14,5 @@ struct The;
 
 impl The {
     fn iceman(c: Vec<[i32]>) {}
-    //~^ ERROR `[i32]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/issue-20605.rs b/src/test/compile-fail/issue-20605.rs
index c5a724bba80..2d8d9c65655 100644
--- a/src/test/compile-fail/issue-20605.rs
+++ b/src/test/compile-fail/issue-20605.rs
@@ -10,7 +10,7 @@
 
 fn changer<'a>(mut things: Box<Iterator<Item=&'a mut u8>>) {
     for item in *things { *item = 0 }
-//~^ ERROR `std::iter::Iterator<Item=&mut u8>` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-22874.rs b/src/test/compile-fail/issue-22874.rs
index de176486af7..cb199580b10 100644
--- a/src/test/compile-fail/issue-22874.rs
+++ b/src/test/compile-fail/issue-22874.rs
@@ -10,7 +10,7 @@
 
 struct Table {
     rows: [[String]],
-    //~^ ERROR `[std::string::String]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn f(table: &Table) -> &[String] {
diff --git a/src/test/compile-fail/issue-23281.rs b/src/test/compile-fail/issue-23281.rs
index fdab3b59d1b..d6b5c329825 100644
--- a/src/test/compile-fail/issue-23281.rs
+++ b/src/test/compile-fail/issue-23281.rs
@@ -14,7 +14,7 @@ pub struct Struct;
 
 impl Struct {
     pub fn function(funs: Vec<Fn() -> ()>) {}
-    //~^ ERROR `std::ops::Fn() + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-24446.rs b/src/test/compile-fail/issue-24446.rs
index cef68dd811b..74c68c50ae3 100644
--- a/src/test/compile-fail/issue-24446.rs
+++ b/src/test/compile-fail/issue-24446.rs
@@ -10,8 +10,8 @@
 
 fn main() {
     static foo: Fn() -> u32 = || -> u32 {
-        //~^ ERROR: mismatched types
-        //~| ERROR: `std::ops::Fn() -> u32 + 'static` does not have a constant size known at
+        //~^ ERROR mismatched types
+        //~| ERROR the size for value values of type
         0
     };
 }
diff --git a/src/test/compile-fail/issue-27060-2.rs b/src/test/compile-fail/issue-27060-2.rs
index 123bbf3358d..bc5567e1686 100644
--- a/src/test/compile-fail/issue-27060-2.rs
+++ b/src/test/compile-fail/issue-27060-2.rs
@@ -10,7 +10,7 @@
 
 #[repr(packed)]
 pub struct Bad<T: ?Sized> {
-    data: T, //~ ERROR `T` does not have a constant size known at compile-time
+    data: T, //~ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-27078.rs b/src/test/compile-fail/issue-27078.rs
index 32933fa6176..6efc1f10243 100644
--- a/src/test/compile-fail/issue-27078.rs
+++ b/src/test/compile-fail/issue-27078.rs
@@ -13,7 +13,7 @@
 trait Foo {
     const BAR: i32;
     fn foo(self) -> &'static i32 {
-        //~^ ERROR `Self` does not have a constant size known at compile-time
+        //~^ ERROR the size for value values of type
         &<Self>::BAR
     }
 }
diff --git a/src/test/compile-fail/issue-35988.rs b/src/test/compile-fail/issue-35988.rs
index 8f5b68986e5..805b1a48a03 100644
--- a/src/test/compile-fail/issue-35988.rs
+++ b/src/test/compile-fail/issue-35988.rs
@@ -10,7 +10,7 @@
 
 enum E {
     V([Box<E>]),
-    //~^ ERROR `[std::boxed::Box<E>]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-38954.rs b/src/test/compile-fail/issue-38954.rs
index 960099f3193..1b64d17bbef 100644
--- a/src/test/compile-fail/issue-38954.rs
+++ b/src/test/compile-fail/issue-38954.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 fn _test(ref _p: str) {}
-//~^ ERROR `str` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 fn main() { }
diff --git a/src/test/compile-fail/issue-41229-ref-str.rs b/src/test/compile-fail/issue-41229-ref-str.rs
index b1e24c818d8..6207e669d00 100644
--- a/src/test/compile-fail/issue-41229-ref-str.rs
+++ b/src/test/compile-fail/issue-41229-ref-str.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn example(ref s: str) {}
-//~^ ERROR `str` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-42312.rs b/src/test/compile-fail/issue-42312.rs
index 89eb5c5ebc1..2ab44433ede 100644
--- a/src/test/compile-fail/issue-42312.rs
+++ b/src/test/compile-fail/issue-42312.rs
@@ -12,10 +12,10 @@ use std::ops::Deref;
 
 pub trait Foo {
     fn baz(_: Self::Target) where Self: Deref {}
-    //~^ ERROR `<Self as std::ops::Deref>::Target` does not have a constant size known at
+    //~^ ERROR the size for value values of type
 }
 
 pub fn f(_: ToString) {}
-//~^ ERROR `std::string::ToString + 'static` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 fn main() { }
diff --git a/src/test/compile-fail/issue-5883.rs b/src/test/compile-fail/issue-5883.rs
index 580625f4955..82d4666ce54 100644
--- a/src/test/compile-fail/issue-5883.rs
+++ b/src/test/compile-fail/issue-5883.rs
@@ -15,8 +15,8 @@ struct Struct {
 }
 
 fn new_struct(r: A+'static)
-    -> Struct { //~^  ERROR `A + 'static` does not have a constant size known at compile-time
-    //~^ ERROR `A + 'static` does not have a constant size known at compile-time
+    -> Struct { //~^ ERROR the size for value values of type
+    //~^ ERROR the size for value values of type
     Struct { r: r }
 }
 
diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs
index 3fb62b8d869..ed26204bbe1 100644
--- a/src/test/compile-fail/range-1.rs
+++ b/src/test/compile-fail/range-1.rs
@@ -22,5 +22,5 @@ pub fn main() {
     // Unsized type.
     let arr: &[_] = &[1, 2, 3];
     let range = *arr..;
-    //~^ ERROR `[{integer}]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/str-mut-idx.rs b/src/test/compile-fail/str-mut-idx.rs
index c25d257d5f8..cc5fd7e3f24 100644
--- a/src/test/compile-fail/str-mut-idx.rs
+++ b/src/test/compile-fail/str-mut-idx.rs
@@ -12,8 +12,8 @@ fn bot<T>() -> T { loop {} }
 
 fn mutate(s: &mut str) {
     s[1..2] = bot();
-    //~^ ERROR `str` does not have a constant size known at compile-time
-    //~| ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
+    //~| ERROR the size for value values of type
     s[1usize] = bot();
     //~^ ERROR the type `str` cannot be mutably indexed by `usize`
 }
diff --git a/src/test/compile-fail/substs-ppaux.rs b/src/test/compile-fail/substs-ppaux.rs
index 94d2a549a86..b8557cb79e3 100644
--- a/src/test/compile-fail/substs-ppaux.rs
+++ b/src/test/compile-fail/substs-ppaux.rs
@@ -56,6 +56,6 @@ fn foo<'z>() where &'z (): Sized {
     //[normal]~| found type `fn() {foo::<'static>}`
 
     <str as Foo<u8>>::bar;
-    //[verbose]~^ ERROR `str` does not have a constant size known at compile-time
-    //[normal]~^^ ERROR `str` does not have a constant size known at compile-time
+    //[verbose]~^ ERROR the size for value values of type
+    //[normal]~^^ ERROR the size for value values of type
 }
diff --git a/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs b/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs
index fbf23357393..89fddf1f65f 100644
--- a/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs
+++ b/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs
@@ -15,7 +15,7 @@ trait Foo {
 // This should emit the less confusing error, not the more confusing one.
 
 fn foo(_x: Foo + Send) {
-    //~^ ERROR `Foo + std::marker::Send + 'static` does not have a constant size known at
+    //~^ ERROR the size for value values of type
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/union/union-unsized.rs b/src/test/compile-fail/union/union-unsized.rs
index 32f22f052c1..a9a2a3c4c92 100644
--- a/src/test/compile-fail/union/union-unsized.rs
+++ b/src/test/compile-fail/union/union-unsized.rs
@@ -12,14 +12,15 @@
 
 union U {
     a: str,
-    //~^ ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
+
     b: u8,
 }
 
 union W {
     a: u8,
     b: str,
-    //~^ ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/unsized-bare-typaram.rs b/src/test/compile-fail/unsized-bare-typaram.rs
index be1f1dea28c..736794ac538 100644
--- a/src/test/compile-fail/unsized-bare-typaram.rs
+++ b/src/test/compile-fail/unsized-bare-typaram.rs
@@ -10,5 +10,5 @@
 
 fn bar<T: Sized>() { }
 fn foo<T: ?Sized>() { bar::<T>() }
-//~^ ERROR `T` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 fn main() { }
diff --git a/src/test/compile-fail/unsized-enum.rs b/src/test/compile-fail/unsized-enum.rs
index 2041c69da54..f9702e29f1d 100644
--- a/src/test/compile-fail/unsized-enum.rs
+++ b/src/test/compile-fail/unsized-enum.rs
@@ -15,7 +15,7 @@ fn not_sized<T: ?Sized>() { }
 enum Foo<U> { FooSome(U), FooNone }
 fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
 fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
-//~^ ERROR `T` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 //
 // Not OK: `T` is not sized.
 
diff --git a/src/test/compile-fail/unsized-inherent-impl-self-type.rs b/src/test/compile-fail/unsized-inherent-impl-self-type.rs
index 5e5280ff3ea..03d3d98b59f 100644
--- a/src/test/compile-fail/unsized-inherent-impl-self-type.rs
+++ b/src/test/compile-fail/unsized-inherent-impl-self-type.rs
@@ -15,7 +15,7 @@
 struct S5<Y>(Y);
 
 impl<X: ?Sized> S5<X> {
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/unsized-struct.rs b/src/test/compile-fail/unsized-struct.rs
index 830ac5d6c20..8cb1f760664 100644
--- a/src/test/compile-fail/unsized-struct.rs
+++ b/src/test/compile-fail/unsized-struct.rs
@@ -15,14 +15,14 @@ fn not_sized<T: ?Sized>() { }
 struct Foo<T> { data: T }
 fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
 fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
-//~^ ERROR `T` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 //
 // Not OK: `T` is not sized.
 
 struct Bar<T: ?Sized> { data: T }
 fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
 fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
-//~^ ERROR `T` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 //
 // Not OK: `Bar<T>` is not sized, but it should be.
 
diff --git a/src/test/compile-fail/unsized-trait-impl-self-type.rs b/src/test/compile-fail/unsized-trait-impl-self-type.rs
index 9bf4cf7a0bb..b3610a4c9b9 100644
--- a/src/test/compile-fail/unsized-trait-impl-self-type.rs
+++ b/src/test/compile-fail/unsized-trait-impl-self-type.rs
@@ -18,7 +18,7 @@ trait T3<Z: ?Sized> {
 struct S5<Y>(Y);
 
 impl<X: ?Sized> T3<X> for S5<X> {
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/unsized-trait-impl-trait-arg.rs b/src/test/compile-fail/unsized-trait-impl-trait-arg.rs
index b3a848954d1..50a058a4338 100644
--- a/src/test/compile-fail/unsized-trait-impl-trait-arg.rs
+++ b/src/test/compile-fail/unsized-trait-impl-trait-arg.rs
@@ -16,7 +16,7 @@ trait T2<Z> {
 }
 struct S4<Y: ?Sized>(Box<Y>);
 impl<X: ?Sized> T2<X> for S4<X> {
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/unsized3.rs b/src/test/compile-fail/unsized3.rs
index e08cf8280fd..945f20b2877 100644
--- a/src/test/compile-fail/unsized3.rs
+++ b/src/test/compile-fail/unsized3.rs
@@ -15,7 +15,7 @@ use std::marker;
 // Unbounded.
 fn f1<X: ?Sized>(x: &X) {
     f2::<X>(x);
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 fn f2<X>(x: &X) {
 }
@@ -26,7 +26,7 @@ trait T {
 }
 fn f3<X: ?Sized + T>(x: &X) {
     f4::<X>(x);
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 fn f4<X: T>(x: &X) {
 }
@@ -41,20 +41,20 @@ struct S<X: ?Sized> {
 
 fn f8<X: ?Sized>(x1: &S<X>, x2: &S<X>) {
     f5(x1);
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     f6(x2); // ok
 }
 
 // Test some tuples.
 fn f9<X: ?Sized>(x1: Box<S<X>>) {
     f5(&(*x1, 34));
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn f10<X: ?Sized>(x1: Box<S<X>>) {
     f5(&(32, *x1));
-    //~^ ERROR `X` does not have a constant size known at compile-time
-    //~| ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
+    //~| ERROR the size for value values of type
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/unsized5.rs b/src/test/compile-fail/unsized5.rs
index 1fb32da5e31..e04aa3599e9 100644
--- a/src/test/compile-fail/unsized5.rs
+++ b/src/test/compile-fail/unsized5.rs
@@ -12,32 +12,32 @@
 
 struct S1<X: ?Sized> {
     f1: X,
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     f2: isize,
 }
 struct S2<X: ?Sized> {
     f: isize,
     g: X,
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     h: isize,
 }
 struct S3 {
     f: str,
-    //~^ ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     g: [usize]
 }
 struct S4 {
     f: [u8],
-    //~^ ERROR `[u8]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     g: usize
 }
 enum E<X: ?Sized> {
     V1(X, isize),
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 enum F<X: ?Sized> {
     V2{f1: X, f: isize},
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/unsized6.rs b/src/test/compile-fail/unsized6.rs
index 7ce0e1eb4d8..8ac9fe4c587 100644
--- a/src/test/compile-fail/unsized6.rs
+++ b/src/test/compile-fail/unsized6.rs
@@ -15,40 +15,40 @@ trait T {}
 fn f1<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized>(x: &X) {
     let _: W; // <-- this is OK, no bindings created, no initializer.
     let _: (isize, (X, isize));
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let y: Y;
-    //~^ ERROR `Y` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let y: (isize, (Z, usize));
-    //~^ ERROR `Z` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 fn f2<X: ?Sized, Y: ?Sized>(x: &X) {
     let y: X;
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let y: (isize, (Y, isize));
-    //~^ ERROR `Y` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
     let y: X = *x1;
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let y = *x2;
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let (y, z) = (*x3, 4);
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
     let y: X = *x1;
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let y = *x2;
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     let (y, z) = (*x3, 4);
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn g1<X: ?Sized>(x: X) {}
-//~^ ERROR `X` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 fn g2<X: ?Sized + T>(x: X) {}
-//~^ ERROR `X` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 pub fn main() {
 }
diff --git a/src/test/compile-fail/unsized7.rs b/src/test/compile-fail/unsized7.rs
index 8a3d78f0827..44d7df35680 100644
--- a/src/test/compile-fail/unsized7.rs
+++ b/src/test/compile-fail/unsized7.rs
@@ -20,7 +20,7 @@ trait T1<Z: T> {
 
 struct S3<Y: ?Sized>(Box<Y>);
 impl<X: ?Sized + T> T1<X> for S3<X> {
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() { }
diff --git a/src/test/ui/const-unsized.rs b/src/test/ui/const-unsized.rs
index 61ee622e21b..c0a367604c3 100644
--- a/src/test/ui/const-unsized.rs
+++ b/src/test/ui/const-unsized.rs
@@ -11,16 +11,16 @@
 use std::fmt::Debug;
 
 const CONST_0: Debug+Sync = *(&0 as &(Debug+Sync));
-//~^ ERROR `std::fmt::Debug + std::marker::Sync + 'static` does not have a constant size known at
+//~^ ERROR the size for value values of type
 
 const CONST_FOO: str = *"foo";
-//~^ ERROR `str` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 static STATIC_1: Debug+Sync = *(&1 as &(Debug+Sync));
-//~^ ERROR `std::fmt::Debug + std::marker::Sync + 'static` does not have a constant size known at
+//~^ ERROR the size for value values of type
 
 static STATIC_BAR: str = *"bar";
-//~^ ERROR `str` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 fn main() {
     println!("{:?} {:?} {:?} {:?}", &CONST_0, &CONST_FOO, &STATIC_1, &STATIC_BAR);
diff --git a/src/test/ui/const-unsized.stderr b/src/test/ui/const-unsized.stderr
index 6baeab90db2..2cde4aec2b5 100644
--- a/src/test/ui/const-unsized.stderr
+++ b/src/test/ui/const-unsized.stderr
@@ -1,38 +1,38 @@
-error[E0277]: `std::fmt::Debug + std::marker::Sync + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `std::fmt::Debug + std::marker::Sync + 'static` cannot be known at compilation time
   --> $DIR/const-unsized.rs:13:29
    |
 LL | const CONST_0: Debug+Sync = *(&0 as &(Debug+Sync));
-   |                             ^^^^^^^^^^^^^^^^^^^^^^ `std::fmt::Debug + std::marker::Sync + 'static` does not have a constant size known at compile-time
+   |                             ^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `std::fmt::Debug + std::marker::Sync + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: constant expressions must have a statically known size
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/const-unsized.rs:16:24
    |
 LL | const CONST_FOO: str = *"foo";
-   |                        ^^^^^^ `str` does not have a constant size known at compile-time
+   |                        ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: constant expressions must have a statically known size
 
-error[E0277]: `std::fmt::Debug + std::marker::Sync + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `std::fmt::Debug + std::marker::Sync + 'static` cannot be known at compilation time
   --> $DIR/const-unsized.rs:19:31
    |
 LL | static STATIC_1: Debug+Sync = *(&1 as &(Debug+Sync));
-   |                               ^^^^^^^^^^^^^^^^^^^^^^ `std::fmt::Debug + std::marker::Sync + 'static` does not have a constant size known at compile-time
+   |                               ^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `std::fmt::Debug + std::marker::Sync + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: constant expressions must have a statically known size
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/const-unsized.rs:22:26
    |
 LL | static STATIC_BAR: str = *"bar";
-   |                          ^^^^^^ `str` does not have a constant size known at compile-time
+   |                          ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/error-codes/E0277.rs b/src/test/ui/error-codes/E0277.rs
index 9ff2ef4da90..95f10e7206f 100644
--- a/src/test/ui/error-codes/E0277.rs
+++ b/src/test/ui/error-codes/E0277.rs
@@ -21,7 +21,7 @@ fn some_func<T: Foo>(foo: T) {
 }
 
 fn f(p: Path) { }
-//~^ ERROR `[u8]` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 fn main() {
     some_func(5i32);
diff --git a/src/test/ui/error-codes/E0277.stderr b/src/test/ui/error-codes/E0277.stderr
index e1c3183104a..ca5b0d2b987 100644
--- a/src/test/ui/error-codes/E0277.stderr
+++ b/src/test/ui/error-codes/E0277.stderr
@@ -1,8 +1,8 @@
-error[E0277]: `[u8]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[u8]` cannot be known at compilation time
   --> $DIR/E0277.rs:23:6
    |
 LL | fn f(p: Path) { }
-   |      ^ `[u8]` does not have a constant size known at compile-time
+   |      ^ doesn't have a size known at compile-time
    |
    = help: within `std::path::Path`, the trait `std::marker::Sized` is not implemented for `[u8]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/feature-gate-trivial_bounds.stderr b/src/test/ui/feature-gate-trivial_bounds.stderr
index 9344e78c23c..db280f2d1f7 100644
--- a/src/test/ui/feature-gate-trivial_bounds.stderr
+++ b/src/test/ui/feature-gate-trivial_bounds.stderr
@@ -87,24 +87,24 @@ LL | | }
    = help: see issue #48214
    = help: add #![feature(trivial_bounds)] to the crate attributes to enable
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/feature-gate-trivial_bounds.rs:62:1
    |
 LL | struct TwoStrs(str, str) where str: Sized; //~ ERROR
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `str` does not have a constant size known at compile-time
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: see issue #48214
    = help: add #![feature(trivial_bounds)] to the crate attributes to enable
 
-error[E0277]: `A + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `A + 'static` cannot be known at compilation time
   --> $DIR/feature-gate-trivial_bounds.rs:65:1
    |
 LL | / fn unsized_local() where Dst<A>: Sized { //~ ERROR
 LL | |     let x: Dst<A> = *(Box::new(Dst { x: 1 }) as Box<Dst<A>>);
 LL | | }
-   | |_^ `A + 'static` does not have a constant size known at compile-time
+   | |_^ doesn't have a size known at compile-time
    |
    = help: within `Dst<A + 'static>`, the trait `std::marker::Sized` is not implemented for `A + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
@@ -112,13 +112,13 @@ LL | | }
    = help: see issue #48214
    = help: add #![feature(trivial_bounds)] to the crate attributes to enable
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/feature-gate-trivial_bounds.rs:69:1
    |
 LL | / fn return_str() -> str where str: Sized { //~ ERROR
 LL | |     *"Sized".to_string().into_boxed_str()
 LL | | }
-   | |_^ `str` does not have a constant size known at compile-time
+   | |_^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/generator/sized-yield.rs b/src/test/ui/generator/sized-yield.rs
index 165e2702597..efaee4095c1 100644
--- a/src/test/ui/generator/sized-yield.rs
+++ b/src/test/ui/generator/sized-yield.rs
@@ -15,9 +15,9 @@ use std::ops::Generator;
 fn main() {
    let s = String::from("foo");
    let mut gen = move || {
-   //~^ ERROR `str` does not have a constant size known at compile-time
+   //~^ ERROR the size for value values of type
        yield s[..];
    };
    unsafe { gen.resume(); }
-   //~^ ERROR `str` does not have a constant size known at compile-time
+   //~^ ERROR the size for value values of type
 }
diff --git a/src/test/ui/generator/sized-yield.stderr b/src/test/ui/generator/sized-yield.stderr
index 7918101850e..2938268a804 100644
--- a/src/test/ui/generator/sized-yield.stderr
+++ b/src/test/ui/generator/sized-yield.stderr
@@ -1,22 +1,22 @@
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/sized-yield.rs:17:26
    |
 LL |      let mut gen = move || {
    |  __________________________^
-LL | |    //~^ ERROR `str` does not have a constant size known at compile-time
+LL | |    //~^ ERROR the size for value values of type
 LL | |        yield s[..];
 LL | |    };
-   | |____^ `str` does not have a constant size known at compile-time
+   | |____^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: the yield type of a generator must have a statically known size
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/sized-yield.rs:21:17
    |
 LL |    unsafe { gen.resume(); }
-   |                 ^^^^^^ `str` does not have a constant size known at compile-time
+   |                 ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/mismatched_types/cast-rfc0401.rs b/src/test/ui/mismatched_types/cast-rfc0401.rs
index 67aa8f89ddf..d76c4a015a2 100644
--- a/src/test/ui/mismatched_types/cast-rfc0401.rs
+++ b/src/test/ui/mismatched_types/cast-rfc0401.rs
@@ -60,7 +60,7 @@ fn main()
 
     let _ = 42usize as *const [u8]; //~ ERROR is invalid
     let _ = v as *const [u8]; //~ ERROR cannot cast
-    let _ = fat_v as *const Foo; //~ ERROR `[u8]` does not have a constant size known at
+    let _ = fat_v as *const Foo; //~ ERROR the size for value values of type
     let _ = foo as *const str; //~ ERROR is invalid
     let _ = foo as *mut str; //~ ERROR is invalid
     let _ = main as *mut str; //~ ERROR is invalid
@@ -69,7 +69,7 @@ fn main()
     let _ = fat_sv as usize; //~ ERROR is invalid
 
     let a : *const str = "hello";
-    let _ = a as *const Foo; //~ ERROR `str` does not have a constant size known at compile-time
+    let _ = a as *const Foo; //~ ERROR the size for value values of type
 
     // check no error cascade
     let _ = main.f as *const u32; //~ ERROR no field
diff --git a/src/test/ui/mismatched_types/cast-rfc0401.stderr b/src/test/ui/mismatched_types/cast-rfc0401.stderr
index a5992cd6802..feaf492837f 100644
--- a/src/test/ui/mismatched_types/cast-rfc0401.stderr
+++ b/src/test/ui/mismatched_types/cast-rfc0401.stderr
@@ -216,21 +216,21 @@ LL |     let _ = cf as *const Bar; //~ ERROR is invalid
    |
    = note: vtable kinds may not match
 
-error[E0277]: `[u8]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[u8]` cannot be known at compilation time
   --> $DIR/cast-rfc0401.rs:63:13
    |
-LL |     let _ = fat_v as *const Foo; //~ ERROR `[u8]` does not have a constant size known at
-   |             ^^^^^ `[u8]` does not have a constant size known at compile-time
+LL |     let _ = fat_v as *const Foo; //~ ERROR the size for value values of type
+   |             ^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[u8]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: required for the cast to the object type `Foo`
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/cast-rfc0401.rs:72:13
    |
-LL |     let _ = a as *const Foo; //~ ERROR `str` does not have a constant size known at compile-time
-   |             ^ `str` does not have a constant size known at compile-time
+LL |     let _ = a as *const Foo; //~ ERROR the size for value values of type
+   |             ^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/resolve/issue-5035-2.rs b/src/test/ui/resolve/issue-5035-2.rs
index f6cdb05394a..ca854f9f701 100644
--- a/src/test/ui/resolve/issue-5035-2.rs
+++ b/src/test/ui/resolve/issue-5035-2.rs
@@ -12,6 +12,6 @@ trait I {}
 type K = I+'static;
 
 fn foo(_x: K) {}
-//~^ ERROR `I + 'static` does not have a constant size known at compile-time
+//~^ ERROR the size for value values of type
 
 fn main() {}
diff --git a/src/test/ui/resolve/issue-5035-2.stderr b/src/test/ui/resolve/issue-5035-2.stderr
index 1488f6b9985..efcd0b36248 100644
--- a/src/test/ui/resolve/issue-5035-2.stderr
+++ b/src/test/ui/resolve/issue-5035-2.stderr
@@ -1,8 +1,8 @@
-error[E0277]: `I + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `I + 'static` cannot be known at compilation time
   --> $DIR/issue-5035-2.rs:14:8
    |
 LL | fn foo(_x: K) {}
-   |        ^^ `I + 'static` does not have a constant size known at compile-time
+   |        ^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `I + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/suggestions/str-array-assignment.rs b/src/test/ui/suggestions/str-array-assignment.rs
index f6b75981a66..8fbab402232 100644
--- a/src/test/ui/suggestions/str-array-assignment.rs
+++ b/src/test/ui/suggestions/str-array-assignment.rs
@@ -15,7 +15,7 @@ fn main() {
   let u: &str = if true { s[..2] } else { s };
   //~^ ERROR mismatched types
   let v = s[..2];
-  //~^ ERROR `str` does not have a constant size known at compile-time
+  //~^ ERROR the size for value values of type
   let w: &str = s[..2];
   //~^ ERROR mismatched types
 }
diff --git a/src/test/ui/suggestions/str-array-assignment.stderr b/src/test/ui/suggestions/str-array-assignment.stderr
index acf51f89fc4..12699d8b25f 100644
--- a/src/test/ui/suggestions/str-array-assignment.stderr
+++ b/src/test/ui/suggestions/str-array-assignment.stderr
@@ -19,13 +19,13 @@ LL |   let u: &str = if true { s[..2] } else { s };
    = note: expected type `&str`
               found type `str`
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/str-array-assignment.rs:17:7
    |
 LL |   let v = s[..2];
    |       ^   ------ help: consider borrowing here: `&s[..2]`
    |       |
-   |       `str` does not have a constant size known at compile-time
+   |       doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/trait-suggest-where-clause.rs b/src/test/ui/trait-suggest-where-clause.rs
index 7962dbea371..dd74f4f4797 100644
--- a/src/test/ui/trait-suggest-where-clause.rs
+++ b/src/test/ui/trait-suggest-where-clause.rs
@@ -15,10 +15,10 @@ struct Misc<T:?Sized>(T);
 fn check<T: Iterator, U: ?Sized>() {
     // suggest a where-clause, if needed
     mem::size_of::<U>();
-    //~^ ERROR `U` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     mem::size_of::<Misc<U>>();
-    //~^ ERROR `U` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     // ... even if T occurs as a type parameter
 
@@ -36,10 +36,10 @@ fn check<T: Iterator, U: ?Sized>() {
     // ... and also not if the error is not related to the type
 
     mem::size_of::<[T]>();
-    //~^ ERROR `[T]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     mem::size_of::<[&U]>();
-    //~^ ERROR `[&U]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() {
diff --git a/src/test/ui/trait-suggest-where-clause.stderr b/src/test/ui/trait-suggest-where-clause.stderr
index d87641d8d0f..feb31ae22d8 100644
--- a/src/test/ui/trait-suggest-where-clause.stderr
+++ b/src/test/ui/trait-suggest-where-clause.stderr
@@ -1,19 +1,19 @@
-error[E0277]: `U` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `U` cannot be known at compilation time
   --> $DIR/trait-suggest-where-clause.rs:17:5
    |
 LL |     mem::size_of::<U>();
-   |     ^^^^^^^^^^^^^^^^^ `U` does not have a constant size known at compile-time
+   |     ^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `U`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where U: std::marker::Sized` bound
    = note: required by `std::mem::size_of`
 
-error[E0277]: `U` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `U` cannot be known at compilation time
   --> $DIR/trait-suggest-where-clause.rs:20:5
    |
 LL |     mem::size_of::<Misc<U>>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ `U` does not have a constant size known at compile-time
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `Misc<U>`, the trait `std::marker::Sized` is not implemented for `U`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
@@ -47,21 +47,21 @@ LL |     <Misc<_> as From<T>>::from;
    |
    = note: required by `std::convert::From::from`
 
-error[E0277]: `[T]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[T]` cannot be known at compilation time
   --> $DIR/trait-suggest-where-clause.rs:38:5
    |
 LL |     mem::size_of::<[T]>();
-   |     ^^^^^^^^^^^^^^^^^^^ `[T]` does not have a constant size known at compile-time
+   |     ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[T]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: required by `std::mem::size_of`
 
-error[E0277]: `[&U]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[&U]` cannot be known at compilation time
   --> $DIR/trait-suggest-where-clause.rs:41:5
    |
 LL |     mem::size_of::<[&U]>();
-   |     ^^^^^^^^^^^^^^^^^^^^ `[&U]` does not have a constant size known at compile-time
+   |     ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[&U]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/trivial-bounds-leak.stderr b/src/test/ui/trivial-bounds-leak.stderr
index 6f1f885a506..d08574c3d87 100644
--- a/src/test/ui/trivial-bounds-leak.stderr
+++ b/src/test/ui/trivial-bounds-leak.stderr
@@ -1,8 +1,8 @@
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/trivial-bounds-leak.rs:22:25
    |
 LL | fn cant_return_str() -> str { //~ ERROR
-   |                         ^^^ `str` does not have a constant size known at compile-time
+   |                         ^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/union/union-sized-field.rs b/src/test/ui/union/union-sized-field.rs
index e40c6d11cb3..15822ae4299 100644
--- a/src/test/ui/union/union-sized-field.rs
+++ b/src/test/ui/union/union-sized-field.rs
@@ -12,18 +12,18 @@
 
 union Foo<T: ?Sized> {
     value: T,
-    //~^ ERROR `T` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 struct Foo2<T: ?Sized> {
     value: T,
-    //~^ ERROR `T` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     t: u32,
 }
 
 enum Foo3<T: ?Sized> {
     Value(T),
-    //~^ ERROR `T` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 fn main() {}
diff --git a/src/test/ui/union/union-sized-field.stderr b/src/test/ui/union/union-sized-field.stderr
index 9fdc5af0481..c6b7cf4e078 100644
--- a/src/test/ui/union/union-sized-field.stderr
+++ b/src/test/ui/union/union-sized-field.stderr
@@ -1,30 +1,30 @@
-error[E0277]: `T` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `T` cannot be known at compilation time
   --> $DIR/union-sized-field.rs:14:5
    |
 LL |     value: T,
-   |     ^^^^^^^^ `T` does not have a constant size known at compile-time
+   |     ^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `T`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where T: std::marker::Sized` bound
    = note: no field of a union may have a dynamically sized type
 
-error[E0277]: `T` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `T` cannot be known at compilation time
   --> $DIR/union-sized-field.rs:19:5
    |
 LL |     value: T,
-   |     ^^^^^^^^ `T` does not have a constant size known at compile-time
+   |     ^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `T`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where T: std::marker::Sized` bound
    = note: only the last field of a struct may have a dynamically sized type
 
-error[E0277]: `T` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `T` cannot be known at compilation time
   --> $DIR/union-sized-field.rs:25:11
    |
 LL |     Value(T),
-   |           ^ `T` does not have a constant size known at compile-time
+   |           ^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `T`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
diff --git a/src/test/ui/unsized-enum2.rs b/src/test/ui/unsized-enum2.rs
index 4e42b92289b..9082ea4abdd 100644
--- a/src/test/ui/unsized-enum2.rs
+++ b/src/test/ui/unsized-enum2.rs
@@ -31,53 +31,53 @@ struct Path4(PathHelper4);
 enum E<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized> {
     // parameter
     VA(W),
-    //~^ ERROR `W` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VB{x: X},
-    //~^ ERROR `X` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VC(isize, Y),
-    //~^ ERROR `Y` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VD{u: isize, x: Z},
-    //~^ ERROR `Z` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     // slice / str
     VE([u8]),
-    //~^ ERROR `[u8]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VF{x: str},
-    //~^ ERROR `str` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VG(isize, [f32]),
-    //~^ ERROR `[f32]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VH{u: isize, x: [u32]},
-    //~^ ERROR `[u32]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     // unsized struct
     VI(Path1),
-    //~^ ERROR `PathHelper1 + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VJ{x: Path2},
-    //~^ ERROR `PathHelper2 + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VK(isize, Path3),
-    //~^ ERROR `PathHelper3 + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VL{u: isize, x: Path4},
-    //~^ ERROR `PathHelper4 + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     // plain trait
     VM(Foo),
-    //~^ ERROR `Foo + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VN{x: Bar},
-    //~^ ERROR `Bar + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VO(isize, FooBar),
-    //~^ ERROR `FooBar + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VP{u: isize, x: BarFoo},
-    //~^ ERROR `BarFoo + 'static` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 
     // projected
     VQ(<&'static [i8] as Deref>::Target),
-    //~^ ERROR `[i8]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VR{x: <&'static [char] as Deref>::Target},
-    //~^ ERROR `[char]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VS(isize, <&'static [f64] as Deref>::Target),
-    //~^ ERROR `[f64]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
     VT{u: isize, x: <&'static [i32] as Deref>::Target},
-    //~^ ERROR `[i32]` does not have a constant size known at compile-time
+    //~^ ERROR the size for value values of type
 }
 
 
diff --git a/src/test/ui/unsized-enum2.stderr b/src/test/ui/unsized-enum2.stderr
index 91b8e5def7e..ff2aa1d1ef9 100644
--- a/src/test/ui/unsized-enum2.stderr
+++ b/src/test/ui/unsized-enum2.stderr
@@ -1,205 +1,205 @@
-error[E0277]: `W` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `W` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:33:8
    |
 LL |     VA(W),
-   |        ^ `W` does not have a constant size known at compile-time
+   |        ^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `W`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where W: std::marker::Sized` bound
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `X` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `X` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:35:8
    |
 LL |     VB{x: X},
-   |        ^^^^ `X` does not have a constant size known at compile-time
+   |        ^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `X`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where X: std::marker::Sized` bound
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `Y` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `Y` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:37:15
    |
 LL |     VC(isize, Y),
-   |               ^ `Y` does not have a constant size known at compile-time
+   |               ^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `Y`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where Y: std::marker::Sized` bound
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `Z` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `Z` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:39:18
    |
 LL |     VD{u: isize, x: Z},
-   |                  ^^^^ `Z` does not have a constant size known at compile-time
+   |                  ^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `Z`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = help: consider adding a `where Z: std::marker::Sized` bound
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[u8]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[u8]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:43:8
    |
 LL |     VE([u8]),
-   |        ^^^^ `[u8]` does not have a constant size known at compile-time
+   |        ^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[u8]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `str` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `str` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:45:8
    |
 LL |     VF{x: str},
-   |        ^^^^^^ `str` does not have a constant size known at compile-time
+   |        ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `str`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[f32]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[f32]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:47:15
    |
 LL |     VG(isize, [f32]),
-   |               ^^^^^ `[f32]` does not have a constant size known at compile-time
+   |               ^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[f32]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[u32]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[u32]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:49:18
    |
 LL |     VH{u: isize, x: [u32]},
-   |                  ^^^^^^^^ `[u32]` does not have a constant size known at compile-time
+   |                  ^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[u32]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `Foo + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `Foo + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:63:8
    |
 LL |     VM(Foo),
-   |        ^^^ `Foo + 'static` does not have a constant size known at compile-time
+   |        ^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `Foo + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `Bar + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `Bar + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:65:8
    |
 LL |     VN{x: Bar},
-   |        ^^^^^^ `Bar + 'static` does not have a constant size known at compile-time
+   |        ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `Bar + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `FooBar + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `FooBar + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:67:15
    |
 LL |     VO(isize, FooBar),
-   |               ^^^^^^ `FooBar + 'static` does not have a constant size known at compile-time
+   |               ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `FooBar + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `BarFoo + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `BarFoo + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:69:18
    |
 LL |     VP{u: isize, x: BarFoo},
-   |                  ^^^^^^^^^ `BarFoo + 'static` does not have a constant size known at compile-time
+   |                  ^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `BarFoo + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[i8]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[i8]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:73:8
    |
 LL |     VQ(<&'static [i8] as Deref>::Target),
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `[i8]` does not have a constant size known at compile-time
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[i8]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[char]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[char]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:75:8
    |
 LL |     VR{x: <&'static [char] as Deref>::Target},
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `[char]` does not have a constant size known at compile-time
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[char]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[f64]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[f64]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:77:15
    |
 LL |     VS(isize, <&'static [f64] as Deref>::Target),
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `[f64]` does not have a constant size known at compile-time
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[f64]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `[i32]` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `[i32]` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:79:18
    |
 LL |     VT{u: isize, x: <&'static [i32] as Deref>::Target},
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `[i32]` does not have a constant size known at compile-time
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `std::marker::Sized` is not implemented for `[i32]`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `PathHelper1 + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `PathHelper1 + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:53:8
    |
 LL |     VI(Path1),
-   |        ^^^^^ `PathHelper1 + 'static` does not have a constant size known at compile-time
+   |        ^^^^^ doesn't have a size known at compile-time
    |
    = help: within `Path1`, the trait `std::marker::Sized` is not implemented for `PathHelper1 + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: required because it appears within the type `Path1`
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `PathHelper2 + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `PathHelper2 + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:55:8
    |
 LL |     VJ{x: Path2},
-   |        ^^^^^^^^ `PathHelper2 + 'static` does not have a constant size known at compile-time
+   |        ^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `Path2`, the trait `std::marker::Sized` is not implemented for `PathHelper2 + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: required because it appears within the type `Path2`
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `PathHelper3 + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `PathHelper3 + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:57:15
    |
 LL |     VK(isize, Path3),
-   |               ^^^^^ `PathHelper3 + 'static` does not have a constant size known at compile-time
+   |               ^^^^^ doesn't have a size known at compile-time
    |
    = help: within `Path3`, the trait `std::marker::Sized` is not implemented for `PathHelper3 + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>
    = note: required because it appears within the type `Path3`
    = note: no field of an enum variant may have a dynamically sized type
 
-error[E0277]: `PathHelper4 + 'static` does not have a constant size known at compile-time
+error[E0277]: the size for value values of type `PathHelper4 + 'static` cannot be known at compilation time
   --> $DIR/unsized-enum2.rs:59:18
    |
 LL |     VL{u: isize, x: Path4},
-   |                  ^^^^^^^^ `PathHelper4 + 'static` does not have a constant size known at compile-time
+   |                  ^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `Path4`, the trait `std::marker::Sized` is not implemented for `PathHelper4 + 'static`
    = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types--sized>