devlensio 0.6.2 → 1.0.0

package/extractors/rust/src/inheritance.rs

@@ -0,0 +1,233 @@
+// inheritance.rs — IMPLEMENTS + EXTENDS edges (mirrors go/inheritance.go).
+//
+// IMPLEMENTS (documented Rust semantics — impl blocks ARE the mechanism):
+//   `impl Trait for Type`  → IMPLEMENTS Type→Trait (local TRAIT node; external
+//                            trait → gated [crate]/name::Trait member node —
+//                            parity with Go's external gorm.Model embeds)
+//   plain `impl Type`      → IMPLEMENTS IMPL_BLOCK→STRUCT (the tracker/
+//                            phase-5.html convention: the impl block attaches
+//                            to its target type)
+// EXTENDS:
+//   trait supertraits `trait Child: Parent` → EXTENDS Child→Parent (Rust's
+//                            documented inheritance mechanism)
+//   #[derive(LocalTrait)]  → EXTENDS struct→trait when the derive resolves to
+//                            a LOCAL trait (rare; flagged heuristic)
+
+use crate::contract::{edge, CodeEdge};
+use crate::extractor::{Options, ParsedRepo};
+use crate::fingerprint::ParsedManifest;
+use crate::lookup::LookupMaps;
+use crate::module_map::ModuleMap;
+use crate::parser::ParsedFile;
+use crate::thirdparty::ThirdPartyRegistry;
+
+pub struct InheritanceOutput {
+    pub edges: Vec<CodeEdge>,
+    pub third_party_nodes: Vec<crate::contract::CodeNode>,
+}
+
+pub fn detect_inheritance(
+    repo: &ParsedRepo,
+    mf: &ParsedManifest,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+    tp: &mut ThirdPartyRegistry,
+    _opts: &Options,
+) -> InheritanceOutput {
+    let mut edges = vec![];
+    let mut nodes = vec![];
+    for pf in &repo.files {
+        if pf.is_test_file {
+            continue;
+        }
+        for item in &pf.items {
+            if item.is_test {
+                continue;
+            }
+            match item.kind {
+                crate::parser::KIND_IMPL_BLOCK => {
+                    let impl_id = crate::lookup::node_id_for_item(&pf.rel_path, item);
+                    let target = &item.impl_target;
+                    if target.is_empty() {
+                        continue;
+                    }
+                    if let Some(trait_path) = &item.impl_trait_path {
+                        // impl Trait for Type → Type IMPLEMENTS Trait
+                        if let Some(type_id) = resolve_type_id(target, pf, module_map, lookup) {
+                            if let Some(trait_id) = resolve_trait_id(
+                                trait_path, pf, module_map, lookup, mf, tp, &mut nodes,
+                            ) {
+                                edges.push(edge(&type_id, &trait_id, "IMPLEMENTS"));
+                            }
+                        }
+                    } else {
+                        // plain impl Type → IMPL_BLOCK IMPLEMENTS STRUCT
+                        if let Some(type_id) = resolve_type_id(target, pf, module_map, lookup) {
+                            edges.push(edge(&impl_id, &type_id, "IMPLEMENTS"));
+                        }
+                    }
+                }
+                crate::parser::KIND_TRAIT => {
+                    // supertraits: trait Child: Parent → EXTENDS Child→Parent
+                    let child_id = crate::lookup::node_id_for_item(&pf.rel_path, item);
+                    for st in &item.supertraits {
+                        if let Some(parent_id) =
+                            resolve_trait_id(st, pf, module_map, lookup, mf, tp, &mut nodes)
+                        {
+                            edges.push(edge(&child_id, &parent_id, "EXTENDS"));
+                        }
+                    }
+                }
+                crate::parser::KIND_STRUCT | crate::parser::KIND_ENUM => {
+                    // derives resolving to LOCAL traits → EXTENDS (heuristic)
+                    let id = crate::lookup::node_id_for_item(&pf.rel_path, item);
+                    for d in &item.derives {
+                        if is_std_derive(d) {
+                            continue;
+                        }
+                        let base_module = crate::walker::module_path_for_file(&pf.rel_path);
+                        if let Some((file, rest)) = module_map.resolve(d, &base_module) {
+                            let name = if rest.is_empty() {
+                                d.rsplit("::").next().unwrap_or(d)
+                            } else {
+                                rest.split("::").next().unwrap_or(&rest)
+                            };
+                            let file_module = crate::walker::module_path_for_file(&file);
+                            let key = if file_module.is_empty() {
+                                name.to_string()
+                            } else {
+                                format!("{}::{}", file_module, name)
+                            };
+                            if let Some(tid) = lookup.item_by_module_name.get(&key).cloned() {
+                                if lookup
+                                    .get(&tid)
+                                    .map(|n| n.node_type == "TRAIT")
+                                    .unwrap_or(false)
+                                {
+                                    edges.push(edge(&id, &tid, "EXTENDS"));
+                                }
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    let _ = mf;
+    InheritanceOutput {
+        edges,
+        third_party_nodes: nodes,
+    }
+}
+
+/// Common derives that are never local traits (std + well-known derives).
+fn is_std_derive(d: &str) -> bool {
+    matches!(
+        d,
+        "Debug"
+            | "Clone"
+            | "Copy"
+            | "PartialEq"
+            | "Eq"
+            | "PartialOrd"
+            | "Ord"
+            | "Hash"
+            | "Default"
+            | "Serialize"
+            | "Deserialize"
+            | "Queryable"
+            | "Insertable"
+            | "QueryableByName"
+            | "Associations"
+            | "Identifiable"
+            | "AsChangeset"
+            | "Selectable"
+            | "FromRow"
+            | "DebugWith"
+            | "thiserror::Error"
+            | "Error"
+    )
+}
+
+/// Resolve a type path (`User`, `models::User`, `crate::models::user::User`)
+/// to its STRUCT/ENUM node id.
+fn resolve_type_id(
+    target: &str,
+    pf: &ParsedFile,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+) -> Option<String> {
+    let base_module = crate::walker::module_path_for_file(&pf.rel_path);
+    if let Some((file, rest)) = module_map.resolve(target, &base_module) {
+        let file_module = crate::walker::module_path_for_file(&file);
+        let name = if rest.is_empty() {
+            target.rsplit("::").next().unwrap_or(target).to_string()
+        } else {
+            rest.split("::").next().unwrap_or(&rest).to_string()
+        };
+        let key = if file_module.is_empty() {
+            name.clone()
+        } else {
+            format!("{}::{}", file_module, name)
+        };
+        if let Some(id) = lookup.item_by_module_name.get(&key) {
+            return Some(id.clone());
+        }
+        // generic target like `Vec<T>` — strip generics, try the base name
+        if let Some(open) = name.find('<') {
+            let base = name[..open].to_string();
+            let key = if file_module.is_empty() {
+                base.clone()
+            } else {
+                format!("{}::{}", file_module, base)
+            };
+            return lookup.item_by_module_name.get(&key).cloned();
+        }
+        return None;
+    }
+    // same-file name
+    lookup.closest_by_path(target, &pf.rel_path)
+}
+
+/// Resolve a trait path to its node id — local TRAIT node, or (external) a
+/// gated [crate]/name::Trait member node.
+fn resolve_trait_id(
+    trait_path: &str,
+    pf: &ParsedFile,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+    mf: &ParsedManifest,
+    tp: &mut ThirdPartyRegistry,
+    nodes: &mut Vec<crate::contract::CodeNode>,
+) -> Option<String> {
+    let base_module = crate::walker::module_path_for_file(&pf.rel_path);
+    if let Some((file, rest)) = module_map.resolve(trait_path, &base_module) {
+        let file_module = crate::walker::module_path_for_file(&file);
+        let name = if rest.is_empty() {
+            trait_path.rsplit("::").next().unwrap_or(trait_path)
+        } else {
+            rest.split("::").next().unwrap_or(&rest)
+        };
+        let key = if file_module.is_empty() {
+            name.to_string()
+        } else {
+            format!("{}::{}", file_module, name)
+        };
+        return lookup.item_by_module_name.get(&key).cloned();
+    }
+    // external trait (serde::Serialize) → gated [crate]/name::Trait member
+    let first = crate::thirdparty::first_segment(trait_path);
+    if crate::thirdparty::is_std(first) {
+        return None;
+    }
+    if !crate::thirdparty::is_external_crate(first, mf) {
+        return None;
+    }
+    if let Some(node) = tp.member_node(first, &trait_path[first.len() + 1..]) {
+        let id = node.id.clone();
+        nodes.push(node);
+        return Some(id);
+    }
+    None
+}

package/extractors/rust/src/lookup.rs

@@ -0,0 +1,226 @@
+// lookup.rs — LookupMaps: ONE shared index built once from parsed facts,
+// consumed by every edge detector. Edge resolution is dict lookups only —
+// never re-walks ASTs (playbook rule). Mirrors go/lookup.go.
+
+use crate::contract::CodeNode;
+use crate::parser::{ParsedFile, ParsedItem};
+use std::collections::HashMap;
+
+pub struct LookupMaps {
+    /// node id → node (all emitted nodes register here)
+    pub node_by_id: HashMap<String, CodeNode>,
+    /// file node per rel path
+    pub file_nodes_by_path: HashMap<String, String>,
+    /// plain name → node ids (collisions disambiguated by closest_by_path)
+    pub nodes_by_name: HashMap<String, Vec<String>>,
+    /// symbol maps: rel file → alias → resolved use target
+    /// (e.g. "User" → "crate::models::user::User") — the bridge for
+    /// Calls/Routes/Tests (mirrors python's symbol_maps)
+    pub symbol_maps: HashMap<String, HashMap<String, String>>,
+    /// glob use targets per file: alias-less → base path ("crate::models")
+    pub glob_maps: HashMap<String, Vec<String>>,
+    /// module_path::Name → node id (exact resolution; Rust names are unique
+    /// per module, so no closest_by_path needed here)
+    pub item_by_module_name: HashMap<String, String>,
+    /// impl owner (target type) → METHOD ids (for receiver-free lookups)
+    pub methods_by_owner: HashMap<String, Vec<String>>,
+    /// trait name (last segment) → METHOD ids from `impl Trait for ...` blocks
+    /// — resolves `Entity::table_name(&x)` trait-dispatch calls
+    pub methods_by_trait: HashMap<String, Vec<String>>,
+}
+
+impl LookupMaps {
+    pub fn new() -> Self {
+        LookupMaps {
+            node_by_id: HashMap::new(),
+            file_nodes_by_path: HashMap::new(),
+            nodes_by_name: HashMap::new(),
+            symbol_maps: HashMap::new(),
+            glob_maps: HashMap::new(),
+            item_by_module_name: HashMap::new(),
+            methods_by_owner: HashMap::new(),
+            methods_by_trait: HashMap::new(),
+        }
+    }
+
+    pub fn register(&mut self, node: CodeNode) {
+        let id = node.id.clone();
+        let name = node.name.clone();
+        self.node_by_id.insert(id.clone(), node);
+        self.nodes_by_name.entry(name).or_default().push(id);
+    }
+
+    pub fn get(&self, id: &str) -> Option<&CodeNode> {
+        self.node_by_id.get(id)
+    }
+
+    /// name lookup with file proximity: prefer nodes in the same file
+    /// (python/go closest_by_path trick).
+    pub fn closest_by_path(&self, name: &str, rel_path: &str) -> Option<String> {
+        let ids = self.nodes_by_name.get(name)?;
+        if ids.is_empty() {
+            return None;
+        }
+        if ids.len() == 1 {
+            return Some(ids[0].clone());
+        }
+        ids.iter()
+            .find(|id| id.starts_with(&format!("{}::", rel_path)))
+            .cloned()
+            .or_else(|| ids.first().cloned())
+    }
+}
+
+// ── node id schemes (deterministic, file-scoped — mirrors go) ──
+
+pub fn func_node_id(rel: &str, name: &str) -> String {
+    format!("{}::{}", rel, name)
+}
+
+pub fn method_node_id(rel: &str, owner: &str, method: &str, trait_path: Option<&str>) -> String {
+    match trait_path {
+        Some(t) => format!("{}::{}.{}::{}", rel, owner, method, last_seg(t)),
+        None => format!("{}::{}.{}", rel, owner, method),
+    }
+}
+
+pub fn struct_node_id(rel: &str, name: &str) -> String {
+    format!("{}::{}", rel, name)
+}
+
+pub fn enum_node_id(rel: &str, name: &str) -> String {
+    format!("{}::{}", rel, name)
+}
+
+pub fn trait_node_id(rel: &str, name: &str) -> String {
+    format!("{}::{}", rel, name)
+}
+
+pub fn impl_block_node_id(rel: &str, label: &str, start_line: i64) -> String {
+    format!("{}::{} [L{}]", rel, label, start_line)
+}
+
+pub fn third_party_id(crate_name: &str) -> String {
+    format!("[crate]/{}", crate_name)
+}
+
+pub fn last_seg(p: &str) -> String {
+    p.rsplit("::").next().unwrap_or(p).to_string()
+}
+
+/// The code-node id for a parsed item (shared by nodes.rs, calls.rs,
+/// routes.rs — ONE source of truth for id computation).
+pub fn node_id_for_item(rel: &str, item: &ParsedItem) -> String {
+    match item.kind {
+        crate::parser::KIND_FUNCTION => func_node_id(rel, &item.name),
+        crate::parser::KIND_METHOD => method_node_id(
+            rel,
+            &item.impl_target,
+            &item.name,
+            item.impl_trait_path.as_deref(),
+        ),
+        crate::parser::KIND_STRUCT => struct_node_id(rel, &item.name),
+        crate::parser::KIND_ENUM => enum_node_id(rel, &item.name),
+        crate::parser::KIND_TRAIT => trait_node_id(rel, &item.name),
+        crate::parser::KIND_IMPL_BLOCK => {
+            let label = if item.impl_trait.is_some() {
+                format!(
+                    "impl {} for {}",
+                    item.impl_trait_path.as_deref().unwrap_or(""),
+                    item.impl_target
+                )
+            } else {
+                format!("impl {}", item.impl_target)
+            };
+            impl_block_node_id(rel, &label, item.start_line)
+        }
+        _ => String::new(),
+    }
+}
+
+/// Build lookup maps from parsed facts. `files_by_rel` maps rel → ParsedFile.
+pub fn build_lookup_maps(files: &[ParsedFile], nodes: &[CodeNode]) -> LookupMaps {
+    let mut l = LookupMaps::new();
+
+    // file nodes
+    for pf in files {
+        l.file_nodes_by_path
+            .insert(pf.rel_path.clone(), format!("file::{}", pf.rel_path));
+    }
+
+    // code nodes (already built by nodes.rs — register + index)
+    for n in nodes {
+        l.register(n.clone());
+    }
+
+    // symbol maps from use declarations
+    for pf in files {
+        let mut syms: HashMap<String, String> = HashMap::new();
+        let mut globs: Vec<String> = vec![];
+        for u in &pf.uses {
+            if u.glob {
+                globs.push(u.target.clone());
+            } else if !u.alias.is_empty() {
+                syms.insert(u.alias.clone(), u.target.clone());
+            }
+        }
+        l.symbol_maps.insert(pf.rel_path.clone(), syms);
+        l.glob_maps.insert(pf.rel_path.clone(), globs);
+    }
+
+    // item maps + impl indexes from parsed items
+    for pf in files {
+        let module_path = crate::walker::module_path_for_file(&pf.rel_path);
+        for item in &pf.items {
+            match item.kind {
+                crate::parser::KIND_STRUCT
+                | crate::parser::KIND_ENUM
+                | crate::parser::KIND_TRAIT => {
+                    let key = if module_path.is_empty() {
+                        item.name.clone()
+                    } else {
+                        format!("{}::{}", module_path, item.name)
+                    };
+                    // prefer the code-node id (impl_blocks have line labels)
+                    let id = struct_node_id(&pf.rel_path, &item.name);
+                    l.item_by_module_name.insert(key, id);
+                }
+                crate::parser::KIND_FUNCTION => {
+                    let key = if module_path.is_empty() {
+                        item.name.clone()
+                    } else {
+                        format!("{}::{}", module_path, item.name)
+                    };
+                    l.item_by_module_name
+                        .insert(key, func_node_id(&pf.rel_path, &item.name));
+                }
+                crate::parser::KIND_METHOD => {
+                    // owner = impl target (set by the impl block's item); the
+                    // method ParsedItem carries it via impl_target? — methods
+                    // are collected inside impl blocks; we resolve the owner
+                    // from the enclosing impl in nodes.rs; here we just index
+                    // what nodes.rs emitted via item_by_module_name too
+                    let owner = &item.impl_target;
+                    if !owner.is_empty() {
+                        let mid = crate::lookup::method_node_id(
+                            &pf.rel_path,
+                            owner,
+                            &item.name,
+                            item.impl_trait_path.as_deref(),
+                        );
+                        l.methods_by_owner
+                            .entry(owner.clone())
+                            .or_default()
+                            .push(mid.clone());
+                        if let Some(t) = &item.impl_trait_path {
+                            let tname = crate::lookup::last_seg(t);
+                            l.methods_by_trait.entry(tname).or_default().push(mid);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    l
+}

package/extractors/rust/src/main.rs

@@ -0,0 +1,53 @@
+// main.rs — entry point: stdin JSON {repoPath, options} → stdout JSON
+// ExtractorResult. JSON only on stdout; logs go to stderr. Mirrors
+// extractors/go/main.go.
+
+mod calls;
+mod contract;
+mod enrich;
+mod extractor;
+mod fingerprint;
+mod imports;
+mod inheritance;
+mod lookup;
+mod module_map;
+mod nodes;
+mod orm_edges;
+mod parser;
+mod routes;
+mod tests;
+mod thirdparty;
+mod walker;
+
+use std::io::Read;
+
+fn main() {
+    let mut raw = String::new();
+    if let Err(e) = std::io::stdin().read_to_string(&mut raw) {
+        eprintln!("error reading stdin: {}", e);
+        std::process::exit(1);
+    }
+    let input: contract::ExtractorInput = match serde_json::from_str(&raw) {
+        Ok(v) => v,
+        Err(e) => {
+            eprintln!("bad input json: {}", e);
+            std::process::exit(1);
+        }
+    };
+    if input.repo_path.is_empty() {
+        eprintln!("repoPath is required");
+        std::process::exit(1);
+    }
+
+    // Options: the engine forwards includeThirdPartyLibs (both spellings are
+    // accepted: engine truth + contract.html docs alias).
+    let opts = extractor::Options::from_json(&input.options);
+
+    let result = extractor::run(&input.repo_path, &opts);
+
+    if let Err(e) = serde_json::to_writer(std::io::stdout(), &result) {
+        eprintln!("error marshaling result: {}", e);
+        std::process::exit(1);
+    }
+    println!();
+}

package/extractors/rust/src/module_map.rs

@@ -0,0 +1,131 @@
+// module_map.rs — module path → file resolution (the Rust analog of Go's
+// package grouping).
+//
+// Module paths are derived from the FILESYSTEM (walker::module_path_for_file):
+//   src/models/user.rs → module `models::user`
+// `mod foo;` declarations are also recorded (mod_decls) but the map itself is
+// filesystem-driven — deterministic by construction.
+//
+// Resolution rules (documented Rust module semantics):
+//   crate::a::b  → absolute within the crate
+//   super::a     → parent of the current file's module
+//   self::a      → sibling of the current file's module
+//   bare `a::b`  → try relative to the current module, then crate root
+
+use crate::parser::ParsedFile;
+use std::collections::HashMap;
+
+pub struct ModuleMap {
+    /// module path → rel file path (all .rs files, empty path = crate root)
+    map: HashMap<String, String>,
+}
+
+impl ModuleMap {
+    pub fn build(files: &[ParsedFile]) -> Self {
+        let mut map = HashMap::new();
+        for pf in files {
+            let mpath = crate::walker::module_path_for_file(&pf.rel_path);
+            map.insert(mpath, pf.rel_path.clone());
+        }
+        ModuleMap { map }
+    }
+
+    /// Is `name` a module reachable from `base_module` (or the crate root)?
+    /// Resolve a use/call path from a file whose module is `base_module`.
+    /// Returns (file rel path, remaining item path) for the LONGEST module
+    /// prefix of the path. External crates / std → None.
+    ///
+    /// `crate::models::user::User` (base "models::db") →
+    ///    candidates: "models::user" (module) + "User" (item)
+    pub fn resolve(&self, path: &str, base_module: &str) -> Option<(String, String)> {
+        let (crate_abs, stripped) = normalize(path, base_module);
+        if crate_abs {
+            // absolute within this crate: try longest module prefix
+            return self.longest_prefix(&stripped);
+        }
+        // bare path: relative to base module first, then crate root
+        if !base_module.is_empty() {
+            let rel = format!("{}::{}", base_module, stripped);
+            if let Some(hit) = self.longest_prefix(&rel) {
+                return Some(hit);
+            }
+        }
+        self.longest_prefix(&stripped)
+    }
+
+    /// Resolve a `use` path (edition-2018 semantics): bare first segments are
+    /// crate-root-absolute — `use axum::routing::get` NEVER means "relative
+    /// to this module"; relative requires explicit `self::`/`super::` (which
+    /// normalize() handles). Call paths (calls.rs) keep resolve()'s
+    /// relative-first ladder; use paths MUST NOT (a bare path whose first
+    /// segment collides with the current module would self-resolve).
+    pub fn resolve_use(&self, path: &str, base_module: &str) -> Option<(String, String)> {
+        let (crate_abs, stripped) = normalize(path, base_module);
+        if crate_abs {
+            return self.longest_prefix(&stripped);
+        }
+        self.longest_prefix(&stripped)
+    }
+
+    /// Try the full path as a module, then backtrack segment by segment.
+    /// `models::user::User` → module `models::user`, item `User`.
+    fn longest_prefix(&self, path: &str) -> Option<(String, String)> {
+        let segs: Vec<&str> = path.split("::").collect();
+        for cut in (1..=segs.len()).rev() {
+            let module = segs[..cut].join("::");
+            if let Some(file) = self.map.get(&module) {
+                let rest = segs[cut..].join("::");
+                return Some((file.clone(), rest));
+            }
+        }
+        None
+    }
+}
+
+/// Normalize a path against the base module. Returns (is_crate_absolute, path).
+fn normalize(path: &str, base_module: &str) -> (bool, String) {
+    // bare root/self/super tokens (glob targets like `use crate::*`)
+    if path == "crate" {
+        return (true, String::new());
+    }
+    if path == "self" {
+        return (true, base_module.to_string());
+    }
+    if path == "super" {
+        let mut base_parts: Vec<&str> = base_module.split("::").collect();
+        base_parts.pop();
+        return (true, base_parts.join("::"));
+    }
+    if let Some(rest) = path.strip_prefix("crate::") {
+        return (true, rest.to_string());
+    }
+    if let Some(rest) = path.strip_prefix("self::") {
+        let p = if base_module.is_empty() {
+            rest.to_string()
+        } else {
+            format!("{}::{}", base_module, rest)
+        };
+        return (true, p);
+    }
+    if let Some(rest) = path.strip_prefix("super::") {
+        // count supers
+        let mut count = 1;
+        let mut rest = rest.to_string();
+        while let Some(r2) = rest.strip_prefix("super::") {
+            count += 1;
+            rest = r2.to_string();
+        }
+        let mut base_parts: Vec<&str> = base_module.split("::").collect();
+        for _ in 0..count {
+            base_parts.pop();
+        }
+        let p = if base_parts.is_empty() {
+            rest
+        } else {
+            format!("{}::{}", base_parts.join("::"), rest)
+        };
+        return (true, p);
+    }
+    // bare — resolve() decides relative-vs-root
+    (false, path.to_string())
+}