fix(python): resolve self./cls. calls into local Calls edges

Two independent bugs meant a call from inside one method to another via
self./cls. — the majority of calls inside any Python class — never became a
Calls edge in the graph:

- ir_to_graph registered functions in node_map only under their bare name,
  but extract_class extracts calls with a qualified caller name
  ("ClassName.method_name"). Looking up the caller always missed, so the
  call fell through to cross-file unresolved-call resolution instead of a
  same-file edge.
- extract_callee_name returned the full attribute text ("self.helper") for
  a `self.helper()` call instead of the bare method name, which couldn't
  match anything in node_map either.

Register methods under both the bare and qualified name, and strip
self./cls. from the callee name before matching. Also fixes Contains
(class -> method) edges incorrectly linking same-named methods across two
different classes in one file, which used the same bare-name lookup.

get_callers/get_callees/get_call_graph/analyze_impact on methods were
systematically undercounting call relationships unless the callee happened
to also be found by the cross-file fallback.

Author: Znbiz

crates/codegraph-python/src/extractor.rs

@@ -604,12 +604,32 @@ fn extract_calls_recursive(
     }
 }
 
-/// Extract the callee name from a call's function node
+/// Extract the callee name from a call's function node.
+///
+/// For `self.method()`/`cls.method()` — by far the most common call shape
+/// inside any method — returns the bare `method` name, not `self.method`.
+/// `self`/`cls` are Python's instance/class-reference convention, not a
+/// real qualifier; graph nodes are keyed by bare name (or `Class.method`
+/// for the *caller* side, see `parser_impl::ir_to_graph`), so a literal
+/// `"self.method"` string never matched anything and every such call was
+/// silently dropped instead of becoming a same-file Calls edge. Other
+/// `obj.method()` shapes keep the full dotted text — resolving those
+/// would need type inference this extractor doesn't do, so falling back
+/// to unresolved (as before) is still correct there.
 fn extract_callee_name(source: &[u8], node: Node) -> String {
     match node.kind() {
         "identifier" => node.utf8_text(source).unwrap_or("").to_string(),
         "attribute" => {
-            // Handle obj.method() or self.method()
+            let object_is_self_or_cls = node
+                .child_by_field_name("object")
+                .and_then(|o| o.utf8_text(source).ok())
+                .is_some_and(|t| t == "self" || t == "cls");
+            if object_is_self_or_cls {
+                if let Some(attr) = node.child_by_field_name("attribute") {
+                    return attr.utf8_text(source).unwrap_or("").to_string();
+                }
+            }
+            // Handle obj.method() — kept as the full dotted text (unresolved).
             node.utf8_text(source).unwrap_or("").to_string()
         }
         _ => String::new(),

crates/codegraph-python/src/parser_impl.rs

@@ -155,6 +155,16 @@ impl PythonParser {
                 .map_err(|e| ParserError::GraphError(e.to_string()))?;
 
             node_map.insert(func.name.clone(), func_id);
+            // Methods are extracted with a qualified caller name
+            // ("ClassName.method_name", see extractor.rs) for their own call
+            // sites, but were only ever registered here under the bare name
+            // — so `node_map.get(&call.caller)` below always missed for
+            // calls originating inside a method, and every such call was
+            // silently dropped into `unresolved_calls` instead of becoming
+            // a same-file Calls edge. Register the qualified name too.
+            if let Some(parent) = &func.parent_class {
+                node_map.insert(format!("{parent}.{}", func.name), func_id);
+            }
             function_ids.push(func_id);
 
             // Link function to file
@@ -193,10 +203,16 @@ impl PythonParser {
                 .map_err(|e| ParserError::GraphError(e.to_string()))?;
 
             // Methods are already added via ir.functions with parent_class set
-            // Just create edges from class to its methods
+            // Just create edges from class to its methods. Prefer the
+            // qualified key — two classes with a same-named method (e.g.
+            // `__init__`) would otherwise both resolve to whichever one
+            // `node_map`'s bare-name entry happened to be last written by.
             for method in &class.methods {
-                let method_name = method.name.clone();
-                if let Some(&method_id) = node_map.get(&method_name) {
+                let qualified = format!("{}.{}", class.name, method.name);
+                let method_id = node_map
+                    .get(&qualified)
+                    .or_else(|| node_map.get(&method.name));
+                if let Some(&method_id) = method_id {
                     // Link method to class
                     graph
                         .add_edge(class_id, method_id, EdgeType::Contains, PropertyMap::new())
@@ -588,6 +604,51 @@ mod tests {
         assert_eq!(metrics.files_failed, 0);
     }
 
+    #[test]
+    fn test_call_from_inside_method_creates_local_calls_edge() {
+        use codegraph::EdgeType;
+
+        // Regression test: calls made from inside a class method were never
+        // wired as Calls edges because the extractor emits a qualified
+        // caller name ("Foo.caller_method") for method-body calls, but
+        // `node_map` only ever registered functions under their bare name.
+        // `get_callers`/`get_callees` on any method silently returned
+        // nothing for same-file calls.
+        let source = "\
+class Foo:
+    def helper(self):
+        return 1
+
+    def caller_method(self):
+        return self.helper()
+";
+        let parser = PythonParser::new();
+        let mut graph = codegraph::CodeGraph::in_memory().unwrap();
+        let file_info = parser
+            .parse_source(source, Path::new("test.py"), &mut graph)
+            .unwrap();
+
+        let node_named = |name: &str| {
+            file_info
+                .functions
+                .iter()
+                .copied()
+                .find(|&id| graph.get_node(id).unwrap().properties.get_string("name") == Some(name))
+                .unwrap_or_else(|| panic!("no function node named {name}"))
+        };
+
+        let helper_id = node_named("helper");
+        let caller_id = node_named("caller_method");
+
+        let edges = graph.get_edges_between(caller_id, helper_id).unwrap();
+        assert!(
+            edges
+                .iter()
+                .any(|&eid| graph.get_edge(eid).unwrap().edge_type == EdgeType::Calls),
+            "expected a Calls edge from caller_method to helper"
+        );
+    }
+
     #[test]
     fn test_implements_edge_creation() {
         use codegraph::{CodeGraph, EdgeType};