Use HIR local analysis for resource retain escapes

Author: olwang

README.md

@@ -25,7 +25,7 @@ It currently implements:
 - Per-function HIR body views that group bindings, calls, fields, effects, and returns
 - AST-driven mode and call checks for local-only features, named arguments, data effects, and retaining APIs
 - AST-driven body checks for local moves, early-exit-aware `fresh` returns, resource escape, resolved handle-field `take`, and managed closure captures
-- Local ownership effect application now indexes binding types and move/retain events from resolved HIR body trees
+- Local ownership and resource-retain escape checks now index binding types and move/retain events from resolved HIR body trees
 - Focused check modules for mode, calls, body semantics, and forbidden operator behavior
 - Fixture-based pass/fail scenario tests under `tests/fixtures`
 

src/checks/body.rs

@@ -1,8 +1,6 @@
 use crate::analyzer::Analyzer;
 use crate::diagnostic::{Diagnostic, code};
-use crate::hir::{
-    CallResolution, HirEffectEventKind, HirReturnProof, HirTypeKind, ResolvedCalleeKind,
-};
+use crate::hir::{CallResolution, HirReturnProof, HirTypeKind, ResolvedCalleeKind};
 use crate::syntax::ast::{Block, Callee, DataEffect, Expr, FunctionDecl, Item, LetKind, Stmt};
 
 use super::local::{BodyState, LocalAnalysis, merge_if_state, merge_loop_state};
@@ -110,7 +108,7 @@ fn check_stmt_semantics(
             Flow::Return
         }
         Stmt::With(stmt) => {
-            check_resource_escape(analyzer, &stmt.binding, &stmt.body);
+            check_resource_escape(analyzer, local_analysis, &stmt.binding, &stmt.body);
             check_block(analyzer, local_analysis, function, &stmt.body, state)
         }
         Stmt::If(stmt) => {
@@ -383,7 +381,12 @@ fn check_take_of_handle_in_stmt(analyzer: &mut Analyzer<'_>, statement: &Stmt, s
     }
 }
 
-fn check_resource_escape(analyzer: &mut Analyzer<'_>, binding: &str, body: &Block) {
+fn check_resource_escape(
+    analyzer: &mut Analyzer<'_>,
+    local_analysis: &LocalAnalysis,
+    binding: &str,
+    body: &Block,
+) {
     for statement in &body.statements {
         match statement {
             Stmt::Return(stmt) => {
@@ -393,7 +396,7 @@ fn check_resource_escape(analyzer: &mut Analyzer<'_>, binding: &str, body: &Bloc
                     resource_escape_diagnostic(analyzer, binding, span.clone());
                 }
                 if let Some(value) = &stmt.value {
-                    check_resource_escape_expr(analyzer, binding, value);
+                    check_resource_escape_expr(analyzer, local_analysis, binding, value);
                 }
             }
             Stmt::Let(stmt) => {
@@ -404,73 +407,73 @@ fn check_resource_escape(analyzer: &mut Analyzer<'_>, binding: &str, body: &Bloc
                     resource_capture_diagnostic(analyzer, binding, span.clone());
                 }
                 if let Some(value) = &stmt.value {
-                    check_resource_escape_expr(analyzer, binding, value);
+                    check_resource_escape_expr(analyzer, local_analysis, binding, value);
                 }
             }
-            Stmt::Expr(expr) => check_resource_escape_expr(analyzer, binding, expr),
-            Stmt::With(stmt) => check_resource_escape(analyzer, binding, &stmt.body),
+            Stmt::Expr(expr) => check_resource_escape_expr(analyzer, local_analysis, binding, expr),
+            Stmt::With(stmt) => {
+                check_resource_escape(analyzer, local_analysis, binding, &stmt.body)
+            }
             Stmt::If(stmt) => {
-                check_resource_escape_expr(analyzer, binding, &stmt.condition);
-                check_resource_escape(analyzer, binding, &stmt.then_body);
+                check_resource_escape_expr(analyzer, local_analysis, binding, &stmt.condition);
+                check_resource_escape(analyzer, local_analysis, binding, &stmt.then_body);
                 if let Some(else_body) = &stmt.else_body {
-                    check_resource_escape(analyzer, binding, else_body);
+                    check_resource_escape(analyzer, local_analysis, binding, else_body);
                 }
             }
             Stmt::Loop(stmt) => {
                 if let Some(condition) = &stmt.condition {
-                    check_resource_escape_expr(analyzer, binding, condition);
+                    check_resource_escape_expr(analyzer, local_analysis, binding, condition);
                 }
-                check_resource_escape(analyzer, binding, &stmt.body);
+                check_resource_escape(analyzer, local_analysis, binding, &stmt.body);
             }
             Stmt::Break(_) | Stmt::Continue(_) => {}
             Stmt::Unknown(_) => {}
         }
     }
 }
 
-fn check_resource_escape_expr(analyzer: &mut Analyzer<'_>, binding: &str, expr: &Expr) {
+fn check_resource_escape_expr(
+    analyzer: &mut Analyzer<'_>,
+    local_analysis: &LocalAnalysis,
+    binding: &str,
+    expr: &Expr,
+) {
     match expr {
         Expr::Manage { value, span } => {
             if let Expr::Ident(name, _) = value.as_ref()
                 && name == binding
             {
                 resource_escape_diagnostic(analyzer, binding, span.clone());
             }
-            check_resource_escape_expr(analyzer, binding, value);
+            check_resource_escape_expr(analyzer, local_analysis, binding, value);
+        }
+        Expr::Effect { value, .. } => {
+            check_resource_escape_expr(analyzer, local_analysis, binding, value);
         }
-        Expr::Effect { value, .. } => check_resource_escape_expr(analyzer, binding, value),
         Expr::Call { args, span, .. } => {
-            check_resource_retained_by_call(analyzer, binding, span);
+            check_resource_retained_by_call(analyzer, local_analysis, binding, span);
             for arg in args {
-                check_resource_escape_expr(analyzer, binding, &arg.value);
+                check_resource_escape_expr(analyzer, local_analysis, binding, &arg.value);
             }
         }
-        Expr::Field { base, .. } => check_resource_escape_expr(analyzer, binding, base),
-        Expr::Closure { body, .. } => check_resource_escape(analyzer, binding, body),
+        Expr::Field { base, .. } => {
+            check_resource_escape_expr(analyzer, local_analysis, binding, base);
+        }
+        Expr::Closure { body, .. } => {
+            check_resource_escape(analyzer, local_analysis, binding, body)
+        }
         Expr::Ident(_, _) | Expr::Number(_, _) | Expr::String(_, _) | Expr::Unknown(_) => {}
     }
 }
 
 fn check_resource_retained_by_call(
     analyzer: &mut Analyzer<'_>,
+    local_analysis: &LocalAnalysis,
     binding: &str,
     span: &crate::diagnostic::Span,
 ) {
-    let escaping_spans: Vec<crate::diagnostic::Span> = analyzer
-        .hir
-        .effect_events(span)
-        .iter()
-        .filter_map(|event| {
-            if matches!(event.kind, HirEffectEventKind::Retain { .. })
-                && event.binding_name == binding
-            {
-                Some(event.value_span.clone())
-            } else {
-                None
-            }
-        })
-        .collect();
-    for escaping_span in escaping_spans {
+    for escaping_span in local_analysis.retained_value_spans(span, binding) {
         resource_escape_diagnostic(analyzer, binding, escaping_span);
     }
 }

src/checks/local.rs

@@ -58,6 +58,21 @@ impl LocalAnalysis {
         state.apply_retention_events(self.effect_events(span));
     }
 
+    pub(crate) fn retained_value_spans(&self, span: &Span, binding: &str) -> Vec<Span> {
+        self.effect_events(span)
+            .iter()
+            .filter_map(|event| {
+                if matches!(event.kind, HirEffectEventKind::Retain { .. })
+                    && event.binding_name == binding
+                {
+                    Some(event.value_span.clone())
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
     pub(crate) fn binding_type(&self, span: &Span) -> Option<&str> {
         self.binding_types_by_span.get(span).map(String::as_str)
     }
@@ -528,6 +543,10 @@ mod tests {
 
         assert_eq!(state.value_type("pool"), Some("ResourcePool<File>"));
         assert_eq!(local_analysis.binding_type(&span(2)), Some("Image"));
+        assert_eq!(
+            local_analysis.retained_value_spans(&span(20), "cached"),
+            vec![span(20)]
+        );
 
         local_analysis.apply_retention_events(&span(20), &mut state);
         local_analysis.apply_move_events(&span(21), &mut state);

src/hir.rs

@@ -283,7 +283,6 @@ pub struct Hir {
     field_accesses: Vec<HirFieldAccess>,
     field_accesses_by_span: HashMap<Span, HirFieldAccess>,
     effect_events: Vec<HirEffectEvent>,
-    effect_events_by_span: HashMap<Span, Vec<HirEffectEvent>>,
     returns: Vec<HirReturn>,
     returns_by_span: HashMap<Span, HirReturn>,
     function_bodies: HashMap<String, HirFunctionBody>,
@@ -375,12 +374,6 @@ impl Hir {
         self.field_accesses_by_span.get(span)
     }
 
-    pub fn effect_events(&self, span: &Span) -> &[HirEffectEvent] {
-        self.effect_events_by_span
-            .get(span)
-            .map_or(&[], Vec::as_slice)
-    }
-
     pub fn return_fact(&self, span: &Span) -> Option<&HirReturn> {
         self.returns_by_span.get(span)
     }
@@ -457,16 +450,6 @@ impl Hir {
             .iter()
             .map(|field| (field.span.clone(), field.clone()))
             .collect();
-        self.effect_events_by_span = facts.effect_events.iter().fold(
-            HashMap::<Span, Vec<HirEffectEvent>>::new(),
-            |mut by_span, event| {
-                by_span
-                    .entry(event.span.clone())
-                    .or_default()
-                    .push(event.clone());
-                by_span
-            },
-        );
         self.returns_by_span = facts
             .returns
             .iter()
@@ -1946,7 +1929,13 @@ fn publish(cache: mut ImageCache, path: read Path) -> Unit {
             HirEffectEventKind::Take
         ));
         assert_eq!(hir.effect_events[2].binding_name, "image");
-        assert_eq!(hir.effect_events(&hir.effect_events[0].span).len(), 1);
+        assert_eq!(
+            hir.function_body("publish")
+                .expect("publish body exists")
+                .effect_events
+                .len(),
+            3
+        );
     }
 
     #[test]