Introduce Operand::unevaluated_constant.

Author: cjgillot

compiler/rustc_middle/src/mir/statement.rs

@@ -597,6 +597,18 @@ impl<'tcx> Operand<'tcx> {
         }))
     }
 
+    /// Convenience helper to make a constant that refers to the given `DefId` and args. Since this
+    /// is used to synthesize MIR, assumes `user_ty` is None.
+    pub fn unevaluated_constant(
+        tcx: TyCtxt<'tcx>,
+        def_id: DefId,
+        args: &[GenericArg<'tcx>],
+        span: Span,
+    ) -> Self {
+        let const_ = Const::from_unevaluated(tcx, def_id).instantiate(tcx, args);
+        Operand::Constant(Box::new(ConstOperand { span, user_ty: None, const_ }))
+    }
+
     pub fn is_move(&self) -> bool {
         matches!(self, Operand::Move(..))
     }

compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs

@@ -127,21 +127,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let source_info = this.source_info(expr_span);
 
                 let size = tcx.require_lang_item(LangItem::SizeOf, expr_span);
-                let size = Const::from_unevaluated(tcx, size).instantiate(tcx, &[value_ty.into()]);
-                let size = Operand::Constant(Box::new(ConstOperand {
-                    span: expr_span,
-                    user_ty: None,
-                    const_: size,
-                }));
+                let size = Operand::unevaluated_constant(tcx, size, &[value_ty.into()], expr_span);
 
                 let align = tcx.require_lang_item(LangItem::AlignOf, expr_span);
                 let align =
-                    Const::from_unevaluated(tcx, align).instantiate(tcx, &[value_ty.into()]);
-                let align = Operand::Constant(Box::new(ConstOperand {
-                    span: expr_span,
-                    user_ty: None,
-                    const_: align,
-                }));
+                    Operand::unevaluated_constant(tcx, align, &[value_ty.into()], expr_span);
 
                 // malloc some memory of suitable size and align:
                 let exchange_malloc = Operand::function_handle(

compiler/rustc_mir_transform/src/check_alignment.rs

@@ -61,13 +61,8 @@ fn insert_alignment_check<'tcx>(
 
     // Get the alignment of the pointee
     let align_def_id = tcx.require_lang_item(LangItem::AlignOf, source_info.span);
-    let align_const =
-        Const::from_unevaluated(tcx, align_def_id).instantiate(tcx, &[pointee_ty.into()]);
-    let alignment = Operand::Constant(Box::new(ConstOperand {
-        span: source_info.span,
-        user_ty: None,
-        const_: align_const,
-    }));
+    let alignment =
+        Operand::unevaluated_constant(tcx, align_def_id, &[pointee_ty.into()], source_info.span);
 
     // Subtract 1 from the alignment to get the alignment mask
     let alignment_mask =

compiler/rustc_mir_transform/src/check_null.rs

@@ -69,12 +69,8 @@ fn insert_null_check<'tcx>(
         // Other usages of null pointers only are UB if the pointee is not a ZST.
         _ => {
             let size_of = tcx.require_lang_item(LangItem::SizeOf, source_info.span);
-            let size_of = Operand::Constant(Box::new(ConstOperand {
-                span: source_info.span,
-                user_ty: None,
-                const_: Const::from_unevaluated(tcx, size_of)
-                    .instantiate(tcx, &[pointee_ty.into()]),
-            }));
+            let size_of =
+                Operand::unevaluated_constant(tcx, size_of, &[pointee_ty.into()], source_info.span);
 
             let pointee_should_be_checked =
                 local_decls.push(LocalDecl::with_source_info(tcx.types.bool, source_info)).into();

compiler/rustc_mir_transform/src/instsimplify.rs

@@ -274,13 +274,12 @@ impl<'tcx> InstSimplifyContext<'_, 'tcx> {
             && let ty::Slice(elem_ty) = *generics.type_at(0).kind()
         {
             let align_def_id = self.tcx.require_lang_item(LangItem::AlignOf, source_info.span);
-            let align_const = Const::from_unevaluated(self.tcx, align_def_id)
-                .instantiate(self.tcx, &[elem_ty.into()]);
-            let align_const = Operand::Constant(Box::new(ConstOperand {
-                span: source_info.span,
-                user_ty: None,
-                const_: align_const,
-            }));
+            let align_const = Operand::unevaluated_constant(
+                self.tcx,
+                align_def_id,
+                &[elem_ty.into()],
+                source_info.span,
+            );
             statements.push(Statement::new(
                 source_info,
                 StatementKind::Assign(Box::new((*destination, Rvalue::Use(align_const)))),