ImproperCTypes: change what type is blamed, use nested help messages

A major change to the content of linting messages, but not where they
occur.
Now, the "uses type `_`" part of the message mentions the type directly
visible where the error occurs, and the nested note/help messages trace
the link to the actual source of the FFI-unsafety

Author: niacdoial

compiler/rustc_lint/messages.ftl

@@ -402,6 +402,8 @@ lint_improper_ctypes_str_reason = string slices have no C equivalent
 lint_improper_ctypes_struct_fieldless_help = consider adding a member to this struct
 
 lint_improper_ctypes_struct_fieldless_reason = this struct has no fields
+lint_improper_ctypes_struct_dueto = this struct/enum/union (`{$ty}`) is FFI-unsafe due to a `{$inner_ty}` field
+
 lint_improper_ctypes_struct_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
 
 lint_improper_ctypes_struct_layout_reason = this struct has unspecified layout

compiler/rustc_lint/src/types/improper_ctypes.rs

@@ -215,7 +215,6 @@ impl<'tcx> FfiResult<'tcx> {
     /// For instance, if we have a repr(C) struct in a function's argument, FFI unsafeties inside the struct
     /// are to be blamed on the struct and not the members.
     /// This is where we use this wrapper, to tell "all FFI-unsafeties in there are caused by this `ty`"
-    #[expect(unused)]
     fn with_overrides(mut self, override_cause_ty: Option<Ty<'tcx>>) -> FfiResult<'tcx> {
         use FfiResult::*;
 
@@ -737,7 +736,13 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 // `()` fields are FFI-safe!
                 //FfiUnsafe { ty, .. } if ty.is_unit() => false, // TODO get back here
                 FfiPhantom(..) => true,
-                r @ FfiUnsafe { .. } => return r,
+                r @ FfiUnsafe { .. } => {
+                    return r.wrap_all(
+                        ty,
+                        fluent::lint_improper_ctypes_struct_dueto,
+                        None,
+                    );
+                }
             }
         }
 
@@ -788,7 +793,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             );
         }
 
-        if def.non_enum_variant().fields.is_empty() {
+        let ffires = if def.non_enum_variant().fields.is_empty() {
             FfiResult::new_with_reason(
                 ty,
                 if def.is_struct() {
@@ -804,7 +809,19 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             )
         } else {
             self.visit_variant_fields(state, ty, def, def.non_enum_variant(), args)
-        }
+        };
+
+        // from now on in the function, we lint the actual insides of the struct/union: if something is wrong,
+        // then the "fault" comes from inside the struct itself.
+        // even if we add more details to the lint, the initial line must specify that the FFI-unsafety is because of the struct
+        // - if the struct is from the same crate, there is another warning on its definition anyway
+        //   (unless it's about Boxes and references without Option<_>
+        //    which is partly why we keep the details as to why that struct is FFI-unsafe)
+        // - if the struct is from another crate, then there's not much that can be done anyways
+        //
+        // this enum is visited in the middle of another lint,
+        // so we override the "cause type" of the lint
+        ffires.with_overrides(Some(ty))
     }
 
     fn visit_enum(
@@ -851,10 +868,13 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             }
         });
         if let ControlFlow::Break(result) = ret {
-            return result;
+            // this enum is visited in the middle of another lint,
+            // so we override the "cause type" of the lint
+            // (for more detail, see comment in ``visit_struct_union`` before its call to ``result.with_overrides``)
+            result.with_overrides(Some(ty))
+        } else {
+            FfiSafe
         }
-
-        FfiSafe
     }
 
     /// Checks if the given type is "ffi-safe" (has a stable, well-defined

tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.rs

@@ -8,7 +8,7 @@ type Foo = extern "C" fn(::std::ffi::CStr);
 //~^ WARN `extern` callback uses type
 extern "C" {
     fn meh(blah: Foo);
-    //~^ WARN `extern` block uses type
+    // ^ FIXME: the error isn't seen here but at least it's reported elsewhere
 }
 
 fn main() {

tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.stderr

@@ -4,19 +4,11 @@ warning: `extern` callback uses type `CStr`, which is not FFI-safe
 LL | type Foo = extern "C" fn(::std::ffi::CStr);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
-   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: the function pointer to `extern "C" fn(CStr)` is FFI-unsafe due to `CStr`
+   = help: consider passing a `*const std::ffi::c_char` or `*mut std::ffi::c_char` instead,
+           and use (depending on the use case) `CStr::as_ptr()`, `CString::into_raw()` then `CString::from_raw()`, or a dedicated buffer
    = note: `CStr`/`CString` do not have a guaranteed layout
    = note: `#[warn(improper_c_callbacks)]` (part of `#[warn(improper_c_boundaries)]`) on by default
 
-warning: `extern` block uses type `CStr`, which is not FFI-safe
-  --> $DIR/extern-C-non-FFI-safe-arg-ice-52334.rs:10:18
-   |
-LL |     fn meh(blah: Foo);
-   |                  ^^^ not FFI-safe
-   |
-   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
-   = note: `CStr`/`CString` do not have a guaranteed layout
-   = note: `#[warn(improper_ctypes)]` on by default
-
-warning: 2 warnings emitted
+warning: 1 warning emitted
 

tests/ui/extern/extern-C-str-arg-ice-80125.rs

@@ -7,7 +7,7 @@ pub struct Struct(ExternCallback);
 
 #[no_mangle]
 pub extern "C" fn register_something(bind: ExternCallback) -> Struct {
-//~^ WARN `extern` fn uses type `str`, which is not FFI-safe
+// ^ FIXME: the error isn't seen here, but at least it's reported elsewhere
 //~^^ WARN `extern` fn uses type `Struct`, which is not FFI-safe
     Struct(bind)
 }

tests/ui/extern/extern-C-str-arg-ice-80125.stderr

@@ -4,20 +4,11 @@ warning: `extern` callback uses type `str`, which is not FFI-safe
 LL | type ExternCallback = extern "C" fn(*const u8, u32, str);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
+   = note: the function pointer to `extern "C" fn(*const u8, u32, str)` is FFI-unsafe due to `str`
    = help: consider using `*const u8` and a length instead
    = note: string slices have no C equivalent
    = note: `#[warn(improper_c_callbacks)]` (part of `#[warn(improper_c_boundaries)]`) on by default
 
-warning: `extern` fn uses type `str`, which is not FFI-safe
-  --> $DIR/extern-C-str-arg-ice-80125.rs:9:44
-   |
-LL | pub extern "C" fn register_something(bind: ExternCallback) -> Struct {
-   |                                            ^^^^^^^^^^^^^^ not FFI-safe
-   |
-   = help: consider using `*const u8` and a length instead
-   = note: string slices have no C equivalent
-   = note: `#[warn(improper_c_fn_definitions)]` (part of `#[warn(improper_c_boundaries)]`) on by default
-
 warning: `extern` fn uses type `Struct`, which is not FFI-safe
   --> $DIR/extern-C-str-arg-ice-80125.rs:9:63
    |
@@ -31,6 +22,7 @@ note: the type is defined here
    |
 LL | pub struct Struct(ExternCallback);
    | ^^^^^^^^^^^^^^^^^
+   = note: `#[warn(improper_c_fn_definitions)]` (part of `#[warn(improper_c_boundaries)]`) on by default
 
-warning: 3 warnings emitted
+warning: 2 warnings emitted
 

tests/ui/lint/extern-C-fnptr-lints-slices.stderr

@@ -5,7 +5,7 @@ LL | pub type F = extern "C" fn(&[u8]);
    |              ^^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
    = note: the function pointer to `for<'a> extern "C" fn(&'a [u8])` is FFI-unsafe due to `&[u8]`
-   = help: consider using a raw pointer to the slice's first element (and a length) instead
+   = help: consider using a raw pointer instead
    = note: this reference to an unsized type contains metadata, which makes it incompatible with a C pointer
 note: the lint level is defined here
   --> $DIR/extern-C-fnptr-lints-slices.rs:1:8

tests/ui/lint/improper_ctypes/lint-113436-1.rs

@@ -20,8 +20,8 @@ pub struct Bar {
 }
 
 extern "C" fn bar(x: Bar) -> Bar {
-    //~^ ERROR `extern` fn uses type `NotSafe`, which is not FFI-safe
-    //~^^ ERROR `extern` fn uses type `NotSafe`, which is not FFI-safe
+    //~^ ERROR `extern` fn uses type `Bar`, which is not FFI-safe
+    //~^^ ERROR `extern` fn uses type `Bar`, which is not FFI-safe
     todo!()
 }
 

tests/ui/lint/improper_ctypes/lint-113436-1.stderr

@@ -1,9 +1,15 @@
-error: `extern` fn uses type `NotSafe`, which is not FFI-safe
+error: `extern` fn uses type `Bar`, which is not FFI-safe
   --> $DIR/lint-113436-1.rs:22: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
+   |
+LL | pub struct Bar {
+   | ^^^^^^^^^^^^^^
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
@@ -17,12 +23,18 @@ note: the lint level is defined here
 LL | #![deny(improper_c_fn_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `extern` fn uses type `NotSafe`, which is not FFI-safe
+error: `extern` fn uses type `Bar`, which is not FFI-safe
   --> $DIR/lint-113436-1.rs:22: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
+   |
+LL | pub struct Bar {
+   | ^^^^^^^^^^^^^^
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here

tests/ui/lint/improper_ctypes/lint-73249-3.rs

@@ -18,7 +18,7 @@ pub struct A {
 }
 
 extern "C" {
-    pub fn lint_me() -> A; //~ ERROR: uses type `Qux`
+    pub fn lint_me() -> A; //~ ERROR: `extern` block uses type `A`
 }
 
 fn main() {}