added pretty_print_const_expr

formatting

Author: William Utter

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -4,7 +4,7 @@ use crate::query::Providers;
 use crate::traits::util::supertraits_for_pretty_printing;
 use crate::ty::GenericArgKind;
 use crate::ty::{
-    ConstInt, ParamConst, ScalarInt, Term, TermKind, TypeFoldable, TypeSuperFoldable,
+    ConstInt, Expr, ParamConst, ScalarInt, Term, TermKind, TypeFoldable, TypeSuperFoldable,
     TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
 };
 use rustc_apfloat::ieee::{Double, Single};
@@ -1382,12 +1382,83 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             ty::ConstKind::Placeholder(placeholder) => p!(write("{placeholder:?}")),
             // FIXME(generic_const_exprs):
             // write out some legible representation of an abstract const?
-            ty::ConstKind::Expr(_) => p!("{{const expr}}"),
+            ty::ConstKind::Expr(expr) => self.pretty_print_const_expr(expr, print_ty)?,
             ty::ConstKind::Error(_) => p!("{{const error}}"),
         };
         Ok(())
     }
 
+    fn pretty_print_const_expr(
+        &mut self,
+        expr: Expr<'tcx>,
+        print_ty: bool,
+    ) -> Result<(), PrintError> {
+        define_scoped_cx!(self);
+        match expr {
+            Expr::Binop(op, c1, c2) => {
+                let formatted_op = op.to_hir_binop().as_str();
+                p!(print(c1), write(" {formatted_op} "), print(c2));
+            }
+            Expr::UnOp(op, ct) => {
+                use rustc_middle::mir::UnOp;
+                let formatted_op = match op {
+                    UnOp::Not => "!",
+                    UnOp::Neg => "-",
+                };
+                p!(write("{formatted_op}"), print(ct));
+            }
+            Expr::FunctionCall(fn_def, fn_args) => {
+                use ty::TyKind;
+                match fn_def.ty().kind() {
+                    TyKind::FnDef(def_id, gen_args) => {
+                        p!(print_value_path(*def_id, gen_args), "(");
+                        if print_ty {
+                            let tcx = self.tcx();
+                            let sig = tcx.fn_sig(def_id).instantiate(tcx, gen_args).skip_binder();
+
+                            let mut args_with_ty = fn_args.iter().map(|ct| (ct, ct.ty()));
+                            let output_ty = sig.output();
+
+                            if let Some((ct, ty)) = args_with_ty.next() {
+                                self.typed_value(
+                                    |this| this.pretty_print_const(ct, print_ty),
+                                    |this| this.pretty_print_type(ty),
+                                    ": ",
+                                )?;
+                                for (ct, ty) in args_with_ty {
+                                    self.typed_value(
+                                        |this| this.pretty_print_const(ct, print_ty),
+                                        |this| this.pretty_print_type(ty),
+                                        ": ",
+                                    )?;
+                                }
+                            }
+                            p!(write(") -> {output_ty}"));
+                        } else {
+                            p!(comma_sep(fn_args.iter()), ")");
+                        }
+                    }
+                    _ => bug!("unexpected type of fn def"),
+                }
+            }
+            Expr::Cast(kind, ct, ty) => {
+                use ty::abstract_const::CastKind;
+                match kind {
+                    CastKind::As => {
+                        self.typed_value(
+                            |this| this.pretty_print_const(ct, print_ty),
+                            |this| this.pretty_print_type(ty),
+                            "as",
+                        )?;
+                    }
+                    // FIXME?: some implicit coercions might be useful to print
+                    CastKind::Use => self.pretty_print_const(ct, print_ty)?,
+                }
+            }
+        }
+        Ok(())
+    }
+
     fn pretty_print_const_scalar(
         &mut self,
         scalar: Scalar,

tests/ui/const-generics/generic_const_exprs/const_kind_expr/issue_114151.rs

@@ -19,7 +19,7 @@ where
     //~^^ ERROR: unconstrained generic constant
     //~^^^ ERROR: function takes 1 generic argument but 2 generic arguments were supplied
     //~^^^^ ERROR: unconstrained generic constant
-    //~^^^^^ ERROR: unconstrained generic constant `{const expr}`
+    //~^^^^^ ERROR: unconstrained generic constant `L + 1 + L`
 }
 
 fn main() {}

tests/ui/const-generics/generic_const_exprs/const_kind_expr/issue_114151.stderr

@@ -52,7 +52,7 @@ LL | |         }
 LL | |     }],
    | |_____^ required by this bound in `foo`
 
-error: unconstrained generic constant `{const expr}`
+error: unconstrained generic constant `L + 1 + L`
   --> $DIR/issue_114151.rs:17:5
    |
 LL |     foo::<_, L>([(); L + 1 + L]);

tests/ui/const-generics/transmute-fail.stderr

@@ -4,8 +4,8 @@ error[E0512]: cannot transmute between types of different sizes, or dependently-
 LL |     std::mem::transmute(v)
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = note: source type: `[[u32; H+1]; W]` (generic size {const expr})
-   = note: target type: `[[u32; W+1]; H]` (generic size {const expr})
+   = note: source type: `[[u32; H+1]; W]` (generic size H + 1 * 4 * W)
+   = note: target type: `[[u32; W+1]; H]` (generic size W + 1 * 4 * H)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
   --> $DIR/transmute-fail.rs:16:5
@@ -22,8 +22,8 @@ error[E0512]: cannot transmute between types of different sizes, or dependently-
 LL |     std::mem::transmute(v)
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = note: source type: `[[u32; H]; W]` (generic size {const expr})
-   = note: target type: `[u32; W * H * H]` (generic size {const expr})
+   = note: source type: `[[u32; H]; W]` (generic size 4 * H * W)
+   = note: target type: `[u32; W * H * H]` (generic size 4 * H * H * W)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
   --> $DIR/transmute-fail.rs:30:5