Error out of layout calculation if a non-last struct field is unsized

Fixes an ICE that occurs when a struct with an unsized field
at a non-last position is const evaluated.

Author: gurry

Diff for: compiler/rustc_ty_utils/src/layout.rs

@@ -8,7 +8,9 @@ use rustc_middle::ty::layout::{
     IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, MAX_SIMD_LANES,
 };
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, AdtDef, EarlyBinder, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{
+    self, AdtDef, EarlyBinder, FieldDef, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt,
+};
 use rustc_session::{DataTypeKind, FieldInfo, FieldKind, SizeKind, VariantInfo};
 use rustc_span::sym;
 use rustc_span::symbol::Symbol;
@@ -506,6 +508,33 @@ fn layout_of_uncached<'tcx>(
                 ));
             }
 
+            let is_unsized_field = |field: &FieldDef| {
+                let field_ty = tcx.type_of(field.did);
+                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 def.is_struct()
+                && let Some((_, fields_except_last)) =
+                    def.non_enum_variant().fields.raw.split_last()
+            {
+                for f in fields_except_last {
+                    if is_unsized_field(f)? {
+                        cx.tcx.dcx().span_delayed_bug(
+                            tcx.def_span(def.did()),
+                            "only the last field of a struct can be unsized",
+                        );
+                        return Err(error(cx, LayoutError::Unknown(ty)));
+                    }
+                }
+            }
+
             let get_discriminant_type =
                 |min, max| Integer::repr_discr(tcx, ty, &def.repr(), min, max);
 

Diff for: tests/ui/layout/ice-non-last-unsized-field-issue-121473.rs

@@ -0,0 +1,29 @@
+// 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],
+}
+
+// Tests that projection type fields that normalize
+// to a sized type should 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::<StructWithProjections>();
+    let _a = StructWithProjections { field1: [1, 3].iter(), field2: 3 };
+}

Diff for: tests/ui/layout/ice-non-last-unsized-field-issue-121473.stderr

@@ -0,0 +1,21 @@
+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: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.