Constify panic!("{}", non_str) and panic!(non_str) under const_panic_extra

Author: nbdd0121

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -48,18 +48,10 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
                     .unwrap(),
                 ));
             }
-        } else if Some(def_id) == self.tcx.lang_items().panic_display()
-            || Some(def_id) == self.tcx.lang_items().begin_panic_fn()
-        {
-            // &str or &&str
+        } else if Some(def_id) == self.tcx.lang_items().begin_panic_fn() {
             assert!(args.len() == 1);
-
-            let mut msg_place = self.deref_operand(&args[0])?;
-            while msg_place.layout.ty.is_ref() {
-                msg_place = self.deref_operand(&msg_place.into())?;
-            }
-
-            let msg = Symbol::intern(self.read_str(&msg_place)?);
+            let msg = self.eval_const_panic_any(args[0])?;
+            let msg = Symbol::intern(&msg);
             let span = self.find_closest_untracked_caller_location();
             let (file, line, col) = self.location_triple_for_span(span);
             return Err(ConstEvalErrKind::Panic { msg, file, line, col }.into());
@@ -71,6 +63,7 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
             let (file, line, col) = self.location_triple_for_span(span);
             return Err(ConstEvalErrKind::Panic { msg, file, line, col }.into());
         }
+
         Ok(None)
     }
 }

compiler/rustc_const_eval/src/const_eval/panic.rs

@@ -158,6 +158,10 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
             ty::Adt(adt, _) if self.tcx.is_diagnostic_item(sym::Arguments, adt.did) => {
                 return self.fmt_arguments(arg, f);
             }
+            ty::Adt(adt, _) if self.tcx.is_diagnostic_item(sym::String, adt.did) => {
+                // NOTE(nbdd0121): const `String` can only be empty.
+                dispatch_fmt!("", Display);
+            }
 
             // FIXME(nbdd0121): ty::Adt(..) => (),
             _ => {
@@ -241,4 +245,18 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
         self.fmt_arguments(arguments, &mut formatter)?;
         Ok(msg)
     }
+
+    pub(super) fn eval_const_panic_any(&mut self, arg: OpTy<'tcx>) -> InterpResult<'tcx, String> {
+        match arg.layout.ty.kind() {
+            ty::Ref(_, ty, _) if ty.is_str() => {
+                let place = self.deref_operand(&arg)?;
+                Ok(self.read_str(&place)?.to_string())
+            }
+            ty::Adt(adt, _) if self.tcx.is_diagnostic_item(sym::String, adt.did) => {
+                // NOTE(nbdd0121): const `String` can only be empty.
+                Ok(String::new())
+            }
+            _ => Ok("Box<dyn Any>".to_string()),
+        }
+    }
 }

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -893,7 +893,7 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
                 if Some(callee) == tcx.lang_items().begin_panic_fn() {
                     match args[0].ty(&self.ccx.body.local_decls, tcx).kind() {
                         ty::Ref(_, ty, _) if ty.is_str() => return,
-                        _ => self.check_op(ops::PanicNonStr),
+                        _ => (),
                     }
                 }
 
@@ -904,7 +904,7 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
                         {
                             return;
                         }
-                        _ => self.check_op(ops::PanicNonStr),
+                        _ => (),
                     }
                 }
 

compiler/rustc_const_eval/src/transform/check_consts/ops.rs

@@ -368,18 +368,6 @@ impl NonConstOp for MutDeref {
     }
 }
 
-/// A call to a `panic()` lang item where the first argument is _not_ a `&str`.
-#[derive(Debug)]
-pub struct PanicNonStr;
-impl NonConstOp for PanicNonStr {
-    fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
-        ccx.tcx.sess.struct_span_err(
-            span,
-            "argument to `panic!()` in a const context must have type `&str`",
-        )
-    }
-}
-
 /// Comparing raw pointers for equality.
 /// Not currently intended to ever be allowed, even behind a feature gate: operation depends on
 /// allocation base addresses that are not known at compile-time.

library/core/src/panicking.rs

@@ -51,13 +51,13 @@ pub const fn panic(expr: &'static str) -> ! {
 #[track_caller]
 #[lang = "panic_str"] // needed for `non-fmt-panics` lint
 pub const fn panic_str(expr: &str) -> ! {
-    panic_display(&expr);
+    panic_fmt(format_args!("{}", expr));
 }
 
 #[inline]
 #[track_caller]
 #[lang = "panic_display"] // needed for const-evaluated panics
-#[rustc_do_not_const_check] // hooked by const-eval
+#[rustc_const_unstable(feature = "const_panic_extra", issue = "none")]
 pub const fn panic_display<T: fmt::Display>(x: &T) -> ! {
     panic_fmt(format_args!("{}", *x));
 }

library/std/src/panicking.rs

@@ -515,6 +515,7 @@ pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
 #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
 #[cold]
 #[track_caller]
+#[rustc_const_unstable(feature = "const_panic_extra", issue = "none")]
 #[rustc_do_not_const_check] // hooked by const-eval
 pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
     if cfg!(feature = "panic_immediate_abort") {