fix(printer.rs): include ZeroSized FnDef consts in functions (#112)

- Problem: stable-mir-json misses function items (FnDef) that appear as
ConstantKind::ZeroSized when passed as values (e.g.
Option::map(u64::from_le_bytes)), so the emitted functions list is
incomplete.
- Fix: In InternedValueCollector::visit_mir_const, detect ZeroSized
constants whose type is FnDef, resolve an Instance (prefer
resolve_for_fn_ptr, fallback to resolve), and add it to the link map
with ItemSource(FPTR) so it is emitted in functions.
- Robustness: Avoid panicking on inconsistent symbol mappings by
skipping insertion when the existing LinkMapKey already maps to a
different symbol (direct-call vs reify shim cases).
- Related: #55 (and downstream
runtimeverification/mir-semantics#891
runtimeverification/mir-semantics#488).

Author: Stevengre

src/printer.rs

@@ -600,6 +600,10 @@ struct InternedValueCollector<'tcx, 'local> {
 
 type InternedValues<'tcx> = (LinkMap<'tcx>, AllocMap, TyMap, SpanMap);
 
+fn is_reify_shim(kind: &middle::ty::InstanceKind<'_>) -> bool {
+    matches!(kind, middle::ty::InstanceKind::ReifyShim(..))
+}
+
 fn update_link_map<'tcx>(
     link_map: &mut LinkMap<'tcx>,
     fn_sym: Option<FnSymInfo<'tcx>>,
@@ -609,14 +613,26 @@ fn update_link_map<'tcx>(
         return;
     }
     let (ty, kind, name) = fn_sym.unwrap();
-    let new_val = (source, name);
+    let new_val = (source, name.clone());
     let key = if link_instance_enabled() {
         LinkMapKey(ty, Some(kind))
     } else {
         LinkMapKey(ty, None)
     };
     if let Some(curr_val) = link_map.get_mut(&key.clone()) {
         if curr_val.1 != new_val.1 {
+            if !link_instance_enabled() {
+                // When LINK_INST is disabled, prefer Item over ReifyShim.
+                // ReifyShim has no body in items, so Item is more useful.
+                if is_reify_shim(&kind) {
+                    // New entry is ReifyShim, existing is Item → skip
+                    return;
+                }
+                // New entry is Item, existing is ReifyShim → replace
+                curr_val.1 = name;
+                curr_val.0 .0 |= new_val.0 .0;
+                return;
+            }
             panic!(
                 "Added inconsistent entries into link map! {:?} -> {:?}, {:?}",
                 (ty, ty.kind().fn_def(), &kind),
@@ -898,7 +914,27 @@ impl MirVisitor for InternedValueCollector<'_, '_> {
                     panic!("TyConstKind::Value");
                 }
             }
-            ConstantKind::Unevaluated(_) | ConstantKind::Param(_) | ConstantKind::ZeroSized => {}
+            ConstantKind::ZeroSized => {
+                // Zero-sized constants can represent function items (FnDef) used as values,
+                // e.g. when passing a function pointer to a higher-order function.
+                // Ensure such functions are included in the link map so they appear in the
+                // `functions` array of the SMIR JSON.
+                if constant.ty().kind().fn_def().is_some() {
+                    if let Some(inst) = fn_inst_for_ty(constant.ty(), false)
+                        .or_else(|| fn_inst_for_ty(constant.ty(), true))
+                    {
+                        let fn_sym = fn_inst_sym(self.tcx, Some(constant.ty()), Some(&inst));
+                        if let Some((ty, kind, name)) = fn_sym {
+                            update_link_map(
+                                self.link_map,
+                                Some((ty, kind, name)),
+                                ItemSource(FPTR),
+                            );
+                        }
+                    }
+                }
+            }
+            ConstantKind::Unevaluated(_) | ConstantKind::Param(_) => {}
         }
         self.super_mir_const(constant, loc);
     }

tests/integration/normalise-filter.jq

@@ -11,7 +11,7 @@
 # Apply the normalisation filter
 { allocs:    ( .allocs | sort ),
   functions: (.functions | sort ),
-  items:     (.items | sort ),
+  items:     (.items | map(walk(if type == "object" then del(.ty) else . end)) | sort ),
   types: ( [
 # sort by constructors and remove unstable IDs within each
     ( .types | map(select(.[0].PrimitiveType)) | sort ),
@@ -20,7 +20,7 @@
     ( .types | map(select(.[0].StructType) | del(.[0].StructType.adt_def) | .[0].StructType.fields = "elided" ) | sort_by(.[0].StructType.name) ),
     ( .types | map(select(.[0].UnionType) | del(.[0].UnionType.adt_def)) | sort_by(.[0].UnionType.name) ),
   # delete unstable Ty IDs for arrays and tuples
-    ( .types | map(select(.[0].ArrayType) | del(.[0].ArrayType.elem_type) | del(.[0].ArrayType.size.id)) | sort ),
+    ( .types | map(select(.[0].ArrayType) | del(.[0].ArrayType.elem_type) | del(.[0].ArrayType.size.id) | del(.[0].ArrayType.size.kind.Value[0])) | sort ),
     ( .types | map(select(.[0].TupleType) | .[0].TupleType.types = "elided") ),
   # replace unstable Ty IDs for references by zero
     ( .types | map(select(.[0].PtrType) | .[0].PtrType.pointee_type = "elided") | sort ),