``) 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,
@@ -3347,15 +3912,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",
@@ -4010,6 +4580,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
for child in node.children:
if child.type in (
@@ -4182,6 +4835,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]:
@@ -4295,6 +4985,51 @@ 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}")
else:
# Fallback: just record the text
imports.append(text)
@@ -4308,6 +5043,23 @@ 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.
+
# Scala: instance_expression (new Foo(...)) – extract the type name
if node.type == "instance_expression":
for child in node.children:
@@ -4644,21 +5396,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,