Auto merge of #42304 - Mark-Simulacrum:issue-37157, r=nikomatsakis

bors · bors · commit 737962056a67 · 2017-06-23T00:32:40.000Z
Print the two types in the span label for transmute errors. Fixes #37157. I'm not entirely happy with the changes here but overall it's better in my opinion; we certainly avoid the odd language in that issue, which changes to: ``` error[E0512]: transmute called with differently sized types: <C as TypeConstructor<'a>>::T (size can vary because of <C as TypeConstructor>::T) to <C as TypeConstructor<'b>>::T (size can vary because of <C as TypeConstructor>::T) --> test.rs:8:5 | 8 | ::std::mem::transmute(x) | ^^^^^^^^^^^^^^^^^^^^^ transmuting between <C as TypeConstructor<'a>>::T and <C as TypeConstructor<'b>>::T error: aborting due to previous error(s) ```
diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs
@@ -1631,7 +1631,7 @@ fn takes_u8(_: u8) {}
 
 fn main() {
     unsafe { takes_u8(::std::mem::transmute(0u16)); }
-    // error: transmute called with differently sized types
+    // error: transmute called with types of different sizes
 }
 ```
 
diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs
@@ -86,17 +86,16 @@ impl<'a, 'tcx> ExprVisitor<'a, 'tcx> {
             // Special-case transmutting from `typeof(function)` and
             // `Option<typeof(function)>` to present a clearer error.
             let from = unpack_option_like(self.tcx.global_tcx(), from);
-            match (&from.sty, sk_to) {
-                (&ty::TyFnDef(..), SizeSkeleton::Known(size_to))
-                        if size_to == Pointer.size(self.tcx) => {
+            if let (&ty::TyFnDef(..), SizeSkeleton::Known(size_to)) = (&from.sty, sk_to) {
+                if size_to == Pointer.size(self.tcx) {
                     struct_span_err!(self.tcx.sess, span, E0591,
-                                     "`{}` is zero-sized and can't be transmuted to `{}`",
-                                     from, to)
-                        .span_note(span, "cast with `as` to a pointer instead")
+                                     "can't transmute zero-sized type")
+                        .note(&format!("source type: {}", from))
+                        .note(&format!("target type: {}", to))
+                        .help("cast with `as` to a pointer instead")
                         .emit();
                     return;
                 }
-                _ => {}
             }
         }
 
@@ -111,7 +110,7 @@ impl<'a, 'tcx> ExprVisitor<'a, 'tcx> {
                 }
                 Err(LayoutError::Unknown(bad)) => {
                     if bad == ty {
-                        format!("size can vary")
+                        format!("this type's size can vary")
                     } else {
                         format!("size can vary because of {}", bad)
                     }
@@ -121,14 +120,9 @@ impl<'a, 'tcx> ExprVisitor<'a, 'tcx> {
         };
 
         struct_span_err!(self.tcx.sess, span, E0512,
-                  "transmute called with differently sized types: \
-                   {} ({}) to {} ({})",
-                  from, skeleton_string(from, sk_from),
-                  to, skeleton_string(to, sk_to))
-            .span_label(span,
-                format!("transmuting between {} and {}",
-                    skeleton_string(from, sk_from),
-                    skeleton_string(to, sk_to)))
+            "transmute called with types of different sizes")
+            .note(&format!("source type: {} ({})", from, skeleton_string(from, sk_from)))
+            .note(&format!("target type: {} ({})", to, skeleton_string(to, sk_to)))
             .emit();
     }
 }
diff --git a/src/test/compile-fail/E0512.rs b/src/test/compile-fail/E0512.rs
@@ -12,5 +12,4 @@ fn takes_u8(_: u8) {}
 
 fn main() {
     unsafe { takes_u8(::std::mem::transmute(0u16)); } //~ ERROR E0512
-                                                      //~| transmuting between 16 bits and 8 bits
 }
diff --git a/src/test/compile-fail/issue-21174.rs b/src/test/compile-fail/issue-21174.rs
@@ -15,7 +15,7 @@ trait Trait<'a> {
 
 fn foo<'a, T: Trait<'a>>(value: T::A) {
     let new: T::B = unsafe { std::mem::transmute(value) };
-//~^ ERROR: transmute called with differently sized types
+//~^ ERROR: transmute called with types of different sizes
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/issue-28625.rs b/src/test/compile-fail/issue-28625.rs
@@ -17,7 +17,7 @@ struct ArrayPeano<T: Bar> {
 }
 
 fn foo<T>(a: &ArrayPeano<T>) -> &[T] where T: Bar {
-    unsafe { std::mem::transmute(a) } //~ ERROR transmute called with differently sized types
+    unsafe { std::mem::transmute(a) } //~ ERROR transmute called with types of different sizes
 }
 
 impl Bar for () {
diff --git a/src/test/compile-fail/issue-32377.rs b/src/test/compile-fail/issue-32377.rs
@@ -21,7 +21,7 @@ struct Bar<U: Foo> {
 
 fn foo<U: Foo>(x: [usize; 2]) -> Bar<U> {
     unsafe { mem::transmute(x) }
-    //~^ ERROR transmute called with differently sized types
+    //~^ ERROR transmute called with types of different sizes
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs
@@ -13,7 +13,7 @@
 // the error points to the start of the file, not the line with the
 // transmute
 
-// error-pattern: transmute called with differently sized types
+// error-pattern: transmute called with types of different sizes
 
 use std::mem;
 
diff --git a/src/test/compile-fail/packed-struct-transmute.rs b/src/test/compile-fail/packed-struct-transmute.rs
@@ -13,7 +13,7 @@
 // the error points to the start of the file, not the line with the
 // transmute
 
-// error-pattern: transmute called with differently sized types
+// error-pattern: transmute called with types of different sizes
 
 use std::mem;
 
diff --git a/src/test/compile-fail/transmute-different-sizes.rs b/src/test/compile-fail/transmute-different-sizes.rs
@@ -17,12 +17,12 @@ use std::mem::transmute;
 
 unsafe fn f() {
     let _: i8 = transmute(16i16);
-    //~^ ERROR transmute called with differently sized types
+    //~^ ERROR transmute called with types of different sizes
 }
 
 unsafe fn g<T>(x: &T) {
     let _: i8 = transmute(x);
-    //~^ ERROR transmute called with differently sized types
+    //~^ ERROR transmute called with types of different sizes
 }
 
 trait Specializable { type Output; }
@@ -33,7 +33,7 @@ impl<T> Specializable for T {
 
 unsafe fn specializable<T>(x: u16) -> <T as Specializable>::Output {
     transmute(x)
-    //~^ ERROR transmute called with differently sized types
+    //~^ ERROR transmute called with types of different sizes
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/transmute-fat-pointers.rs b/src/test/compile-fail/transmute-fat-pointers.rs
@@ -15,11 +15,11 @@
 use std::mem::transmute;
 
 fn a<T, U: ?Sized>(x: &[T]) -> &U {
-    unsafe { transmute(x) } //~ ERROR transmute called with differently sized types
+    unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes
 }
 
 fn b<T: ?Sized, U: ?Sized>(x: &T) -> &U {
-    unsafe { transmute(x) } //~ ERROR transmute called with differently sized types
+    unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes
 }
 
 fn c<T, U>(x: &T) -> &U {
@@ -31,11 +31,11 @@ fn d<T, U>(x: &[T]) -> &[U] {
 }
 
 fn e<T: ?Sized, U>(x: &T) -> &U {
-    unsafe { transmute(x) } //~ ERROR transmute called with differently sized types
+    unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes
 }
 
 fn f<T, U: ?Sized>(x: &T) -> &U {
-    unsafe { transmute(x) } //~ ERROR transmute called with differently sized types
+    unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/transmute-impl.rs b/src/test/compile-fail/transmute-impl.rs
@@ -26,7 +26,7 @@ impl<T: ?Sized> Foo<T> {
 
     fn n(x: &T) -> &isize {
         // Not OK here, because T : Sized is not in scope.
-        unsafe { transmute(x) } //~ ERROR transmute called with differently sized types
+        unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes
     }
 }
 
diff --git a/src/test/ui/transmute/main.rs b/src/test/ui/transmute/main.rs
@@ -0,0 +1,42 @@
+// Copyright 2017 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.
+
+// ignore-x86
+// ignore-arm
+// ignore-emscripten
+// ignore 32-bit platforms (test output is different)
+
+#![feature(untagged_unions)]
+use std::mem::transmute;
+
+pub trait TypeConstructor<'a> {
+    type T;
+}
+
+unsafe fn transmute_lifetime<'a, 'b, C>(x: <C as TypeConstructor<'a>>::T)
+                                        -> <C as TypeConstructor<'b>>::T
+where for<'z> C: TypeConstructor<'z> {
+    transmute(x) //~ ERROR transmute called with types of different sizes
+}
+
+unsafe fn sizes() {
+    let x: u8 = transmute(10u16); //~ ERROR transmute called with types of different sizes
+}
+
+unsafe fn ptrs() {
+    let x: u8 = transmute("test"); //~ ERROR transmute called with types of different sizes
+}
+
+union Foo { x: () }
+unsafe fn vary() {
+    let x: Foo = transmute(10); //~ ERROR transmute called with types of different sizes
+}
+
+fn main() {}
diff --git a/src/test/ui/transmute/main.stderr b/src/test/ui/transmute/main.stderr
@@ -0,0 +1,38 @@
+error[E0512]: transmute called with types of different sizes
+  --> $DIR/main.rs:26:5
+   |
+26 |     transmute(x) //~ ERROR transmute called with types of different sizes
+   |     ^^^^^^^^^
+   |
+   = note: source type: <C as TypeConstructor<'a>>::T (size can vary because of <C as TypeConstructor>::T)
+   = note: target type: <C as TypeConstructor<'b>>::T (size can vary because of <C as TypeConstructor>::T)
+
+error[E0512]: transmute called with types of different sizes
+  --> $DIR/main.rs:30:17
+   |
+30 |     let x: u8 = transmute(10u16); //~ ERROR transmute called with types of different sizes
+   |                 ^^^^^^^^^
+   |
+   = note: source type: u16 (16 bits)
+   = note: target type: u8 (8 bits)
+
+error[E0512]: transmute called with types of different sizes
+  --> $DIR/main.rs:34:17
+   |
+34 |     let x: u8 = transmute("test"); //~ ERROR transmute called with types of different sizes
+   |                 ^^^^^^^^^
+   |
+   = note: source type: &str (128 bits)
+   = note: target type: u8 (8 bits)
+
+error[E0512]: transmute called with types of different sizes
+  --> $DIR/main.rs:39:18
+   |
+39 |     let x: Foo = transmute(10); //~ ERROR transmute called with types of different sizes
+   |                  ^^^^^^^^^
+   |
+   = note: source type: i32 (32 bits)
+   = note: target type: Foo (0 bits)
+
+error: aborting due to previous error(s)
+
diff --git a/src/test/ui/transmute/transmute-from-fn-item-types-error.rs b/src/test/ui/transmute/transmute-from-fn-item-types-error.rs
@@ -8,9 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-x86
+// ignore-arm
+// ignore-emscripten
+// ignore 32-bit platforms (test output is different)
+
 use std::mem;
 
-unsafe fn foo() -> (isize, *const (), Option<fn()>) {
+unsafe fn foo() -> (i32, *const (), Option<fn()>) {
     let i = mem::transmute(bar);
     //~^ ERROR is zero-sized and can't be transmuted
     //~^^ NOTE cast with `as` to a pointer instead
@@ -29,8 +34,8 @@ unsafe fn foo() -> (isize, *const (), Option<fn()>) {
 unsafe fn bar() {
     // Error as usual if the resulting type is not pointer-sized.
     mem::transmute::<_, u8>(main);
-    //~^ ERROR transmute called with differently sized types
-    //~^^ NOTE transmuting between 0 bits and 8 bits
+    //~^ ERROR transmute called with types of different sizes
+    //~^^ NOTE transmuting between fn() {main} and u8
 
     mem::transmute::<_, *mut ()>(foo);
     //~^ ERROR is zero-sized and can't be transmuted
@@ -41,7 +46,7 @@ unsafe fn bar() {
     //~^^ NOTE cast with `as` to a pointer instead
 
     // No error if a coercion would otherwise occur.
-    mem::transmute::<fn(), usize>(main);
+    mem::transmute::<fn(), u32>(main);
 }
 
 unsafe fn baz() {
@@ -58,7 +63,7 @@ unsafe fn baz() {
     //~^^ NOTE cast with `as` to a pointer instead
 
     // No error if a coercion would otherwise occur.
-    mem::transmute::<Option<fn()>, usize>(Some(main));
+    mem::transmute::<Option<fn()>, u32>(Some(main));
 }
 
 fn main() {
diff --git a/src/test/ui/transmute/transmute-from-fn-item-types-error.stderr b/src/test/ui/transmute/transmute-from-fn-item-types-error.stderr
diff --git a/src/test/ui/transmute/transmute-type-parameters.rs b/src/test/ui/transmute/transmute-type-parameters.rs
diff --git a/src/test/ui/transmute/transmute-type-parameters.stderr b/src/test/ui/transmute/transmute-type-parameters.stderr

Original file line number	Diff line number	Diff line change
`@@ -1631,7 +1631,7 @@ fn takes_u8(_: u8) {}`
`1631`	`1631`
`1632`	`1632`	`fn main() {`
`1633`	`1633`	`unsafe { takes_u8(::std::mem::transmute(0u16)); }`
`1634`		`- // error: transmute called with differently sized types`
	`1634`	`+ // error: transmute called with types of different sizes`
`1635`	`1635`	`}`
`1636`	`1636`	```
`1637`	`1637`
Original file line number	Diff line number	Diff line change
`@@ -12,5 +12,4 @@ fn takes_u8(_: u8) {}`
`12`	`12`
`13`	`13`	`fn main() {`
`14`	`14`	`unsafe { takes_u8(::std::mem::transmute(0u16)); } //~ ERROR E0512`
`15`		`- //~\| transmuting between 16 bits and 8 bits`
`16`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ trait Trait<'a> {`
`15`	`15`
`16`	`16`	`fn foo<'a, T: Trait<'a>>(value: T::A) {`
`17`	`17`	`let new: T::B = unsafe { std::mem::transmute(value) };`
`18`		`-//~^ ERROR: transmute called with differently sized types`
	`18`	`+//~^ ERROR: transmute called with types of different sizes`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`fn main() { }`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ struct ArrayPeano<T: Bar> {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`fn foo<T>(a: &ArrayPeano<T>) -> &[T] where T: Bar {`
`20`		`- unsafe { std::mem::transmute(a) } //~ ERROR transmute called with differently sized types`
	`20`	`+ unsafe { std::mem::transmute(a) } //~ ERROR transmute called with types of different sizes`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`impl Bar for () {`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ struct Bar<U: Foo> {`
`21`	`21`
`22`	`22`	`fn foo<U: Foo>(x: [usize; 2]) -> Bar<U> {`
`23`	`23`	`unsafe { mem::transmute(x) }`
`24`		`- //~^ ERROR transmute called with differently sized types`
	`24`	`+ //~^ ERROR transmute called with types of different sizes`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,12 @@ use std::mem::transmute;`
`17`	`17`
`18`	`18`	`unsafe fn f() {`
`19`	`19`	`let _: i8 = transmute(16i16);`
`20`		`- //~^ ERROR transmute called with differently sized types`
	`20`	`+ //~^ ERROR transmute called with types of different sizes`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`unsafe fn g<T>(x: &T) {`
`24`	`24`	`let _: i8 = transmute(x);`
`25`		`- //~^ ERROR transmute called with differently sized types`
	`25`	`+ //~^ ERROR transmute called with types of different sizes`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`trait Specializable { type Output; }`
`@@ -33,7 +33,7 @@ impl<T> Specializable for T {`
`33`	`33`
`34`	`34`	`unsafe fn specializable<T>(x: u16) -> <T as Specializable>::Output {`
`35`	`35`	`transmute(x)`
`36`		`- //~^ ERROR transmute called with differently sized types`
	`36`	`+ //~^ ERROR transmute called with types of different sizes`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -15,11 +15,11 @@`
`15`	`15`	`use std::mem::transmute;`
`16`	`16`
`17`	`17`	`fn a<T, U: ?Sized>(x: &[T]) -> &U {`
`18`		`- unsafe { transmute(x) } //~ ERROR transmute called with differently sized types`
	`18`	`+ unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`fn b<T: ?Sized, U: ?Sized>(x: &T) -> &U {`
`22`		`- unsafe { transmute(x) } //~ ERROR transmute called with differently sized types`
	`22`	`+ unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`fn c<T, U>(x: &T) -> &U {`
`@@ -31,11 +31,11 @@ fn d<T, U>(x: &[T]) -> &[U] {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`fn e<T: ?Sized, U>(x: &T) -> &U {`
`34`		`- unsafe { transmute(x) } //~ ERROR transmute called with differently sized types`
	`34`	`+ unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`fn f<T, U: ?Sized>(x: &T) -> &U {`
`38`		`- unsafe { transmute(x) } //~ ERROR transmute called with differently sized types`
	`38`	`+ unsafe { transmute(x) } //~ ERROR transmute called with types of different sizes`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`fn main() { }`