Resolve handle field checks through local HIR analysis

olwang · olwang · commit 833ae67eb5e0 · 2026-05-27T21:24:18.000-07:00
diff --git a/README.md b/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 and resource-retain escape checks now index binding types and move/retain events from resolved HIR body trees
+- Local ownership, resource-retain escape, and handle-field `take` checks now index binding types, field accesses, 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`
 
diff --git a/src/checks/body.rs b/src/checks/body.rs
@@ -94,7 +94,7 @@ fn check_stmt_semantics(
             }
 
             if let Some(value) = &stmt.value {
-                check_take_of_handle_field(analyzer, value, state);
+                check_take_of_handle_field(analyzer, local_analysis, value, state);
             }
             Flow::Fallthrough
         }
@@ -103,7 +103,7 @@ fn check_stmt_semantics(
                 if function.returns_fresh {
                     check_fresh_return(analyzer, function, value, state);
                 }
-                check_take_of_handle_field(analyzer, value, state);
+                check_take_of_handle_field(analyzer, local_analysis, value, state);
             }
             Flow::Return
         }
@@ -112,7 +112,7 @@ fn check_stmt_semantics(
             check_block(analyzer, local_analysis, function, &stmt.body, state)
         }
         Stmt::If(stmt) => {
-            check_take_of_handle_field(analyzer, &stmt.condition, state);
+            check_take_of_handle_field(analyzer, local_analysis, &stmt.condition, state);
             apply_expr_effects(local_analysis, &stmt.condition, state);
 
             let base_state = state.clone();
@@ -141,7 +141,7 @@ fn check_stmt_semantics(
         }
         Stmt::Loop(stmt) => {
             if let Some(condition) = &stmt.condition {
-                check_take_of_handle_field(analyzer, condition, state);
+                check_take_of_handle_field(analyzer, local_analysis, condition, state);
                 apply_expr_effects(local_analysis, condition, state);
             }
 
@@ -164,7 +164,7 @@ fn check_stmt_semantics(
             )
         }
         Stmt::Expr(expr) => {
-            check_take_of_handle_field(analyzer, expr, state);
+            check_take_of_handle_field(analyzer, local_analysis, expr, state);
             Flow::Fallthrough
         }
         Stmt::Break(_) => Flow::Break,
@@ -295,7 +295,12 @@ fn check_managed_closure_captures(analyzer: &mut Analyzer<'_>, body: &Block, sta
     }
 }
 
-fn check_take_of_handle_field(analyzer: &mut Analyzer<'_>, expr: &Expr, state: &BodyState) {
+fn check_take_of_handle_field(
+    analyzer: &mut Analyzer<'_>,
+    local_analysis: &LocalAnalysis,
+    expr: &Expr,
+    state: &BodyState,
+) {
     match expr {
         Expr::Effect {
             effect: DataEffect::Take,
@@ -307,7 +312,7 @@ fn check_take_of_handle_field(analyzer: &mut Analyzer<'_>, expr: &Expr, state: &
                 name,
                 span: field_span,
             } = value.as_ref()
-                && is_handle_field(analyzer, state, base, name, field_span)
+                && is_handle_field(analyzer, local_analysis, state, base, name, field_span)
             {
                 analyzer.diagnostics.push(
                     Diagnostic::error(
@@ -319,63 +324,74 @@ fn check_take_of_handle_field(analyzer: &mut Analyzer<'_>, expr: &Expr, state: &
                     .with_cause("Handle fields are managed references and cannot be consumed as local inline values."),
                 );
             }
-            check_take_of_handle_field(analyzer, value, state);
+            check_take_of_handle_field(analyzer, local_analysis, value, state);
+        }
+        Expr::Effect { value, .. } => {
+            check_take_of_handle_field(analyzer, local_analysis, value, state);
+        }
+        Expr::Manage { value, .. } => {
+            check_take_of_handle_field(analyzer, local_analysis, value, state);
         }
-        Expr::Effect { value, .. } => check_take_of_handle_field(analyzer, value, state),
-        Expr::Manage { value, .. } => check_take_of_handle_field(analyzer, value, state),
         Expr::Call { args, .. } => {
             for arg in args {
-                check_take_of_handle_field(analyzer, &arg.value, state);
+                check_take_of_handle_field(analyzer, local_analysis, &arg.value, state);
             }
         }
-        Expr::Field { base, .. } => check_take_of_handle_field(analyzer, base, state),
+        Expr::Field { base, .. } => {
+            check_take_of_handle_field(analyzer, local_analysis, base, state);
+        }
         Expr::Closure { body, .. } => {
             for statement in &body.statements {
-                check_take_of_handle_in_stmt(analyzer, statement, state);
+                check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);
             }
         }
         Expr::Ident(_, _) | Expr::Number(_, _) | Expr::String(_, _) | Expr::Unknown(_) => {}
     }
 }
 
-fn check_take_of_handle_in_stmt(analyzer: &mut Analyzer<'_>, statement: &Stmt, state: &BodyState) {
+fn check_take_of_handle_in_stmt(
+    analyzer: &mut Analyzer<'_>,
+    local_analysis: &LocalAnalysis,
+    statement: &Stmt,
+    state: &BodyState,
+) {
     match statement {
         Stmt::Let(stmt) => {
             if let Some(value) = &stmt.value {
-                check_take_of_handle_field(analyzer, value, state);
+                check_take_of_handle_field(analyzer, local_analysis, value, state);
             }
         }
         Stmt::Return(stmt) => {
             if let Some(value) = &stmt.value {
-                check_take_of_handle_field(analyzer, value, state);
+                check_take_of_handle_field(analyzer, local_analysis, value, state);
             }
         }
         Stmt::With(stmt) => {
-            check_take_of_handle_field(analyzer, &stmt.resource, state);
+            check_take_of_handle_field(analyzer, local_analysis, &stmt.resource, state);
             for statement in &stmt.body.statements {
-                check_take_of_handle_in_stmt(analyzer, statement, state);
+                check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);
             }
         }
         Stmt::If(stmt) => {
-            check_take_of_handle_field(analyzer, &stmt.condition, state);
+            check_take_of_handle_field(analyzer, local_analysis, &stmt.condition, state);
             for statement in &stmt.then_body.statements {
-                check_take_of_handle_in_stmt(analyzer, statement, state);
+                check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);
             }
             if let Some(else_body) = &stmt.else_body {
                 for statement in &else_body.statements {
-                    check_take_of_handle_in_stmt(analyzer, statement, state);
+                    check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);
                 }
             }
         }
         Stmt::Loop(stmt) => {
             if let Some(condition) = &stmt.condition {
-                check_take_of_handle_field(analyzer, condition, state);
+                check_take_of_handle_field(analyzer, local_analysis, condition, state);
             }
             for statement in &stmt.body.statements {
-                check_take_of_handle_in_stmt(analyzer, statement, state);
+                check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);
             }
         }
-        Stmt::Expr(expr) => check_take_of_handle_field(analyzer, expr, state),
+        Stmt::Expr(expr) => check_take_of_handle_field(analyzer, local_analysis, expr, state),
         Stmt::Break(_) | Stmt::Continue(_) => {}
         Stmt::Unknown(_) => {}
     }
@@ -676,12 +692,13 @@ fn infer_call_type(
 
 fn is_handle_field(
     analyzer: &Analyzer<'_>,
+    local_analysis: &LocalAnalysis,
     state: &BodyState,
     base: &Expr,
     field_name: &str,
     field_span: &crate::diagnostic::Span,
 ) -> bool {
-    if let Some(field) = analyzer.hir.field_access(field_span) {
+    if let Some(field) = local_analysis.field_access(field_span) {
         return field.is_handle;
     }
 
diff --git a/src/checks/local.rs b/src/checks/local.rs
@@ -3,7 +3,7 @@ use std::collections::{HashMap, HashSet};
 use crate::diagnostic::Span;
 use crate::hir::{
     HirBinding, HirBindingKind, HirBlock, HirEffectEvent, HirEffectEventKind, HirExpr,
-    HirFunctionBody, HirStmt,
+    HirFieldAccess, HirFunctionBody, HirStmt,
 };
 
 use super::body::Flow;
@@ -21,6 +21,7 @@ pub(crate) struct LocalAnalysis {
     body: Option<HirFunctionBody>,
     events_by_span: HashMap<Span, Vec<HirEffectEvent>>,
     binding_types_by_span: HashMap<Span, String>,
+    field_accesses_by_span: HashMap<Span, HirFieldAccess>,
 }
 
 impl LocalAnalysis {
@@ -34,11 +35,16 @@ impl LocalAnalysis {
             .as_ref()
             .and_then(|body| body.block.as_ref())
             .map_or_else(HashMap::new, index_binding_types_from_block);
+        let field_accesses_by_span = body
+            .as_ref()
+            .and_then(|body| body.block.as_ref())
+            .map_or_else(HashMap::new, index_field_accesses_from_block);
 
         Self {
             body,
             events_by_span,
             binding_types_by_span,
+            field_accesses_by_span,
         }
     }
 
@@ -77,6 +83,10 @@ impl LocalAnalysis {
         self.binding_types_by_span.get(span).map(String::as_str)
     }
 
+    pub(crate) fn field_access(&self, span: &Span) -> Option<&HirFieldAccess> {
+        self.field_accesses_by_span.get(span)
+    }
+
     fn effect_events(&self, span: &Span) -> &[HirEffectEvent] {
         self.events_by_span.get(span).map_or(&[], Vec::as_slice)
     }
@@ -230,6 +240,83 @@ fn collect_stmt_binding_types(statement: &HirStmt, types: &mut HashMap<Span, Str
     }
 }
 
+fn index_field_accesses_from_block(block: &HirBlock) -> HashMap<Span, HirFieldAccess> {
+    let mut accesses = HashMap::new();
+    collect_block_field_accesses(block, &mut accesses);
+    accesses
+}
+
+fn collect_block_field_accesses(block: &HirBlock, accesses: &mut HashMap<Span, HirFieldAccess>) {
+    for statement in &block.statements {
+        collect_stmt_field_accesses(statement, accesses);
+    }
+}
+
+fn collect_stmt_field_accesses(statement: &HirStmt, accesses: &mut HashMap<Span, HirFieldAccess>) {
+    match statement {
+        HirStmt::Let {
+            value: Some(value), ..
+        }
+        | HirStmt::Return {
+            value: Some(value), ..
+        }
+        | HirStmt::Expr(value) => collect_expr_field_accesses(value, accesses),
+        HirStmt::With { resource, body, .. } => {
+            collect_expr_field_accesses(resource, accesses);
+            collect_block_field_accesses(body, accesses);
+        }
+        HirStmt::If {
+            condition,
+            then_body,
+            else_body,
+            ..
+        } => {
+            collect_expr_field_accesses(condition, accesses);
+            collect_block_field_accesses(then_body, accesses);
+            if let Some(else_body) = else_body {
+                collect_block_field_accesses(else_body, accesses);
+            }
+        }
+        HirStmt::Loop {
+            condition, body, ..
+        } => {
+            if let Some(condition) = condition {
+                collect_expr_field_accesses(condition, accesses);
+            }
+            collect_block_field_accesses(body, accesses);
+        }
+        HirStmt::Let { value: None, .. }
+        | HirStmt::Return { value: None, .. }
+        | HirStmt::Break(_)
+        | HirStmt::Continue(_)
+        | HirStmt::Unknown(_) => {}
+    }
+}
+
+fn collect_expr_field_accesses(expr: &HirExpr, accesses: &mut HashMap<Span, HirFieldAccess>) {
+    match expr {
+        HirExpr::Field {
+            base, access, span, ..
+        } => {
+            accesses.insert(span.clone(), access.clone());
+            collect_expr_field_accesses(base, accesses);
+        }
+        HirExpr::Call { args, .. } => {
+            for arg in args {
+                collect_expr_field_accesses(&arg.value, accesses);
+            }
+        }
+        HirExpr::Effect { value, .. } | HirExpr::Manage { value, .. } => {
+            collect_expr_field_accesses(value, accesses);
+        }
+        HirExpr::Closure { body, .. } => collect_block_field_accesses(body, accesses),
+        HirExpr::Ident { .. }
+        | HirExpr::Number { .. }
+        | HirExpr::String { .. }
+        | HirExpr::Unknown(_) => {}
+    }
+}
+
 impl BodyState {
     pub(crate) fn seed_params(&mut self, bindings: &[HirBinding]) {
         for binding in bindings {
@@ -435,7 +522,7 @@ fn merge_fallthrough_states(base: &BodyState, left: &BodyState, right: &BodyStat
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::hir::{CallResolution, HirBlock, HirExpr, HirStmt};
+    use crate::hir::{CallResolution, HirBlock, HirExpr, HirFieldAccess, HirStmt};
     use crate::syntax::ast::Callee;
 
     fn span(line: usize) -> Span {
@@ -531,6 +618,23 @@ mod tests {
                         type_name: Some("Image".to_string()),
                         span: span(21),
                     }),
+                    HirStmt::Expr(HirExpr::Field {
+                        base: Box::new(HirExpr::Ident {
+                            name: "config".to_string(),
+                            type_name: Some("Config".to_string()),
+                            span: span(22),
+                        }),
+                        name: "rules".to_string(),
+                        access: HirFieldAccess {
+                            function_name: "run".to_string(),
+                            name: "rules".to_string(),
+                            span: span(22),
+                            base_type: Some("Config".to_string()),
+                            type_name: Some("Rules".to_string()),
+                            is_handle: true,
+                        },
+                        span: span(22),
+                    }),
                 ],
                 span: span(1),
             }),
@@ -547,6 +651,11 @@ mod tests {
             local_analysis.retained_value_spans(&span(20), "cached"),
             vec![span(20)]
         );
+        assert!(
+            local_analysis
+                .field_access(&span(22))
+                .is_some_and(|access| access.is_handle)
+        );
 
         local_analysis.apply_retention_events(&span(20), &mut state);
         local_analysis.apply_move_events(&span(21), &mut state);
diff --git a/src/hir.rs b/src/hir.rs

Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ fn check_stmt_semantics(`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`if let Some(value) = &stmt.value {`
`97`		`- check_take_of_handle_field(analyzer, value, state);`
	`97`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
`98`	`98`	`}`
`99`	`99`	`Flow::Fallthrough`
`100`	`100`	`}`
`@@ -103,7 +103,7 @@ fn check_stmt_semantics(`
`103`	`103`	`if function.returns_fresh {`
`104`	`104`	`check_fresh_return(analyzer, function, value, state);`
`105`	`105`	`}`
`106`		`- check_take_of_handle_field(analyzer, value, state);`
	`106`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
`107`	`107`	`}`
`108`	`108`	`Flow::Return`
`109`	`109`	`}`
`@@ -112,7 +112,7 @@ fn check_stmt_semantics(`
`112`	`112`	`check_block(analyzer, local_analysis, function, &stmt.body, state)`
`113`	`113`	`}`
`114`	`114`	`Stmt::If(stmt) => {`
`115`		`- check_take_of_handle_field(analyzer, &stmt.condition, state);`
	`115`	`+ check_take_of_handle_field(analyzer, local_analysis, &stmt.condition, state);`
`116`	`116`	`apply_expr_effects(local_analysis, &stmt.condition, state);`
`117`	`117`
`118`	`118`	`let base_state = state.clone();`
`@@ -141,7 +141,7 @@ fn check_stmt_semantics(`
`141`	`141`	`}`
`142`	`142`	`Stmt::Loop(stmt) => {`
`143`	`143`	`if let Some(condition) = &stmt.condition {`
`144`		`- check_take_of_handle_field(analyzer, condition, state);`
	`144`	`+ check_take_of_handle_field(analyzer, local_analysis, condition, state);`
`145`	`145`	`apply_expr_effects(local_analysis, condition, state);`
`146`	`146`	`}`
`147`	`147`
`@@ -164,7 +164,7 @@ fn check_stmt_semantics(`
`164`	`164`	`)`
`165`	`165`	`}`
`166`	`166`	`Stmt::Expr(expr) => {`
`167`		`- check_take_of_handle_field(analyzer, expr, state);`
	`167`	`+ check_take_of_handle_field(analyzer, local_analysis, expr, state);`
`168`	`168`	`Flow::Fallthrough`
`169`	`169`	`}`
`170`	`170`	`Stmt::Break(_) => Flow::Break,`
`@@ -295,7 +295,12 @@ fn check_managed_closure_captures(analyzer: &mut Analyzer<'_>, body: &Block, sta`
`295`	`295`	`}`
`296`	`296`	`}`
`297`	`297`
`298`		`-fn check_take_of_handle_field(analyzer: &mut Analyzer<'_>, expr: &Expr, state: &BodyState) {`
	`298`	`+fn check_take_of_handle_field(`
	`299`	`+ analyzer: &mut Analyzer<'_>,`
	`300`	`+ local_analysis: &LocalAnalysis,`
	`301`	`+ expr: &Expr,`
	`302`	`+ state: &BodyState,`
	`303`	`+) {`
`299`	`304`	`match expr {`
`300`	`305`	`Expr::Effect {`
`301`	`306`	`effect: DataEffect::Take,`
`@@ -307,7 +312,7 @@ fn check_take_of_handle_field(analyzer: &mut Analyzer<'_>, expr: &Expr, state: &`
`307`	`312`	`name,`
`308`	`313`	`span: field_span,`
`309`	`314`	`} = value.as_ref()`
`310`		`- && is_handle_field(analyzer, state, base, name, field_span)`
	`315`	`+ && is_handle_field(analyzer, local_analysis, state, base, name, field_span)`
`311`	`316`	`{`
`312`	`317`	`analyzer.diagnostics.push(`
`313`	`318`	`Diagnostic::error(`
`@@ -319,63 +324,74 @@ fn check_take_of_handle_field(analyzer: &mut Analyzer<'_>, expr: &Expr, state: &`
`319`	`324`	`.with_cause("Handle fields are managed references and cannot be consumed as local inline values."),`
`320`	`325`	`);`
`321`	`326`	`}`
`322`		`- check_take_of_handle_field(analyzer, value, state);`
	`327`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
	`328`	`+ }`
	`329`	`+ Expr::Effect { value, .. } => {`
	`330`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
	`331`	`+ }`
	`332`	`+ Expr::Manage { value, .. } => {`
	`333`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
`323`	`334`	`}`
`324`		`- Expr::Effect { value, .. } => check_take_of_handle_field(analyzer, value, state),`
`325`		`- Expr::Manage { value, .. } => check_take_of_handle_field(analyzer, value, state),`
`326`	`335`	`Expr::Call { args, .. } => {`
`327`	`336`	`for arg in args {`
`328`		`- check_take_of_handle_field(analyzer, &arg.value, state);`
	`337`	`+ check_take_of_handle_field(analyzer, local_analysis, &arg.value, state);`
`329`	`338`	`}`
`330`	`339`	`}`
`331`		`- Expr::Field { base, .. } => check_take_of_handle_field(analyzer, base, state),`
	`340`	`+ Expr::Field { base, .. } => {`
	`341`	`+ check_take_of_handle_field(analyzer, local_analysis, base, state);`
	`342`	`+ }`
`332`	`343`	`Expr::Closure { body, .. } => {`
`333`	`344`	`for statement in &body.statements {`
`334`		`- check_take_of_handle_in_stmt(analyzer, statement, state);`
	`345`	`+ check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);`
`335`	`346`	`}`
`336`	`347`	`}`
`337`	`348`	`Expr::Ident(_, _) \| Expr::Number(_, _) \| Expr::String(_, _) \| Expr::Unknown(_) => {}`
`338`	`349`	`}`
`339`	`350`	`}`
`340`	`351`
`341`		`-fn check_take_of_handle_in_stmt(analyzer: &mut Analyzer<'_>, statement: &Stmt, state: &BodyState) {`
	`352`	`+fn check_take_of_handle_in_stmt(`
	`353`	`+ analyzer: &mut Analyzer<'_>,`
	`354`	`+ local_analysis: &LocalAnalysis,`
	`355`	`+ statement: &Stmt,`
	`356`	`+ state: &BodyState,`
	`357`	`+) {`
`342`	`358`	`match statement {`
`343`	`359`	`Stmt::Let(stmt) => {`
`344`	`360`	`if let Some(value) = &stmt.value {`
`345`		`- check_take_of_handle_field(analyzer, value, state);`
	`361`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
`346`	`362`	`}`
`347`	`363`	`}`
`348`	`364`	`Stmt::Return(stmt) => {`
`349`	`365`	`if let Some(value) = &stmt.value {`
`350`		`- check_take_of_handle_field(analyzer, value, state);`
	`366`	`+ check_take_of_handle_field(analyzer, local_analysis, value, state);`
`351`	`367`	`}`
`352`	`368`	`}`
`353`	`369`	`Stmt::With(stmt) => {`
`354`		`- check_take_of_handle_field(analyzer, &stmt.resource, state);`
	`370`	`+ check_take_of_handle_field(analyzer, local_analysis, &stmt.resource, state);`
`355`	`371`	`for statement in &stmt.body.statements {`
`356`		`- check_take_of_handle_in_stmt(analyzer, statement, state);`
	`372`	`+ check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);`
`357`	`373`	`}`
`358`	`374`	`}`
`359`	`375`	`Stmt::If(stmt) => {`
`360`		`- check_take_of_handle_field(analyzer, &stmt.condition, state);`
	`376`	`+ check_take_of_handle_field(analyzer, local_analysis, &stmt.condition, state);`
`361`	`377`	`for statement in &stmt.then_body.statements {`
`362`		`- check_take_of_handle_in_stmt(analyzer, statement, state);`
	`378`	`+ check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);`
`363`	`379`	`}`
`364`	`380`	`if let Some(else_body) = &stmt.else_body {`
`365`	`381`	`for statement in &else_body.statements {`
`366`		`- check_take_of_handle_in_stmt(analyzer, statement, state);`
	`382`	`+ check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);`
`367`	`383`	`}`
`368`	`384`	`}`
`369`	`385`	`}`
`370`	`386`	`Stmt::Loop(stmt) => {`
`371`	`387`	`if let Some(condition) = &stmt.condition {`
`372`		`- check_take_of_handle_field(analyzer, condition, state);`
	`388`	`+ check_take_of_handle_field(analyzer, local_analysis, condition, state);`
`373`	`389`	`}`
`374`	`390`	`for statement in &stmt.body.statements {`
`375`		`- check_take_of_handle_in_stmt(analyzer, statement, state);`
	`391`	`+ check_take_of_handle_in_stmt(analyzer, local_analysis, statement, state);`
`376`	`392`	`}`
`377`	`393`	`}`
`378`		`- Stmt::Expr(expr) => check_take_of_handle_field(analyzer, expr, state),`
	`394`	`+ Stmt::Expr(expr) => check_take_of_handle_field(analyzer, local_analysis, expr, state),`
`379`	`395`	`Stmt::Break(_) \| Stmt::Continue(_) => {}`
`380`	`396`	`Stmt::Unknown(_) => {}`
`381`	`397`	`}`
`@@ -676,12 +692,13 @@ fn infer_call_type(`
`676`	`692`
`677`	`693`	`fn is_handle_field(`
`678`	`694`	`analyzer: &Analyzer<'_>,`
	`695`	`+ local_analysis: &LocalAnalysis,`
`679`	`696`	`state: &BodyState,`
`680`	`697`	`base: &Expr,`
`681`	`698`	`field_name: &str,`
`682`	`699`	`field_span: &crate::diagnostic::Span,`
`683`	`700`	`) -> bool {`
`684`		`- if let Some(field) = analyzer.hir.field_access(field_span) {`
	`701`	`+ if let Some(field) = local_analysis.field_access(field_span) {`
`685`	`702`	`return field.is_handle;`
`686`	`703`	`}`
`687`	`704`