ImproperCTypes: rename associated tests

niacdoial · niacdoial · commit 0df23fad8518 · 2025-09-21T12:21:28.000+02:00
Rustc is trying to shift away from test names that are just issue
numbers, so we add this as part of its effort, since this commit chain
is moving and rewriting these files anyway.
The directory containing all tests is also renamed.
diff --git a/tests/ui/lint/improper-ctypes/ice-fnptr-slicearg.rs b/tests/ui/lint/improper-ctypes/ice-fnptr-slicearg.rs
@@ -1,6 +1,9 @@
 #![crate_type = "lib"]
 #![deny(improper_c_fn_definitions, improper_c_callbacks)]
 
+// Issue: https://github.com/rust-lang/rust/issues/94223
+// ice when a FnPtr has an unsized array argument
+
 pub fn bad(f: extern "C" fn([u8])) {}
 //~^ ERROR `extern` callback uses type `[u8]`, which is not FFI-safe
 
diff --git a/tests/ui/lint/improper-ctypes/ice-fnptr-slicearg.stderr b/tests/ui/lint/improper-ctypes/ice-fnptr-slicearg.stderr
@@ -1,5 +1,5 @@
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:4:15
+  --> $DIR/ice-fnptr-slicearg.rs:7:15
    |
 LL | pub fn bad(f: extern "C" fn([u8])) {}
    |               ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -8,13 +8,13 @@ LL | pub fn bad(f: extern "C" fn([u8])) {}
    = help: consider using a raw pointer to the slice's first element (and a length) instead
    = note: slices have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-94223.rs:2:36
+  --> $DIR/ice-fnptr-slicearg.rs:2:36
    |
 LL | #![deny(improper_c_fn_definitions, improper_c_callbacks)]
    |                                    ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:7:28
+  --> $DIR/ice-fnptr-slicearg.rs:10:28
    |
 LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    |                            ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -24,7 +24,7 @@ LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    = note: slices have no C equivalent
 
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:7:49
+  --> $DIR/ice-fnptr-slicearg.rs:10:49
    |
 LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    |                                                 ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -34,7 +34,7 @@ LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    = note: slices have no C equivalent
 
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:11:18
+  --> $DIR/ice-fnptr-slicearg.rs:14:18
    |
 LL | struct BadStruct(extern "C" fn([u8]));
    |                  ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -44,7 +44,7 @@ LL | struct BadStruct(extern "C" fn([u8]));
    = note: slices have no C equivalent
 
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:15:7
+  --> $DIR/ice-fnptr-slicearg.rs:18:7
    |
 LL |     A(extern "C" fn([u8])),
    |       ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -54,7 +54,7 @@ LL |     A(extern "C" fn([u8])),
    = note: slices have no C equivalent
 
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:20:7
+  --> $DIR/ice-fnptr-slicearg.rs:23:7
    |
 LL |     A(extern "C" fn([u8])),
    |       ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -64,7 +64,7 @@ LL |     A(extern "C" fn([u8])),
    = note: slices have no C equivalent
 
 error: `extern` callback uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:24:12
+  --> $DIR/ice-fnptr-slicearg.rs:27:12
    |
 LL | type Foo = extern "C" fn([u8]);
    |            ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -74,7 +74,7 @@ LL | type Foo = extern "C" fn([u8]);
    = note: slices have no C equivalent
 
 error: `extern` callback uses type `Option<&<T as FooTrait>::FooType>`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:31:20
+  --> $DIR/ice-fnptr-slicearg.rs:34:20
    |
 LL | pub type Foo2<T> = extern "C" fn(Option<&<T as FooTrait>::FooType>);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -84,7 +84,7 @@ LL | pub type Foo2<T> = extern "C" fn(Option<&<T as FooTrait>::FooType>);
    = note: enum has no representation hint
 
 error: `extern` callback uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:41:17
+  --> $DIR/ice-fnptr-slicearg.rs:44:17
    |
 LL | pub static BAD: extern "C" fn(FfiUnsafe) = f;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -93,13 +93,13 @@ LL | pub static BAD: extern "C" fn(FfiUnsafe) = f;
    = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `FfiUnsafe`
    = note: `FfiUnsafe` has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-94223.rs:34:1
+  --> $DIR/ice-fnptr-slicearg.rs:37:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` callback uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:44:30
+  --> $DIR/ice-fnptr-slicearg.rs:47:30
    |
 LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUnsafe)> = Ok(f);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -108,13 +108,13 @@ LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUns
    = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `FfiUnsafe`
    = note: `FfiUnsafe` has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-94223.rs:34:1
+  --> $DIR/ice-fnptr-slicearg.rs:37:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` callback uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:44:56
+  --> $DIR/ice-fnptr-slicearg.rs:47:56
    |
 LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUnsafe)> = Ok(f);
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -123,13 +123,13 @@ LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUns
    = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `FfiUnsafe`
    = note: `FfiUnsafe` has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-94223.rs:34:1
+  --> $DIR/ice-fnptr-slicearg.rs:37:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` callback uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-94223.rs:48:22
+  --> $DIR/ice-fnptr-slicearg.rs:51:22
    |
 LL | pub const BAD_CONST: extern "C" fn(FfiUnsafe) = f;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -138,7 +138,7 @@ LL | pub const BAD_CONST: extern "C" fn(FfiUnsafe) = f;
    = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `FfiUnsafe`
    = note: `FfiUnsafe` has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-94223.rs:34:1
+  --> $DIR/ice-fnptr-slicearg.rs:37:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-1.rs b/tests/ui/lint/improper-ctypes/ice-fully-normalize-1.rs
@@ -1,6 +1,9 @@
 //@ check-pass
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// "ICE: could not fully normalize"
+
 pub trait Foo {
     type Assoc: 'static;
 }
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-2.rs b/tests/ui/lint/improper-ctypes/ice-fully-normalize-2.rs
@@ -3,6 +3,9 @@
 #![feature(type_alias_impl_trait)]
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// "ICE: could not fully normalize"
+
 trait Baz {}
 
 impl Baz for () {}
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-3.rs b/tests/ui/lint/improper-ctypes/ice-fully-normalize-3.rs
@@ -1,6 +1,9 @@
 #![feature(type_alias_impl_trait)]
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// "ICE: could not fully normalize"
+
 pub trait Baz {}
 
 impl Baz for u32 {}
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-3.stderr b/tests/ui/lint/improper-ctypes/ice-fully-normalize-3.stderr
@@ -1,18 +1,18 @@
 error: `extern` block uses type `A`, which is not FFI-safe
-  --> $DIR/lint-73249-5.rs:21:25
+  --> $DIR/ice-fully-normalize-3.rs:24:25
    |
 LL |     pub fn lint_me() -> A;
    |                         ^ not FFI-safe
    |
    = note: this struct/enum/union (`A`) is FFI-unsafe due to a `Qux` field
 note: the type is defined here
-  --> $DIR/lint-73249-5.rs:16:1
+  --> $DIR/ice-fully-normalize-3.rs:19:1
    |
 LL | pub struct A {
    | ^^^^^^^^^^^^
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-73249-5.rs:2:9
+  --> $DIR/ice-fully-normalize-3.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-4.rs b/tests/ui/lint/improper-ctypes/ice-fully-normalize-4.rs
@@ -1,6 +1,9 @@
 //@ check-pass
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// "ICE: could not fully normalize"
+
 use std::marker::PhantomData;
 
 trait Foo {
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-5.rs b/tests/ui/lint/improper-ctypes/ice-fully-normalize-5.rs
@@ -1,6 +1,9 @@
 #![feature(type_alias_impl_trait)]
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// "ICE: could not fully normalize"
+
 pub trait Baz {}
 
 impl Baz for u32 {}
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize-5.stderr b/tests/ui/lint/improper-ctypes/ice-fully-normalize-5.stderr
@@ -1,18 +1,18 @@
 error: `extern` block uses type `A`, which is not FFI-safe
-  --> $DIR/lint-73249-3.rs:21:25
+  --> $DIR/ice-fully-normalize-5.rs:24:25
    |
 LL |     pub fn lint_me() -> A;
    |                         ^ not FFI-safe
    |
    = note: this struct/enum/union (`A`) is FFI-unsafe due to a `Qux` field
 note: the type is defined here
-  --> $DIR/lint-73249-3.rs:16:1
+  --> $DIR/ice-fully-normalize-5.rs:19:1
    |
 LL | pub struct A {
    | ^^^^^^^^^^^^
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-73249-3.rs:2:9
+  --> $DIR/ice-fully-normalize-5.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/improper-ctypes/ice-fully-normalize.rs b/tests/ui/lint/improper-ctypes/ice-fully-normalize.rs
@@ -1,6 +1,9 @@
 //@ check-pass
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// "ICE: could not fully normalize"
+
 pub trait Foo {
     type Assoc;
 }
diff --git a/tests/ui/lint/improper-ctypes/ice-irregular-recursive-types.rs b/tests/ui/lint/improper-ctypes/ice-irregular-recursive-types.rs
diff --git a/tests/ui/lint/improper-ctypes/ice-normalize-cast.rs b/tests/ui/lint/improper-ctypes/ice-normalize-cast.rs
@@ -1,5 +1,8 @@
 //@ check-pass
 
+// Issue: https://github.com/rust-lang/rust/issues/73747
+// ICE that seems to happen in type normalization when dealing with casts
+
 #[repr(transparent)]
 struct NonNullRawComPtr<T: ComInterface> {
     inner: std::ptr::NonNull<<T as ComInterface>::VTable>,
diff --git a/tests/ui/lint/improper-ctypes/ice-normalize.rs b/tests/ui/lint/improper-ctypes/ice-normalize.rs
@@ -1,5 +1,6 @@
 //@ check-pass
 
+// Issue: https://github.com/rust-lang/rust/issues/113900
 // Extending `improper_ctypes` to check external-ABI fn-ptrs means that it can encounter
 // projections which cannot be normalized - unsurprisingly, this shouldn't crash the compiler.
 
diff --git a/tests/ui/lint/improper-ctypes/ice-tykind-coverage.rs b/tests/ui/lint/improper-ctypes/ice-tykind-coverage.rs
@@ -3,6 +3,8 @@
 //! comprehensive coverage when the changes are to be relanded, as this is a basic sanity check to
 //! check that the fuzzed example from #134060 doesn't ICE.
 
+// Issue: https://github.com/rust-lang/rust/issues/134060
+
 //@ check-pass
 
 #![crate_type = "lib"]
diff --git a/tests/ui/lint/improper-ctypes/ice-tykind-coverage.stderr b/tests/ui/lint/improper-ctypes/ice-tykind-coverage.stderr
@@ -1,5 +1,5 @@
 warning: `extern` fn uses type `()`, which is not FFI-safe
-  --> $DIR/mustpass-134060.rs:11:34
+  --> $DIR/ice-tykind-coverage.rs:13:34
    |
 LL |     extern "C" fn foo_(&self, _: ()) -> i64 {
    |                                  ^^ not FFI-safe
diff --git a/tests/ui/lint/improper-ctypes/issue-associated-opaque.rs b/tests/ui/lint/improper-ctypes/issue-associated-opaque.rs
@@ -3,6 +3,10 @@
 #![feature(type_alias_impl_trait)]
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73249
+// Decisions on whether projections that normalize to opaque types then to something else
+// should warn or not
+
 trait Foo {
     type Assoc;
 }
diff --git a/tests/ui/lint/improper-ctypes/issue-fnptr-wrapped-unit-1.rs b/tests/ui/lint/improper-ctypes/issue-fnptr-wrapped-unit-1.rs
@@ -1,5 +1,8 @@
 #![deny(improper_c_fn_definitions)]
 
+// Issue: https://github.com/rust-lang/rust/issues/113436
+// `()` in (fnptr!) return types and ADT fields should be safe
+
 #[repr(C)]
 pub struct Foo {
     a: u8,
diff --git a/tests/ui/lint/improper-ctypes/issue-fnptr-wrapped-unit-1.stderr b/tests/ui/lint/improper-ctypes/issue-fnptr-wrapped-unit-1.stderr
@@ -1,44 +1,44 @@
 error: `extern` fn uses type `Bar`, which is not FFI-safe
-  --> $DIR/lint-113436-1.rs:22:22
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:25:22
    |
 LL | extern "C" fn bar(x: Bar) -> Bar {
    |                      ^^^ not FFI-safe
    |
    = note: this struct/enum/union (`Bar`) is FFI-unsafe due to a `NotSafe` field
 note: the type is defined here
-  --> $DIR/lint-113436-1.rs:16:1
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:19:1
    |
 LL | pub struct Bar {
    | ^^^^^^^^^^^^^^
    = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `NotSafe`
    = note: `NotSafe` has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-113436-1.rs:13:1
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:16:1
    |
 LL | struct NotSafe(u32);
    | ^^^^^^^^^^^^^^
 note: the lint level is defined here
-  --> $DIR/lint-113436-1.rs:1:9
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:1:9
    |
 LL | #![deny(improper_c_fn_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `Bar`, which is not FFI-safe
-  --> $DIR/lint-113436-1.rs:22:30
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:25:30
    |
 LL | extern "C" fn bar(x: Bar) -> Bar {
    |                              ^^^ not FFI-safe
    |
    = note: this struct/enum/union (`Bar`) is FFI-unsafe due to a `NotSafe` field
 note: the type is defined here
-  --> $DIR/lint-113436-1.rs:16:1
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:19:1
    |
 LL | pub struct Bar {
    | ^^^^^^^^^^^^^^
    = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `NotSafe`
    = note: `NotSafe` has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-113436-1.rs:13:1
+  --> $DIR/issue-fnptr-wrapped-unit-1.rs:16:1
    |
 LL | struct NotSafe(u32);
    | ^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/improper-ctypes/issue-fnptr-wrapped-unit.rs b/tests/ui/lint/improper-ctypes/issue-fnptr-wrapped-unit.rs
@@ -1,5 +1,8 @@
 //@ check-pass
-#![deny(improper_c_fn_definitions, improper_c_callbacks)]
+#![deny(improper_c_fn_definitions)]
+
+// Issue: https://github.com/rust-lang/rust/issues/113436
+// `()` in (fnptr!) return types and ADT fields should be safe
 
 #[repr(C)]
 pub struct Wrap<T>(T);
diff --git a/tests/ui/lint/improper-ctypes/issue-normalize-return.rs b/tests/ui/lint/improper-ctypes/issue-normalize-return.rs
@@ -2,6 +2,7 @@
 
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/66202
 // This test checks that return types are normalized before being checked for FFI-safety, and that
 // transparent newtype wrappers are FFI-safe if the type being wrapped is FFI-safe.
 
diff --git a/tests/ui/lint/improper-ctypes/issue-project-opaque-1.rs b/tests/ui/lint/improper-ctypes/issue-project-opaque-1.rs
@@ -1,6 +1,10 @@
 #![feature(type_alias_impl_trait)]
 #![deny(improper_ctypes)]
 
+// Issue: https://github.com/rust-lang/rust/issues/73251
+// Decisions on whether projections that normalize to opaque types then to something else
+// should warn or not
+
 trait Baz {}
 
 impl Baz for u32 {}
diff --git a/tests/ui/lint/improper-ctypes/issue-project-opaque-1.stderr b/tests/ui/lint/improper-ctypes/issue-project-opaque-1.stderr
diff --git a/tests/ui/lint/improper-ctypes/issue-project-opaque-2.rs b/tests/ui/lint/improper-ctypes/issue-project-opaque-2.rs
diff --git a/tests/ui/lint/improper-ctypes/issue-project-opaque-2.stderr b/tests/ui/lint/improper-ctypes/issue-project-opaque-2.stderr
diff --git a/tests/ui/lint/improper-ctypes/mustpass-non-recursion-limit.rs b/tests/ui/lint/improper-ctypes/mustpass-non-recursion-limit.rs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,9 @@`
`1`	`1`	`//@ check-pass`
`2`	`2`	`#![deny(improper_ctypes)]`
`3`	`3`
	`4`	`+// Issue: https://github.com/rust-lang/rust/issues/73249`
	`5`	`+// "ICE: could not fully normalize"`
	`6`	`+`
`4`	`7`	`pub trait Foo {`
`5`	`8`	`type Assoc: 'static;`
`6`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,18 @@`
`1`	`1`	error: `extern` block uses type `A`, which is not FFI-safe
`2`		`- --> $DIR/lint-73249-5.rs:21:25`
	`2`	`+ --> $DIR/ice-fully-normalize-3.rs:24:25`
`3`	`3`	`\|`
`4`	`4`	`LL \| pub fn lint_me() -> A;`
`5`	`5`	`\| ^ not FFI-safe`
`6`	`6`	`\|`
`7`	`7`	= note: this struct/enum/union (`A`) is FFI-unsafe due to a `Qux` field
`8`	`8`	`note: the type is defined here`
`9`		`- --> $DIR/lint-73249-5.rs:16:1`
	`9`	`+ --> $DIR/ice-fully-normalize-3.rs:19:1`
`10`	`10`	`\|`
`11`	`11`	`LL \| pub struct A {`
`12`	`12`	`\| ^^^^^^^^^^^^`
`13`	`13`	`= note: opaque types have no C equivalent`
`14`	`14`	`note: the lint level is defined here`
`15`		`- --> $DIR/lint-73249-5.rs:2:9`
	`15`	`+ --> $DIR/ice-fully-normalize-3.rs:2:9`
`16`	`16`	`\|`
`17`	`17`	`LL \| #![deny(improper_ctypes)]`
`18`	`18`	`\| ^^^^^^^^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,18 @@`
`1`	`1`	error: `extern` block uses type `A`, which is not FFI-safe
`2`		`- --> $DIR/lint-73249-3.rs:21:25`
	`2`	`+ --> $DIR/ice-fully-normalize-5.rs:24:25`
`3`	`3`	`\|`
`4`	`4`	`LL \| pub fn lint_me() -> A;`
`5`	`5`	`\| ^ not FFI-safe`
`6`	`6`	`\|`
`7`	`7`	= note: this struct/enum/union (`A`) is FFI-unsafe due to a `Qux` field
`8`	`8`	`note: the type is defined here`
`9`		`- --> $DIR/lint-73249-3.rs:16:1`
	`9`	`+ --> $DIR/ice-fully-normalize-5.rs:19:1`
`10`	`10`	`\|`
`11`	`11`	`LL \| pub struct A {`
`12`	`12`	`\| ^^^^^^^^^^^^`
`13`	`13`	`= note: opaque types have no C equivalent`
`14`	`14`	`note: the lint level is defined here`
`15`		`- --> $DIR/lint-73249-3.rs:2:9`
	`15`	`+ --> $DIR/ice-fully-normalize-5.rs:2:9`
`16`	`16`	`\|`
`17`	`17`	`LL \| #![deny(improper_ctypes)]`
`18`	`18`	`\| ^^^^^^^^^^^^^^^`