devlensio 1.0.4 → 1.1.0

package/extractors/python/devlens_extractors_python/parser/functions.py

@@ -61,16 +61,110 @@ def call_name(func: ast.AST) -> str | None:
 
 def extract_calls(body: list[ast.stmt]) -> list[str]:
     """Collect every called name in a function body, deduped."""
+    return extract_calls_with_sites(body)[0]
+
+
+def _infer_arg_type(arg: ast.AST) -> str:
+    """Cheap literal arg-type tag in the same vocabulary as parameter
+    annotations (str/int/bool/list/dict); anything else stays unknown."""
+    if isinstance(arg, ast.Constant):
+        if isinstance(arg.value, bool):
+            return "bool"
+        if isinstance(arg.value, str):
+            return "str"
+        if isinstance(arg.value, (int, float)):
+            return "int" if isinstance(arg.value, int) else "float"
+        return "unknown"
+    if isinstance(arg, ast.JoinedStr):
+        return "str"
+    if isinstance(arg, ast.List):
+        return "list"
+    if isinstance(arg, ast.Dict):
+        return "dict"
+    if isinstance(arg, ast.Tuple):
+        return "tuple"
+    return "unknown"
+
+
+def extract_calls_with_sites(body: list[ast.stmt]) -> tuple[list[str], list[dict]]:
+    """ONE scope-guarded walk producing both outputs: the legacy deduped call
+    name list and structured call sites {name, argCount, argTypes, hasSpread}.
+    argCount counts positional args + keyword args; *args/**kwargs set
+    hasSpread (runtime arity unknowable). One record per
+    (name, argCount, argTypes) triple so same-arity different-type call sites
+    both survive (each can hit a different overload sibling)."""
     calls: list[str] = []
+    sites: list[dict] = []
+    seen_sites: set[str] = set()
 
     def visit(node: ast.AST) -> None:
-        if isinstance(node, ast.Call):
-            name = call_name(node.func)
-            if name:
-                calls.append(name)
+        if not isinstance(node, ast.Call):
+            return
+        name = call_name(node.func)
+        if not name:
+            return
+        if name not in calls:
+            calls.append(name)
+
+        arg_types: list[str] = []
+        has_spread = False
+        for a in node.args:
+            if isinstance(a, ast.Starred):
+                has_spread = True
+                arg_types.append("unknown")
+            else:
+                arg_types.append(_infer_arg_type(a))
+        for kw in node.keywords:
+            if kw.arg is None:          # **kwargs
+                has_spread = True
+                arg_types.append("unknown")
+            else:
+                arg_types.append(_infer_arg_type(kw.value))
+
+        arg_count = len(node.args) + len(node.keywords)
+        key = f"{name}/{arg_count}/{','.join(arg_types)}"
+        if key in seen_sites:
+            return
+        seen_sites.add(key)
+        site = {"name": name, "argCount": arg_count, "argTypes": arg_types}
+        if has_spread:
+            site["hasSpread"] = True
+        sites.append(site)
 
     _walk_scope(body, visit)
-    return list(dict.fromkeys(calls))   # dedupe, keep first-seen order
+    return calls, sites
+
+
+def _param_records(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[dict]:
+    """Typed parameter records {name, type, isOptional?, isRest?} for arity and
+    type-shape matching. vararg/kwarg ride as isRest entries; defaults mark
+    isOptional. Annotation text is the type vocabulary used by callSites."""
+    records: list[dict] = []
+    a = node.args
+    positional = a.posonlyargs + a.args
+    defaults = a.defaults                       # aligns with positional[-len(defaults):]
+    kw_defaults = a.kw_defaults                 # aligns with kwonlyargs (None = required)
+
+    def record(arg: ast.arg, optional: bool, rest: bool) -> None:
+        rec: dict = {"name": arg.arg,
+                     "type": ast.unparse(arg.annotation) if arg.annotation else "unknown"}
+        if rest:
+            rec["isRest"] = True
+        if optional:
+            rec["isOptional"] = True
+        records.append(rec)
+
+    offset = len(positional) - len(defaults)
+    for i, arg in enumerate(positional):
+        record(arg, i >= offset, False)
+    # kwonly: kw_defaults aligns 1:1 with kwonlyargs (None = required)
+    for i, arg in enumerate(a.kwonlyargs):
+        record(arg, kw_defaults[i] is not None, False)
+    if a.vararg:
+        record(a.vararg, False, True)
+    if a.kwarg:
+        record(a.kwarg, False, True)
+    return records
 
 
 def _match_orm_call(call: ast.Call) -> dict | None:
@@ -140,12 +234,15 @@ def extract_function(node: ast.FunctionDef | ast.AsyncFunctionDef, rel_path: str
     raw = ast.get_source_segment(source, node) or ""
     params = [a.arg for a in node.args.posonlyargs + node.args.args + node.args.kwonlyargs]
     decorators = [ast.unparse(d) for d in node.decorator_list]
+    calls, call_sites = extract_calls_with_sites(node.body)
 
     # hasErrorHandling/throws use ast.walk deliberately — mirrors the JS
     # extractor, which scans the whole function subtree for try/raise.
     metadata = {
         "params": params,
-        "calls": extract_calls(node.body),
+        "parameters": _param_records(node),
+        "calls": calls,
+        "callSites": call_sites,
         "ormOps": extract_orm_ops(node.body),
         "isAsync": is_async,
         "hasErrorHandling": any(isinstance(n, (ast.Try, ast.TryStar)) for n in ast.walk(node)),

package/extractors/python/devlens_extractors_python/parser/overloads.py

@@ -0,0 +1,105 @@
+"""Overload disambiguation — same-name function-likes in the same file.
+
+Node ids are ``rel/path.py::name``, so two same-name defs in one file (Python
+shadowing, dynamic redefinition) produced two nodes with ONE id; downstream
+dedupe silently dropped all but the first and every CALLS edge picked one
+arbitrarily.
+
+Convention (mirrors the TypeScript reference, src/parser/overloads.ts — keep
+in sync, see MULTI_LANGUAGE_EXPANSION.md):
+  - unique name in file        → id unchanged
+  - distinct arities in group  → ``#arity`` suffix (the def's OWN param count,
+                                 never ordinals)
+  - same arity, different types → ``#arity#<sig8>`` where sig8 = first 8 hex
+                                 chars of sha-256 over the signature string
+                                 "(T1,T2)" (rest params prefixed "...",
+                                 optional suffixed "?", untyped "unknown")
+  - signature-identical defs collapse to one node (prefer the one with a
+    body; Python defs always have bodies so the first by line order wins)
+Groups are per file; the same name in different files or on different classes
+(dotted names) never collides.
+"""
+from __future__ import annotations
+
+import hashlib
+
+_OVERLOADABLE_TYPES = {"FUNCTION", "METHOD"}
+
+
+def _param_types(node: dict) -> list[str]:
+    parameters = node.get("metadata", {}).get("parameters")
+    if not isinstance(parameters, list):
+        return []
+    types: list[str] = []
+    for p in parameters:
+        t = p.get("type") if isinstance(p, dict) else None
+        t = t if isinstance(t, str) and t else "unknown"
+        if p.get("isRest"):
+            types.append(f"...{t}")
+        elif p.get("isOptional"):
+            types.append(f"{t}?")
+        else:
+            types.append(t)
+    return types
+
+
+def _signature_key(node: dict) -> str:
+    return f"({','.join(_param_types(node))})"
+
+
+def _arity(node: dict) -> int:
+    params = node.get("metadata", {}).get("params")
+    return len(params) if isinstance(params, list) else 0
+
+
+def _has_body(node: dict) -> bool:
+    return node.get("metadata", {}).get("isOverloadSignature") is not True
+
+
+def apply_overload_disambiguation(nodes: list[dict], rel_path: str) -> None:
+    """Suffix colliding ids in place; mark signature-identical duplicates with
+    metadata.isDuplicateOverload for the caller to drop."""
+    groups: dict[str, list[dict]] = {}
+    for node in nodes:
+        if node.get("type") in _OVERLOADABLE_TYPES:
+            groups.setdefault(node["name"], []).append(node)
+
+    for name, group in groups.items():
+        if len(group) < 2:
+            continue
+        group.sort(key=lambda n: n["startLine"])
+
+        # Collapse signature-identical defs, preferring the one with a body.
+        by_signature: dict[str, dict] = {}
+        keys: dict[int, str] = {}
+        for node in group:
+            key = _signature_key(node)
+            keys[id(node)] = key
+            existing = by_signature.get(key)
+            if existing is None:
+                by_signature[key] = node
+            elif not _has_body(existing) and _has_body(node):
+                by_signature[key] = node
+        survivors = sorted(by_signature.values(), key=lambda n: n["startLine"])
+        if len(survivors) < len(group):
+            kept = {id(n) for n in survivors}
+            for node in group:
+                if id(node) not in kept:
+                    node["metadata"]["isDuplicateOverload"] = True
+
+        # Single survivor after collapse → the name is unique again, no suffix.
+        if len(survivors) < 2:
+            continue
+
+        # Distinct arities within the group → readable #arity suffix.
+        arities = {_arity(n) for n in survivors}
+        use_arity_only = len(arities) == len(survivors)
+
+        for node in survivors:
+            arity = _arity(node)
+            if use_arity_only:
+                suffix = f"#{arity}"
+            else:
+                sig8 = hashlib.sha256(keys[id(node)].encode("utf-8")).hexdigest()[:8]
+                suffix = f"#{arity}#{sig8}"
+            node["id"] = f"{rel_path}::{name}{suffix}"

package/extractors/rust/src/calls.rs

@@ -18,7 +18,7 @@
 // metadata.calls already carries the raw strings (parser); resolved targets
 // are written back as metadata.resolvedCalls.
 
-use crate::contract::{edge, CodeEdge};
+use crate::contract::{edge_with_meta, CodeEdge};
 use crate::extractor::{Options, ParsedRepo};
 use crate::fingerprint::ParsedManifest;
 use crate::lookup::LookupMaps;
@@ -54,9 +54,10 @@ pub fn detect_calls(
             }
             let base_module = crate::walker::module_path_for_file(&pf.rel_path);
             let mut resolved: Vec<String> = vec![];
-            for call in &item.calls {
-                if let Some(target) = resolve_call(
-                    call,
+            for site in &item.call_sites {
+                if let Some((target, matched_by)) = resolve_call(
+                    &site.name,
+                    site.arg_count,
                     item,
                     &pf.rel_path,
                     &base_module,
@@ -65,7 +66,13 @@ pub fn detect_calls(
                     mf,
                     tp,
                 ) {
-                    edges.push(edge(&from, &target, "CALLS"));
+                    let mut meta = serde_json::Map::new();
+                    meta.insert(
+                        "calledName".to_string(),
+                        serde_json::Value::from(site.name.clone()),
+                    );
+                    meta.insert("matchedBy".to_string(), serde_json::Value::from(matched_by));
+                    edges.push(edge_with_meta(&from, &target, "CALLS", meta));
                     resolved.push(target);
                 }
             }
@@ -91,8 +98,10 @@ pub fn detect_calls(
 
 /// Resolve one call string → target node id (or None).
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::too_many_arguments)]
 fn resolve_call(
     call: &str,
+    arg_count: usize,
     item: &ParsedItem,
     rel_path: &str,
     base_module: &str,
@@ -100,7 +109,7 @@ fn resolve_call(
     lookup: &LookupMaps,
     mf: &ParsedManifest,
     tp: &mut ThirdPartyRegistry,
-) -> Option<String> {
+) -> Option<(String, &'static str)> {
     // `x.method()` — receiver form
     if let Some((recv, method)) = call.split_once('.') {
         if recv == "self" {
@@ -109,12 +118,12 @@ fn resolve_call(
             if owner.is_empty() {
                 return None;
             }
-            return method_of_owner(owner, method, rel_path, lookup);
+            return method_of_owner(owner, method, rel_path, lookup).map(|t| (t, "name"));
         }
         // other receivers: no type resolution in V1 — metadata only
         return None;
     }
-    resolve_path_call(call, rel_path, base_module, module_map, lookup, mf, tp)
+    resolve_path_call(call, arg_count, rel_path, base_module, module_map, lookup, mf, tp)
 }
 
 /// Resolve a path-form call (`a::b::c`, `Type::m`, plain `bar`) to a node id.
@@ -126,21 +135,23 @@ fn resolve_call(
 /// crate → lazy [crate]/name::member (gated).
 pub fn resolve_path_call(
     call: &str,
+    arg_count: usize,
     rel_path: &str,
     base_module: &str,
     module_map: &ModuleMap,
     lookup: &LookupMaps,
     mf: &ParsedManifest,
     tp: &mut ThirdPartyRegistry,
-) -> Option<String> {
+) -> Option<(String, &'static str)> {
     let segs: Vec<&str> = call.split("::").collect();
     if segs.is_empty() {
         return None;
     }
     if segs.len() == 1 {
-        // plain name → same-file FUNCTION, then crate-wide
-        if let Some(id) = lookup.closest_by_path(segs[0], rel_path) {
-            return Some(id);
+        // plain name → same-file FUNCTION, then crate-wide; arity filters
+        // cross-file same-name candidates before path proximity decides
+        if let Some(res) = lookup.closest_by_path_arity(segs[0], rel_path, arg_count) {
+            return Some(res);
         }
         return None;
     }
@@ -167,7 +178,7 @@ pub fn resolve_path_call(
     // handlers actually live (brought into scope via `use crate::controllers::*;`).
     if let Some((file, rest)) = module_map.resolve(&full_path, base_module) {
         if let Some(id) = resolve_in_file(&file, &rest, rel_path, lookup) {
-            return Some(id);
+            return Some((id, "name"));
         }
         // don't return None — fall through to glob unroll + crate-root
     }
@@ -181,7 +192,7 @@ pub fn resolve_path_call(
                 let cand = format!("{}::{}", g, full_path);
                 if let Some((file, rest)) = module_map.resolve(&cand, base_module) {
                     if let Some(id) = resolve_in_file(&file, &rest, rel_path, lookup) {
-                        return Some(id);
+                        return Some((id, "name"));
                     }
                 }
             }
@@ -196,7 +207,7 @@ pub fn resolve_path_call(
     // misresolve against the caller's own module.
     if let Some((file, rest)) = module_map.resolve_use(&full_path, base_module) {
         if let Some(id) = resolve_in_file(&file, &rest, rel_path, lookup) {
-            return Some(id);
+            return Some((id, "name"));
         }
     }
 
@@ -207,7 +218,7 @@ pub fn resolve_path_call(
     }
     if crate::thirdparty::is_external_crate(first, mf) {
         let member = full_path.split("::").skip(1).collect::<Vec<_>>().join("::");
-        return tp.member_node(first, &member).map(|n| n.id.clone());
+        return tp.member_node(first, &member).map(|n| (n.id.clone(), "name"));
     }
     None
 }

package/extractors/rust/src/contract.rs

@@ -95,6 +95,8 @@ pub struct ExtractorResult {
     pub nodes: Vec<CodeNode>,
     pub edges: Vec<CodeEdge>,
     pub routes: Vec<RouteNode>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub exports: Option<crate::exports::ExportsMap>,
     pub stats: Stats,
     pub errors: Vec<ExtractorError>,
 }