Change:
<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for how to create smaller examples. --(reduced) (original) <details<summary<strongOriginal Code</strong</summary<p</p</detailsI guess the original code is mutated from , where the type of field of is tweaked from to . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: with no other options <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI can find various , but none of them has the same ICE location as this one.
Bisects to , but I guess it just made the ICE easier to reach. cc
Jup, here it is on stable:
Related to
Regression in nightly-2023-08-11 (...) Out of PRs merged in that range there were 3 rollups: and one PR that had to do with :

Discussion:
IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, MAX_SIMD_LANES, }; use rustc_middle::ty::print::with_no_trimmed_paths; <del> use rustc_middle::ty::{self, AdtDef, EarlyBinder, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt}; </del> <ins> use rustc_middle::ty::{ self, AdtDef, EarlyBinder, FieldDef, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt, }; </ins> use rustc_session::{DataTypeKind, FieldInfo, FieldKind, SizeKind, VariantInfo}; use rustc_span::sym; use rustc_span::symbol::Symbol;

)); } <ins> let err_if_unsized = |field: &FieldDef, err_msg: &str| { let field_ty = tcx.type_of(field.did); let is_unsized = tcx .try_instantiate_and_normalize_erasing_regions(args, cx.param_env, field_ty) .map(|f| !f.is_sized(tcx, cx.param_env)) .map_err(|e| { error( cx, LayoutError::NormalizationFailure(field_ty.instantiate_identity(), e), ) })?; if is_unsized { cx.tcx.dcx().span_delayed_bug(tcx.def_span(def.did()), err_msg.to_owned()); Err(error(cx, LayoutError::Unknown(ty))) } else { Ok(()) } }; if def.is_struct() { if let Some((_, fields_except_last)) = def.non_enum_variant().fields.raw.split_last() { for f in fields_except_last { err_if_unsized(f, "only the last field of a struct can be unsized")?; } } } else { for f in def.all_fields() { err_if_unsized(f, &format!("{}s cannot have unsized fields", def.descr()))?; } } </ins> let get_discriminant_type = |min, max| Integer::repr_discr(tcx, ty, &def.repr(), min, max);

<ins> // Regression test for #121473 // Checks that no ICE occurs when `size_of` // is applied to a struct that has an unsized // field which is not its last field use std::mem::size_of; pub struct BadStruct { pub field1: i32, pub field2: str, // Unsized field that is not the last field //~^ ERROR the size for values of type `str` cannot be known at compilation time pub field3: [u8; 16], } enum BadEnum1 { Variant1 { field1: i32, field2: str, // Unsized //~^ ERROR the size for values of type `str` cannot be known at compilation time field3: [u8; 16], }, } enum BadEnum2 { Variant1( i32, str, // Unsized //~^ ERROR the size for values of type `str` cannot be known at compilation time [u8; 16] ), } enum BadEnumMultiVariant { Variant1(i32), Variant2 { field1: i32, field2: str, // Unsized //~^ ERROR the size for values of type `str` cannot be known at compilation time field3: [u8; 16], }, Variant3 } union BadUnion { field1: i32, field2: str, // Unsized //~^ ERROR the size for values of type `str` cannot be known at compilation time //~| ERROR field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union field3: [u8; 16], } // Used to test that projection type fields that normalize // to a sized type do not cause problems struct StructWithProjections<'a> { field1: <&'a [i32] as IntoIterator>::IntoIter, field2: i32 } pub fn main() { let _a = &size_of::<BadStruct>(); assert_eq!(size_of::<BadStruct>(), 21); let _a = &size_of::<BadEnum1>(); assert_eq!(size_of::<BadEnum1>(), 21); let _a = &size_of::<BadEnum2>(); assert_eq!(size_of::<BadEnum2>(), 21); let _a = &size_of::<BadEnumMultiVariant>(); assert_eq!(size_of::<BadEnumMultiVariant>(), 21); let _a = &size_of::<BadUnion>(); assert_eq!(size_of::<BadUnion>(), 21); let _a = &size_of::<StructWithProjections>(); assert_eq!(size_of::<StructWithProjections>(), 21); let _a = StructWithProjections { field1: [1, 3].iter(), field2: 3 }; } </ins>

<ins> error[E0277]: the size for values of type `str` cannot be known at compilation time --> $DIR/ice-non-last-unsized-field-issue-121473.rs:10:17 | LL |     pub field2: str, // Unsized field that is not the last field |                 ^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `str` = note: only the last field of a struct may have a dynamically sized type = help: change the field's type to have a statically known size help: borrowed types always have a statically known size | LL |     pub field2: &str, // Unsized field that is not the last field |                 + help: the `Box` type always has a statically known size and allocates its contents in the heap | LL |     pub field2: Box<str>, // Unsized field that is not the last field |                 ++++   + error[E0277]: the size for values of type `str` cannot be known at compilation time --> $DIR/ice-non-last-unsized-field-issue-121473.rs:18:17 | LL |         field2: str, // Unsized |                 ^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `str` = note: no field of an enum variant may have a dynamically sized type = help: change the field's type to have a statically known size help: borrowed types always have a statically known size | LL |         field2: &str, // Unsized |                 + help: the `Box` type always has a statically known size and allocates its contents in the heap | LL |         field2: Box<str>, // Unsized |                 ++++   + error[E0277]: the size for values of type `str` cannot be known at compilation time --> $DIR/ice-non-last-unsized-field-issue-121473.rs:27:9 | LL |         str, // Unsized |         ^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `str` = note: no field of an enum variant may have a dynamically sized type = help: change the field's type to have a statically known size help: borrowed types always have a statically known size | LL |         &str, // Unsized |         + help: the `Box` type always has a statically known size and allocates its contents in the heap | LL |         Box<str>, // Unsized |         ++++   + error[E0277]: the size for values of type `str` cannot be known at compilation time --> $DIR/ice-non-last-unsized-field-issue-121473.rs:37:17 | LL |         field2: str, // Unsized |                 ^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `str` = note: no field of an enum variant may have a dynamically sized type = help: change the field's type to have a statically known size help: borrowed types always have a statically known size | LL |         field2: &str, // Unsized |                 + help: the `Box` type always has a statically known size and allocates its contents in the heap | LL |         field2: Box<str>, // Unsized |                 ++++   + error[E0277]: the size for values of type `str` cannot be known at compilation time --> $DIR/ice-non-last-unsized-field-issue-121473.rs:46:13 | LL |     field2: str, // Unsized |             ^^^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `str` = note: no field of a union may have a dynamically sized type = help: change the field's type to have a statically known size help: borrowed types always have a statically known size | LL |     field2: &str, // Unsized |             + help: the `Box` type always has a statically known size and allocates its contents in the heap | LL |     field2: Box<str>, // Unsized |             ++++   + error[E0740]: field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union --> $DIR/ice-non-last-unsized-field-issue-121473.rs:46:5 | LL |     field2: str, // Unsized |     ^^^^^^^^^^^ | = note: union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>` help: wrap the field type in `ManuallyDrop<...>` | LL |     field2: std::mem::ManuallyDrop<str>, // Unsized |             +++++++++++++++++++++++   + error: aborting due to 6 previous errors Some errors have detailed explanations: E0277, E0740. For more information about an error, try `rustc --explain E0277`. </ins>