ImproperCTypes: don't consider packed reprs

`[repr(C,packed)]` structs shouldn't be considered FFI-safe

Author: niacdoial

compiler/rustc_lint/src/types/improper_ctypes.rs

@@ -251,22 +251,21 @@ fn check_struct_for_power_alignment<'tcx>(
     item: &'tcx hir::Item<'tcx>,
     adt_def: AdtDef<'tcx>,
 ) {
-    let tcx = cx.tcx;
-
     // Only consider structs (not enums or unions) on AIX.
-    if tcx.sess.target.os != "aix" || !adt_def.is_struct() {
+    if cx.tcx.sess.target.os != "aix" || !adt_def.is_struct() {
         return;
     }
 
     // The struct must be repr(C), but ignore it if it explicitly specifies its alignment with
     // either `align(N)` or `packed(N)`.
-    if adt_def.repr().c() && !adt_def.repr().packed() && adt_def.repr().align.is_none() {
+    debug_assert!(adt_def.repr().c() && !adt_def.repr().packed() && adt_def.repr().align.is_none());
+    if cx.tcx.sess.target.os == "aix" && !adt_def.all_fields().next().is_none() {
         let struct_variant_data = item.expect_struct().2;
         for field_def in struct_variant_data.fields().iter().skip(1) {
             // Struct fields (after the first field) are checked for the
             // power alignment rule, as fields after the first are likely
             // to be the fields that are misaligned.
-            let ty = tcx.type_of(field_def.def_id).instantiate_identity();
+            let ty = cx.tcx.type_of(field_def.def_id).instantiate_identity();
             if check_arg_for_power_alignment(cx, ty) {
                 cx.emit_span_lint(USES_POWER_ALIGNMENT, field_def.span, UsesPowerAlignment);
             }
@@ -1060,7 +1059,11 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         // otherwise, having all fields be phantoms
         // takes priority over transparent_with_all_zst_fields
         if let FfiUnsafe(explanations) = ffires_accumulator {
-            debug_assert!(def.repr().c() || def.repr().transparent() || def.repr().int.is_some());
+            debug_assert!(
+                (def.repr().c() && !def.repr().packed())
+                    || def.repr().transparent()
+                    || def.repr().int.is_some()
+            );
 
             if def.repr().transparent() || matches!(def.adt_kind(), AdtKind::Enum) {
                 let field_ffires = FfiUnsafe(explanations).wrap_all(
@@ -1130,7 +1133,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     ) -> FfiResult<'tcx> {
         debug_assert!(matches!(def.adt_kind(), AdtKind::Struct | AdtKind::Union));
 
-        if !def.repr().c() && !def.repr().transparent() {
+        if !((def.repr().c() && !def.repr().packed()) || def.repr().transparent()) {
+            // FIXME(ctypes) packed reprs prevent C compatibility, right?
             return FfiResult::new_with_reason(
                 ty,
                 if def.is_struct() {
@@ -1202,7 +1206,10 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         }
         // Check for a repr() attribute to specify the size of the
         // discriminant.
-        if !def.repr().c() && !def.repr().transparent() && def.repr().int.is_none() {
+        if !(def.repr().c() && !def.repr().packed())
+            && !def.repr().transparent()
+            && def.repr().int.is_none()
+        {
             // Special-case types like `Option<extern fn()>` and `Result<extern fn(), ()>`
             if let Some(inner_ty) = repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty) {
                 return self.visit_type(state.get_next(ty), inner_ty);

tests/ui/lint/improper-ctypes/repr-rust-is-undefined.stderr

@@ -23,19 +23,13 @@ error: `extern` block uses type `B`, which is not FFI-safe
 LL |     fn bar(x: B);
    |               ^ not FFI-safe
    |
-   = note: this struct/enum/union (`B`) is FFI-unsafe due to a `A` field
+   = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `B`
+   = note: `B` has unspecified layout
 note: the type is defined here
   --> $DIR/repr-rust-is-undefined.rs:13:1
    |
 LL | struct B {
    | ^^^^^^^^
-   = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `A`
-   = note: `A` has unspecified layout
-note: the type is defined here
-  --> $DIR/repr-rust-is-undefined.rs:8:1
-   |
-LL | struct A {
-   | ^^^^^^^^
 
 error: `extern` block uses type `A`, which is not FFI-safe
   --> $DIR/repr-rust-is-undefined.rs:37:15
@@ -57,19 +51,13 @@ error: `extern` block uses type `B`, which is not FFI-safe
 LL |     fn quux(x: B2);
    |                ^^ not FFI-safe
    |
-   = note: this struct/enum/union (`B`) is FFI-unsafe due to a `A` field
+   = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `B`
+   = note: `B` has unspecified layout
 note: the type is defined here
   --> $DIR/repr-rust-is-undefined.rs:13:1
    |
 LL | struct B {
    | ^^^^^^^^
-   = help: consider adding a `#[repr(C)]` (not `#[repr(C,packed)]`) or `#[repr(transparent)]` attribute to `A`
-   = note: `A` has unspecified layout
-note: the type is defined here
-  --> $DIR/repr-rust-is-undefined.rs:8:1
-   |
-LL | struct A {
-   | ^^^^^^^^
 
 error: `extern` block uses type `D`, which is not FFI-safe
   --> $DIR/repr-rust-is-undefined.rs:40:16