refine hir and block APIs

Author: allenanswerzq

crates/llmcc-collect/src/collect.rs

@@ -50,8 +50,8 @@ pub fn collect_nodes(project: &ProjectGraph) -> Vec<RenderNode> {
             let symbol_opt = block
                 .node()
                 .as_scope()
-                .and_then(|scope_node| scope_node.opt_scope())
-                .and_then(|scope| scope.opt_symbol());
+                .and_then(|scope_node| scope_node.try_scope())
+                .and_then(|scope| scope.try_symbol());
 
             let sym_kind = symbol_opt.map(|s| s.kind());
 

crates/llmcc-core/src/block.rs

@@ -3,7 +3,6 @@
 use parking_lot::RwLock;
 use std::collections::HashSet;
 use std::fmt;
-use std::sync::atomic::{AtomicBool, Ordering};
 use strum_macros::{Display, EnumIter, EnumString, FromRepr};
 
 use crate::context::CompileUnit;
@@ -592,13 +591,8 @@ pub struct BlockFunc<'blk> {
     name: String,
     pub parameters: RwLock<Vec<BlockId>>,
     pub returns: RwLock<Option<BlockId>>,
-    /// Types used inside function body (excludes parameter/return types)
-    /// Examples: local variable types, static method receivers (Foo::method)
-    pub type_deps: RwLock<HashSet<BlockId>>,
     /// Functions/methods called by this function
     pub func_deps: RwLock<HashSet<BlockId>>,
-    /// Whether this is a method (inside impl block) vs a free function
-    pub is_method: AtomicBool,
 }
 
 impl<'blk> BlockFunc<'blk> {
@@ -627,22 +621,16 @@ impl<'blk> BlockFunc<'blk> {
             name,
             parameters: RwLock::new(Vec::new()),
             returns: RwLock::new(None),
-            type_deps: RwLock::new(HashSet::new()),
             func_deps: RwLock::new(HashSet::new()),
-            is_method: AtomicBool::new(false),
         }
     }
 
     pub fn name(&self) -> Option<&str> {
         (!self.name.is_empty()).then_some(&self.name)
     }
 
-    pub fn set_is_method(&self, is_method: bool) {
-        self.is_method.store(is_method, Ordering::Relaxed);
-    }
-
     pub fn is_method(&self) -> bool {
-        self.is_method.load(Ordering::Relaxed)
+        self.base.kind == BlockKind::Method
     }
 
     pub fn add_parameter(&self, param: BlockId) {
@@ -662,11 +650,11 @@ impl<'blk> BlockFunc<'blk> {
     }
 
     pub fn add_type_dep(&self, type_id: BlockId) {
-        self.type_deps.write().insert(type_id);
+        self.base.add_type_dep(type_id);
     }
 
     pub fn type_deps(&self) -> HashSet<BlockId> {
-        self.type_deps.read().clone()
+        self.base.type_deps()
     }
 
     pub fn add_func_dep(&self, func_id: BlockId) {

crates/llmcc-core/src/graph_builder.rs

@@ -128,7 +128,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
             .into_iter()
             .find(|ident| {
                 ident
-                    .opt_symbol()
+                    .try_symbol()
                     .is_some_and(|sym| matches!(sym.kind(), crate::symbol::SymKind::Variable))
             })
             .map(|ident| ident.name.to_string())
@@ -157,7 +157,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
         // The scope's symbol is authoritative - if a scope is set, it means
         // the collector intentionally created this as a defining scope
         if let Some(scope) = node.as_scope()
-            && let Some(sym) = scope.opt_symbol()
+            && let Some(sym) = scope.try_symbol()
         {
             return Some(sym);
         }
@@ -172,7 +172,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
         // For fields, use the language's name_field to avoid finding decorator identifiers
         if kind == BlockKind::Field
             && let Some(ident) = node.query(&self.unit).ident_with_field(L::name_field())
-            && let Some(sym) = ident.opt_symbol()
+            && let Some(sym) = ident.try_symbol()
         {
             return Some(sym);
         }
@@ -181,7 +181,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
         // This avoids cases like `handle(@inject req: string)` where `find_ident` returns `inject`.
         if kind == BlockKind::Parameter {
             for ident in node.query(&self.unit).identifiers() {
-                if let Some(sym) = ident.opt_symbol()
+                if let Some(sym) = ident.try_symbol()
                     && matches!(sym.kind(), SymKind::Variable)
                 {
                     return Some(sym);
@@ -191,15 +191,15 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
 
         // Try identifier (for parameters, etc.)
         if let Some(ident) = node.query(&self.unit).first_ident()
-            && let Some(sym) = ident.opt_symbol()
+            && let Some(sym) = ident.try_symbol()
         {
             return Some(sym);
         }
 
         // Try children's identifiers (for self_parameter where the identifier is a child)
         for child in node.children(&self.unit) {
             if let Some(ident) = child.as_ident()
-                && let Some(sym) = ident.opt_symbol()
+                && let Some(sym) = ident.try_symbol()
             {
                 return Some(sym);
             }
@@ -241,7 +241,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
                 // Populate crate_name and module_path from scope chain.
                 // The binding phase sets up proper parent scopes with Module/Crate symbols.
                 if let Some(scope_node) = node.as_scope()
-                    && let Some(scope) = scope_node.opt_scope()
+                    && let Some(scope) = scope_node.try_scope()
                 {
                     use crate::symbol::SymKind;
 
@@ -289,9 +289,6 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
             }
             BlockKind::Func | BlockKind::Method => {
                 let block = BlockFunc::new_with_symbol(id, node, kind, parent, children, symbol);
-                if kind == BlockKind::Method {
-                    block.set_is_method(true);
-                }
                 let block_ref = self
                     .unit
                     .context()
@@ -375,7 +372,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
 
                 // Get target type from the "type" field (e.g., `impl Foo` or `impl Trait for Foo`)
                 if let Some(target_ident) = node.query(&self.unit).ident_with_field(L::type_field())
-                    && let Some(sym) = target_ident.opt_symbol()
+                    && let Some(sym) = target_ident.try_symbol()
                 {
                     // Follow type_of chain to get the actual type symbol for block_id
                     let resolved = sym
@@ -388,7 +385,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
 
                 // Get trait from the "trait" field (e.g., `impl Trait for Foo`)
                 if let Some(trait_ident) = node.query(&self.unit).ident_with_field(L::trait_field())
-                    && let Some(sym) = trait_ident.opt_symbol()
+                    && let Some(sym) = trait_ident.try_symbol()
                 {
                     // Follow type_of chain to get the actual trait symbol
                     let resolved = sym
@@ -608,7 +605,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
         let mut type_symbol = node
             .query(&self.unit)
             .first_ident()
-            .and_then(|ident| ident.opt_symbol());
+            .and_then(|ident| ident.try_symbol());
 
         // Strategy 2: Look at children for symbol
         if type_symbol.is_none() {
@@ -624,7 +621,7 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
             && let Some(scope) = node.as_scope()
             && let Some(ident) = *scope.ident.read()
         {
-            type_symbol = ident.opt_symbol();
+            type_symbol = ident.try_symbol();
         }
         // Strategy 4: Node's own symbol
         if type_symbol.is_none() {
@@ -804,8 +801,8 @@ impl<'tcx, L: Language> HirVisitor<'tcx> for GraphBuilder<'tcx, L> {
             if matches!(kind, BlockKind::Func | BlockKind::Method) {
                 let has_symbol = node
                     .as_scope()
-                    .and_then(|scope| scope.opt_scope())
-                    .and_then(|scope| scope.opt_symbol())
+                    .and_then(|scope| scope.try_scope())
+                    .and_then(|scope| scope.try_symbol())
                     .is_some();
                 if !has_symbol {
                     // No symbol means this is a function pointer variable, not a function declaration

crates/llmcc-core/src/ir.rs

@@ -91,12 +91,12 @@ pub enum HirNode<'hir> {
 impl<'hir> HirNode<'hir> {
     #[inline]
     fn expect_base(&self, method: &'static str) -> &HirBase {
-        self.base()
+        self.try_base()
             .unwrap_or_else(|| panic!("HirNode::{method} called on Undefined"))
     }
 
     pub fn label(&self) -> String {
-        self.base()
+        self.try_base()
             .map(|base| format!("{}:{}", base.kind, base.id))
             .unwrap_or_else(|| "undefined".to_string())
     }
@@ -107,7 +107,7 @@ impl<'hir> HirNode<'hir> {
     }
 
     /// Shared metadata for this node, if it is not `Undefined`.
-    pub fn base(&self) -> Option<&HirBase> {
+    pub fn try_base(&self) -> Option<&HirBase> {
         match self {
             HirNode::Undefined => None,
             HirNode::Root(node) => Some(&node.base),
@@ -119,9 +119,14 @@ impl<'hir> HirNode<'hir> {
         }
     }
 
+    /// Shared metadata for this node, panicking if it is `Undefined`.
+    pub fn base(&self) -> &HirBase {
+        self.expect_base("base")
+    }
+
     /// Coarse HIR kind used by llmcc visitors and builders.
     pub fn kind(&self) -> HirKind {
-        self.base().map_or(HirKind::Undefined, |base| base.kind)
+        self.try_base().map_or(HirKind::Undefined, |base| base.kind)
     }
 
     /// Returns true when this node has the given coarse HIR kind.
@@ -131,17 +136,17 @@ impl<'hir> HirNode<'hir> {
 
     /// HIR id if this node is not `Undefined`.
     pub fn try_id(&self) -> Option<HirId> {
-        self.base().map(|base| base.id)
+        self.try_base().map(|base| base.id)
     }
 
     /// Tree-sitter field id if this node is not `Undefined`.
     pub fn try_field_id(&self) -> Option<u16> {
-        self.base().map(|base| base.field_id)
+        self.try_base().map(|base| base.field_id)
     }
 
     /// Tree-sitter kind id if this node is not `Undefined`.
     pub fn try_kind_id(&self) -> Option<u16> {
-        self.base().map(|base| base.kind_id)
+        self.try_base().map(|base| base.kind_id)
     }
 
     /// Tree-sitter field id assigned by the parent cursor.
@@ -151,12 +156,12 @@ impl<'hir> HirNode<'hir> {
 
     /// Child node ids in source order.
     pub fn child_ids(&self) -> &[HirId] {
-        self.base().map_or(&[], |base| &base.children)
+        self.try_base().map_or(&[], |base| &base.children)
     }
 
     /// Child nodes in source order.
     pub fn children(&self, unit: &CompileUnit<'hir>) -> SmallVec<[HirNode<'hir>; 8]> {
-        self.base().map_or(SmallVec::new(), |base| {
+        self.try_base().map_or(SmallVec::new(), |base| {
             base.children.iter().map(|id| unit.hir_node(*id)).collect()
         })
     }
@@ -193,19 +198,19 @@ impl<'hir> HirNode<'hir> {
 
     /// Parent node id, if this is not the root.
     pub fn parent(&self) -> Option<HirId> {
-        self.base().and_then(|base| base.parent)
+        self.try_base().and_then(|base| base.parent)
     }
 
     /// Direct child with the given tree-sitter field id.
     pub fn child_by_field(&self, unit: &CompileUnit<'hir>, field_id: u16) -> Option<HirNode<'hir>> {
-        self.base()?.child_by_field(unit, field_id)
+        self.try_base()?.child_by_field(unit, field_id)
     }
 
     /// Direct child with the given tree-sitter kind id.
     pub fn child_by_kind(&self, unit: &CompileUnit<'hir>, kind_id: u16) -> Option<HirNode<'hir>> {
         self.children(unit)
             .into_iter()
-            .find(|child| child.base().is_some_and(|base| base.kind_id == kind_id))
+            .find(|child| child.try_base().is_some_and(|base| base.kind_id == kind_id))
     }
 
     #[inline]
@@ -298,7 +303,11 @@ impl HirBase {
         self.children
             .iter()
             .map(|id| unit.hir_node(*id))
-            .find(|child| child.base().is_some_and(|base| base.field_id == field_id))
+            .find(|child| {
+                child
+                    .try_base()
+                    .is_some_and(|base| base.field_id == field_id)
+            })
     }
 }
 
@@ -399,7 +408,7 @@ impl<'hir> HirScope<'hir> {
     }
 
     /// Semantic scope if it has been attached.
-    pub fn opt_scope(&self) -> Option<&'hir Scope<'hir>> {
+    pub fn try_scope(&self) -> Option<&'hir Scope<'hir>> {
         *self.scope.read()
     }
 
@@ -409,7 +418,7 @@ impl<'hir> HirScope<'hir> {
     }
 
     /// Identifier that names this scope, if present.
-    pub fn opt_ident(&self) -> Option<&'hir HirIdent<'hir>> {
+    pub fn try_ident(&self) -> Option<&'hir HirIdent<'hir>> {
         *self.ident.read()
     }
 
@@ -421,8 +430,8 @@ impl<'hir> HirScope<'hir> {
     }
 
     /// Symbol associated with this scope through its semantic `Scope`.
-    pub fn opt_symbol(&self) -> Option<&'hir Symbol> {
-        self.opt_scope().and_then(|scope| scope.opt_symbol())
+    pub fn try_symbol(&self) -> Option<&'hir Symbol> {
+        self.try_scope().and_then(|scope| scope.try_symbol())
     }
 }
 
@@ -476,7 +485,7 @@ impl<'hir> HirIdent<'hir> {
 
     /// Resolved symbol if one has been attached.
     #[inline]
-    pub fn opt_symbol(&self) -> Option<&'hir Symbol> {
+    pub fn try_symbol(&self) -> Option<&'hir Symbol> {
         let ptr = self.symbol.load(Ordering::Acquire);
         if ptr.is_null() {
             None