also complain about uninhabited types being ignored in repr(transparent)

RalfJung · RalfJung · commit eee5199009b5 · 2025-10-08T22:43:02.000+02:00
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1541,21 +1541,24 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
         NonExhaustive,
         PrivateField,
         ReprC,
+        Uninhabited,
     }
     struct UnsuitedInfo<'tcx> {
-        descr: &'static str,
-        def_id: DefId,
-        args: GenericArgsRef<'tcx>,
+        ty: Ty<'tcx>,
         reason: UnsuitedReason,
     }
 
     fn check_unsuited_1zst<'tcx>(
         tcx: TyCtxt<'tcx>,
-        t: Ty<'tcx>,
+        adt: DefId,
+        ty: 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),
+        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(_))
@@ -1565,9 +1568,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
                     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,
+                            ty,
                             reason: if non_exhaustive {
                                 UnsuitedReason::NonExhaustive
                             } else {
@@ -1577,16 +1578,11 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
                     }
                 }
                 if def.repr().c() {
-                    return ControlFlow::Break(UnsuitedInfo {
-                        descr: def.descr(),
-                        def_id: def.did(),
-                        args,
-                        reason: UnsuitedReason::ReprC,
-                    });
+                    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, t))
+                    .try_for_each(|t| check_unsuited_1zst(tcx, adt, t))
             }
             _ => ControlFlow::Continue(()),
         }
@@ -1597,7 +1593,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
         if !trivial {
             continue;
         }
-        if let Some(unsuited) = check_unsuited_1zst(tcx, ty).break_value() {
+        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_unsuited_1zst {
@@ -1610,13 +1606,13 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
                     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",
                 };
-                let field_ty = tcx.def_path_str_with_args(unsuited.def_id, unsuited.args);
                 diag.note(format!(
-                    "this {descr} contains `{field_ty}`, which {note}, \
+                    "this field contains `{field_ty}`, which {note}, \
                                 and makes it not a breaking change to become \
                                 non-zero-sized in the future.",
-                    descr = unsuited.descr,
+                    field_ty = unsuited.ty,
                 ));
                 diag.emit();
             } else {
diff --git a/tests/ui/repr/repr-transparent-non-exhaustive.stderr b/tests/ui/repr/repr-transparent-non-exhaustive.stderr
@@ -4,127 +4,127 @@ error: zero-sized fields in `repr(transparent)` cannot contain external non-exha
 LL | pub struct T5(Sized, Private);
    |                      ^^^^^^^
    |
-   = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:41:22
    |
 LL | pub struct T6(Sized, NonExhaustive);
    |                      ^^^^^^^^^^^^^
    |
-   = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:45:22
    |
 LL | pub struct T7(Sized, NonExhaustiveEnum);
    |                      ^^^^^^^^^^^^^^^^^
    |
-   = note: this enum contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:49:22
    |
 LL | pub struct T8(Sized, NonExhaustiveVariant);
    |                      ^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this enum contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:53:22
    |
 LL | pub struct T9(Sized, InternalIndirection<Private>);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:57:23
    |
 LL | pub struct T10(Sized, InternalIndirection<NonExhaustive>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:61:23
    |
 LL | pub struct T11(Sized, InternalIndirection<NonExhaustiveEnum>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this enum contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:65:23
    |
 LL | pub struct T12(Sized, InternalIndirection<NonExhaustiveVariant>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this enum contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:69:23
    |
 LL | pub struct T13(Sized, ExternalIndirection<Private>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:73:23
    |
 LL | pub struct T14(Sized, ExternalIndirection<NonExhaustive>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:77:23
    |
 LL | pub struct T15(Sized, ExternalIndirection<NonExhaustiveEnum>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this enum contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:81:23
    |
 LL | pub struct T16(Sized, ExternalIndirection<NonExhaustiveVariant>);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this enum contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:85:16
    |
 LL | pub struct T17(NonExhaustive, Sized);
    |                ^^^^^^^^^^^^^
    |
-   = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:89:31
    |
 LL | pub struct T18(NonExhaustive, NonExhaustive);
    |                               ^^^^^^^^^^^^^
    |
-   = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:93:31
    |
 LL | pub struct T19(NonExhaustive, Private);
    |                               ^^^^^^^
    |
-   = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-non-exhaustive.rs:97:32
    |
 LL | pub struct T19Flipped(Private, NonExhaustive);
    |                                ^^^^^^^^^^^^^
    |
-   = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/repr/repr-transparent-repr-c.stderr b/tests/ui/repr/repr-transparent-repr-c.stderr
@@ -4,23 +4,23 @@ error: zero-sized fields in `repr(transparent)` cannot contain external non-exha
 LL | pub struct T5(Sized, ReprC1Zst);
    |                      ^^^^^^^^^
    |
-   = note: this struct contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-repr-c.rs:22:15
    |
 LL | pub struct T6(ReprC1Zst, Sized);
    |               ^^^^^^^^^
    |
-   = note: this struct contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
   --> $DIR/repr-transparent-repr-c.rs:26:15
    |
 LL | pub struct T7(T1, Sized); // still wrong, even when the repr(C) is hidden inside another type
    |               ^^
    |
-   = note: this struct contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
+   = note: this field contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/repr/repr-transparent-uninhabited.rs b/tests/ui/repr/repr-transparent-uninhabited.rs
@@ -0,0 +1,23 @@
+#![feature(never_type)]
+#![deny(repr_transparent_external_private_fields)]
+
+enum Void {}
+
+pub type Sized = i32;
+
+#[repr(transparent)]
+pub struct T1(!);
+#[repr(transparent)]
+pub struct T2((), Void);
+#[repr(transparent)]
+pub struct T3(!, ());
+
+#[repr(transparent)]
+pub struct T5(Sized, Void);
+//~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
+
+#[repr(transparent)]
+pub struct T6(!, Sized);
+//~^ ERROR zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
+
+fn main() {}
diff --git a/tests/ui/repr/repr-transparent-uninhabited.stderr b/tests/ui/repr/repr-transparent-uninhabited.stderr
@@ -0,0 +1,18 @@
+error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
+  --> $DIR/repr-transparent-uninhabited.rs:16:22
+   |
+LL | pub struct T5(Sized, Void);
+   |                      ^^^^
+   |
+   = note: this field contains `Void`, which is not (publicly) inhabited, and makes it not a breaking change to become non-zero-sized in the future.
+
+error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
+  --> $DIR/repr-transparent-uninhabited.rs:20:15
+   |
+LL | pub struct T6(!, Sized);
+   |               ^
+   |
+   = note: this field contains `!`, which is not (publicly) inhabited, and makes it not a breaking change to become non-zero-sized in the future.
+
+error: aborting due to 2 previous errors
+

Original file line number	Diff line number	Diff line change
@@ -4,127 +4,127 @@ error: zero-sized fields in `repr(transparent)` cannot contain external non-exha
`4`	`4`	`LL \| pub struct T5(Sized, Private);`
`5`	`5`	`\| ^^^^^^^`
`6`	`6`	`\|`
`7`		- = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
	`7`	+ = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
`8`	`8`
`9`	`9`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`10`	`10`	`--> $DIR/repr-transparent-non-exhaustive.rs:41:22`
`11`	`11`	`\|`
`12`	`12`	`LL \| pub struct T6(Sized, NonExhaustive);`
`13`	`13`	`\| ^^^^^^^^^^^^^`
`14`	`14`	`\|`
`15`		- = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`15`	+ = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`16`	`16`
`17`	`17`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`18`	`18`	`--> $DIR/repr-transparent-non-exhaustive.rs:45:22`
`19`	`19`	`\|`
`20`	`20`	`LL \| pub struct T7(Sized, NonExhaustiveEnum);`
`21`	`21`	`\| ^^^^^^^^^^^^^^^^^`
`22`	`22`	`\|`
`23`		- = note: this enum contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`23`	+ = note: this field contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`24`	`24`
`25`	`25`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`26`	`26`	`--> $DIR/repr-transparent-non-exhaustive.rs:49:22`
`27`	`27`	`\|`
`28`	`28`	`LL \| pub struct T8(Sized, NonExhaustiveVariant);`
`29`	`29`	`\| ^^^^^^^^^^^^^^^^^^^^`
`30`	`30`	`\|`
`31`		- = note: this enum contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`31`	+ = note: this field contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`32`	`32`
`33`	`33`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`34`	`34`	`--> $DIR/repr-transparent-non-exhaustive.rs:53:22`
`35`	`35`	`\|`
`36`	`36`	`LL \| pub struct T9(Sized, InternalIndirection<Private>);`
`37`	`37`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`38`	`38`	`\|`
`39`		- = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
	`39`	+ = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
`40`	`40`
`41`	`41`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`42`	`42`	`--> $DIR/repr-transparent-non-exhaustive.rs:57:23`
`43`	`43`	`\|`
`44`	`44`	`LL \| pub struct T10(Sized, InternalIndirection<NonExhaustive>);`
`45`	`45`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`46`	`46`	`\|`
`47`		- = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`47`	+ = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`48`	`48`
`49`	`49`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`50`	`50`	`--> $DIR/repr-transparent-non-exhaustive.rs:61:23`
`51`	`51`	`\|`
`52`	`52`	`LL \| pub struct T11(Sized, InternalIndirection<NonExhaustiveEnum>);`
`53`	`53`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`54`	`54`	`\|`
`55`		- = note: this enum contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`55`	+ = note: this field contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`56`	`56`
`57`	`57`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`58`	`58`	`--> $DIR/repr-transparent-non-exhaustive.rs:65:23`
`59`	`59`	`\|`
`60`	`60`	`LL \| pub struct T12(Sized, InternalIndirection<NonExhaustiveVariant>);`
`61`	`61`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`62`	`62`	`\|`
`63`		- = note: this enum contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`63`	+ = note: this field contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`64`	`64`
`65`	`65`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`66`	`66`	`--> $DIR/repr-transparent-non-exhaustive.rs:69:23`
`67`	`67`	`\|`
`68`	`68`	`LL \| pub struct T13(Sized, ExternalIndirection<Private>);`
`69`	`69`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`70`	`70`	`\|`
`71`		- = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
	`71`	+ = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
`72`	`72`
`73`	`73`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`74`	`74`	`--> $DIR/repr-transparent-non-exhaustive.rs:73:23`
`75`	`75`	`\|`
`76`	`76`	`LL \| pub struct T14(Sized, ExternalIndirection<NonExhaustive>);`
`77`	`77`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`78`	`78`	`\|`
`79`		- = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`79`	+ = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`80`	`80`
`81`	`81`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`82`	`82`	`--> $DIR/repr-transparent-non-exhaustive.rs:77:23`
`83`	`83`	`\|`
`84`	`84`	`LL \| pub struct T15(Sized, ExternalIndirection<NonExhaustiveEnum>);`
`85`	`85`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`86`	`86`	`\|`
`87`		- = note: this enum contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`87`	+ = note: this field contains `NonExhaustiveEnum`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`88`	`88`
`89`	`89`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`90`	`90`	`--> $DIR/repr-transparent-non-exhaustive.rs:81:23`
`91`	`91`	`\|`
`92`	`92`	`LL \| pub struct T16(Sized, ExternalIndirection<NonExhaustiveVariant>);`
`93`	`93`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`94`	`94`	`\|`
`95`		- = note: this enum contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`95`	+ = note: this field contains `NonExhaustiveVariant`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`96`	`96`
`97`	`97`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`98`	`98`	`--> $DIR/repr-transparent-non-exhaustive.rs:85:16`
`99`	`99`	`\|`
`100`	`100`	`LL \| pub struct T17(NonExhaustive, Sized);`
`101`	`101`	`\| ^^^^^^^^^^^^^`
`102`	`102`	`\|`
`103`		- = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`103`	+ = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`104`	`104`
`105`	`105`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`106`	`106`	`--> $DIR/repr-transparent-non-exhaustive.rs:89:31`
`107`	`107`	`\|`
`108`	`108`	`LL \| pub struct T18(NonExhaustive, NonExhaustive);`
`109`	`109`	`\| ^^^^^^^^^^^^^`
`110`	`110`	`\|`
`111`		- = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`111`	+ = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`112`	`112`
`113`	`113`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`114`	`114`	`--> $DIR/repr-transparent-non-exhaustive.rs:93:31`
`115`	`115`	`\|`
`116`	`116`	`LL \| pub struct T19(NonExhaustive, Private);`
`117`	`117`	`\| ^^^^^^^`
`118`	`118`	`\|`
`119`		- = note: this struct contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
	`119`	+ = note: this field contains `Private`, which contains private fields, and makes it not a breaking change to become non-zero-sized in the future.
`120`	`120`
`121`	`121`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`122`	`122`	`--> $DIR/repr-transparent-non-exhaustive.rs:97:32`
`123`	`123`	`\|`
`124`	`124`	`LL \| pub struct T19Flipped(Private, NonExhaustive);`
`125`	`125`	`\| ^^^^^^^^^^^^^`
`126`	`126`	`\|`
`127`		- = note: this struct contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
	`127`	+ = note: this field contains `NonExhaustive`, which is marked with `#[non_exhaustive]`, and makes it not a breaking change to become non-zero-sized in the future.
`128`	`128`
`129`	`129`	`error: aborting due to 16 previous errors`
`130`	`130`
Original file line number	Diff line number	Diff line change
@@ -4,23 +4,23 @@ error: zero-sized fields in `repr(transparent)` cannot contain external non-exha
`4`	`4`	`LL \| pub struct T5(Sized, ReprC1Zst);`
`5`	`5`	`\| ^^^^^^^^^`
`6`	`6`	`\|`
`7`		- = note: this struct contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
	`7`	+ = note: this field contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
`8`	`8`
`9`	`9`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`10`	`10`	`--> $DIR/repr-transparent-repr-c.rs:22:15`
`11`	`11`	`\|`
`12`	`12`	`LL \| pub struct T6(ReprC1Zst, Sized);`
`13`	`13`	`\| ^^^^^^^^^`
`14`	`14`	`\|`
`15`		- = note: this struct contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
	`15`	+ = note: this field contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
`16`	`16`
`17`	`17`	error: zero-sized fields in `repr(transparent)` cannot contain external non-exhaustive types
`18`	`18`	`--> $DIR/repr-transparent-repr-c.rs:26:15`
`19`	`19`	`\|`
`20`	`20`	`LL \| pub struct T7(T1, Sized); // still wrong, even when the repr(C) is hidden inside another type`
`21`	`21`	`\| ^^`
`22`	`22`	`\|`
`23`		- = note: this struct contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
	`23`	+ = note: this field contains `ReprC1Zst`, which is marked with `#[repr(C)]`, and makes it not a breaking change to become non-zero-sized in the future.
`24`	`24`
`25`	`25`	`error: aborting due to 3 previous errors`
`26`	`26`