coverage: Extract helper for getting HIR info for coverage

Author: Zalathar

compiler/rustc_middle/src/mir/coverage.rs

@@ -2,7 +2,7 @@
 
 use rustc_index::IndexVec;
 use rustc_macros::HashStable;
-use rustc_span::Symbol;
+use rustc_span::{Span, Symbol};
 
 use std::fmt::{self, Debug, Formatter};
 
@@ -176,3 +176,15 @@ pub struct FunctionCoverageInfo {
     pub expressions: IndexVec<ExpressionId, Expression>,
     pub mappings: Vec<Mapping>,
 }
+
+/// Coverage information captured from HIR/THIR during MIR building.
+///
+/// A MIR body that does not have this information cannot be instrumented for
+/// coverage.
+#[derive(Clone, Debug)]
+#[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
+pub struct HirInfo {
+    pub function_source_hash: u64,
+    pub fn_sig_span: Span,
+    pub body_span: Span,
+}

compiler/rustc_mir_transform/src/coverage/mod.rs

@@ -22,7 +22,7 @@ use rustc_middle::mir::{
     TerminatorKind,
 };
 use rustc_middle::ty::TyCtxt;
-use rustc_span::def_id::{DefId, LocalDefId};
+use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{ExpnKind, SourceFile, Span, Symbol};
 
@@ -77,29 +77,15 @@ struct Instrumentor<'a, 'tcx> {
 impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
     fn new(tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>) -> Self {
         let source_map = tcx.sess.source_map();
-        let def_id = mir_body.source.def_id();
-        let (some_fn_sig, hir_body) = fn_sig_and_body(tcx, def_id);
 
-        let body_span = get_body_span(tcx, hir_body, mir_body);
+        let def_id = mir_body.source.def_id().expect_local();
+        let mir::coverage::HirInfo { function_source_hash, fn_sig_span, body_span, .. } =
+            make_coverage_hir_info(tcx, def_id);
 
         let source_file = source_map.lookup_source_file(body_span.lo());
-        let fn_sig_span = match some_fn_sig.filter(|fn_sig| {
-            fn_sig.span.eq_ctxt(body_span)
-                && Lrc::ptr_eq(&source_file, &source_map.lookup_source_file(fn_sig.span.lo()))
-        }) {
-            Some(fn_sig) => fn_sig.span.with_hi(body_span.lo()),
-            None => body_span.shrink_to_lo(),
-        };
-
-        debug!(
-            "instrumenting {}: {:?}, fn sig span: {:?}, body span: {:?}",
-            if tcx.is_closure(def_id) { "closure" } else { "function" },
-            def_id,
-            fn_sig_span,
-            body_span
-        );
 
-        let function_source_hash = hash_mir_source(tcx, hir_body);
+        debug!(?fn_sig_span, ?body_span, "instrumenting {def_id:?}",);
+
         let basic_coverage_blocks = CoverageGraph::from_mir(mir_body);
         let coverage_counters = CoverageCounters::new(&basic_coverage_blocks);
 
@@ -327,13 +313,33 @@ fn is_eligible_for_coverage(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     true
 }
 
+fn make_coverage_hir_info(tcx: TyCtxt<'_>, def_id: LocalDefId) -> mir::coverage::HirInfo {
+    let source_map = tcx.sess.source_map();
+    let (some_fn_sig, hir_body) = fn_sig_and_body(tcx, def_id);
+
+    let body_span = get_body_span(tcx, hir_body, def_id);
+
+    let source_file = source_map.lookup_source_file(body_span.lo());
+    let fn_sig_span = match some_fn_sig.filter(|fn_sig| {
+        fn_sig.span.eq_ctxt(body_span)
+            && Lrc::ptr_eq(&source_file, &source_map.lookup_source_file(fn_sig.span.lo()))
+    }) {
+        Some(fn_sig) => fn_sig.span.with_hi(body_span.lo()),
+        None => body_span.shrink_to_lo(),
+    };
+
+    let function_source_hash = hash_mir_source(tcx, hir_body);
+
+    mir::coverage::HirInfo { function_source_hash, fn_sig_span, body_span }
+}
+
 fn fn_sig_and_body(
     tcx: TyCtxt<'_>,
-    def_id: DefId,
+    def_id: LocalDefId,
 ) -> (Option<&rustc_hir::FnSig<'_>>, &rustc_hir::Body<'_>) {
     // FIXME(#79625): Consider improving MIR to provide the information needed, to avoid going back
     // to HIR for it.
-    let hir_node = tcx.hir().get_if_local(def_id).expect("expected DefId is local");
+    let hir_node = tcx.hir().get_by_def_id(def_id);
     let (_, fn_body_id) =
         hir::map::associated_body(hir_node).expect("HIR node is a function with body");
     (hir_node.fn_sig(), tcx.hir().body(fn_body_id))
@@ -342,12 +348,11 @@ fn fn_sig_and_body(
 fn get_body_span<'tcx>(
     tcx: TyCtxt<'tcx>,
     hir_body: &rustc_hir::Body<'tcx>,
-    mir_body: &mut mir::Body<'tcx>,
+    def_id: LocalDefId,
 ) -> Span {
     let mut body_span = hir_body.value.span;
-    let def_id = mir_body.source.def_id();
 
-    if tcx.is_closure(def_id) {
+    if tcx.is_closure(def_id.to_def_id()) {
         // If the MIR function is a closure, and if the closure body span
         // starts from a macro, but it's content is not in that macro, try
         // to find a non-macro callsite, and instrument the spans there