perf(analyzer): borrow HIR body in LocalAnalysis instead of double-cloning (Phase 5)

LocalAnalysis::new cloned the HIR function body (`let body = body.cloned()`),
but checks/body/mod.rs already clones each body into an owned `hir_body`
(detached from analyzer.hir, which must stay borrowable for the downstream
check_*(&mut analyzer, ...) calls). LocalAnalysis then cloned that owned copy a
SECOND time. Make LocalAnalysis borrow instead — `struct LocalAnalysis<'a>` with
`body: Option<&'a HirFunctionBody>` — so it references the already-owned body.
Halves per-function body cloning during semantic analysis; all 5 index traversals
and the initial_state/moved_uses/retained/fresh_return methods only read the body.

Behavior-identical: cascade was a mechanical lifetime annotation on the 13
`&LocalAnalysis` params across body/{semantics,resource_pool,effects,binding}.rs;
no diagnostic message/order/span change. Verified: build+clippy clean, runtime
455/0, differential 33/0, checks lib 16/0.

Scope was clone-removal only (pass-fusion deferred). Left load-bearing clones:
checks/calls.rs items.clone() and body/mod.rs functions/hir_body clones (transitive
reads of syntax_program.items / detachment from analyzer.hir make mem::take unsafe),
and hir/infer.rs value_types.cloned() (Cow/&str would cascade across 47 call sites).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/checks/body/binding.rs

@@ -2,7 +2,7 @@ use super::*;
 
 pub(super) fn check_block(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     block: &HirBlock,
     state: &mut BodyState,
     check_resource_contexts: bool,

crates/rsscript/src/checks/body/effects.rs

@@ -209,15 +209,15 @@ pub(super) fn arm_span(arms: &[HirMatchArm]) -> Span {
     )
 }
 
-pub(super) fn check_moved_uses(analyzer: &mut Analyzer<'_>, local_analysis: &LocalAnalysis) {
+pub(super) fn check_moved_uses(analyzer: &mut Analyzer<'_>, local_analysis: &LocalAnalysis<'_>) {
     for moved_use in local_analysis.moved_uses() {
         moved_use_diagnostic(analyzer, moved_use);
     }
 }
 
 pub(super) fn check_managed_to_local_uses(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
 ) {
     for managed_to_local in local_analysis.managed_to_local_uses() {
         managed_to_local_diagnostic(analyzer, managed_to_local);
@@ -226,7 +226,7 @@ pub(super) fn check_managed_to_local_uses(
 
 pub(super) fn check_retained_local_uses(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
 ) {
     for retained in local_analysis.retained_local_uses() {
         retained_local_diagnostic(analyzer, retained);
@@ -235,7 +235,7 @@ pub(super) fn check_retained_local_uses(
 
 pub(super) fn check_retained_closure_captures(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
 ) {
     for capture in local_analysis.retained_closure_captures() {
         retained_closure_capture_diagnostic(analyzer, capture);
@@ -244,7 +244,7 @@ pub(super) fn check_retained_closure_captures(
 
 pub(super) fn check_take_handle_fields(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
 ) {
     for field in local_analysis.take_handle_fields() {
         take_handle_field_diagnostic(analyzer, field);
@@ -253,7 +253,7 @@ pub(super) fn check_take_handle_fields(
 
 pub(super) fn check_fresh_returns(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     function: &FunctionDecl,
 ) {
     if !function.returns_fresh {

crates/rsscript/src/checks/body/resource_pool.rs

@@ -23,7 +23,7 @@ pub(super) fn check_resource_pool_bindings(
 }
 pub(super) fn check_managed_closure_captures(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     statement_span: &crate::diagnostic::Span,
     state: &BodyState,
 ) {
@@ -47,7 +47,7 @@ pub(super) fn check_managed_closure_captures(
 
 pub(super) fn check_resource_escape(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     with_span: &crate::diagnostic::Span,
 ) {
     if let Some(escapes) = local_analysis.resource_escapes(with_span) {
@@ -1698,7 +1698,7 @@ pub(super) fn is_resource_pool_type(type_name: &str) -> bool {
 }
 
 pub(super) fn resource_is_active_at(
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     binding: &str,
     span: &crate::diagnostic::Span,
 ) -> bool {

crates/rsscript/src/checks/body/semantics.rs

@@ -3,7 +3,7 @@ use crate::checks::diagnostic_helpers::error_cause_manual_fix;
 
 pub(super) fn check_stmt_semantics(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     statement: &HirStmt,
     state: &mut BodyState,
     check_resource_contexts: bool,
@@ -342,7 +342,7 @@ pub(super) fn apply_stmt_effects(statement: &HirStmt, state: &mut BodyState) {
 
 pub(super) fn check_expr_semantics(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     expr: &HirExpr,
     state: &BodyState,
     live_after: &HashSet<String>,
@@ -1086,7 +1086,7 @@ pub(super) fn first_mutating_effect_stmt(
 
 pub(super) fn check_expr_semantics_with_context(
     analyzer: &mut Analyzer<'_>,
-    local_analysis: &LocalAnalysis,
+    local_analysis: &LocalAnalysis<'_>,
     expr: &HirExpr,
     state: &BodyState,
     allow_weak_upgrade_arg: bool,

crates/rsscript/src/checks/local.rs

@@ -76,8 +76,8 @@ pub(crate) struct FreshReturnIssue {
     pub(crate) span: Span,
 }
 
-pub(crate) struct LocalAnalysis {
-    body: Option<HirFunctionBody>,
+pub(crate) struct LocalAnalysis<'a> {
+    body: Option<&'a HirFunctionBody>,
     managed_closure_uses_by_span: HashMap<Span, Vec<(String, Span)>>,
     resource_escapes_by_with_span: HashMap<Span, Vec<ResourceEscape>>,
     take_handle_fields: Vec<TakeHandleField>,
@@ -149,27 +149,22 @@ pub(crate) struct ResourceEscape {
     pub(crate) span: Span,
 }
 
-impl LocalAnalysis {
-    pub(crate) fn new(body: Option<&HirFunctionBody>) -> Self {
-        let body = body.cloned();
+impl<'a> LocalAnalysis<'a> {
+    pub(crate) fn new(body: Option<&'a HirFunctionBody>) -> Self {
         let managed_closure_uses_by_span = body
-            .as_ref()
             .and_then(|body| body.block.as_ref())
             .map_or_else(HashMap::new, index_managed_closure_uses_from_block);
         let resource_escapes_by_with_span = body
-            .as_ref()
             .and_then(|body| body.block.as_ref())
             .map_or_else(HashMap::new, index_resource_escapes_from_block);
         let take_handle_fields = body
-            .as_ref()
             .and_then(|body| body.block.as_ref())
             .map_or_else(Vec::new, collect_take_handle_fields);
         let flow_steps = body
-            .as_ref()
             .and_then(|body| body.block.as_ref())
             .map_or_else(Vec::new, collect_local_flow_steps);
         let flow_entry_states_by_span =
-            collect_flow_entry_states(&flow_steps, initial_state_from_body(body.as_ref()));
+            collect_flow_entry_states(&flow_steps, initial_state_from_body(body));
 
         Self {
             body,
@@ -182,7 +177,7 @@ impl LocalAnalysis {
     }
 
     pub(crate) fn initial_state(&self) -> BodyState {
-        initial_state_from_body(self.body.as_ref())
+        initial_state_from_body(self.body)
     }
 
     pub(crate) fn managed_closure_ident_uses(&self, span: &Span) -> Option<&[(String, Span)]> {
@@ -207,7 +202,7 @@ impl LocalAnalysis {
 
     pub(crate) fn moved_uses(&self) -> Vec<MovedUse> {
         let mut moved_uses = Vec::new();
-        if let Some(block) = self.body.as_ref().and_then(|body| body.block.as_ref()) {
+        if let Some(block) = self.body.and_then(|body| body.block.as_ref()) {
             collect_ordered_moved_uses_from_block(
                 block,
                 &self.flow_entry_states_by_span,
@@ -278,7 +273,7 @@ impl LocalAnalysis {
 
     pub(crate) fn retained_closure_captures(&self) -> Vec<RetainedClosureCapture> {
         let mut captures = Vec::new();
-        if let Some(block) = self.body.as_ref().and_then(|body| body.block.as_ref()) {
+        if let Some(block) = self.body.and_then(|body| body.block.as_ref()) {
             collect_retained_closure_captures_from_block(
                 block,
                 &self.flow_entry_states_by_span,
@@ -290,7 +285,7 @@ impl LocalAnalysis {
 
     pub(crate) fn fresh_return_issues(&self) -> Vec<FreshReturnIssue> {
         let mut issues = Vec::new();
-        if let Some(block) = self.body.as_ref().and_then(|body| body.block.as_ref()) {
+        if let Some(block) = self.body.and_then(|body| body.block.as_ref()) {
             collect_fresh_return_issues_from_block(
                 block,
                 &self.flow_entry_states_by_span,