Bless changes in UI test output

Author: steffahn

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

@@ -63,7 +63,7 @@ LL |         asm!("{}", in(reg) [1, 2, 3]);
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
-error: cannot use value of type `fn() {main}` for inline assembly
+error: cannot use value of type `[fn item {main}: fn()]` for inline assembly
   --> $DIR/type-check-2.rs:66:31
    |
 LL |         asm!("{}", inout(reg) f);

src/test/ui/associated-types/substs-ppaux.normal.stderr

@@ -2,15 +2,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:16:17
    |
 LL |     fn bar<'a, T>() where T: 'a {}
-   |     --------------------------- fn() {<i8 as Foo<'static, 'static, u8>>::bar::<'static, char>} defined here
+   |     --------------------------- [fn item {<i8 as Foo<'static, 'static, u8>>::bar::<'static, char>}: fn()] defined here
 ...
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::bar::<'static, char>;
    |            --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {<i8 as Foo<'static, 'static, u8>>::bar::<'static, char>}`
+                found fn item `[fn item {<i8 as Foo<'static, 'static, u8>>::bar::<'static, char>}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::bar::<'static, char>();
@@ -20,15 +20,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:25:17
    |
 LL |     fn bar<'a, T>() where T: 'a {}
-   |     --------------------------- fn() {<i8 as Foo<'static, 'static>>::bar::<'static, char>} defined here
+   |     --------------------------- [fn item {<i8 as Foo<'static, 'static>>::bar::<'static, char>}: fn()] defined here
 ...
 LL |     let x: () = <i8 as Foo<'static, 'static,  u32>>::bar::<'static, char>;
    |            --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {<i8 as Foo<'static, 'static>>::bar::<'static, char>}`
+                found fn item `[fn item {<i8 as Foo<'static, 'static>>::bar::<'static, char>}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = <i8 as Foo<'static, 'static,  u32>>::bar::<'static, char>();
@@ -38,15 +38,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:33:17
    |
 LL |     fn baz() {}
-   |     -------- fn() {<i8 as Foo<'static, 'static, u8>>::baz} defined here
+   |     -------- [fn item {<i8 as Foo<'static, 'static, u8>>::baz}: fn()] defined here
 ...
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::baz;
    |            --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {<i8 as Foo<'static, 'static, u8>>::baz}`
+                found fn item `[fn item {<i8 as Foo<'static, 'static, u8>>::baz}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::baz();
@@ -56,15 +56,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:41:17
    |
 LL | fn foo<'z>() where &'z (): Sized {
-   | -------------------------------- fn() {foo::<'static>} defined here
+   | -------------------------------- [fn item {foo::<'static>}: fn()] defined here
 ...
 LL |     let x: () = foo::<'static>;
    |            --   ^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {foo::<'static>}`
+                found fn item `[fn item {foo::<'static>}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = foo::<'static>();

src/test/ui/associated-types/substs-ppaux.verbose.stderr

@@ -2,15 +2,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:16:17
    |
 LL |     fn bar<'a, T>() where T: 'a {}
-   |     --------------------------- fn() {<i8 as Foo<ReStatic, ReStatic, u8>>::bar::<ReStatic, char>} defined here
+   |     --------------------------- [fn item {<i8 as Foo<ReStatic, ReStatic, u8>>::bar::<ReStatic, char>}: fn()] defined here
 ...
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::bar::<'static, char>;
    |            --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {<i8 as Foo<ReStatic, ReStatic, u8>>::bar::<ReStatic, char>}`
+                found fn item `[fn item {<i8 as Foo<ReStatic, ReStatic, u8>>::bar::<ReStatic, char>}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::bar::<'static, char>();
@@ -20,15 +20,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:25:17
    |
 LL |     fn bar<'a, T>() where T: 'a {}
-   |     --------------------------- fn() {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>} defined here
+   |     --------------------------- [fn item {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}: fn()] defined here
 ...
 LL |     let x: () = <i8 as Foo<'static, 'static,  u32>>::bar::<'static, char>;
    |            --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}`
+                found fn item `[fn item {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = <i8 as Foo<'static, 'static,  u32>>::bar::<'static, char>();
@@ -38,15 +38,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:33:17
    |
 LL |     fn baz() {}
-   |     -------- fn() {<i8 as Foo<ReStatic, ReStatic, u8>>::baz} defined here
+   |     -------- [fn item {<i8 as Foo<ReStatic, ReStatic, u8>>::baz}: fn()] defined here
 ...
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::baz;
    |            --   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {<i8 as Foo<ReStatic, ReStatic, u8>>::baz}`
+                found fn item `[fn item {<i8 as Foo<ReStatic, ReStatic, u8>>::baz}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = <i8 as Foo<'static, 'static,  u8>>::baz();
@@ -56,15 +56,15 @@ error[E0308]: mismatched types
   --> $DIR/substs-ppaux.rs:41:17
    |
 LL | fn foo<'z>() where &'z (): Sized {
-   | -------------------------------- fn() {foo::<ReStatic>} defined here
+   | -------------------------------- [fn item {foo::<ReStatic>}: fn()] defined here
 ...
 LL |     let x: () = foo::<'static>;
    |            --   ^^^^^^^^^^^^^^ expected `()`, found fn item
    |            |
    |            expected due to this
    |
    = note: expected unit type `()`
-                found fn item `fn() {foo::<ReStatic>}`
+                found fn item `[fn item {foo::<ReStatic>}: fn()]`
 help: use parentheses to call this function
    |
 LL |     let x: () = foo::<'static>();

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

@@ -1,24 +1,24 @@
-error[E0369]: binary operation `==` cannot be applied to type `for<'r> fn(&'r i32) -> &'r i32 {foo}`
+error[E0369]: binary operation `==` cannot be applied to type `[fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]`
   --> $DIR/issue-77910-1.rs:8:5
    |
 LL |     assert_eq!(foo, y);
    |     ^^^^^^^^^^^^^^^^^^
    |     |
-   |     for<'r> fn(&'r i32) -> &'r i32 {foo}
+   |     [fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]
    |     _
    |
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: `for<'r> fn(&'r i32) -> &'r i32 {foo}` doesn't implement `Debug`
+error[E0277]: `[fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]` doesn't implement `Debug`
   --> $DIR/issue-77910-1.rs:8:5
    |
 LL | fn foo(s: &i32) -> &i32 {
    |    --- consider calling this function
 ...
 LL |     assert_eq!(foo, y);
-   |     ^^^^^^^^^^^^^^^^^^ `for<'r> fn(&'r i32) -> &'r i32 {foo}` cannot be formatted using `{:?}` because it doesn't implement `Debug`
+   |     ^^^^^^^^^^^^^^^^^^ `[fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]` cannot be formatted using `{:?}` because it doesn't implement `Debug`
    |
-   = help: the trait `Debug` is not implemented for `for<'r> fn(&'r i32) -> &'r i32 {foo}`
+   = help: the trait `Debug` is not implemented for `[fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]`
    = help: use parentheses to call the function: `foo(s)`
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 

src/test/ui/binop/issue-77910-2.stderr

@@ -1,10 +1,10 @@
-error[E0369]: binary operation `==` cannot be applied to type `for<'r> fn(&'r i32) -> &'r i32 {foo}`
+error[E0369]: binary operation `==` cannot be applied to type `[fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]`
   --> $DIR/issue-77910-2.rs:7:12
    |
 LL |     if foo == y {}
    |        --- ^^ - _
    |        |
-   |        for<'r> fn(&'r i32) -> &'r i32 {foo}
+   |        [fn item {foo}: for<'r> fn(&'r i32) -> &'r i32]
 
 error: aborting due to previous error
 

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

@@ -1,4 +1,4 @@
-error[E0617]: can't pass `fn(*const u8) {bar}` to variadic function
+error[E0617]: can't pass `[fn item {bar}: fn(*const u8)]` to variadic function
   --> $DIR/issue-32201.rs:9:16
    |
 LL |         foo(0, bar);

src/test/ui/c-variadic/variadic-ffi-1.stderr

@@ -45,7 +45,7 @@ LL |         let x: unsafe extern "C" fn(f: isize, x: u8) = foo;
    |                expected due to this
    |
    = note: expected fn pointer `unsafe extern "C" fn(_, _)`
-                 found fn item `unsafe extern "C" fn(_, _, ...) {foo}`
+                 found fn item `[fn item {foo}: unsafe extern "C" fn(_, _, ...)]`
 
 error[E0308]: mismatched types
   --> $DIR/variadic-ffi-1.rs:24:54
@@ -56,7 +56,7 @@ LL |         let y: extern "C" fn(f: isize, x: u8, ...) = bar;
    |                expected due to this
    |
    = note: expected fn pointer `extern "C" fn(_, _, ...)`
-                 found fn item `extern "C" fn(_, _) {bar}`
+                 found fn item `[fn item {bar}: extern "C" fn(_, _)]`
 
 error[E0617]: can't pass `f32` to variadic function
   --> $DIR/variadic-ffi-1.rs:26:19

src/test/ui/cast/cast-to-bare-fn.stderr

@@ -1,4 +1,4 @@
-error[E0605]: non-primitive cast: `fn(isize) {foo}` as `extern "C" fn() -> isize`
+error[E0605]: non-primitive cast: `[fn item {foo}: fn(isize)]` as `extern "C" fn() -> isize`
   --> $DIR/cast-to-bare-fn.rs:5:13
    |
 LL |     let x = foo as extern "C" fn() -> isize;

src/test/ui/closures/closure_cap_coerce_many_fail.stderr

@@ -4,14 +4,14 @@ error[E0308]: `match` arms have incompatible types
 LL |       let _ = match "+" {
    |  _____________-
 LL | |         "+" => add,
-   | |                --- this is found to be of type `fn(i32, i32) -> i32 {add}`
+   | |                --- this is found to be of type `[fn item {add}: fn(i32, i32) -> i32]`
 LL | |         "-" => |a, b| (a - b + cap) as i32,
    | |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found closure
 LL | |         _ => unimplemented!(),
 LL | |     };
    | |_____- `match` arms have incompatible types
    |
-   = note: expected fn item `fn(i32, i32) -> i32 {add}`
+   = note: expected fn item `[fn item {add}: fn(i32, i32) -> i32]`
               found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:9:16: 9:22]`
 
 error[E0308]: `match` arms have incompatible types

src/test/ui/closures/coerce-unsafe-to-closure.stderr

@@ -1,12 +1,12 @@
-error[E0277]: expected a `FnOnce<(&str,)>` closure, found `unsafe extern "rust-intrinsic" fn(_) -> _ {transmute::<_, _>}`
+error[E0277]: expected a `FnOnce<(&str,)>` closure, found `[fn item {transmute::<_, _>}: unsafe extern "rust-intrinsic" fn(_) -> _]`
   --> $DIR/coerce-unsafe-to-closure.rs:2:44
    |
 LL |     let x: Option<&[u8]> = Some("foo").map(std::mem::transmute);
    |                                        --- ^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }`
    |                                        |
    |                                        required by a bound introduced by this call
    |
-   = help: the trait `FnOnce<(&str,)>` is not implemented for `unsafe extern "rust-intrinsic" fn(_) -> _ {transmute::<_, _>}`
+   = help: the trait `FnOnce<(&str,)>` is not implemented for `[fn item {transmute::<_, _>}: unsafe extern "rust-intrinsic" fn(_) -> _]`
    = note: unsafe function cannot be called generically without an unsafe block
 note: required by a bound in `Option::<T>::map`
   --> $SRC_DIR/core/src/option.rs:LL:COL

src/test/ui/const-generics/generic_const_exprs/eval-privacy.stderr

@@ -1,11 +1,11 @@
-error[E0446]: private type `fn(u8) -> u8 {my_const_fn}` in public interface
+error[E0446]: private type `[fn item {my_const_fn}: fn(u8) -> u8]` in public interface
   --> $DIR/eval-privacy.rs:16:5
    |
 LL |     type AssocTy = Const<{ my_const_fn(U) }>;
    |     ^^^^^^^^^^^^ can't leak private type
 ...
 LL | const fn my_const_fn(val: u8) -> u8 {
-   | ----------------------------------- `fn(u8) -> u8 {my_const_fn}` declared as private
+   | ----------------------------------- `[fn item {my_const_fn}: fn(u8) -> u8]` declared as private
 
 error: aborting due to previous error
 

src/test/ui/consts/const-float-bits-reject-conv.stderr

@@ -13,12 +13,12 @@ LL |         unsafe { intrinsics::const_eval_select((self,), ct_f32_to_u32, rt_f
   ::: $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
 LL |     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-   |     ------------------------------------------------------------------ inside `<fn(f32) -> u32 {core::f32::<impl f32>::to_bits::ct_f32_to_u32} as FnOnce<(f32,)>>::call_once - shim(fn(f32) -> u32 {core::f32::<impl f32>::to_bits::ct_f32_to_u32})` at $SRC_DIR/core/src/ops/function.rs:LL:COL
+   |     ------------------------------------------------------------------ inside `<[fn item {core::f32::<impl f32>::to_bits::ct_f32_to_u32}: fn(f32) -> u32] as FnOnce<(f32,)>>::call_once - shim([fn item {core::f32::<impl f32>::to_bits::ct_f32_to_u32}: fn(f32) -> u32])` at $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
   ::: $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
 LL |     called_in_const.call_once(arg)
-   |     ------------------------------ inside `const_eval_select::<(f32,), fn(f32) -> u32 {core::f32::<impl f32>::to_bits::ct_f32_to_u32}, [closure@core::f32::<impl f32>::to_bits::{closure#0}], u32>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
+   |     ------------------------------ inside `const_eval_select::<(f32,), [fn item {core::f32::<impl f32>::to_bits::ct_f32_to_u32}: fn(f32) -> u32], [closure@core::f32::<impl f32>::to_bits::{closure#0}], u32>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
   ::: $DIR/const-float-bits-reject-conv.rs:27:30
    |
@@ -42,12 +42,12 @@ LL |         unsafe { intrinsics::const_eval_select((self,), ct_f32_to_u32, rt_f
   ::: $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
 LL |     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-   |     ------------------------------------------------------------------ inside `<fn(f32) -> u32 {core::f32::<impl f32>::to_bits::ct_f32_to_u32} as FnOnce<(f32,)>>::call_once - shim(fn(f32) -> u32 {core::f32::<impl f32>::to_bits::ct_f32_to_u32})` at $SRC_DIR/core/src/ops/function.rs:LL:COL
+   |     ------------------------------------------------------------------ inside `<[fn item {core::f32::<impl f32>::to_bits::ct_f32_to_u32}: fn(f32) -> u32] as FnOnce<(f32,)>>::call_once - shim([fn item {core::f32::<impl f32>::to_bits::ct_f32_to_u32}: fn(f32) -> u32])` at $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
   ::: $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
 LL |     called_in_const.call_once(arg)
-   |     ------------------------------ inside `const_eval_select::<(f32,), fn(f32) -> u32 {core::f32::<impl f32>::to_bits::ct_f32_to_u32}, [closure@core::f32::<impl f32>::to_bits::{closure#0}], u32>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
+   |     ------------------------------ inside `const_eval_select::<(f32,), [fn item {core::f32::<impl f32>::to_bits::ct_f32_to_u32}: fn(f32) -> u32], [closure@core::f32::<impl f32>::to_bits::{closure#0}], u32>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
   ::: $DIR/const-float-bits-reject-conv.rs:28:30
    |
@@ -120,12 +120,12 @@ LL |         unsafe { intrinsics::const_eval_select((self,), ct_f64_to_u64, rt_f
   ::: $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
 LL |     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-   |     ------------------------------------------------------------------ inside `<fn(f64) -> u64 {core::f64::<impl f64>::to_bits::ct_f64_to_u64} as FnOnce<(f64,)>>::call_once - shim(fn(f64) -> u64 {core::f64::<impl f64>::to_bits::ct_f64_to_u64})` at $SRC_DIR/core/src/ops/function.rs:LL:COL
+   |     ------------------------------------------------------------------ inside `<[fn item {core::f64::<impl f64>::to_bits::ct_f64_to_u64}: fn(f64) -> u64] as FnOnce<(f64,)>>::call_once - shim([fn item {core::f64::<impl f64>::to_bits::ct_f64_to_u64}: fn(f64) -> u64])` at $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
   ::: $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
 LL |     called_in_const.call_once(arg)
-   |     ------------------------------ inside `const_eval_select::<(f64,), fn(f64) -> u64 {core::f64::<impl f64>::to_bits::ct_f64_to_u64}, [closure@core::f64::<impl f64>::to_bits::{closure#0}], u64>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
+   |     ------------------------------ inside `const_eval_select::<(f64,), [fn item {core::f64::<impl f64>::to_bits::ct_f64_to_u64}: fn(f64) -> u64], [closure@core::f64::<impl f64>::to_bits::{closure#0}], u64>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
   ::: $DIR/const-float-bits-reject-conv.rs:54:30
    |
@@ -149,12 +149,12 @@ LL |         unsafe { intrinsics::const_eval_select((self,), ct_f64_to_u64, rt_f
   ::: $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
 LL |     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-   |     ------------------------------------------------------------------ inside `<fn(f64) -> u64 {core::f64::<impl f64>::to_bits::ct_f64_to_u64} as FnOnce<(f64,)>>::call_once - shim(fn(f64) -> u64 {core::f64::<impl f64>::to_bits::ct_f64_to_u64})` at $SRC_DIR/core/src/ops/function.rs:LL:COL
+   |     ------------------------------------------------------------------ inside `<[fn item {core::f64::<impl f64>::to_bits::ct_f64_to_u64}: fn(f64) -> u64] as FnOnce<(f64,)>>::call_once - shim([fn item {core::f64::<impl f64>::to_bits::ct_f64_to_u64}: fn(f64) -> u64])` at $SRC_DIR/core/src/ops/function.rs:LL:COL
    |
   ::: $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
 LL |     called_in_const.call_once(arg)
-   |     ------------------------------ inside `const_eval_select::<(f64,), fn(f64) -> u64 {core::f64::<impl f64>::to_bits::ct_f64_to_u64}, [closure@core::f64::<impl f64>::to_bits::{closure#0}], u64>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
+   |     ------------------------------ inside `const_eval_select::<(f64,), [fn item {core::f64::<impl f64>::to_bits::ct_f64_to_u64}: fn(f64) -> u64], [closure@core::f64::<impl f64>::to_bits::{closure#0}], u64>` at $SRC_DIR/core/src/intrinsics.rs:LL:COL
    |
   ::: $DIR/const-float-bits-reject-conv.rs:55:30
    |

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

@@ -28,7 +28,7 @@ error[E0617]: can't pass `u16` to variadic function
 LL |         printf(::std::ptr::null(), 0u16);
    |                                    ^^^^ help: cast the value to `c_uint`: `0u16 as c_uint`
 
-error[E0617]: can't pass `unsafe extern "C" fn(*const i8, ...) {printf}` to variadic function
+error[E0617]: can't pass `[fn item {printf}: unsafe extern "C" fn(*const i8, ...)]` to variadic function
   --> $DIR/E0617.rs:22:36
    |
 LL |         printf(::std::ptr::null(), printf);

src/test/ui/expr/if/if-typeck.stderr

@@ -5,7 +5,7 @@ LL |     if f { }
    |        ^ expected `bool`, found fn item
    |
    = note: expected type `bool`
-           found fn item `fn() {f}`
+           found fn item `[fn item {f}: fn()]`
 
 error: aborting due to previous error