handle ty::Str once and for all at the top level

Author: Jaic1

compiler/rustc_symbol_mangling/src/v0.rs

@@ -574,31 +574,6 @@ 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)?;
@@ -619,30 +594,43 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
             }
 
             // Handle `str` as partial support for unsized constants
-            ty::Str => print_str(self),
+            ty::Str => {
+                let tcx = self.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
+                self.push("e");
+
+                // FIXME(eddyb) use a specialized hex-encoding loop.
+                for byte in s.bytes() {
+                    let _ = write!(self.out, "{byte:02x}");
+                }
+
+                self.push("_");
+            }
 
             // FIXME(valtrees): Remove the special case for `str`
             // here and fully support unsized constants.
-            ty::Ref(_, inner_ty, mutbl) => {
+            ty::Ref(_, _, mutbl) => {
                 self.push(match mutbl {
                     hir::Mutability::Not => "R",
                     hir::Mutability::Mut => "Q",
                 });
 
-                match inner_ty.kind() {
-                    ty::Str => {
-                        assert!(mutbl.is_not(), "&mut str is not expected");
-                        print_str(self);
-                    }
-                    _ => {
-                        let pointee_ty = ct_ty
-                            .builtin_deref(true)
-                            .expect("tried to dereference on non-ptr type");
-                        let dereferenced_const =
-                            ty::Const::new_value(self.tcx, valtree, pointee_ty);
-                        dereferenced_const.print(self)?;
-                    }
-                }
+                let pointee_ty =
+                    ct_ty.builtin_deref(true).expect("tried to dereference on non-ptr type");
+                let dereferenced_const = ty::Const::new_value(self.tcx, valtree, pointee_ty);
+                dereferenced_const.print(self)?;
             }
 
             ty::Array(..) | ty::Tuple(..) | ty::Adt(..) | ty::Slice(_) => {