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

Repr c not 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,94 @@ 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,
+ }
+ struct UnsuitedInfo<'tcx> {
+ descr: &'static str,
+ def_id: DefId,
+ args: GenericArgsRef<'tcx>,
+ reason: UnsuitedReason,
+ }
+
+ fn check_unsuited_1zst<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ t: Ty<'tcx>,
+ ) -> ControlFlow<UnsuitedInfo<'tcx>> {
+ match t.kind() {
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited_1zst(tcx, t)),
+ ty::Array(ty, _) => check_unsuited_1zst(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(UnsuitedInfo {
+ descr: def.descr(),
+ def_id: def.did(),
+ args,
+ reason: if non_exhaustive {
+ UnsuitedReason::NonExhaustive
+ } else {
+ UnsuitedReason::PrivateField
+ },
+ });
+ }
+ }
+ if def.repr().c() {
+ return ControlFlow::Break(UnsuitedInfo {
+ descr: def.descr(),
+ def_id: def.did(),
+ args,
+ reason: UnsuitedReason::ReprC,
+ });
+ }
+ def.all_fields()
+ .map(|field| field.ty(tcx, args))
+ .try_for_each(|t| check_unsuited_1zst(tcx, 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, 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)]`",
+ };
+ let field_ty = tcx.def_path_str_with_args(unsuited.def_id, unsuited.args);
+ diag.note(format!(
+ "this {descr} 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.",
+ descr = unsuited.descr,
+ ));
+ 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);