Update error messages in UI tests

Author: steffahn

src/test/ui/asm/x86_64/type-check-2.rs

@@ -64,7 +64,7 @@ fn main() {
         let mut r = &mut 0;
         asm!("{}", in(reg) f);
         asm!("{}", inout(reg) f);
-        //~^ ERROR cannot use value of type `fn() {main}` for inline assembly
+        //~^ ERROR cannot use value of type `[fn item {main}: fn()]` for inline assembly
         asm!("{}", in(reg) r);
         asm!("{}", inout(reg) r);
         //~^ ERROR cannot use value of type `&mut i32` for inline assembly

src/test/ui/associated-types/substs-ppaux.rs

@@ -16,35 +16,35 @@ fn foo<'z>() where &'z (): Sized {
     let x: () = <i8 as Foo<'static, 'static,  u8>>::bar::<'static, char>;
     //[verbose]~^ ERROR mismatched types
     //[verbose]~| expected unit type `()`
-    //[verbose]~| found fn item `fn() {<i8 as Foo<ReStatic, ReStatic, u8>>::bar::<ReStatic, char>}`
+    //[verbose]~| found fn item `[fn item {<i8 as Foo<ReStatic, ReStatic, u8>>::bar::<ReStatic, char>}: fn()]`
     //[normal]~^^^^ ERROR mismatched types
     //[normal]~| expected unit type `()`
-    //[normal]~| found fn item `fn() {<i8 as Foo<'static, 'static, u8>>::bar::<'static, char>}`
+    //[normal]~| found fn item `[fn item {<i8 as Foo<'static, 'static, u8>>::bar::<'static, char>}: fn()]`
 
 
     let x: () = <i8 as Foo<'static, 'static,  u32>>::bar::<'static, char>;
     //[verbose]~^ ERROR mismatched types
     //[verbose]~| expected unit type `()`
-    //[verbose]~| found fn item `fn() {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}`
+    //[verbose]~| found fn item `[fn item {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}: fn()]`
     //[normal]~^^^^ ERROR mismatched types
     //[normal]~| expected unit type `()`
-    //[normal]~| found fn item `fn() {<i8 as Foo<'static, 'static>>::bar::<'static, char>}`
+    //[normal]~| found fn item `[fn item {<i8 as Foo<'static, 'static>>::bar::<'static, char>}: fn()]`
 
     let x: () = <i8 as Foo<'static, 'static,  u8>>::baz;
     //[verbose]~^ ERROR mismatched types
     //[verbose]~| expected unit type `()`
-    //[verbose]~| found fn item `fn() {<i8 as Foo<ReStatic, ReStatic, u8>>::baz}`
+    //[verbose]~| found fn item `[fn item {<i8 as Foo<ReStatic, ReStatic, u8>>::baz}: fn()]`
     //[normal]~^^^^ ERROR mismatched types
     //[normal]~| expected unit type `()`
-    //[normal]~| found fn item `fn() {<i8 as Foo<'static, 'static, u8>>::baz}`
+    //[normal]~| found fn item `[fn item {<i8 as Foo<'static, 'static, u8>>::baz}: fn()]`
 
     let x: () = foo::<'static>;
     //[verbose]~^ ERROR mismatched types
     //[verbose]~| expected unit type `()`
-    //[verbose]~| found fn item `fn() {foo::<ReStatic>}`
+    //[verbose]~| found fn item `[fn item {foo::<ReStatic>}: fn()]`
     //[normal]~^^^^ ERROR mismatched types
     //[normal]~| expected unit type `()`
-    //[normal]~| found fn item `fn() {foo::<'static>}`
+    //[normal]~| found fn item `[fn item {foo::<'static>}: fn()]`
 
     <str as Foo<u8>>::bar;
     //[verbose]~^ ERROR the size for values of type

src/test/ui/binop/issue-77910-1.rs

@@ -7,5 +7,5 @@ fn main() {
     // we shouldn't ice with the bound var here.
     assert_eq!(foo, y);
     //~^ ERROR binary operation `==` cannot be applied to type
-    //~| ERROR `for<'r> fn(&'r i32) -> &'r i32 {foo}` doesn't implement `Debug`
+    //~| ERROR `[fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]` doesn't implement `Debug`
 }

src/test/ui/c-variadic/issue-32201.rs

@@ -7,7 +7,7 @@ fn bar(_: *const u8) {}
 fn main() {
     unsafe {
         foo(0, bar);
-        //~^ ERROR can't pass `fn(*const u8) {bar}` to variadic function
+        //~^ ERROR can't pass `[fn item {bar}: fn(*const u8)]` to variadic function
         //~| HELP cast the value to `fn(*const u8)`
     }
 }

src/test/ui/error-codes/E0617.rs

@@ -20,7 +20,7 @@ fn main() {
         //~^ ERROR can't pass `u16` to variadic function
         //~| HELP cast the value to `c_uint`
         printf(::std::ptr::null(), printf);
-        //~^ ERROR can't pass `unsafe extern "C" fn(*const i8, ...) {printf}` to variadic function
+        //~^ ERROR can't pass `[fn item {printf}: unsafe extern "C" fn(*const i8, ...)]` to variadic function
         //~| HELP cast the value to `unsafe extern "C" fn(*const i8, ...)`
     }
 }

src/test/ui/extern/extern-wrong-value-type.rs

@@ -7,5 +7,5 @@ fn main() {
     // extern functions are extern "C" fn
     let _x: extern "C" fn() = f; // OK
     is_fn(f);
-    //~^ ERROR expected a `Fn<()>` closure, found `extern "C" fn() {f}`
+    //~^ ERROR expected a `Fn<()>` closure, found `[fn item {f}: extern "C" fn()]`
 }

src/test/ui/fn/fn-item-type.rs

@@ -12,8 +12,8 @@ impl<T> Foo for T { /* `foo` is still default here */ }
 fn main() {
     eq(foo::<u8>, bar::<u8>);
     //~^ ERROR mismatched types
-    //~| expected fn item `fn(_) -> _ {foo::<u8>}`
-    //~| found fn item `fn(_) -> _ {bar::<u8>}`
+    //~| expected fn item `[fn item {foo::<u8>}: fn(_) -> _]`
+    //~| found fn item `[fn item {bar::<u8>}: fn(_) -> _]`
     //~| expected fn item, found a different fn item
     //~| different `fn` items always have unique types, even if their signatures are the same
     //~| change the expected type to be function pointer
@@ -28,7 +28,7 @@ fn main() {
 
     eq(bar::<String>, bar::<Vec<u8>>);
     //~^ ERROR mismatched types
-    //~| found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
+    //~| found fn item `[fn item {bar::<Vec<u8>>}: fn(_) -> _]`
     //~| expected struct `String`, found struct `Vec`
     //~| different `fn` items always have unique types, even if their signatures are the same
     //~| change the expected type to be function pointer

src/test/ui/hygiene/impl_items.rs

@@ -9,7 +9,7 @@ mod foo {
     }
 
     pub macro m() {
-        let _: () = S.f(); //~ ERROR type `for<'r> fn(&'r foo::S) {foo::S::f}` is private
+        let _: () = S.f(); //~ ERROR type `[fn item {foo::S::f}: for<'r> fn(&'r foo::S)]` is private
     }
 }
 

src/test/ui/hygiene/intercrate.rs

@@ -8,5 +8,5 @@ extern crate intercrate;
 
 fn main() {
     assert_eq!(intercrate::foo::m!(), 1);
-    //~^ ERROR type `fn() -> u32 {foo::bar::f}` is private
+    //~^ ERROR type `[fn item {foo::bar::f}: fn() -> u32]` is private
 }

src/test/ui/issues/issue-59488.rs

@@ -12,22 +12,22 @@ enum Foo {
 
 fn main() {
     foo > 12;
-    //~^ ERROR binary operation `>` cannot be applied to type `fn() -> i32 {foo}` [E0369]
+    //~^ ERROR binary operation `>` cannot be applied to type `[fn item {foo}: fn() -> i32]` [E0369]
     //~| ERROR mismatched types [E0308]
 
     bar > 13;
-    //~^ ERROR binary operation `>` cannot be applied to type `fn(i64) -> i64 {bar}` [E0369]
+    //~^ ERROR binary operation `>` cannot be applied to type `[fn item {bar}: fn(i64) -> i64]` [E0369]
     //~| ERROR mismatched types [E0308]
 
     foo > foo;
-    //~^ ERROR binary operation `>` cannot be applied to type `fn() -> i32 {foo}` [E0369]
+    //~^ ERROR binary operation `>` cannot be applied to type `[fn item {foo}: fn() -> i32]` [E0369]
 
     foo > bar;
-    //~^ ERROR binary operation `>` cannot be applied to type `fn() -> i32 {foo}` [E0369]
+    //~^ ERROR binary operation `>` cannot be applied to type `[fn item {foo}: fn() -> i32]` [E0369]
     //~| ERROR mismatched types [E0308]
 
     let i = Foo::Bar;
     assert_eq!(Foo::Bar, i);
-    //~^ ERROR binary operation `==` cannot be applied to type `fn(usize) -> Foo {Foo::Bar}` [E0369]
-    //~| ERROR `fn(usize) -> Foo {Foo::Bar}` doesn't implement `Debug` [E0277]
+    //~^ ERROR binary operation `==` cannot be applied to type `[fn item {Foo::Bar}: fn(usize) -> Foo]` [E0369]
+    //~| ERROR `[fn item {Foo::Bar}: fn(usize) -> Foo]` doesn't implement `Debug` [E0277]
 }

src/test/ui/lint/trivial_casts.rs

@@ -67,7 +67,7 @@ pub fn main() {
 
     // functions
     fn baz(_x: i32) {}
-    let _ = &baz as &dyn Fn(i32); //~ERROR `&fn(i32) {baz}` as `&dyn Fn(i32)`
+    let _ = &baz as &dyn Fn(i32); //~ERROR `&[fn item {baz}: fn(i32)]` as `&dyn Fn(i32)`
     let _: &dyn Fn(i32) = &baz;
     let x = |_x: i32| {};
     let _ = &x as &dyn Fn(i32); //~ERROR trivial cast

src/test/ui/privacy/associated-item-privacy-inherent.rs

@@ -11,11 +11,11 @@ mod priv_nominal {
 
     pub macro mac() {
         let value = Pub::method;
-        //~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
+        //~^ ERROR type `[fn item {priv_nominal::Pub::method}: for<'r> fn(&'r priv_nominal::Pub)]` is private
         value;
-        //~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
+        //~^ ERROR type `[fn item {priv_nominal::Pub::method}: for<'r> fn(&'r priv_nominal::Pub)]` is private
         Pub.method();
-        //~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
+        //~^ ERROR type `[fn item {priv_nominal::Pub::method}: for<'r> fn(&'r priv_nominal::Pub)]` is private
         Pub::CONST;
         //~^ ERROR associated constant `CONST` is private
         // let _: Pub::AssocTy;

src/test/ui/privacy/associated-item-privacy-trait.rs

@@ -13,11 +13,11 @@ mod priv_trait {
 
     pub macro mac() {
         let value = <Pub as PrivTr>::method;
-        //~^ ERROR type `for<'r> fn(&'r priv_trait::Pub) {<priv_trait::Pub as PrivTr>::method}` is private
+        //~^ ERROR type `[fn item {<priv_trait::Pub as PrivTr>::method}: for<'r> fn(&'r priv_trait::Pub)]` is private
         value;
-        //~^ ERROR type `for<'r> fn(&'r priv_trait::Pub) {<priv_trait::Pub as PrivTr>::method}` is private
+        //~^ ERROR type `[fn item {<priv_trait::Pub as PrivTr>::method}: for<'r> fn(&'r priv_trait::Pub)]` is private
         Pub.method();
-        //~^ ERROR type `for<'r> fn(&'r Self) {<Self as PrivTr>::method}` is private
+        //~^ ERROR type `[fn item {<Self as PrivTr>::method}: for<'r> fn(&'r Self)]` is private
         <Pub as PrivTr>::CONST;
         //~^ ERROR associated constant `<Pub as PrivTr>::CONST` is private
         let _: <Pub as PrivTr>::AssocTy;

src/test/ui/privacy/private-inferred-type-3.rs

@@ -1,12 +1,12 @@
 // aux-build:private-inferred-type.rs
 
-// error-pattern:type `fn() {ext::priv_fn}` is private
+// error-pattern:type `[fn item {ext::priv_fn}: fn()]` is private
 // error-pattern:static `PRIV_STATIC` is private
 // error-pattern:type `ext::PrivEnum` is private
-// error-pattern:type `fn() {<u8 as ext::PrivTrait>::method}` is private
-// error-pattern:type `fn(u8) -> ext::PrivTupleStruct {ext::PrivTupleStruct}` is private
-// error-pattern:type `fn(u8) -> PubTupleStruct {PubTupleStruct}` is private
-// error-pattern:type `for<'r> fn(&'r Pub<u8>) {Pub::<u8>::priv_method}` is private
+// error-pattern:type `[fn item {<u8 as ext::PrivTrait>::method}: fn()]` is private
+// error-pattern:type `[fn item {ext::PrivTupleStruct}: fn(u8) -> ext::PrivTupleStruct]` is private
+// error-pattern:type `[fn item {PubTupleStruct}: fn(u8) -> PubTupleStruct]` is private
+// error-pattern:type `[fn item {Pub::<u8>::priv_method}: for<'r> fn(&'r Pub<u8>)]` is private
 
 #![feature(decl_macro)]
 

src/test/ui/privacy/private-inferred-type.rs

@@ -36,18 +36,18 @@ mod m {
     impl TraitWithAssocTy for Priv { type AssocTy = u8; }
 
     pub macro m() {
-        priv_fn; //~ ERROR type `fn() {priv_fn}` is private
+        priv_fn; //~ ERROR type `[fn item {priv_fn}: fn()]` is private
         PRIV_STATIC; // OK, not cross-crate
         PrivEnum::Variant; //~ ERROR type `PrivEnum` is private
         PubEnum::Variant; // OK
-        <u8 as PrivTrait>::method; //~ ERROR type `fn() {<u8 as PrivTrait>::method}` is private
+        <u8 as PrivTrait>::method; //~ ERROR type `[fn item {<u8 as PrivTrait>::method}: fn()]` is private
         <u8 as PubTrait>::method; // OK
         PrivTupleStruct;
-        //~^ ERROR type `fn(u8) -> PrivTupleStruct {PrivTupleStruct}` is private
+        //~^ ERROR type `[fn item {PrivTupleStruct}: fn(u8) -> PrivTupleStruct]` is private
         PubTupleStruct;
-        //~^ ERROR type `fn(u8) -> PubTupleStruct {PubTupleStruct}` is private
+        //~^ ERROR type `[fn item {PubTupleStruct}: fn(u8) -> PubTupleStruct]` is private
         Pub(0u8).priv_method();
-        //~^ ERROR type `for<'r> fn(&'r Pub<u8>) {Pub::<u8>::priv_method}` is private
+        //~^ ERROR type `[fn item {Pub::<u8>::priv_method}: for<'r> fn(&'r Pub<u8>)]` is private
     }
 
     trait Trait {}

src/test/ui/proc-macro/signature.rs

@@ -8,6 +8,6 @@ extern crate proc_macro;
 
 #[proc_macro_derive(A)]
 pub unsafe extern "C" fn foo(a: i32, b: u32) -> u32 {
-    //~^ ERROR: expected a `Fn<(proc_macro::TokenStream,)>` closure, found `unsafe extern "C" fn
+    //~^ ERROR: expected a `Fn<(proc_macro::TokenStream,)>` closure, found `[fn item {foo}: unsafe extern "C" fn
     loop {}
 }

src/test/ui/rfcs/rfc-2396-target_feature-11/fn-traits.rs

@@ -21,14 +21,14 @@ fn call_once(f: impl FnOnce()) {
 }
 
 fn main() {
-    call(foo); //~ ERROR expected a `Fn<()>` closure, found `fn() {foo}`
-    call_mut(foo); //~ ERROR expected a `FnMut<()>` closure, found `fn() {foo}`
-    call_once(foo); //~ ERROR expected a `FnOnce<()>` closure, found `fn() {foo}`
+    call(foo); //~ ERROR expected a `Fn<()>` closure, found `[fn item {foo}: fn()]`
+    call_mut(foo); //~ ERROR expected a `FnMut<()>` closure, found `[fn item {foo}: fn()]`
+    call_once(foo); //~ ERROR expected a `FnOnce<()>` closure, found `[fn item {foo}: fn()]`
 
     call(foo_unsafe);
-    //~^ ERROR expected a `Fn<()>` closure, found `unsafe fn() {foo_unsafe}`
+    //~^ ERROR expected a `Fn<()>` closure, found `[fn item {foo_unsafe}: unsafe fn()]`
     call_mut(foo_unsafe);
-    //~^ ERROR expected a `FnMut<()>` closure, found `unsafe fn() {foo_unsafe}`
+    //~^ ERROR expected a `FnMut<()>` closure, found `[fn item {foo_unsafe}: unsafe fn()]`
     call_once(foo_unsafe);
-    //~^ ERROR expected a `FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}`
+    //~^ ERROR expected a `FnOnce<()>` closure, found `[fn item {foo_unsafe}: unsafe fn()]`
 }

src/test/ui/type-alias-impl-trait/issue-98608.rs

@@ -2,7 +2,7 @@ fn hi() -> impl Sized { std::ptr::null::<u8>() }
 
 fn main() {
     let b: Box<dyn Fn() -> Box<u8>> = Box::new(hi);
-    //~^ ERROR type mismatch resolving `<fn() -> impl Sized {hi} as FnOnce<()>>::Output == Box<u8>`
+    //~^ ERROR type mismatch resolving `<[fn item {hi}: fn() -> impl Sized] as FnOnce<()>>::Output == Box<u8>`
     let boxed = b();
     let null = *boxed;
     println!("{null:?}");

src/test/ui/typeck/issue-87181/empty-tuple-method.rs

@@ -10,5 +10,5 @@ impl Foo {
 fn main() {
     let thing = Bar { bar: Foo };
     thing.bar.foo();
-    //~^ ERROR no method named `foo` found for fn item `fn() -> Foo {Foo}` in the current scope [E0599]
+    //~^ ERROR no method named `foo` found for fn item `[fn item {Foo}: fn() -> Foo]` in the current scope [E0599]
 }

src/test/ui/typeck/issue-87181/enum-variant.rs

@@ -12,5 +12,5 @@ impl Foo {
 fn main() {
     let thing = Bar { bar: Foo::Tup };
     thing.bar.foo();
-    //~^ ERROR no method named `foo` found for fn item `fn() -> Foo {Foo::Tup}` in the current scope [E0599]
+    //~^ ERROR no method named `foo` found for fn item `[fn item {Foo::Tup}: fn() -> Foo]` in the current scope [E0599]
 }

src/test/ui/typeck/issue-87181/tuple-field.rs

@@ -10,5 +10,5 @@ impl Foo {
 fn main() {
     let thing = Bar { bar: Foo };
     thing.bar.0;
-    //~^ ERROR no field `0` on type `fn(char, u16) -> Foo {Foo}` [E0609]
+    //~^ ERROR no field `0` on type `[fn item {Foo}: fn(char, u16) -> Foo]` [E0609]
 }

src/test/ui/typeck/issue-87181/tuple-method.rs

@@ -10,5 +10,5 @@ impl Foo {
 fn main() {
     let thing = Bar { bar: Foo };
     thing.bar.foo();
-    //~^ ERROR no method named `foo` found for fn item `fn(u8, i32) -> Foo {Foo}` in the current scope [E0599]
+    //~^ ERROR no method named `foo` found for fn item `[fn item {Foo}: fn(u8, i32) -> Foo]` in the current scope [E0599]
 }