codegraphcontext-rust 0.9.15__tar.gz → 0.9.16__tar.gz

{codegraphcontext_rust-0.9.15 → codegraphcontext_rust-0.9.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext-rust
-Version: 0.9.15
+Version: 0.9.16
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{codegraphcontext_rust-0.9.15 → codegraphcontext_rust-0.9.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "codegraphcontext-rust"
-version = "0.9.15"
+version = "0.9.16"
 description = "Rust-accelerated code indexing engine for CodeGraphContext. 19 languages, 5-18x faster parsing via tree-sitter + rayon."
 authors = [
     { name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" },

{codegraphcontext_rust-0.9.15 → codegraphcontext_rust-0.9.16}/rust/cgc-core/src/lang/go.rs

@@ -176,8 +176,11 @@ impl GoExtractor {
                 if child.kind() == "parameter_declaration" {
                     let type_node = child.child_by_field_name("type");
                     if let Some(tn) = type_node {
-                        let type_text = get_node_text(&tn, source);
-                        return Some(type_text.trim_start_matches('*').to_string());
+                        // Strip pointer and type parameters: `*List[T]` -> `List`.
+                        return self.base_type_name(&tn, source).or_else(|| {
+                            let type_text = get_node_text(&tn, source);
+                            Some(type_text.trim_start_matches('*').to_string())
+                        });
                     }
                 }
             }
@@ -185,6 +188,69 @@ impl GoExtractor {
         None
     }
 
+    /// Bare type name of a type node: `T`, `*T`, `pkg.T`, `T[U]` all yield `T`.
+    fn base_type_name(&self, type_node: &Node, source: &[u8]) -> Option<String> {
+        match type_node.kind() {
+            "type_identifier" => Some(get_node_text(type_node, source).to_string()),
+            "pointer_type" => type_node
+                .named_child(0)
+                .and_then(|inner| self.base_type_name(&inner, source)),
+            "qualified_type" => type_node
+                .child_by_field_name("name")
+                .map(|n| get_node_text(&n, source).to_string()),
+            "generic_type" => type_node
+                .child_by_field_name("type")
+                .and_then(|inner| self.base_type_name(&inner, source)),
+            _ => None,
+        }
+    }
+
+    /// Embedded (anonymous) fields of a struct_type, e.g. `Base`, `*Base`, `pkg.Base`.
+    fn struct_embedded_bases(&self, struct_type: &Node, source: &[u8]) -> Vec<String> {
+        let mut bases = Vec::new();
+        for i in 0..struct_type.named_child_count() {
+            let Some(field_list) = struct_type.named_child(i) else { continue };
+            if field_list.kind() != "field_declaration_list" {
+                continue;
+            }
+            for j in 0..field_list.named_child_count() {
+                let Some(field) = field_list.named_child(j) else { continue };
+                if field.kind() != "field_declaration" || field.child_by_field_name("name").is_some() {
+                    continue;
+                }
+                if let Some(base) = field
+                    .child_by_field_name("type")
+                    .and_then(|t| self.base_type_name(&t, source))
+                {
+                    bases.push(base);
+                }
+            }
+        }
+        bases
+    }
+
+    /// Embedded interfaces of an interface_type, e.g. `io.Reader`, `Closer`.
+    /// Type-set constraints (`~int | string`) and the builtins `any`/`comparable`
+    /// are not inheritance and are skipped.
+    fn interface_embedded_bases(&self, interface_type: &Node, source: &[u8]) -> Vec<String> {
+        let mut bases = Vec::new();
+        for i in 0..interface_type.named_child_count() {
+            let Some(elem) = interface_type.named_child(i) else { continue };
+            if elem.kind() != "type_elem" || elem.named_child_count() != 1 {
+                continue;
+            }
+            if let Some(base) = elem
+                .named_child(0)
+                .and_then(|t| self.base_type_name(&t, source))
+            {
+                if base != "any" && base != "comparable" {
+                    bases.push(base);
+                }
+            }
+        }
+        bases
+    }
+
     fn get_docstring(&self, func_node: &Node, source: &[u8]) -> Option<String> {
         let mut prev = func_node.prev_sibling();
         while let Some(sib) = prev {
@@ -382,12 +448,18 @@ impl LanguageExtractor for GoExtractor {
                 None => continue,
             };
             let name = get_node_text(&node, source).to_string();
+            let bases = node
+                .parent()
+                .and_then(|spec| spec.child_by_field_name("type"))
+                .filter(|t| t.kind() == "struct_type")
+                .map(|t| self.struct_embedded_bases(&t, source))
+                .unwrap_or_default();
 
             let mut class = ClassData {
                 name,
                 line_number: type_decl.start_position().row + 1,
                 end_line: type_decl.end_position().row + 1,
-                bases: Vec::new(),
+                bases,
                 context: None,
                 decorators: Vec::new(),
                 lang: self.lang_name().to_string(),
@@ -414,12 +486,18 @@ impl LanguageExtractor for GoExtractor {
                 None => continue,
             };
             let name = get_node_text(&node, source).to_string();
+            let bases = node
+                .parent()
+                .and_then(|spec| spec.child_by_field_name("type"))
+                .filter(|t| t.kind() == "interface_type")
+                .map(|t| self.interface_embedded_bases(&t, source))
+                .unwrap_or_default();
 
             let mut class = ClassData {
                 name,
                 line_number: type_decl.start_position().row + 1,
                 end_line: type_decl.end_position().row + 1,
-                bases: Vec::new(),
+                bases,
                 context: None,
                 decorators: Vec::new(),
                 lang: self.lang_name().to_string(),
@@ -668,6 +746,78 @@ type Speaker interface {
         assert!(classes.iter().any(|c| c.name == "Speaker"));
     }
 
+    #[test]
+    fn test_struct_embedded_fields_as_bases() {
+        let code = r#"
+package main
+
+type Server struct {
+    Base
+    *Logger
+    http.Handler
+    name string
+    a, b int
+}
+"#;
+        let (tree, source) = parse_source(code);
+        let ext = GoExtractor;
+        let classes = ext.find_classes(&tree.root_node(), &source, false);
+        let server = classes.iter().find(|c| c.name == "Server").unwrap();
+        assert_eq!(server.bases, vec!["Base", "Logger", "Handler"]);
+    }
+
+    #[test]
+    fn test_interface_embedding_as_bases() {
+        let code = r#"
+package main
+
+type ReadCloser interface {
+    io.Reader
+    Closer
+    Extra() int
+}
+
+type Number interface {
+    ~int | ~float64
+}
+
+type Key interface {
+    comparable
+}
+"#;
+        let (tree, source) = parse_source(code);
+        let ext = GoExtractor;
+        let classes = ext.find_classes(&tree.root_node(), &source, false);
+        let rc = classes.iter().find(|c| c.name == "ReadCloser").unwrap();
+        assert_eq!(rc.bases, vec!["Reader", "Closer"]);
+        let num = classes.iter().find(|c| c.name == "Number").unwrap();
+        assert!(num.bases.is_empty());
+        let key = classes.iter().find(|c| c.name == "Key").unwrap();
+        assert!(key.bases.is_empty());
+    }
+
+    #[test]
+    fn test_generic_receiver_strips_type_params() {
+        let code = r#"
+package main
+
+type List[T any] struct {
+    items []T
+}
+
+func (l *List[T]) Push(v T) {}
+
+func (p Pair[K, V]) Key() K { return p.k }
+"#;
+        let (tree, source) = parse_source(code);
+        let ext = GoExtractor;
+        let funcs = ext.find_functions(&tree.root_node(), &source, false);
+        let push = funcs.iter().find(|f| f.name == "Push").unwrap();
+        assert_eq!(push.class_context.as_deref(), Some("List"));
+        let key = funcs.iter().find(|f| f.name == "Key").unwrap();
+        assert_eq!(key.class_context.as_deref(), Some("Pair"));
+    }
+
     #[test]
     fn test_find_imports() {
         let code = r#"

{codegraphcontext_rust-0.9.15 → codegraphcontext_rust-0.9.16}/rust/cgc-core/src/lang/java.rs

@@ -183,6 +183,37 @@ impl JavaExtractor {
         Some(base.to_string())
     }
 
+    fn child_of_kind<'t>(node: &Node<'t>, kind: &str) -> Option<Node<'t>> {
+        (0..node.child_count())
+            .filter_map(|i| node.child(i))
+            .find(|c| c.kind() == kind)
+    }
+
+    /// Type names listed under a superclass / super_interfaces /
+    /// extends_interfaces node, with generic arguments stripped.
+    fn base_type_names(node: &Node, source: &[u8]) -> Vec<String> {
+        // The types sit either directly under the node (superclass) or in a
+        // type_list child (super_interfaces, extends_interfaces).
+        let holder = Self::child_of_kind(node, "type_list")
+            .or_else(|| Self::child_of_kind(node, "interface_type_list"))
+            .unwrap_or(*node);
+        let mut names = Vec::new();
+        for i in 0..holder.child_count() {
+            let Some(child) = holder.child(i) else { continue };
+            let type_node = match child.kind() {
+                "type_identifier" | "scoped_type_identifier" => child,
+                // generic_type: first child is the raw type, then type_arguments
+                "generic_type" => match child.child(0) {
+                    Some(t) => t,
+                    None => continue,
+                },
+                _ => continue,
+            };
+            names.push(get_node_text(&type_node, source).to_string());
+        }
+        names
+    }
+
     /// Start byte of the closest ancestor of one of `kinds`, if any.
     fn enclosing_scope(node: &Node, kinds: &[&str]) -> Option<usize> {
         let mut curr = node.parent();
@@ -254,6 +285,38 @@ impl JavaExtractor {
         None
     }
 
+    /// Resolve `this.<var>` to a field's declared type, searching only the
+    /// enclosing type declarations (innermost first).
+    fn lookup_field_type(
+        node: &Node,
+        var: &str,
+        typed: &HashMap<(usize, String), String>,
+    ) -> Option<String> {
+        let mut curr = node.parent();
+        while let Some(p) = curr {
+            if TYPE_DECL_KINDS.contains(&p.kind()) {
+                if let Some(t) = typed.get(&(p.start_byte(), var.to_string())) {
+                    return Some(t.clone());
+                }
+            }
+            curr = p.parent();
+        }
+        None
+    }
+
+    /// Simple type name of a constructor call's type node:
+    /// `Box<String>` → `Box`, `a.b.Foo` → `Foo`, `ArrayList<>` → `ArrayList`.
+    fn constructor_name(type_node: &Node, source: &[u8]) -> String {
+        let raw = if type_node.kind() == "generic_type" {
+            type_node.child(0).unwrap_or(*type_node)
+        } else {
+            *type_node
+        };
+        let text = get_node_text(&raw, source);
+        let text = text.split('<').next().unwrap_or(text);
+        text.rsplit('.').next().unwrap_or(text).trim().to_string()
+    }
+
     /// Extract parameter names from a formal_parameters text like "(int x, String name)"
     fn extract_parameter_names(&self, params_text: &str) -> Vec<String> {
         let mut params = Vec::new();
@@ -384,56 +447,24 @@ impl LanguageExtractor for JavaExtractor {
             };
             let class_name = get_node_text(&name_node, source).to_string();
 
+            // Base types, as simple names usable for lookup (generic arguments
+            // dropped): `extends Base<T>` → `Base`, `implements a.b.Api` → `a.b.Api`.
             let mut bases = Vec::new();
 
-            // Look for superclass (extends)
-            if let Some(superclass_node) = node.child_by_field_name("superclass") {
-                bases.push(get_node_text(&superclass_node, source).to_string());
+            // class X extends Base
+            if let Some(superclass) = node.child_by_field_name("superclass") {
+                bases.extend(Self::base_type_names(&superclass, source));
             }
-
-            // Look for interfaces (implements) - try field name first, then scan children
-            let interfaces_node = node
+            // class/record/enum X implements A, B
+            if let Some(ifaces) = node
                 .child_by_field_name("interfaces")
-                .or_else(|| {
-                    (0..node.child_count())
-                        .filter_map(|i| node.child(i))
-                        .find(|c| c.kind() == "super_interfaces")
-                });
-
-            if let Some(ifaces) = interfaces_node {
-                // Find type_list within
-                let type_list = ifaces
-                    .child_by_field_name("list")
-                    .or_else(|| {
-                        (0..ifaces.child_count())
-                            .filter_map(|i| ifaces.child(i))
-                            .find(|c| c.kind() == "type_list")
-                    });
-
-                if let Some(tl) = type_list {
-                    for i in 0..tl.child_count() {
-                        if let Some(child) = tl.child(i) {
-                            if matches!(
-                                child.kind(),
-                                "type_identifier" | "generic_type" | "scoped_type_identifier"
-                            ) {
-                                bases.push(get_node_text(&child, source).to_string());
-                            }
-                        }
-                    }
-                } else {
-                    // Fallback: scan children of interfaces node directly
-                    for i in 0..ifaces.child_count() {
-                        if let Some(child) = ifaces.child(i) {
-                            if matches!(
-                                child.kind(),
-                                "type_identifier" | "generic_type" | "scoped_type_identifier"
-                            ) {
-                                bases.push(get_node_text(&child, source).to_string());
-                            }
-                        }
-                    }
-                }
+                .or_else(|| Self::child_of_kind(&node, "super_interfaces"))
+            {
+                bases.extend(Self::base_type_names(&ifaces, source));
+            }
+            // interface X extends A, B
+            if let Some(ext) = Self::child_of_kind(&node, "extends_interfaces") {
+                bases.extend(Self::base_type_names(&ext, source));
             }
 
             let (context, _, _) = get_parent_context(&node, source, TYPE_DECL_KINDS);
@@ -475,10 +506,11 @@ impl LanguageExtractor for JavaExtractor {
             let trimmed = import_text.trim();
             let path = if let Some(rest) = trimmed.strip_prefix("import") {
                 let rest = rest.trim();
-                let rest = if let Some(r) = rest.strip_prefix("static") {
-                    r.trim()
-                } else {
-                    rest
+                // `static` is a keyword only when followed by whitespace
+                // (a package may be named e.g. `staticfoo`).
+                let rest = match rest.strip_prefix("static") {
+                    Some(r) if r.starts_with(char::is_whitespace) => r.trim(),
+                    _ => rest,
                 };
                 rest.trim_end_matches(';').trim().to_string()
             } else {
@@ -513,10 +545,15 @@ impl LanguageExtractor for JavaExtractor {
                 continue;
             }
 
-            let call_name = get_node_text(&node, source).to_string();
+            let call_text = get_node_text(&node, source);
+            let call_name = if node.parent().map(|p| p.kind()) == Some("object_creation_expression") {
+                Self::constructor_name(&node, source)
+            } else {
+                call_text.to_string()
+            };
             let line_number = node.start_position().row + 1;
 
-            let call_key = format!("{}_{}", call_name, line_number);
+            let call_key = format!("{}_{}", call_text, line_number);
             if seen_calls.contains(&call_key) {
                 continue;
             }
@@ -568,12 +605,19 @@ impl LanguageExtractor for JavaExtractor {
                     // Resolve the receiver variable to its declared type when
                     // known; otherwise keep the identifier (e.g. a static
                     // `Foo.bar()` call, where the identifier is the type).
-                    let base_obj = obj_text.split('.').next().unwrap_or(obj_text);
+                    // `this.repo.save()` → the receiver is the field `repo`.
+                    let (field_only, obj_rest) = match obj_text.strip_prefix("this.") {
+                        Some(rest) => (true, rest),
+                        None => (false, obj_text),
+                    };
+                    let base_obj = obj_rest.split('.').next().unwrap_or(obj_rest);
                     if !base_obj.contains('(') {
-                        inferred_obj_type = Some(
+                        let resolved = if field_only {
+                            Self::lookup_field_type(&node, base_obj, &typed_names)
+                        } else {
                             Self::lookup_receiver_type(&node, base_obj, &typed_names)
-                                .unwrap_or_else(|| base_obj.to_string()),
-                        );
+                        };
+                        inferred_obj_type = Some(resolved.unwrap_or_else(|| base_obj.to_string()));
                     }
                 }
             } else if call_node.kind() == "object_creation_expression" {
@@ -838,4 +882,71 @@ public class PointController {
         assert_eq!(ty("req.validate").as_deref(), Some("Req")); // parameter
         assert_eq!(ty("Helper.run").as_deref(), Some("Helper")); // static call
     }
+
+    #[test]
+    fn test_bases_strip_keywords_and_generics() {
+        let code = r#"
+public class OrderController extends BaseCrudController<
+        CreateReq, UpdateReq> implements Auditable, a.b.Traceable<Order> {
+}
+public interface SettingRepository extends TenantAwareRepository<Setting>, Searchable {
+}
+public record Point(int x) implements Comparable<Point> {
+}
+"#;
+        let (tree, source) = parse_source(code);
+        let classes = JavaExtractor.find_classes(&tree.root_node(), &source, false);
+        let bases = |n: &str| classes.iter().find(|c| c.name == n).unwrap().bases.clone();
+        assert_eq!(bases("OrderController"), vec!["BaseCrudController", "Auditable", "a.b.Traceable"]);
+        assert_eq!(bases("SettingRepository"), vec!["TenantAwareRepository", "Searchable"]);
+        assert_eq!(bases("Point"), vec!["Comparable"]);
+    }
+
+    #[test]
+    fn test_this_field_receiver_type() {
+        let code = r#"
+public class OrderService {
+    private final OrderRepository repo;
+    public void save(Order repo) {
+        this.repo.save(repo);
+    }
+}
+"#;
+        let (tree, source) = parse_source(code);
+        let calls = JavaExtractor.find_calls(&tree.root_node(), &source);
+        let save = calls.iter().find(|c| c.full_name == "this.repo.save").unwrap();
+        // The field type wins over the same-named parameter.
+        assert_eq!(save.inferred_obj_type.as_deref(), Some("OrderRepository"));
+    }
+
+    #[test]
+    fn test_static_import_requires_keyword() {
+        let code = r#"
+import static a.B.c;
+import staticfoo.Bar;
+"#;
+        let (tree, source) = parse_source(code);
+        let imports = JavaExtractor.find_imports(&tree.root_node(), &source);
+        let names: Vec<_> = imports.iter().map(|i| i.name.as_str()).collect();
+        assert_eq!(names, vec!["a.B.c", "staticfoo.Bar"]);
+    }
+
+    #[test]
+    fn test_constructor_call_simple_name() {
+        let code = r#"
+public class Main {
+    public void run() {
+        Box<String> b = new Box<String>();
+        List<String> l = new ArrayList<>();
+        Object f = new a.b.Foo();
+    }
+}
+"#;
+        let (tree, source) = parse_source(code);
+        let calls = JavaExtractor.find_calls(&tree.root_node(), &source);
+        let full = |n: &str| calls.iter().find(|c| c.name == n).unwrap().full_name.clone();
+        assert_eq!(full("Box"), "Box<String>");
+        assert_eq!(full("ArrayList"), "ArrayList<>");
+        assert_eq!(full("Foo"), "a.b.Foo");
+    }
 }