handle unsized consts with type str in v0 symbol mangling

Author: Jaic1

compiler/rustc_symbol_mangling/src/v0.rs

@@ -574,6 +574,31 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
 
         let start = self.out.len();
 
+        let print_str = |this: &mut Self| {
+            let tcx = this.tcx();
+            let ref_ty = if matches!(ct_ty.kind(), ty::Str) {
+                // HACK(jaic1): hide the `str` type behind a reference
+                // for the following transformation from valtree to raw bytes
+                Ty::new_imm_ref(tcx, tcx.lifetimes.re_static, ct_ty)
+            } else {
+                ct_ty
+            };
+            let slice = valtree.try_to_raw_bytes(tcx, ref_ty).unwrap_or_else(|| {
+                bug!("expected to get raw bytes from valtree {:?} for type {:}", valtree, ct_ty)
+            });
+            let s = std::str::from_utf8(slice).expect("non utf8 str from MIR interpreter");
+
+            // "e" for str as a basic type
+            this.push("e");
+
+            // FIXME(eddyb) use a specialized hex-encoding loop.
+            for byte in s.bytes() {
+                let _ = write!(this.out, "{byte:02x}");
+            }
+
+            this.push("_");
+        };
+
         match ct_ty.kind() {
             ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => {
                 ct_ty.print(self)?;
@@ -593,6 +618,9 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
                 let _ = write!(self.out, "{bits:x}_");
             }
 
+            // Handle `str` as partial support for unsized constants
+            ty::Str => print_str(self),
+
             // FIXME(valtrees): Remove the special case for `str`
             // here and fully support unsized constants.
             ty::Ref(_, inner_ty, mutbl) => {
@@ -602,26 +630,9 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
                 });
 
                 match inner_ty.kind() {
-                    ty::Str if mutbl.is_not() => {
-                        let slice =
-                            valtree.try_to_raw_bytes(self.tcx(), ct_ty).unwrap_or_else(|| {
-                                bug!(
-                                    "expected to get raw bytes from valtree {:?} for type {:}",
-                                    valtree,
-                                    ct_ty
-                                )
-                            });
-                        let s =
-                            std::str::from_utf8(slice).expect("non utf8 str from MIR interpreter");
-
-                        self.push("e");
-
-                        // FIXME(eddyb) use a specialized hex-encoding loop.
-                        for byte in s.bytes() {
-                            let _ = write!(self.out, "{byte:02x}");
-                        }
-
-                        self.push("_");
+                    ty::Str => {
+                        assert!(mutbl.is_not(), "&mut str is not expected");
+                        print_str(self);
                     }
                     _ => {
                         let pointee_ty = ct_ty

tests/ui/const-generics/unsized_const_params/symbol_mangling_v0_str.rs

@@ -0,0 +1,23 @@
+//@ check-pass
+#![allow(incomplete_features)]
+#![feature(unsized_const_params)]
+
+// Regression test for #116303
+
+#[derive(PartialEq, Eq)]
+struct MyStr(str);
+impl std::marker::UnsizedConstParamTy for MyStr {}
+
+fn function_with_my_str<const S: &'static MyStr>() -> &'static MyStr {
+    S
+}
+
+impl MyStr {
+    const fn new(s: &'static str) -> &'static MyStr {
+        unsafe { std::mem::transmute(s) }
+    }
+}
+
+pub fn main() {
+    let f = function_with_my_str::<{ MyStr::new("hello") }>();
+}