refine llmcc-rust

Author: allenanswerzq

crates/llmcc-core/src/ir_query.rs

@@ -323,7 +323,12 @@ impl<'hir, 'unit> HirQuery<'hir, 'unit> {
     /// through the type child to return the generic callee (`Repository` in
     /// `Repository<User>`).
     pub fn try_ident_with_field(self, field_id: u16) -> Option<&'hir HirIdent<'hir>> {
-        debug_assert!(!self.node.is_kind(HirKind::Identifier));
+        if self.node.is_kind(HirKind::Identifier) {
+            return (self.node.try_field_id() == Some(field_id))
+                .then(|| self.node.as_ident())
+                .flatten();
+        }
+
         for child in self.node.children(self.unit) {
             if child
                 .try_base()

crates/llmcc-rust/README.md

@@ -1,62 +1,35 @@
 # llmcc-rust
 
-This crate provides Rust language support for the **llmcc** project. It implements the language-specific logic for parsing, symbol collection, and semantic analysis (binding) of Rust code.
-
-## Overview
-
-`llmcc-rust` integrates with the core compiler infrastructure to provide:
-- **Parsing**: Uses `tree-sitter-rust` to generate an AST.
-- **Symbol Collection**: A first pass to declare all symbols (structs, functions, variables) in the scope graph.
-- **Symbol Binding**: A second pass to resolve references, infer types, and build the dependency graph.
-
-## Architecture
-
-The analysis pipeline consists of three main stages, orchestrated by the `LangRust` implementation in `src/token.rs`.
-
-### 1. Parsing (`src/token.rs`)
-The entry point for the crate. It defines the `LangRust` struct which implements the `LanguageImpl`.
-- Wraps `tree-sitter-rust` to produce a concrete syntax tree.
-- Maps Tree-sitter nodes to LLMCC's internal HIR (High-level Intermediate Representation).
-- Auto-generates token definitions via `build.rs`.
-
-### 2. Symbol Collection (`src/collect.rs`)
-The **Collection Pass** walks the AST to identify and declare definitions.
-- **Visitor**: `CollectorVisitor` traverses the AST.
-- **Scopes**: Creates scopes for modules, functions, structs, and blocks.
-- **Declarations**: Registers symbols for:
-  - Primitives (`i32`, `bool`, etc.)
-  - Modules and Crates (parsing `Cargo.toml` via `src/util.rs`)
-  - Functions, Structs, Enums, Traits
-  - Variables (via pattern matching in `let` bindings and parameters)
-- **Visibility**: Handles `pub` and `pub(crate)` modifiers to determine global symbol visibility.
-
-### 3. Symbol Binding (`src/bind/`)
-The **Binding Pass** resolves identifiers to their definitions and builds the call graph. This module is split into focused components:
-
-- **Visitor (`src/bind/visitor.rs`)**: The main driver, `BinderVisitor`, walks the AST again.
-- **Resolution (`src/bind/resolution.rs`)**: `SymbolResolver` handles complex name lookups, including:
-  - Lexical scoping (variables).
-  - Path resolution (`std::collections::HashMap`).
-  - Method resolution (looking up methods in `impl` blocks).
-- **Inference (`src/bind/inference.rs`)**: `ExprResolver` determines the types of expressions to support accurate method resolution.
-- **Linking (`src/bind/linker.rs`)**: `SymbolLinker` connects usage sites to definition sites, forming the dependency graph used by downstream LLM tasks.
-
-### Utilities (`src/util.rs`)
-Helper functions for filesystem and project structure analysis:
-- `parse_crate_name`: Extracts crate names from `Cargo.toml`.
-- `parse_module_name`: Handles Rust's module system conventions (e.g., `mod.rs`).
+Rust language support for llmcc.
 
-## Development
+The public API is intentionally small: use `LangRust` with the generic APIs from `llmcc-core` and `llmcc-resolver`. The collector, binder, inference, and pattern helpers are implementation details of the language adapter.
+
+## Pipeline
+
+`LangRust` implements the core language contract in `src/token.rs`:
+
+- parses Rust source with `tree-sitter-rust`
+- maps tree-sitter nodes and fields to llmcc HIR/block kinds from `src/token_map.toml`
+- creates Rust primitive symbols in the initial global scope
+- dispatches symbol collection and binding to the internal passes
+
+The internal passes are split by responsibility:
 
-### Testing
-The crate includes extensive unit tests ensuring correct symbol resolution and dependency tracking.
+- `collect.rs`: declares Rust symbols and attaches lexical/semantic scopes
+- `bind.rs`: resolves references, associates symbols with types, and records graph-relevant relationships
+- `infer.rs`: infers local expression/type symbols needed by binding
+- `pattern.rs`: propagates known types through Rust binding patterns
+
+## Conventions
+
+- Keep Rust-specific syntax decisions in this crate, not in `llmcc-core` or `llmcc-resolver`.
+- Prefer collection-time publication of global symbols; binding may run per unit in parallel.
+- Avoid panics for recoverable HIR shape drift. Skip or warn when a tree-sitter node is not shaped as expected.
+- Add token-map entries before implementing visitors for new Rust syntax.
+
+## Development
 
 ```bash
-# Run all tests for this crate
 cargo test -p llmcc-rust
+cargo clippy -p llmcc-rust --all-targets -- -D warnings
 ```
-
-### Adding New Features
-1. **New Syntax**: Update `src/token.rs` (or the build script) if new token types are needed.
-2. **New Declarations**: Update `CollectorVisitor` in `src/collect.rs` to register new symbol kinds.
-3. **New Resolution Logic**: Update `src/bind/` modules to handle new scoping rules or reference types.

crates/llmcc-rust/build.rs

@@ -2,8 +2,8 @@ use std::env;
 use std::fs;
 use std::path::PathBuf;
 
-fn main() {
-    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
     let config_path = manifest_dir.join("./src/token_map.toml");
 
     println!("cargo:rerun-if-changed={}", config_path.display());
@@ -14,10 +14,10 @@ fn main() {
         tree_sitter_rust::LANGUAGE.into(),
         tree_sitter_rust::NODE_TYPES,
         &config_path,
-    )
-    .unwrap();
+    )?;
 
-    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let out_dir = PathBuf::from(env::var("OUT_DIR")?);
     let out_file = out_dir.join("rust_tokens.rs");
-    fs::write(&out_file, contents).unwrap();
+    fs::write(&out_file, contents)?;
+    Ok(())
 }