Auto merge of #147185 - RalfJung:repr-c-not-zst, r=<try>

repr(transparent): do not consider repr(C) types to be 1-ZST

Author: rust-bors[bot]

compiler/rustc_hir_analysis/src/check/check.rs

@@ -12,9 +12,7 @@ use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::{LangItem, Node, attrs, find_attr, intravisit};
 use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
 use rustc_infer::traits::{Obligation, ObligationCauseCode, WellFormedLoc};
-use rustc_lint_defs::builtin::{
-    REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS, UNSUPPORTED_CALLING_CONVENTIONS,
-};
+use rustc_lint_defs::builtin::UNSUPPORTED_CALLING_CONVENTIONS;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::middle::stability::EvalResult;
@@ -1510,58 +1508,15 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
         return;
     }
 
-    // For each field, figure out if it's known to have "trivial" layout (i.e., is a 1-ZST), with
-    // "known" respecting #[non_exhaustive] attributes.
+    // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
     let field_infos = adt.all_fields().map(|field| {
         let ty = field.ty(tcx, GenericArgs::identity_for_item(tcx, field.did));
         let typing_env = ty::TypingEnv::non_body_analysis(tcx, field.did);
         let layout = tcx.layout_of(typing_env.as_query_input(ty));
         // We are currently checking the type this field came from, so it must be local
         let span = tcx.hir_span_if_local(field.did).unwrap();
         let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-        if !trivial {
-            return (span, trivial, None);
-        }
-        // Even some 1-ZST fields are not allowed though, if they have `non_exhaustive`.
-
-        fn check_non_exhaustive<'tcx>(
-            tcx: TyCtxt<'tcx>,
-            t: Ty<'tcx>,
-        ) -> ControlFlow<(&'static str, DefId, GenericArgsRef<'tcx>, bool)> {
-            match t.kind() {
-                ty::Tuple(list) => list.iter().try_for_each(|t| check_non_exhaustive(tcx, t)),
-                ty::Array(ty, _) => check_non_exhaustive(tcx, *ty),
-                ty::Adt(def, args) => {
-                    if !def.did().is_local()
-                        && !find_attr!(
-                            tcx.get_all_attrs(def.did()),
-                            AttributeKind::PubTransparent(_)
-                        )
-                    {
-                        let non_exhaustive = def.is_variant_list_non_exhaustive()
-                            || def
-                                .variants()
-                                .iter()
-                                .any(ty::VariantDef::is_field_list_non_exhaustive);
-                        let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-                        if non_exhaustive || has_priv {
-                            return ControlFlow::Break((
-                                def.descr(),
-                                def.did(),
-                                args,
-                                non_exhaustive,
-                            ));
-                        }
-                    }
-                    def.all_fields()
-                        .map(|field| field.ty(tcx, args))
-                        .try_for_each(|t| check_non_exhaustive(tcx, t))
-                }
-                _ => ControlFlow::Continue(()),
-            }
-        }
-
-        (span, trivial, check_non_exhaustive(tcx, ty).break_value())
+        (span, trivial, ty)
     });
 
     let non_trivial_fields = field_infos
@@ -1578,36 +1533,90 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
         );
         return;
     }
-    let mut prev_non_exhaustive_1zst = false;
-    for (span, _trivial, non_exhaustive_1zst) in field_infos {
-        if let Some((descr, def_id, args, non_exhaustive)) = non_exhaustive_1zst {
+
+    // Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+    // fields or `repr(C)`. We call those fields "unsuited". Search for unsuited fields and
+    // error if the repr(transparent) condition relies on them.
+    enum UnsuitedReason {
+        NonExhaustive,
+        PrivateField,
+        ReprC,
+        Uninhabited,
+    }
+    struct UnsuitedInfo<'tcx> {
+        ty: Ty<'tcx>,
+        reason: UnsuitedReason,
+    }
+
+    fn check_unsuited_1zst<'tcx>(
+        tcx: TyCtxt<'tcx>,
+        adt: DefId,
+        ty: Ty<'tcx>,
+    ) -> ControlFlow<UnsuitedInfo<'tcx>> {
+        if !ty.is_inhabited_from(tcx, adt, ty::TypingEnv::non_body_analysis(tcx, adt)) {
+            return ControlFlow::Break(UnsuitedInfo { ty, reason: UnsuitedReason::Uninhabited });
+        }
+        match ty.kind() {
+            ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited_1zst(tcx, adt, t)),
+            ty::Array(ty, _) => check_unsuited_1zst(tcx, adt, *ty),
+            ty::Adt(def, args) => {
+                if !def.did().is_local()
+                    && !find_attr!(tcx.get_all_attrs(def.did()), AttributeKind::PubTransparent(_))
+                {
+                    let non_exhaustive = def.is_variant_list_non_exhaustive()
+                        || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+                    let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+                    if non_exhaustive || has_priv {
+                        return ControlFlow::Break(UnsuitedInfo {
+                            ty,
+                            reason: if non_exhaustive {
+                                UnsuitedReason::NonExhaustive
+                            } else {
+                                UnsuitedReason::PrivateField
+                            },
+                        });
+                    }
+                }
+                if def.repr().c() {
+                    return ControlFlow::Break(UnsuitedInfo { ty, reason: UnsuitedReason::ReprC });
+                }
+                def.all_fields()
+                    .map(|field| field.ty(tcx, args))
+                    .try_for_each(|t| check_unsuited_1zst(tcx, adt, t))
+            }
+            _ => ControlFlow::Continue(()),
+        }
+    }
+
+    let mut prev_unsuited_1zst = false;
+    for (span, trivial, ty) in field_infos {
+        if !trivial {
+            continue;
+        }
+        if let Some(unsuited) = check_unsuited_1zst(tcx, adt.did(), ty).break_value() {
             // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
             // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
-            if non_trivial_count > 0 || prev_non_exhaustive_1zst {
-                tcx.node_span_lint(
-                    REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS,
-                    tcx.local_def_id_to_hir_id(adt.did().expect_local()),
+            if non_trivial_count > 0 || prev_unsuited_1zst {
+                let mut diag = tcx.dcx().struct_span_err(
                     span,
-                    |lint| {
-                        lint.primary_message(
-                            "zero-sized fields in `repr(transparent)` cannot \
+                    "zero-sized fields in `repr(transparent)` cannot \
                              contain external non-exhaustive types",
-                        );
-                        let note = if non_exhaustive {
-                            "is marked with `#[non_exhaustive]`"
-                        } else {
-                            "contains private fields"
-                        };
-                        let field_ty = tcx.def_path_str_with_args(def_id, args);
-                        lint.note(format!(
-                            "this {descr} contains `{field_ty}`, which {note}, \
+                );
+                let note = match unsuited.reason {
+                    UnsuitedReason::NonExhaustive => "is marked with `#[non_exhaustive]`",
+                    UnsuitedReason::PrivateField => "contains private fields",
+                    UnsuitedReason::ReprC => "is marked with `#[repr(C)]`",
+                    UnsuitedReason::Uninhabited => "is not (publicly) inhabited",
+                };
+                diag.note(format!(
+                    "this field contains `{field_ty}`, which {note}, \
                                 and makes it not a breaking change to become \
-                                non-zero-sized in the future."
-                        ));
-                    },
-                )
+                                non-zero-sized in the future.",
+                    field_ty = unsuited.ty,
+                ));
+                diag.emit();
             } else {
-                prev_non_exhaustive_1zst = true;
+                prev_unsuited_1zst = true;
             }
         }
     }

compiler/rustc_lint_defs/src/lib.rs

@@ -403,7 +403,7 @@ pub enum FutureIncompatibilityReason {
     ///
     /// After a lint has been in this state for a while and you feel like it is ready to graduate
     /// to warning everyone, consider setting [`FutureIncompatibleInfo::report_in_deps`] to true.
-    /// (see it's documentation for more guidance)
+    /// (see its documentation for more guidance)
     ///
     /// After some period of time, lints with this variant can be turned into
     /// hard errors (and the lint removed). Preferably when there is some

tests/ui/repr/repr-transparent-non-exhaustive.rs

@@ -36,82 +36,66 @@ pub struct T4(Sized, ExternalIndirection<(InternalPrivate, InternalNonExhaustive
 #[repr(transparent)]
 pub struct T5(Sized, Private);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T6(Sized, NonExhaustive);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T7(Sized, NonExhaustiveEnum);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T8(Sized, NonExhaustiveVariant);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T9(Sized, InternalIndirection<Private>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T10(Sized, InternalIndirection<NonExhaustive>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T11(Sized, InternalIndirection<NonExhaustiveEnum>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T12(Sized, InternalIndirection<NonExhaustiveVariant>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T13(Sized, ExternalIndirection<Private>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T14(Sized, ExternalIndirection<NonExhaustive>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T15(Sized, ExternalIndirection<NonExhaustiveEnum>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T16(Sized, ExternalIndirection<NonExhaustiveVariant>);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T17(NonExhaustive, Sized);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T18(NonExhaustive, NonExhaustive);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T19(NonExhaustive, Private);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T19Flipped(Private, NonExhaustive);
 //~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
-//~| WARN this was previously accepted by the compiler
 
 #[repr(transparent)]
 pub struct T20(NonExhaustive);