Improve Rust callgraph resolution for direct self fields

[onedotmint]

Summary

While testing Rust callgraph output, I ran into a case where Holder::check calls PathBuf::as_path, but AFT could still produce an approximate edge to an unrelated PrinterPath::as_path elsewhere in the project. So i create this pr and explain what I do.

The existing name_match fallback is useful when the receiver type is genuinely unknown, so I didn't want to remove or weaken that behavior. The issue here is that for a simple field receiver like self.path, we can sometimes recover enough local type information to make a better decision — and when we can't, guessing by method name can be misleading.

What changed

This adds a conservative path for direct self.field.method() calls.

When the field can be tied to a concrete local type in the same lexical scope, AFT uses the existing precise type_match path. For example, if self.engine is known to be an Engine, Car::run -> Engine::start is resolved precisely.

If the field is clearly present but its type can't be resolved safely, the call is left unresolved instead of being connected to an unrelated same-named method. Precise candidates are also checked against the field type's lexical module scope, so a same-named type inside a nested module can't accidentally become the target.

I intentionally kept this narrow. This isn't meant to add general Rust type or module resolution. Imported or scoped types, nested fields, generics, trait impls, references, aliases, wrappers, deref/coercion, and cross-file type identities stay conservative unless AFT already knows how to resolve them.

Tests

The tests cover the original PathBuf / PrinterPath case, precise resolution for a local field type, preservation of the existing name_match fallback for genuinely unknown receivers, and the scoped/imported/nested-module cases that could otherwise create false precise edges.

The relevant unit and integration tests pass, along with:

cargo check -p agent-file-tools
cargo fmt --check
git diff --check

The full crate suite still has four failures in this local environment. I reproduced all four against a clean worktree at the same HEAD with the same failure signatures, so they appear to be baseline/environment-related rather than introduced by this change.(I guess it's because of my base environment.)

Thanks for your project. It helps a lot in my coding time.

---

^{Need help on this PR? Tag @codesmith-bot with what you need. Autofix is disabled.}

---

Summary by cubic

Improves Rust callgraph accuracy for direct self.field.method() calls, including spaced forms like self .engine.start(). Resolves only when the field’s type is a proven local concrete struct in the same file and module, and suppresses name-only matches when the field is known but unsafe to resolve.

• Bug Fixes
  • Add conservative Rust self-field inference that uses type_match only when the field’s type is a concrete, local, non-generic struct in the same file and lexical module; validates inherent impl by checking the candidate’s start_line, file, and module scope; rejects trait and generic impls.
  • Normalize whitespace by storing a trimmed receiver_expression, so forms like self .engine and self. engine are detected.
  • When a self field exists but its type can’t be safely proven (nested fields, wrappers, references, aliases, generics, trait impls, imports, cross-file types, or nested same-named types), leave the call unresolved and skip name_match; genuinely unknown receivers keep the fallback.

^{Written for commit 952522a. Summary will update on new commits.}

Greptile Summary

The PR improves Rust callgraph resolution for direct self.field.method() calls while preserving conservative behavior when the field type cannot be proven.

• Retains the full receiver expression and normalizes whitespace around direct field access.
• Resolves locally declared concrete field types through scoped inherent implementations.
• Suppresses misleading name-only fallback when a direct self field is recognized but unresolved.
• Adds unit and integration coverage for precise, unresolved, scoped, and whitespace-separated cases.

Confidence Score: 5/5

The PR appears safe to merge.

No blocking failure remains.

Important Files Changed

Filename	Overview
crates/aft/src/callgraph_store/mod.rs	Adds conservative Rust direct-self-field inference, lexical-scope validation, and whitespace normalization; the previously reported whitespace bypasses are resolved.
crates/aft/tests/integration/callgraph_store_name_match_test.rs	Adds end-to-end coverage for precise field-type resolution and suppression of unrelated method-name matches, including whitespace after the field-access dot.

_{Reviews (5): Last reviewed commit: "Clarify unresolved Rust field test names" | Re-trigger Greptile}

[cubic-dev-ai]

All reported issues were addressed across 2 files

<sub>Reply with feedback, questions, or to request a fix.

Re-trigger cubic</sub>

[cubic-dev-ai]

All reported issues were addressed across 1 file (changes from recent commits).

<sub>Tip: Review your code locally with the cubic CLI to iterate faster.

Re-trigger cubic</sub>

[cubic-dev-ai]

2 issues found across 2 files

Prompt for AI agents (unresolved issues)

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/aft/tests/integration/callgraph_store_name_match_test.rs">

<violation number="1" location="crates/aft/tests/integration/callgraph_store_name_match_test.rs:769">
P2: The nested same-named-type test only asserts the absence of precise type_match edges; it predicates on resolved_by=="type_match" && approximate==false, so a regression that recreates a name_match edge to nested::Engine::start (the false edge this PR exists to prevent) would still pass. Consider also asserting that no edge at all targets nested::Engine::start (e.g. counting edges for that symbol, or checking the child is present with resolved==false), not just that no precise type_match edge exists.</violation>
</file>

<file name="crates/aft/src/callgraph_store/mod.rs">

<violation number="1" location="crates/aft/src/callgraph_store/mod.rs:9811">
P2: Inline comments between a direct self field and method bypass inference and re-enable `name_match`, so `self.path /* ... */ .as_path()` can falsely resolve to an unrelated same-named method. Normalize Rust trivia here or derive direct-field identity from the parsed field-expression before allowing fallback.</violation>
</file>

<sub>Reply with feedback, questions, or to request a fix.

Re-trigger cubic</sub>

[cubic-dev-ai]

P2: The nested same-named-type test only asserts the absence of precise type_match edges; it predicates on resolved_by=="type_match" && approximate==false, so a regression that recreates a name_match edge to nested::Engine::start (the false edge this PR exists to prevent) would still pass. Consider also asserting that no edge at all targets nested::Engine::start (e.g. counting edges for that symbol, or checking the child is present with resolved==false), not just that no precise type_match edge exists.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At crates/aft/tests/integration/callgraph_store_name_match_test.rs, line 769:

<comment>The nested same-named-type test only asserts the absence of precise type_match edges; it predicates on resolved_by=="type_match" && approximate==false, so a regression that recreates a name_match edge to nested::Engine::start (the false edge this PR exists to prevent) would still pass. Consider also asserting that no edge at all targets nested::Engine::start (e.g. counting edges for that symbol, or checking the child is present with resolved==false), not just that no precise type_match edge exists.</comment>

<file context>
@@ -458,6 +726,69 @@ export function entry(permissionRuleEngine: PermissionRuleEngine) {
+        1,
+        true,
+    ));
+    let precise_tree_edge = tree["children"].as_array().unwrap().iter().any(|child| {
+        child["name"] == "Engine::start"
+            && child["resolved_by"] == "type_match"
</file context>

[cubic-dev-ai]

P2: Inline comments between a direct self field and method bypass inference and re-enable name_match, so self.path /* ... */ .as_path() can falsely resolve to an unrelated same-named method. Normalize Rust trivia here or derive direct-field identity from the parsed field-expression before allowing fallback.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At crates/aft/src/callgraph_store/mod.rs, line 9811:

<comment>Inline comments between a direct self field and method bypass inference and re-enable `name_match`, so `self.path /* ... */ .as_path()` can falsely resolve to an unrelated same-named method. Normalize Rust trivia here or derive direct-field identity from the parsed field-expression before allowing fallback.</comment>

<file context>
@@ -9619,19 +9700,200 @@ fn is_code_ident_char(ch: char) -> bool {
+fn rust_direct_self_field_name(receiver_expression: &str) -> Option<&str> {
+    let (base, field) = receiver_expression.split_once('.')?;
+    let base = base.trim();
+    let field = field.trim();
+    (base == "self" && rust_direct_nominal_type_name(field).is_some()).then_some(field)
+}
</file context>