refine llmcc-cpp

Author: allenanswerzq

crates/llmcc-core/src/context.rs

@@ -242,27 +242,35 @@ impl<'tcx> CompileUnit<'tcx> {
 
     /// Return the symbol referenced by `symbol.type_of()` and its graph block id.
     pub fn try_type_of_with_block_id(self, symbol: &Symbol) -> Option<(&'tcx Symbol, BlockId)> {
-        let type_id = symbol.type_of()?;
-        self.try_symbol_with_block_id(type_id)
+        let type_symbol = self.try_resolved_type_link(symbol)?;
+        let block_id = type_symbol.block_id()?;
+        Some((type_symbol, block_id))
     }
 
     /// Resolve `symbol.type_of()` through type links and return its graph block id.
     pub fn try_type_of_block_id(self, symbol: &Symbol) -> Option<BlockId> {
-        let type_id = symbol.type_of()?;
-        self.try_type_block_id(type_id)
+        self.try_resolved_type_link(symbol)?.block_id()
     }
 
     /// Resolve a symbol id through its type link, falling back to the symbol's own block.
     pub fn try_type_block_id(self, symbol_id: SymId) -> Option<BlockId> {
         let symbol = self.try_symbol(symbol_id)?;
-        self.try_type(symbol).unwrap_or(symbol).block_id()
+        self.try_resolved_type_link(symbol)
+            .unwrap_or(symbol)
+            .block_id()
     }
 
     /// Resolve the graph type block for a block-owned symbol.
     pub fn try_type_ref_block_id(self, symbol: Option<&Symbol>) -> Option<BlockId> {
         let symbol = symbol?;
 
-        if let Some(type_symbol) = self.try_type(symbol) {
+        let resolved = if matches!(symbol.kind(), SymKind::TypeAlias | SymKind::TypeParameter) {
+            self.try_resolved_type_link(symbol)
+        } else {
+            self.try_type(symbol)
+        };
+
+        if let Some(type_symbol) = resolved {
             return type_symbol.block_id();
         }
 
@@ -288,6 +296,27 @@ impl<'tcx> CompileUnit<'tcx> {
         Some(type_symbol)
     }
 
+    fn try_resolved_type_link(self, symbol: &Symbol) -> Option<&'tcx Symbol> {
+        let mut current = self.try_type(symbol)?;
+
+        for _ in 0..32 {
+            if !matches!(current.kind(), SymKind::TypeAlias | SymKind::TypeParameter) {
+                return Some(current);
+            }
+
+            let Some(next) = self.try_type(current) else {
+                return Some(current);
+            };
+            current = next;
+        }
+
+        tracing::warn!(
+            symbol_id = symbol.id().0,
+            "type resolution chain exceeded limit"
+        );
+        Some(current)
+    }
+
     /// Return a scope by id, panicking when it is missing.
     pub fn scope(self, scope_id: ScopeId) -> &'tcx Scope<'tcx> {
         self.try_scope(scope_id)

crates/llmcc-core/src/graph_builder.rs

@@ -222,14 +222,10 @@ impl<'tcx, L: Language> GraphBuilder<'tcx, L> {
                 BasicBlock::Return(self.unit.alloc_block(id, block))
             }
             BlockKind::Alias => {
-                let block = BlockAlias::new_with_name(
-                    id,
-                    node,
-                    parent,
-                    children,
-                    query.try_first_ident_name(),
-                    symbol,
-                );
+                let name = symbol
+                    .map(|symbol| self.unit.resolve_name(symbol.name))
+                    .or_else(|| query.try_first_ident_name());
+                let block = BlockAlias::new_with_name(id, node, parent, children, name, symbol);
                 BasicBlock::Alias(self.unit.alloc_block(id, block))
             }
             BlockKind::Module => {

crates/llmcc-cpp/README.md

@@ -0,0 +1,27 @@
+# llmcc-cpp
+
+C/C++ language support for llmcc architecture and dependency graphs.
+
+This crate is a production best-effort analyzer for graph extraction, not a C++ compiler frontend. It uses tree-sitter syntax plus llmcc symbol collection, binding, and type inference to recover project structure and common type dependencies.
+
+## Supported Semantics
+
+- Translation-unit discovery for common C/C++ source and header extensions.
+- Global, file, namespace, class, struct, union, enum, function, method, field, parameter, variable, and alias symbols.
+- Cross-file qualified namespace lookup for paths such as `models::User`.
+- Basic inheritance edges from class/struct base clauses, including qualified base names.
+- Field, parameter, and return type binding for primitive, identifier, qualified, and common wrapper type nodes.
+- Type aliases from `using Alias = Type` and `typedef Type Alias`, including alias-chain resolution for graph type references.
+- Structural overload separation for same-name free functions by parameter signature, with call binding that prefers matching arity and exact primitive argument types.
+- Member lookup through resolved receiver types for ordinary field/method expressions.
+- Architecture graph dependencies through direct qualified types and alias-mediated types.
+
+## Intentional Limits
+
+- No full preprocessor, macro expansion, include-path, or `compile_commands.json` semantics.
+- No compiler-grade overload resolution, implicit conversions, ADL, access checking, or SFINAE. Current overload handling is structural: arity plus exact primitive type matches, without conversion ranking.
+- Template support is structural and best-effort; it does not instantiate templates or fully evaluate dependent names.
+- Standard-library types are resolved only when symbols are available in the analyzed input or built-in primitives.
+- Results are designed for architecture/dependency graphs, not for proving C++ type correctness.
+
+When correctness requires exact C++ compiler semantics, integrate clang tooling and use llmcc output as a graph-oriented projection of that semantic data.

crates/llmcc-cpp/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");
     let node_types = manifest_dir.join("../../third_party/tree-sitter-cpp/src/node-types.json");
 
@@ -15,10 +15,10 @@ fn main() {
         tree_sitter_cpp::LANGUAGE.into(),
         &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("cpp_tokens.rs");
-    fs::write(&out_file, contents).unwrap();
+    fs::write(&out_file, contents)?;
+    Ok(())
 }