Idiomatic Rust cleanup across printer submodules

- let-else and unwrap_or_else instead of is_none()/unwrap() and manual
  if-let-else in link_map.rs
- Remove unnecessary .clone() on HashMap get_mut/insert keys
- Pass offset by value (usize) rather than by reference (&usize)
- Remove redundant prelude re-imports (std::str, std::vec::Vec)
- Extract opaque_placeholder_ty() for the Ty::to_val(0) sentinel
- Tighten hash() visibility from pub to pub(super)

Author: cds-amal

src/printer/items.rs

@@ -10,9 +10,6 @@ extern crate rustc_smir;
 extern crate rustc_span;
 extern crate stable_mir;
 
-use std::str;
-use std::vec::Vec;
-
 use rustc_middle as middle;
 use rustc_middle::ty::{EarlyBinder, FnSig, GenericArgs, Ty, TyCtxt, TypeFoldable};
 use rustc_smir::rustc_internal;
@@ -80,7 +77,7 @@ fn get_body_details(body: &stable_mir::mir::Body) -> BodyDetails {
     let mut v = Vec::new();
     let _ = body.dump(&mut v, "<omitted>");
     BodyDetails {
-        pp: str::from_utf8(&v).unwrap().into(),
+        pp: std::str::from_utf8(&v).unwrap().into(),
     }
 }
 

src/printer/link_map.rs

@@ -31,7 +31,7 @@ pub(super) fn fn_inst_sym<'tcx>(
 ) -> Option<FnSymInfo<'tcx>> {
     use FnSymType::*;
     inst.and_then(|inst| {
-        let ty = if let Some(ty) = ty { ty } else { inst.ty() };
+        let ty = ty.unwrap_or_else(|| inst.ty());
         let kind = ty.kind();
         if kind.fn_def().is_some() {
             let internal_inst = rustc_internal::internal(tcx, inst);
@@ -58,17 +58,16 @@ pub(super) fn update_link_map<'tcx>(
     fn_sym: Option<FnSymInfo<'tcx>>,
     source: ItemSource,
 ) {
-    if fn_sym.is_none() {
+    let Some((ty, kind, name)) = fn_sym else {
         return;
-    }
-    let (ty, kind, name) = fn_sym.unwrap();
+    };
     let new_val = (source, name.clone());
     let key = if super::link_instance_enabled() {
         LinkMapKey(ty, Some(kind))
     } else {
         LinkMapKey(ty, None)
     };
-    if let Some(curr_val) = link_map.get_mut(&key.clone()) {
+    if let Some(curr_val) = link_map.get_mut(&key) {
         if curr_val.1 != new_val.1 {
             if !super::link_instance_enabled() {
                 // When LINK_INST is disabled, prefer Item over ReifyShim.
@@ -103,6 +102,6 @@ pub(super) fn update_link_map<'tcx>(
             key.0.kind().fn_def(),
             new_val
         );
-        link_map.insert(key.clone(), new_val);
+        link_map.insert(key, new_val);
     }
 }

src/printer/mir_visitor.rs

@@ -31,6 +31,12 @@ use super::schema::{
 use super::ty_visitor::TyCollector;
 use super::util::{def_id_to_inst, fn_inst_for_ty};
 
+/// Placeholder type used when the precise pointee type of an allocation cannot
+/// be recovered from the surrounding context.
+fn opaque_placeholder_ty() -> stable_mir::ty::Ty {
+    stable_mir::ty::Ty::to_val(0)
+}
+
 struct InternedValueCollector<'tcx, 'local> {
     tcx: TyCtxt<'tcx>,
     locals: &'local [LocalDecl],
@@ -57,12 +63,12 @@ fn field_for_offset(l: LayoutShape, offset: usize) -> Option<usize> {
     }
 }
 
-fn get_prov_ty(ty: stable_mir::ty::Ty, offset: &usize) -> Option<stable_mir::ty::Ty> {
+fn get_prov_ty(ty: stable_mir::ty::Ty, offset: usize) -> Option<stable_mir::ty::Ty> {
     use stable_mir::ty::RigidTy;
     let ty_kind = ty.kind();
     // if ty is a pointer, box, or Ref, expect no offset and dereference
     if let Some(ty) = ty_kind.builtin_deref(true) {
-        assert!(*offset == 0);
+        assert!(offset == 0);
         return Some(ty.ty);
     }
 
@@ -87,14 +93,14 @@ fn get_prov_ty(ty: stable_mir::ty::Ty, offset: &usize) -> Option<stable_mir::ty:
         }
         // For other structs, consult layout to determine field type
         RigidTy::Adt(adt_def, args) if ty_kind.is_struct() => {
-            let field_idx = field_for_offset(layout, *offset).unwrap();
+            let field_idx = field_for_offset(layout, offset).unwrap();
             // NB struct, single variant
             let fields = adt_def.variants().pop().map(|v| v.fields()).unwrap();
             fields.get(field_idx).map(|f| f.ty_with_args(args))
         }
         RigidTy::Adt(_adt_def, _args) if ty_kind.is_enum() => {
             // we have to figure out which variant we are dealing with (requires the data)
-            match field_for_offset(layout, *offset) {
+            match field_for_offset(layout, offset) {
                 None =>
                 // FIXME we'd have to figure out which variant we are dealing with (requires the data)
                 {
@@ -108,7 +114,7 @@ fn get_prov_ty(ty: stable_mir::ty::Ty, offset: &usize) -> Option<stable_mir::ty:
             }
         }
         RigidTy::Tuple(fields) => {
-            let field_idx = field_for_offset(layout, *offset)?;
+            let field_idx = field_for_offset(layout, offset)?;
             fields.get(field_idx).copied()
         }
         RigidTy::FnPtr(_) => None,
@@ -122,14 +128,14 @@ fn get_prov_ty(ty: stable_mir::ty::Ty, offset: &usize) -> Option<stable_mir::ty:
     };
     match ref_ty {
         None => None,
-        Some(ty) => get_prov_ty(ty, &0),
+        Some(ty) => get_prov_ty(ty, 0),
     }
 }
 
 fn collect_alloc(
     val_collector: &mut InternedValueCollector,
     ty: stable_mir::ty::Ty,
-    offset: &usize,
+    offset: usize,
     val: stable_mir::mir::alloc::AllocId,
 ) {
     let entry = val_collector.visited_allocs.entry(val);
@@ -160,10 +166,10 @@ fn collect_alloc(
                     .ptrs
                     .iter()
                     .for_each(|(prov_offset, prov)| {
-                        collect_alloc(val_collector, p_ty, prov_offset, prov.0);
+                        collect_alloc(val_collector, p_ty, *prov_offset, prov.0);
                     });
             } else {
-                entry.or_insert((stable_mir::ty::Ty::to_val(0), global_alloc.clone()));
+                entry.or_insert((opaque_placeholder_ty(), global_alloc.clone()));
             }
         }
         GlobalAlloc::Static(_) | GlobalAlloc::VTable(_, _) => {
@@ -190,7 +196,7 @@ fn collect_alloc(
                 } else {
                     // Could not recover a precise pointee type; use an opaque 0-valued Ty
                     // as a conservative placeholder.
-                    entry.or_insert((stable_mir::ty::Ty::to_val(0), global_alloc.clone()));
+                    entry.or_insert((opaque_placeholder_ty(), global_alloc.clone()));
                 }
             } else {
                 entry.or_insert((ty, global_alloc.clone()));
@@ -280,7 +286,7 @@ impl MirVisitor for InternedValueCollector<'_, '_> {
                     .provenance
                     .ptrs
                     .iter()
-                    .for_each(|(offset, prov)| collect_alloc(self, constant.ty(), offset, prov.0));
+                    .for_each(|(offset, prov)| collect_alloc(self, constant.ty(), *offset, prov.0));
             }
             ConstantKind::Ty(ty_const) => {
                 if let TyConstKind::Value(..) = ty_const.kind() {

src/printer/util.rs

@@ -10,7 +10,7 @@ use rustc_smir::rustc_internal;
 use rustc_span::symbol;
 use stable_mir::mir::mono::{Instance, MonoItem};
 
-pub fn hash<T: std::hash::Hash>(obj: T) -> u64 {
+pub(super) fn hash<T: std::hash::Hash>(obj: T) -> u64 {
     use std::hash::Hasher;
     let mut hasher = std::hash::DefaultHasher::new();
     obj.hash(&mut hasher);