Record body binding facts in HIR

Author: olwang

README.md

@@ -17,6 +17,7 @@ It currently implements:
 - HIR type and field tables for class/struct/resource declarations and handle fields
 - HIR constructor signatures derived from declared type fields
 - HIR call-site facts with resolved builtin, user function, constructor, enum variant, and unknown callees
+- HIR body binding facts for parameters, managed lets, local lets, and best-effort initial value types
 - 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
 - Focused check modules for mode, calls, body semantics, and forbidden operator behavior

src/checks/body.rs

@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::analyzer::Analyzer;
 use crate::diagnostic::{Diagnostic, code};
-use crate::hir::{CallResolution, HirTypeKind, ResolvedCalleeKind};
+use crate::hir::{CallResolution, HirBindingKind, HirTypeKind, ResolvedCalleeKind};
 use crate::syntax::ast::{
     Block, CallArg, Callee, DataEffect, Expr, FunctionDecl, Item, LetKind, Stmt,
 };
@@ -20,11 +20,7 @@ pub(crate) fn check(analyzer: &mut Analyzer<'_>) {
 
     for function in functions {
         let mut state = BodyState::default();
-        for param in &function.params {
-            state
-                .value_types
-                .insert(param.name.clone(), param.ty.name.clone());
-        }
+        seed_function_bindings(analyzer, &function, &mut state);
         check_block(analyzer, &function, &function.body, &mut state);
     }
 }
@@ -38,6 +34,19 @@ struct BodyState {
     value_types: HashMap<String, String>,
 }
 
+fn seed_function_bindings(analyzer: &Analyzer<'_>, function: &FunctionDecl, state: &mut BodyState) {
+    for binding in analyzer.hir.function_bindings(&function.name) {
+        if binding.kind != HirBindingKind::Param {
+            continue;
+        }
+        if let Some(type_name) = &binding.type_name {
+            state
+                .value_types
+                .insert(binding.name.clone(), type_name.clone());
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Flow {
     Fallthrough,
@@ -175,7 +184,9 @@ fn apply_stmt_effects(analyzer: &mut Analyzer<'_>, statement: &Stmt, state: &mut
                 }
             }
             if let Some(value) = &stmt.value {
-                if let Some(type_name) = infer_expr_type(analyzer, value, state) {
+                if let Some(type_name) = hir_binding_type(analyzer, &stmt.span)
+                    .or_else(|| infer_expr_type(analyzer, value, state))
+                {
                     state.value_types.insert(stmt.name.clone(), type_name);
                 }
                 apply_expr_effects(analyzer, value, state);
@@ -197,6 +208,13 @@ fn apply_stmt_effects(analyzer: &mut Analyzer<'_>, statement: &Stmt, state: &mut
     }
 }
 
+fn hir_binding_type(analyzer: &Analyzer<'_>, span: &crate::diagnostic::Span) -> Option<String> {
+    analyzer
+        .hir
+        .binding(span)
+        .and_then(|binding| binding.type_name.clone())
+}
+
 fn merge_if_state(
     state: &mut BodyState,
     base: &BodyState,