C/C++ preprocessor macros become Macro nodes (#375): #define SIMPLE 1 -> preproc_def #define FN(x) (2 * (x)) -> preproc_function_def The na

Extract all arguments from a call expression into call->args[]. */

Try common field-based callee resolution (function, name, method fields).

Extract callee name from a call node

CFML tag function: <cffunction name="foo" ...> ... </cffunction> (#38). The cf_function_tag node has no `name` field — the name lives in a cf_attribut

Extract methods inside a class body

Extract class-level variables (field declarations inside class bodies)

COBOL: a `CALL 'HELPER'` is a call_statement whose `x` field is a string literal naming the called program; the callee is that string sans quotes.

Recover a queue/topic identity from a Go composite-literal input struct, e.g. &sqs.SendMessageInput{QueueUrl: queueUrl, MessageBody: body} sns.Publish

Handle config language class nodes (TOML, INI, XML, Markdown, HCL). Returns true if handled (caller should return early).

Pull the constructed type name out of a constructor/instantiation node: new_expression (TS/JS) -> `constructor`/`type` field or first t

Extract class/type name from a constructor expression. e.g., new Foo() -> "Foo", Foo() -> "Foo" (if uppercase), Foo{} -> "Foo"

Extract base classes from a C++ base_class_clause node.

Extract base class name text from a single base_class child node.

C++ implicit calls that produce no textual call node: the destructor (`delete p`), the copy/move constructor (`T a = b;` copy-init), and the conversio

C++ overloaded binary operator `a + b`: the operator method (`operator+`) is invoked implicitly, so the call walk never sees a call node. Synthesize a

Run cbm_extract_file in a forked child; return true if the child died from a * signal (SIGBUS/SIGSEGV/...). ASan does not install a SIGBUS handler, s

Extract text from a single C# base_list named child, stripping generic args. */

C# base_list: iterate children, find base_list node, extract bases. */

C# variable extraction: handle field_declaration with nested variable_declaration.

CSS: a `call_expression` (e.g. `url(...)`, `calc(...)`) carries its callee on a plain `function_name` child rather than a `function`/`name` field, so

Look at __construct: any `$this->X = $param;` where $param is a typed * parameter contributes a field type for X. */

Dart: the invocation `selector` (the `(...)` part) follows the callee identifier as a sibling; `new_expression`'s first named child is the type.

Extract decorator function name from the raw attribute/annotation text. * Handles the per-language surface syntaxes: * Python/TS: "@app.route('/a

Tokenize all decorators on a node into unique words. * Returns heap-allocated array, caller frees each word and the array. */

Extract the "decorators" array from a properties_json string. * Returns a NULL-terminated array of strings. Caller must free array and strings. */

Emit individual Variable nodes for each destructured binding. */

Process Elixir call nodes iteratively — handles defmodule/def/defp/defmacro without recursion between extract_elixir_call ↔ extract_elixir_module_def.

Handle Elixir def/defp/defmacro — extract function definition.

Elm: a `function_call_expr` has a `target` field; the callee identifier is target > value_expr > `name` field (value_qid) > lower_case_identifier.

Run full model inference on each token string. Returns (N, D) float32.

Extract enum members as Variable nodes (C#, Java, TypeScript, C++). */

Erlang: extract callee from call node's first child.

Extract compiler flag args from either "arguments" array or "command" string. */

Haskell/OCaml: extract callee from apply/infix nodes.

F#: application_expression head is a long_identifier_or_op wrapper, not a bare identifier, so extract_fp_callee's accepted-type list would miss it.

FunC: a `function_application` carries the callee on its `function:` field.

Extract a Go file using cbm_extract_file (runs single-file LSP internally) */

Extract Go multi-return types from a parameter_list result node.

Go-specific: type_spec/type_alias comment is before the parent type_declaration.

Helm / Go template named-template definition: {{ define "chart.fullname" }} ... {{ end }} (#338). The name is a string-literal child of define_action.

Groovy: function_call's first named child is the callee identifier (the generic first-child fallback misses it because child 0 is anonymous).

Verilog / SystemVerilog: a function_subroutine_call wraps subroutine_call -> tf_call -> [hierarchical_identifier ->] simple_identifier. Descend to the

INI variable extraction: find setting_name/name child, with fallback to first child.

Extract type refs from Java generic_type children.

Java method reference `Lhs::name` (e.g. `String::length`, `Foo::new`). The call walk only visits call_expression-like nodes, so a method_reference nev

JS/TS variable extraction: skip function-assigned declarators.

Phase 2a: Ensure all functions with route_path properties have Route+HANDLES edges. * During incremental indexing, only changed files get Route nodes

Extract a JSON string value from a simple JSON object by key name. */

JSON variable extraction: strip quotes from key.

Jsonnet: a `functioncall` node's callee is its first `id` child (the called binding name); the generic field path misses it (no `function`/`name` fiel

Extract JSX component refs (uppercase tags) as CALLS edges.

Extract base class names from a class node. Julia: a subtype declaration `Foo <: Bar` is a `binary_expression` (operator `<:`) inside the def's `type_

Just: a recipe dependency `recipe: dep` is a `dependency` node whose `name:` field is the referenced recipe.

Descend into the first block_mapping of a document and extract kind and metadata.name. Returns void; fills kind_buf and meta_name_buf.

Try to extract URL/topic from a keyword_argument or pair node.

Kotlin: supertypes live in `delegation_specifier` children. Each holds * either a bare `user_type` (interface) or a `constructor_invocation` whose

Kotlin: `a OP b` desugars to an operator-method call `a.<method>(b)`. The generic call walk keys on call_expression nodes and so never sees these prec

Lisp dialects: a call is a list (`list` / `list_lit`) whose head (first named child) is the function symbol (`symbol` / `sym_lit`). Generic field/firs

LLVM-IR: a `call`/`invoke` is an `instruction_call` whose `callee:` field is a `value -> var -> global_var` chain (e.g. `@inner`). Strip the leading s

local_name feeds the hand-built sqlite_autoindex_edges_1 — its backing * column local_name_gen is GENERATED only for IMPORTS edges (#768). */

Build per-file import map from cached extraction result or graph buffer edges. * Returns parallel arrays of (local_name, module_qn) pairs. Caller fre

Lua variable extraction: handle assignment_statement with function-def filtering.

Make: `$(shell ...)` is a `shell_function` node; the callee is the literal `shell` keyword. tree-sitter-make also exposes `function_call` for other bu

Extract Markdown heading name from atx_heading or setext_heading.

Meson: a builtin invocation (`executable(...)`, `dependency(...)`) is a `normal_command` whose `command` field is the called identifier.

Extract the "name" scalar from a metadata block_mapping.

--- ADL (Argument-Dependent Lookup) --- Extract the namespace from a qualified name: "std.vector" → "std", "boost.asio.ip" → "boost.asio"

Try to extract a narrowing fact from an `if`-condition: `x instanceof Foo`, `typeof x === 'string'`, or `x.kind === 'lit'` (discriminated union). On s

NASM: a `call`/`jmp`-style instruction is an `actual_instruction` whose `instruction:` field is the mnemonic word and whose first operand word is the

Extract type from new_expression / object_creation_expression.

Nickel: function application is `applicative` and curries left-associatively: `f x y` parses as `(applicative t1:(applicative t1:f t2:x) t2:y)`. A rea

Nix: an `apply_expression` (`f x`) carries the applied function on its `function:` field. The head is a `variable_expression` whose `name` is the call