``) are ignored.
- """
- if not enclosing_func:
- return
+ Module-scope JSX (e.g. a top-level ``
`` render call) attributes
+ to the File node.
+ """
target = self._resolve_jsx_component_target(
child, language, file_path, import_map or {}, defined_names or set(),
)
if not target:
return
- caller = self._qualify(enclosing_func, file_path, enclosing_class)
+ caller = (
+ self._qualify(enclosing_func, file_path, enclosing_class)
+ if enclosing_func
+ else file_path
+ )
edges.append(EdgeInfo(
kind="CALLS",
source=caller,
@@ -3882,15 +4465,20 @@ def _extract_solidity_constructs(
Returns True if the child was fully handled and should skip
default recursion.
"""
- # Emit statements: emit EventName(...) -> CALLS edge
- if node_type == "emit_statement" and enclosing_func:
+ # Emit statements: emit EventName(...) -> CALLS edge.
+ # Module-scope emits attribute to the File node.
+ if node_type == "emit_statement":
for sub in child.children:
if sub.type == "expression":
for ident in sub.children:
if ident.type == "identifier":
- caller = self._qualify(
- enclosing_func, file_path,
- enclosing_class,
+ caller = (
+ self._qualify(
+ enclosing_func, file_path,
+ enclosing_class,
+ )
+ if enclosing_func
+ else file_path
)
edges.append(EdgeInfo(
kind="CALLS",
@@ -4288,6 +4876,38 @@ def _do_resolve_module(
# ``dart:core`` / ``dart:async`` etc. are SDK libraries we do
# not track; fall through to return None.
+ elif language == "java":
+ # ``import com.example.pkg.ClassName;`` — convert dot-notation
+ # to a relative path and walk up from the caller's directory to
+ # find the source root. Wildcards (``import pkg.*``) and static
+ # member imports (``import static pkg.Class.member``) that don't
+ # resolve as-is are retried after dropping the last segment
+ # (the member name).
+ if module.endswith(".*"):
+ return None # wildcard import — can't resolve to one file
+ rel_path = module.replace(".", "/") + ".java"
+ current = caller_dir
+ while True:
+ target = current / rel_path
+ if target.is_file():
+ return str(target.resolve())
+ if current == current.parent:
+ break
+ current = current.parent
+ # Static import: ``pkg.Class.member`` — strip member, try again
+ dot = module.rfind(".")
+ if dot > 0:
+ class_module = module[:dot]
+ rel_path2 = class_module.replace(".", "/") + ".java"
+ current = caller_dir
+ while True:
+ target = current / rel_path2
+ if target.is_file():
+ return str(target.resolve())
+ if current == current.parent:
+ break
+ current = current.parent
+
return None
def _find_dart_pubspec_root(
@@ -4531,6 +5151,45 @@ def _get_name(self, node, language: str, kind: str) -> Optional[str]:
result = self._get_name(child, language, kind)
if result:
return result
+ # C++: inside function_declarator, the name appears as
+ # qualified_identifier (Class::method), destructor_name (~Class),
+ # operator_name (operator==), or field_identifier. The generic
+ # loop below only recognizes 'identifier'/'type_identifier',
+ # so scoped method definitions would otherwise fall through and
+ # match the outer return-type type_identifier as the function name.
+ # Nested scopes (Outer::Inner::method) produce nested
+ # qualified_identifier nodes — peel until we find the leaf name.
+ if language == "cpp" and node.type == "function_declarator":
+ def _leaf_name(qi):
+ # Walk right-to-left: the rightmost identifier/
+ # destructor_name/operator_name is the method name.
+ # If the rightmost child is itself a qualified_identifier
+ # (nested scope), recurse into it.
+ for sub in reversed(qi.children):
+ if sub.type in (
+ "identifier",
+ "destructor_name",
+ "operator_name",
+ ):
+ return sub.text.decode(
+ "utf-8", errors="replace")
+ if sub.type == "qualified_identifier":
+ inner = _leaf_name(sub)
+ if inner:
+ return inner
+ return None
+ for child in node.children:
+ if child.type == "qualified_identifier":
+ name = _leaf_name(child)
+ if name:
+ return name
+ if child.type in (
+ "field_identifier",
+ "destructor_name",
+ "operator_name",
+ ):
+ return child.text.decode(
+ "utf-8", errors="replace")
# Objective-C method_definition: the method name is the first
# ``identifier`` child (first part of the selector). Multi-part
@@ -4555,6 +5214,16 @@ def _get_name(self, node, language: str, kind: str) -> Optional[str]:
for child in node.children:
if child.type == "field_identifier":
return child.text.decode("utf-8", errors="replace")
+ # Java methods: tree-sitter-java puts type_identifier or generic_type
+ # (return type) before identifier (method name). Must run before
+ # the generic loop, which would match the return type's
+ # type_identifier (e.g. "String", "ConfigBean").
+ # Constructors are fine — they have no return type node.
+ # Kotlin is unaffected: its syntax places the name before the type.
+ if language == "java" and node.type == "method_declaration":
+ for child in node.children:
+ if child.type == "identifier":
+ return child.text.decode("utf-8", errors="replace")
# Swift extensions: name is inside user_type > type_identifier
# (e.g. `extension MyClass: Protocol { ... }`)
if language == "swift" and node.type == "class_declaration":
@@ -4563,6 +5232,89 @@ def _get_name(self, node, language: str, kind: str) -> Optional[str]:
for sub in child.children:
if sub.type == "type_identifier":
return sub.text.decode("utf-8", errors="replace")
+ # Julia: functions / macros nest the name inside
+ # ``signature > call_expression > identifier``. Qualified names
+ # (``function Base.show``) store the method name as the last
+ # identifier of a ``field_expression``. ``where`` clauses wrap the
+ # call in a ``where_expression``.
+ # Structs and abstract types put the name inside ``type_head``,
+ # possibly wrapped in ``binary_expression`` (``<:``) or
+ # ``parametrized_type_expression`` (``{T}``).
+ if language == "julia":
+ if node.type in ("function_definition", "macro_definition"):
+ for child in node.children:
+ if child.type == "signature":
+ call = child
+ # Unwrap where_expression: signature > where_expression > call_expression
+ for sub in call.children:
+ if sub.type == "where_expression":
+ call = sub
+ break
+ # Unwrap typed_expression: signature > typed_expression > call_expression
+ # (``function foo(x)::ReturnType``)
+ for sub in call.children:
+ if sub.type == "typed_expression":
+ call = sub
+ break
+ for sub in call.children:
+ if sub.type == "call_expression":
+ for target in sub.children:
+ if target.type == "identifier":
+ return target.text.decode(
+ "utf-8", errors="replace",
+ )
+ if target.type == "field_expression":
+ # Qualified: last identifier is method name
+ for ident in reversed(target.children):
+ if ident.type == "identifier":
+ return ident.text.decode(
+ "utf-8", errors="replace",
+ )
+ if target.type == "parametrized_type_expression":
+ # Parametric constructor: Foo{T}(x) = ...
+ for p in target.children:
+ if p.type == "identifier":
+ return p.text.decode(
+ "utf-8", errors="replace",
+ )
+ return None
+ return None
+ if node.type in ("struct_definition", "abstract_definition"):
+ for child in node.children:
+ if child.type == "type_head":
+ # Direct identifier: struct Foo ... end
+ for sub in child.children:
+ if sub.type == "identifier":
+ return sub.text.decode(
+ "utf-8", errors="replace",
+ )
+ # Subtyped: type_head > binary_expression > identifier (first)
+ for sub in child.children:
+ if sub.type == "binary_expression":
+ for ident in sub.children:
+ if ident.type == "identifier":
+ return ident.text.decode(
+ "utf-8", errors="replace",
+ )
+ if ident.type == "parametrized_type_expression":
+ for p in ident.children:
+ if p.type == "identifier":
+ return p.text.decode(
+ "utf-8", errors="replace",
+ )
+ return None
+ return None
+ # Parametric (no <:): type_head > parametrized_type_expression
+ for sub in child.children:
+ if sub.type == "parametrized_type_expression":
+ for p in sub.children:
+ if p.type == "identifier":
+ return p.text.decode(
+ "utf-8", errors="replace",
+ )
+ return None
+ return None
+
# Most languages use a 'name' child.
# field_identifier covers C++ class member function names inside
# function_declarator (e.g. virtual std::string get_name() = 0).
@@ -4650,7 +5402,23 @@ def _get_bases(self, node, language: str, source: bytes) -> list[str]:
for arg in child.children:
if arg.type in ("identifier", "attribute"):
bases.append(arg.text.decode("utf-8", errors="replace"))
- elif language in ("java", "csharp", "kotlin"):
+ elif language == "java":
+ # Java: superclass and super_interfaces wrap the keyword
+ # (extends/implements) around type_identifier children.
+ # Taking .text would include the keyword (e.g. "implements Foo").
+ # Drill into the children to extract bare type names.
+ for child in node.children:
+ if child.type == "superclass":
+ for sub in child.children:
+ if sub.type in ("type_identifier", "generic_type"):
+ bases.append(sub.text.decode("utf-8", errors="replace"))
+ elif child.type == "super_interfaces":
+ for sub in child.children:
+ if sub.type == "type_list":
+ for ident in sub.children:
+ if ident.type in ("type_identifier", "generic_type"):
+ bases.append(ident.text.decode("utf-8", errors="replace"))
+ elif language in ("csharp", "kotlin"):
# Look for superclass/interfaces in extends/implements clauses
for child in node.children:
if child.type in (
@@ -4737,6 +5505,43 @@ def _get_bases(self, node, language: str, source: bytes) -> list[str]:
ident.text.decode("utf-8", errors="replace")
)
break
+ elif language == "julia":
+ # Julia: struct Foo <: Bar / abstract type Foo <: Bar end
+ # AST: type_head > binary_expression with operator "<:" and
+ # identifier children; the identifier AFTER the operator is the
+ # supertype.
+ if node.type in ("struct_definition", "abstract_definition"):
+ for child in node.children:
+ if child.type != "type_head":
+ continue
+ for sub in child.children:
+ if sub.type != "binary_expression":
+ continue
+ has_subtype_op = False
+ for op_child in sub.children:
+ if (
+ op_child.type == "operator"
+ and op_child.text == b"<:"
+ ):
+ has_subtype_op = True
+ break
+ if not has_subtype_op:
+ continue
+ idents = [
+ c for c in sub.children if c.type == "identifier"
+ ]
+ # First identifier is the type being defined; the
+ # second (if present) is the supertype.
+ if len(idents) >= 2:
+ bases.append(
+ idents[1].text.decode("utf-8", errors="replace"),
+ )
+ elif len(idents) == 1:
+ # Could be `Parametric{T} <: Super` where the
+ # first side is parametrized_type_expression.
+ bases.append(
+ idents[0].text.decode("utf-8", errors="replace"),
+ )
return bases
def _extract_import(self, node, language: str, source: bytes) -> list[str]:
@@ -4850,6 +5655,70 @@ def _find_string_literal(n) -> Optional[str]:
val = _find_string_literal(node)
if val:
imports.append(val)
+ elif language == "julia":
+ # using/import statements. Children can be:
+ # - identifier (simple: `using Foo`)
+ # - import_path (dotted: `using Foo.Bar`)
+ # - selected_import (`using Foo: bar, baz` — first child is the
+ # module as identifier/import_path, remaining identifiers after
+ # the ':' are imported names to record as ``Module.name``)
+ def _import_path_text(n) -> str:
+ parts: list[str] = []
+ for sub in n.children:
+ if sub.type == "identifier":
+ parts.append(sub.text.decode("utf-8", errors="replace"))
+ return ".".join(parts)
+
+ for child in node.children:
+ if child.type == "identifier":
+ imports.append(
+ child.text.decode("utf-8", errors="replace"),
+ )
+ elif child.type == "import_path":
+ path = _import_path_text(child)
+ if path:
+ imports.append(path)
+ elif child.type == "selected_import":
+ module_name: Optional[str] = None
+ seen_colon = False
+ for sub in child.children:
+ if sub.type == ":":
+ seen_colon = True
+ continue
+ if not seen_colon:
+ if sub.type == "identifier":
+ module_name = sub.text.decode(
+ "utf-8", errors="replace",
+ )
+ elif sub.type == "import_path":
+ path = _import_path_text(sub)
+ if path:
+ module_name = path
+ else:
+ if sub.type == "identifier" and module_name:
+ imported = sub.text.decode(
+ "utf-8", errors="replace",
+ )
+ imports.append(f"{module_name}.{imported}")
+ elif language == "gdscript":
+ # ``extends Node`` → type > identifier("Node")
+ # ``extends "res://path.gd"`` → string literal
+ # ``extends SomeClass.Nested`` → type node (keep full text)
+ for child in node.children:
+ if child.type == "type":
+ txt = child.text.decode("utf-8", errors="replace").strip()
+ if txt:
+ imports.append(txt)
+ elif child.type == "string":
+ val = child.text.decode("utf-8", errors="replace").strip("'\"")
+ if val:
+ imports.append(val)
+ elif child.type == "identifier":
+ # Fallback: some grammar variants expose the parent type as
+ # a bare identifier next to the ``extends`` keyword.
+ txt = child.text.decode("utf-8", errors="replace")
+ if txt and txt != "extends":
+ imports.append(txt)
else:
# Fallback: just record the text
imports.append(text)
@@ -4863,6 +5732,55 @@ def _get_call_name(self, node, language: str, source: bytes) -> Optional[str]:
first = node.children[0]
+ # Julia macrocall: ``@test expr`` — name is inside
+ # ``macro_identifier > identifier``. Prefix with ``@`` to distinguish
+ # from ordinary calls.
+ if language == "julia" and node.type == "macrocall_expression":
+ for child in node.children:
+ if child.type == "macro_identifier":
+ for sub in child.children:
+ if sub.type == "identifier":
+ raw = sub.text.decode("utf-8", errors="replace")
+ return f"@{raw}"
+ return None
+ return None
+
+ # Julia broadcast call: ``sin.(x)`` — same structure as
+ # call_expression (first child is identifier or field_expression)
+ # so the generic paths below handle it.
+ if language == "php":
+ def _normalize_php_name(text: str) -> str:
+ # PHP global/function names can be prefixed with '\\'.
+ return text.lstrip("\\")
+
+ if node.type == "function_call_expression":
+ for child in node.children:
+ if child.type in ("name", "qualified_name"):
+ raw = child.text.decode("utf-8", errors="replace")
+ return _normalize_php_name(raw)
+ return None
+
+ if node.type in (
+ "member_call_expression",
+ "nullsafe_member_call_expression",
+ ):
+ for child in reversed(node.children):
+ if child.type == "name":
+ return child.text.decode("utf-8", errors="replace")
+ return None
+
+ if node.type == "scoped_call_expression":
+ parts = []
+ for child in node.children:
+ if child.type in ("name", "qualified_name"):
+ raw = child.text.decode("utf-8", errors="replace")
+ parts.append(_normalize_php_name(raw))
+ if len(parts) >= 2:
+ return f"{parts[0]}::{parts[-1]}"
+ if parts:
+ return parts[0]
+ return None
+
# Scala: instance_expression (new Foo(...)) – extract the type name
if node.type == "instance_expression":
for child in node.children:
@@ -5199,21 +6117,25 @@ def _handle_r_call(
import_map, defined_names,
)
- if enclosing_func:
- call_name = self._get_call_name(node, language, source)
- if call_name:
- caller = self._qualify(enclosing_func, file_path, enclosing_class)
- target = self._resolve_call_target(
- call_name, file_path, language,
- import_map or {}, defined_names or set(),
- )
- edges.append(EdgeInfo(
- kind="CALLS",
- source=caller,
- target=target,
- file_path=file_path,
- line=node.start_point[0] + 1,
- ))
+ # Module-scope R calls attribute to the File node.
+ call_name = self._get_call_name(node, language, source)
+ if call_name:
+ caller = (
+ self._qualify(enclosing_func, file_path, enclosing_class)
+ if enclosing_func
+ else file_path
+ )
+ target = self._resolve_call_target(
+ call_name, file_path, language,
+ import_map or {}, defined_names or set(),
+ )
+ edges.append(EdgeInfo(
+ kind="CALLS",
+ source=caller,
+ target=target,
+ file_path=file_path,
+ line=node.start_point[0] + 1,
+ ))
self._extract_from_tree(
node, source, language, file_path, nodes, edges,
diff --git a/tests/test_main.py b/tests/test_main.py
index 61fbbf49..1a536c47 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -16,6 +16,17 @@
from code_review_graph import main as crg_main
+@pytest.fixture(autouse=True)
+def _isolate_crg_tools_env(monkeypatch):
+ """Always strip CRG_TOOLS so that any test invoking ``crg_main.main``
+ does not accidentally permanently shrink the global tool registry
+ when the suite runs under a developer environment that exports
+ ``CRG_TOOLS``. Without this the snapshot/restore in
+ ``TestApplyToolFilter._restore_tools`` only sees the already-filtered
+ set and cannot restore the dropped tools."""
+ monkeypatch.delenv("CRG_TOOLS", raising=False)
+
+
class TestResolveRepoRoot:
"""Precedence rules for _resolve_repo_root (see #222 follow-up)."""
@@ -59,7 +70,7 @@ def fake_run(**kwargs):
monkeypatch.setattr(crg_main.mcp, "run", fake_run)
crg_main.main(repo_root=None)
- assert calls == [{"transport": "stdio"}]
+ assert calls == [{"transport": "stdio", "show_banner": False}]
def test_http_calls_mcp_run_with_host_port(self, monkeypatch):
calls: list[dict] = []
@@ -225,25 +236,37 @@ class TestApplyToolFilter:
def _restore_tools(self):
"""Snapshot registered tools before test, restore after.
- _apply_tool_filter calls ``mcp.remove_tool()`` which is
- permanent. We restore by re-adding from the saved snapshot.
+ ``_apply_tool_filter`` calls ``mcp.remove_tool()`` which is
+ permanent. We snapshot the list of Tool objects via the public
+ ``list_tools()`` async API (FastMCP >=3) and re-register them
+ after the test body runs.
"""
- original = dict(crg_main.mcp._tool_manager._tools)
+ import asyncio
+
+ original = asyncio.run(crg_main.mcp.list_tools())
yield
- crg_main.mcp._tool_manager._tools.clear()
- crg_main.mcp._tool_manager._tools.update(original)
+ current_names = {
+ t.name for t in asyncio.run(crg_main.mcp.list_tools())
+ }
+ for tool in original:
+ if tool.name not in current_names:
+ crg_main.mcp.add_tool(tool)
@pytest.fixture(autouse=True)
def _clean_env(self, monkeypatch):
"""Ensure CRG_TOOLS is not set from the outer environment."""
monkeypatch.delenv("CRG_TOOLS", raising=False)
+ @staticmethod
+ async def _tool_names() -> set[str]:
+ return {t.name for t in await crg_main.mcp.list_tools()}
+
@pytest.mark.asyncio
async def test_no_filter_keeps_all_tools(self):
"""When neither --tools nor CRG_TOOLS is set, all tools remain."""
- before = set((await crg_main.mcp.get_tools()).keys())
+ before = await self._tool_names()
crg_main._apply_tool_filter(None)
- after = set((await crg_main.mcp.get_tools()).keys())
+ after = await self._tool_names()
assert before == after
@pytest.mark.asyncio
@@ -251,7 +274,7 @@ async def test_filter_via_argument(self):
"""The ``tools`` argument keeps only the listed tools."""
keep = "query_graph_tool,semantic_search_nodes_tool"
crg_main._apply_tool_filter(keep)
- remaining = set((await crg_main.mcp.get_tools()).keys())
+ remaining = await self._tool_names()
assert remaining == {"query_graph_tool", "semantic_search_nodes_tool"}
@pytest.mark.asyncio
@@ -259,7 +282,7 @@ async def test_filter_via_env_var(self, monkeypatch):
"""The ``CRG_TOOLS`` env var works as fallback."""
monkeypatch.setenv("CRG_TOOLS", "query_graph_tool")
crg_main._apply_tool_filter(None)
- remaining = set((await crg_main.mcp.get_tools()).keys())
+ remaining = await self._tool_names()
assert remaining == {"query_graph_tool"}
@pytest.mark.asyncio
@@ -267,21 +290,21 @@ async def test_argument_takes_precedence_over_env(self, monkeypatch):
"""CLI --tools wins over CRG_TOOLS env var."""
monkeypatch.setenv("CRG_TOOLS", "list_repos_tool")
crg_main._apply_tool_filter("query_graph_tool")
- remaining = set((await crg_main.mcp.get_tools()).keys())
+ remaining = await self._tool_names()
assert remaining == {"query_graph_tool"}
@pytest.mark.asyncio
async def test_empty_string_is_noop(self):
"""An empty string should not remove all tools."""
- before = set((await crg_main.mcp.get_tools()).keys())
+ before = await self._tool_names()
crg_main._apply_tool_filter("")
- after = set((await crg_main.mcp.get_tools()).keys())
+ after = await self._tool_names()
assert before == after
@pytest.mark.asyncio
async def test_whitespace_handling(self):
"""Spaces around tool names are stripped."""
crg_main._apply_tool_filter(" query_graph_tool , semantic_search_nodes_tool ")
- remaining = set((await crg_main.mcp.get_tools()).keys())
+ remaining = await self._tool_names()
assert remaining == {"query_graph_tool", "semantic_search_nodes_tool"}
diff --git a/tests/test_parser.py b/tests/test_parser.py
index 48bac552..841a62ac 100644
--- a/tests/test_parser.py
+++ b/tests/test_parser.py
@@ -1258,6 +1258,48 @@ def test_elixir_top_level_dotted_call_attributes_to_file(self):
]
assert len(top_level) == 1
+ def test_cpp_scoped_method_names(self, tmp_path):
+ """C++ scoped method definitions must extract the leaf method name,
+ not the return-type identifier.
+
+ Regression: previously ``Ret Class::method()`` indexed as ``Ret``
+ (return type) and ``void Class::method()`` was silently dropped
+ because _get_name() fell through to the generic identifier loop,
+ which did not recognise qualified_identifier, destructor_name, or
+ operator_name nodes inside function_declarator.
+ """
+ src = b"""
+void PlaybackExtension::resetStateForPool() {}
+quint64 PlaybackExtension::startTimestamp() const { return 0; }
+PlaybackExtension::~PlaybackExtension() {}
+~PlaybackExtension() {}
+bool operator==(const A& a, const B& b) { return true; }
+bool MyClass::operator<(const MyClass& o) const { return true; }
+void foo() {}
+int SnapshotController::getHandleIndex() { return 0; }
+bool PlaybackWidget::AllocateResourceStrategy::allocateExtensionResource(int i) { return true; }
+void A::B::C::deep() {}
+ExtensionID PlaybackExtension::ID() const { return {}; }
+"""
+ p = tmp_path / "x.cpp"
+ p.write_bytes(src)
+ nodes, _ = self.parser.parse_file(p)
+ names = [n.name for n in nodes if n.kind == "Function"]
+ assert names == [
+ "resetStateForPool",
+ "startTimestamp",
+ "~PlaybackExtension",
+ "~PlaybackExtension",
+ "operator==",
+ "operator<",
+ "foo",
+ "getHandleIndex",
+ "allocateExtensionResource",
+ "deep",
+ "ID",
+ ]
+
+
class TestCppScopedFunctionName:
"""Regression tests for C++ scoped function name extraction.