Better print ScalarPair when it is tuple or slice

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -213,7 +213,47 @@ impl<Prov: Provenance> std::fmt::Display for ImmTy<'_, Prov> {
                     write!(f, "{:x}: {}", s, self.layout.ty)
                 }
                 Immediate::ScalarPair(a, b) => {
-                    // FIXME(oli-obk): at least print tuples and slices nicely
+                    // Try to print tuples and slices nicely first
+                    // It's *only* printed for internal debugging
+                    if let Some(ty) = tcx.lift(self.layout.ty) {
+                        match ty.kind() {
+                            ty::Tuple(tys) => {
+                                // For tuples, print each field with its proper type
+                                if tys.len() == 2 {
+                                    let a_str =
+                                        FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| {
+                                            p(cx, a, tys[0])
+                                        })?;
+                                    let b_str =
+                                        FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| {
+                                            p(cx, b, tys[1])
+                                        })?;
+
+                                    write!(f, "({}, {}): {}", a_str, b_str, ty)?;
+                                    return Ok(());
+                                }
+                            }
+                            ty::Slice(element_ty) => {
+                                // For slices, the first scalar is the pointer, second is the length
+                                let ptr_str =
+                                    FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| {
+                                        p(cx, a, Ty::new_ptr(tcx, *element_ty, ty::Mutability::Not))
+                                    })?;
+                                let len_str =
+                                    FmtPrinter::print_string(tcx, Namespace::ValueNS, |cx| {
+                                        p(cx, b, tcx.types.usize)
+                                    })?;
+
+                                write!(f, "&[{}; {}]: {}", ptr_str, len_str, ty)?;
+                                return Ok(());
+                            }
+                            _ => {
+                                // For other types, try to print each component with the field types
+                                // Since we can't easily get field types, fall back to the original format for now
+                            }
+                        }
+                    }
+                    // Fallback to the original format if we can't pretty print
                     write!(f, "({:x}, {:x}): {}", a, b, self.layout.ty)
                 }
                 Immediate::Uninit => {