Ensure type is monomorphic enough before evaluating size_of / align_of.

Author: tmiasko

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -187,6 +187,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
             sym::size_of => {
                 let tp_ty = instance.args.type_at(0);
+                ensure_monomorphic_enough(tcx, tp_ty)?;
                 let layout = self.layout_of(tp_ty)?;
                 if !layout.is_sized() {
                     span_bug!(self.cur_span(), "unsized type for `size_of`");
@@ -196,6 +197,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
             sym::align_of => {
                 let tp_ty = instance.args.type_at(0);
+                ensure_monomorphic_enough(tcx, tp_ty)?;
                 let layout = self.layout_of(tp_ty)?;
                 if !layout.is_sized() {
                     span_bug!(self.cur_span(), "unsized type for `align_of`");

tests/ui/consts/size-align-monomorphic.rs

@@ -0,0 +1,21 @@
+// Regression test for #149081. Check that an attempt to evaluate size_of / align_of intrinsics
+// during an optimization, when type parameter is not monomorphic enough, doesn't lead to a
+// compilation failure.
+//
+//@compile-flags: --crate-type=lib -O
+//@build-pass
+
+pub fn size_align_of<T: WithAssoc<Assoc = U>, U>() -> (usize, usize) {
+    let a = const { std::mem::size_of::<Wrapper<T>>() };
+    let b = const { std::mem::align_of::<Wrapper<T>>() };
+    (a, b)
+}
+
+pub struct Wrapper<T: WithAssoc> {
+    pub assoc2: <T::Assoc as WithAssoc>::Assoc,
+    pub value: T,
+}
+
+pub trait WithAssoc {
+    type Assoc: WithAssoc;
+}