/**

* Tree-sitter Parser Wrapper

*

* Handles parsing source code and extracting structural information.

*/

import { Node as SyntaxNode, Tree } from 'web-tree-sitter';

import * as path from 'path';

import {

Language,

Node,

Edge,

NodeKind,

ExtractionResult,

ExtractionError,

UnresolvedReference,

} from '../types';

import { getParser, detectLanguage, isLanguageSupported, isFileLevelOnlyLanguage } from './grammars';

import { generateNodeId, getNodeText, getChildByField, getPrecedingDocstring } from './tree-sitter-helpers';

import type { LanguageExtractor, ExtractorContext } from './tree-sitter-types';

import { EXTRACTORS } from './languages';

import { LiquidExtractor } from './liquid-extractor';

import { RazorExtractor } from './razor-extractor';

import { SvelteExtractor } from './svelte-extractor';

import { DfmExtractor } from './dfm-extractor';

import { VueExtractor } from './vue-extractor';

import { MyBatisExtractor } from './mybatis-extractor';

import {

getAllFrameworkResolvers,

getApplicableFrameworks,

} from '../resolution/frameworks';

// Re-export for backward compatibility

export { generateNodeId } from './tree-sitter-helpers';

/**

* Extract the name from a node based on language

*/

function extractName(node: SyntaxNode, source: string, extractor: LanguageExtractor): string {

const hookName = extractor.resolveName?.(node, source);

if (hookName) return hookName;

// Try field name first

const nameNode = getChildByField(node, extractor.nameField);

if (nameNode) {

// Unwrap pointer_declarator(s) for C/C++ pointer return types

let resolved = nameNode;

while (resolved.type === 'pointer_declarator') {

const inner = getChildByField(resolved, 'declarator') || resolved.namedChild(0);

if (!inner) break;

resolved = inner;

}

// Handle complex declarators (C/C++)

if (resolved.type === 'function_declarator' || resolved.type === 'declarator') {

const innerName = getChildByField(resolved, 'declarator') || resolved.namedChild(0);

return innerName ? getNodeText(innerName, source) : getNodeText(resolved, source);

}

// Lua: `function t.f()` / `function t:m()` — the name node is a dot/method

// index expression; the simple name is the trailing field/method (the table

// receiver is captured separately via getReceiverType).

if (resolved.type === 'dot_index_expression') {

const field = getChildByField(resolved, 'field');

if (field) return getNodeText(field, source);

}

if (resolved.type === 'method_index_expression') {

const method = getChildByField(resolved, 'method');

if (method) return getNodeText(method, source);

}

return getNodeText(resolved, source);

}

// For Dart method_signature, look inside inner signature types

if (node.type === 'method_signature') {

for (let i = 0; i < node.namedChildCount; i++) {

const child = node.namedChild(i);

if (child && (

child.type === 'function_signature' ||

child.type === 'getter_signature' ||

child.type === 'setter_signature' ||

child.type === 'constructor_signature' ||

child.type === 'factory_constructor_signature'

)) {

// Find identifier inside the inner signature

for (let j = 0; j < child.namedChildCount; j++) {

const inner = child.namedChild(j);

if (inner?.type === 'identifier') {

return getNodeText(inner, source);

}

}

}

}

}

// Arrow/function expressions get their name from the parent variable_declarator,

// not from identifiers in their body. Without this, single-expression arrow

// functions like `const fn = () => someIdentifier` get named "someIdentifier"

// instead of "fn", because the fallback below finds the body identifier.

if (node.type === 'arrow_function' || node.type === 'function_expression') {

return '<anonymous>';

}

// Fall back to first identifier child

for (let i = 0; i < node.namedChildCount; i++) {

const child = node.namedChild(i);

if (

child &&

(child.type === 'identifier' ||

child.type === 'type_identifier' ||

child.type === 'simple_identifier' ||

child.type === 'constant')

) {

return getNodeText(child, source);

}

}

return '<anonymous>';

}

/**

* Resolve a Scala type node to its base type NAME for name-matching — unwrapping

* `generic_type` (`Monoid[Int]` → `Monoid`), taking the last segment of a

* qualified `stable_type_identifier` (`cats.Functor` → `Functor`), and falling

* back to a descendant `type_identifier`. Returns null for non-type nodes.

* Shared by Scala inheritance and type-reference extraction.

*/

function scalaBaseTypeName(node: SyntaxNode | null, source: string): string | null {

if (!node) return null;

switch (node.type) {

case 'type_identifier':

case 'identifier':

return getNodeText(node, source);

case 'generic_type':

// `<base> type_arguments` — the base type is the first named child.

return scalaBaseTypeName(node.namedChild(0), source);

case 'stable_type_identifier':

case 'stable_identifier': {

// Qualified `a.b.C` — match on the simple (last) segment.

const ids = node.namedChildren.filter(

(c: SyntaxNode) => c.type === 'type_identifier' || c.type === 'identifier'

);

const last = ids[ids.length - 1];

return last ? getNodeText(last, source) : null;

}

default: {

const id = node.namedChildren.find((c: SyntaxNode) => c.type === 'type_identifier');

return id ? getNodeText(id, source) : null;

}

}

}

/**

* PHP type-position wrapper node kinds (a type-hint is `named_type`,

* `?Foo` is `optional_type`, `A|B` is `union_type`, `A&B` is

* `intersection_type`). Used to find the type subtree inside a parameter /

* property / return position before walking it for class references.

*/

const PHP_TYPE_NODES: ReadonlySet<string> = new Set([

'named_type', 'optional_type', 'nullable_type',

'union_type', 'intersection_type', 'disjunctive_normal_form_type',

'primitive_type',

]);

/**

* Member-access node kinds whose receiver, when it's a capitalized

* type/enum/class name, is a real dependency — `Enum.value`, `Type.CONST`,

* `Foo::BAR`. These VALUE reads (as opposed to `Type.method()` calls, already

* handled) produced no edge, so a type used only via a static member or enum

* value looked like nothing depended on it. See {@link extractStaticMemberRef}.

*/

const MEMBER_ACCESS_TYPES: ReadonlySet<string> = new Set([

'field_access', // java (`Foo.BAR`)

'member_access_expression', // c# (`Foo.Bar`)

'navigation_expression', // kotlin / swift (`Foo.bar`)

'field_expression', // scala (`Foo.bar`)

'class_constant_access_expression', // php (`Foo::CONST`, `Foo::class`)

'scoped_property_access_expression', // php (`Foo::$bar`)

'qualified_identifier', // c++ (`Foo::bar`)

]);

/**

* Languages whose types are Capitalized by convention, so a capitalized

* member-access receiver is reliably a type (not a local/variable). The

* static-member/value-read pass is gated to these — the ones where it was the

* confirmed residual frontier (enum-value / static-field reads). TS/JS/Python

* are deliberately excluded, and a measured A/B confirms the call: extending the

* pass to them adds ZERO coverage — in import-based languages you must `import` a

* type before any `Type.MEMBER` read, so the import edge already covers it (the

* static read is pure duplication) — while adding real graph noise (+1813 edges /

* +2448 `references` on excalidraw, the retrieval-perf benchmark, all pointing at

* already-covered types). Don't re-add `member_expression`/`attribute` here.

*/

const STATIC_MEMBER_LANGS: ReadonlySet<string> = new Set([

'java', 'csharp', 'kotlin', 'swift', 'scala', 'dart', 'php', 'cpp',

]);

/**

* Tree-sitter node kinds that represent constructor invocations

* (`new Foo()` and friends). Used by extractInstantiation to emit

* an `instantiates` reference targeting the class name.

*/

const INSTANTIATION_KINDS: ReadonlySet<string> = new Set([

'new_expression', // typescript / javascript / tsx / jsx

'object_creation_expression', // java / c#

'instance_creation_expression', // some grammars

'composite_literal', // go — `Widget{...}` / `pkga.Widget{...}`

'struct_expression', // rust — `Widget { n: 1 }` / `m::Widget { .. }`

'instance_expression', // scala — `new Monoid[Int] { ... }`

]);

/**

* TreeSitterExtractor - Main extraction class

*/

export class TreeSitterExtractor {

private filePath: string;

private language: Language;

private source: string;

private tree: Tree | null = null;

private nodes: Node[] = [];

private edges: Edge[] = [];

private unresolvedReferences: UnresolvedReference[] = [];

private errors: ExtractionError[] = [];

private extractor: LanguageExtractor | null = null;

private nodeStack: string[] = []; // Stack of parent node IDs

private methodIndex: Map<string, string> | null = null; // lookup key → node ID for Pascal defProc lookup

constructor(filePath: string, source: string, language?: Language) {

this.filePath = filePath;

this.source = source;

this.language = language || detectLanguage(filePath, source);

this.extractor = EXTRACTORS[this.language] || null;

}

/**

* Parse and extract from the source code

*/

extract(): ExtractionResult {

const startTime = Date.now();

if (!isLanguageSupported(this.language)) {

return {

nodes: [],

edges: [],

unresolvedReferences: [],

errors: [

{

message: `Unsupported language: ${this.language}`,

filePath: this.filePath,

severity: 'error',

code: 'unsupported_language',

},

],

durationMs: Date.now() - startTime,

};

}

const parser = getParser(this.language);

if (!parser) {

return {

nodes: [],

edges: [],

unresolvedReferences: [],

errors: [

{

message: `Failed to get parser for language: ${this.language}`,

filePath: this.filePath,

severity: 'error',

code: 'parser_error',

},

],

durationMs: Date.now() - startTime,

};

}

try {

// Optional pre-parse source transform (offset-preserving) to work around

// grammar gaps — e.g. C# blanks conditional-compilation directive lines

// the grammar mis-parses inside enum bodies (#237). We reassign

// this.source so downstream getNodeText reads the same bytes the parser

// saw (identical outside the blanked directive lines).

if (this.extractor?.preParse) {

this.source = this.extractor.preParse(this.source);

}

this.tree = parser.parse(this.source) ?? null;

if (!this.tree) {

throw new Error('Parser returned null tree');

}

// Create file node representing the source file

const fileNode: Node = {

id: `file:${this.filePath}`,

kind: 'file',

name: path.basename(this.filePath),

qualifiedName: this.filePath,

filePath: this.filePath,

language: this.language,

startLine: 1,

endLine: this.source.split('\n').length,

startColumn: 0,

endColumn: 0,

isExported: false,

updatedAt: Date.now(),

};

this.nodes.push(fileNode);

// Push file node onto stack so top-level declarations get contains edges

this.nodeStack.push(fileNode.id);

// File-level package declaration (Kotlin/Java). Creates an implicit

// `namespace` node wrapping every top-level declaration so their

// qualifiedName carries the FQN — required for cross-file import

// resolution on JVM languages where filename ≠ class name.

const packageNodeId = this.extractFilePackage(this.tree.rootNode);

if (packageNodeId) this.nodeStack.push(packageNodeId);

this.visitNode(this.tree.rootNode);

if (packageNodeId) this.nodeStack.pop();

this.nodeStack.pop();

} catch (error) {

const msg = error instanceof Error ? error.message : String(error);

// WASM memory errors leave the module in a corrupted state — all subsequent

// parses would also fail. Re-throw so the worker can detect and crash,

// forcing a clean restart with a fresh heap.

if (msg.includes('memory access out of bounds') || msg.includes('out of memory')) {

throw error;

}

this.errors.push({

message: `Parse error: ${msg}`,

filePath: this.filePath,

severity: 'error',

code: 'parse_error',

});

} finally {

// Free tree-sitter WASM memory immediately — trees hold native heap memory

// invisible to V8's GC that accumulates across thousands of files.

if (this.tree) {

this.tree.delete();

this.tree = null;

}

// Release source string to reduce GC pressure

this.source = '';

}

return {

nodes: this.nodes,

edges: this.edges,

unresolvedReferences: this.unresolvedReferences,

errors: this.errors,

durationMs: Date.now() - startTime,

};

}

/**

* Visit a node and extract information

*/

private visitNode(node: SyntaxNode): void {

if (!this.extractor) return;

const nodeType = node.type;

let skipChildren = false;

// Language-specific custom visitor hook

if (this.extractor.visitNode) {

const ctx = this.makeExtractorContext();

const handled = this.extractor.visitNode(node, ctx);

if (handled) return;

}

// Pascal-specific AST handling

if (this.language === 'pascal') {

skipChildren = this.visitPascalNode(node);

if (skipChildren) return;

}

// Check for function declarations

// For Python/Ruby, function_definition inside a class should be treated as method

if (this.extractor.functionTypes.includes(nodeType)) {

if (this.isInsideClassLikeNode() && this.extractor.methodTypes.includes(nodeType)) {

// Inside a class - treat as method

this.extractMethod(node);

skipChildren = true; // extractMethod visits children via visitFunctionBody

} else {

this.extractFunction(node);

skipChildren = true; // extractFunction visits children via visitFunctionBody

}

}

// Check for class declarations

else if (this.extractor.classTypes.includes(nodeType)) {

// Some languages reuse class_declaration for structs/enums (e.g. Swift)

const classification = this.extractor.classifyClassNode?.(node) ?? 'class';

if (classification === 'struct') {

this.extractStruct(node);

} else if (classification === 'enum') {

this.extractEnum(node);

} else if (classification === 'interface') {

this.extractInterface(node);

} else if (classification === 'trait') {

this.extractClass(node, 'trait');

} else {

this.extractClass(node);

}

skipChildren = true; // extractClass visits body children

}

// Extra class node types (e.g. Dart mixin_declaration, extension_declaration)

else if (this.extractor.extraClassNodeTypes?.includes(nodeType)) {

this.extractClass(node);

skipChildren = true;

}

// Check for method declarations (only if not already handled by functionTypes)

else if (this.extractor.methodTypes.includes(nodeType)) {

this.extractMethod(node);

skipChildren = true; // extractMethod visits children via visitFunctionBody

}

// Check for interface/protocol/trait declarations

else if (this.extractor.interfaceTypes.includes(nodeType)) {

this.extractInterface(node);

skipChildren = true; // extractInterface visits body children

}

// Check for struct declarations

else if (this.extractor.structTypes.includes(nodeType)) {

this.extractStruct(node);

skipChildren = true; // extractStruct visits body children

}

// Check for enum declarations

else if (this.extractor.enumTypes.includes(nodeType)) {

this.extractEnum(node);

skipChildren = true; // extractEnum visits body children

}

// Check for type alias declarations (e.g. `type X = ...` in TypeScript)

// For Go, type_spec wraps struct/interface definitions — resolveTypeAliasKind

// detects these and extractTypeAlias creates the correct node kind.

else if (this.extractor.typeAliasTypes.includes(nodeType)) {

skipChildren = this.extractTypeAlias(node);

}

// Check for class properties (e.g. C# property_declaration)

else if (this.extractor.propertyTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {

this.extractProperty(node);

skipChildren = true;

}

// Check for class fields (e.g. Java field_declaration, C# field_declaration)

else if (this.extractor.fieldTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {

this.extractField(node);

skipChildren = true;

}

// Check for variable declarations (const, let, var, etc.)

// Only extract top-level variables (not inside functions/methods)

else if (this.extractor.variableTypes.includes(nodeType) && !this.isInsideClassLikeNode()) {

this.extractVariable(node);

skipChildren = true; // extractVariable handles children

}

// Swift stored properties inside a type. Swift instance properties aren't

// extracted as their own nodes, but a property's PROPERTY WRAPPER

// (`@Argument`/`@Published`/`@State`/custom) and declared type ARE

// dependencies — attribute them to the enclosing type so the wrapper/type

// files get dependents. Don't skipChildren: an initializer's calls still

// matter. (Other languages extract properties via property/field types.)

else if (

this.language === 'swift' &&

nodeType === 'property_declaration' &&

this.isInsideClassLikeNode()

) {

const ownerId = this.nodeStack[this.nodeStack.length - 1];

if (ownerId) {

this.extractDecoratorsFor(node, ownerId);

this.extractVariableTypeAnnotation(node, ownerId);

// Fluent / SwiftUI property-wrapper attributes often reference a model or

// type by metatype in their ARGUMENTS — `@Siblings(through: Pivot.self,

// …)`, `@Group(…)`. extractDecoratorsFor captures the wrapper type

// (`Siblings`); this pulls the TYPE out of the argument expressions

// (`Pivot.self` → a dependency on Pivot), so a model reached ONLY through

// a relationship (a many-to-many pivot/join model) isn't left orphaned.

// extractStaticMemberRef self-filters to `Type.member` navigation, so the

// `\.$keypath` arguments and the wrapper `user_type` are skipped.

const modifiers = node.namedChildren.find((c: SyntaxNode) => c.type === 'modifiers');

if (modifiers) {

const walkAttrArgs = (n: SyntaxNode): void => {

this.extractStaticMemberRef(n);

for (let i = 0; i < n.namedChildCount; i++) {

const c = n.namedChild(i);

if (c) walkAttrArgs(c);

}

};

walkAttrArgs(modifiers);

}

}

}

// `export_statement` itself is not extracted — the walker descends

// into children, where the inner declaration (lexical_declaration,

// function_declaration, class_declaration, etc.) is dispatched to

// its own extractor. `isExported` walks the parent chain, so the

// exported flag is preserved automatically.

//

// Calling extractExportedVariables here AND descending caused every

// `export const X = ...` to produce two nodes for the same symbol —

// one kind:'variable' from extractExportedVariables and one

// kind:'constant' from extractVariable. The dedicated dispatch is

// the correct one (it picks kind from isConst, captures the

// initializer signature, and walks type annotations); the

// export-statement helper was redundant.

// Check for imports

else if (this.extractor.importTypes.includes(nodeType)) {

this.extractImport(node);

}

// Re-export from another module — `export { X } from './y'` (TS/JS). A

// re-export is a dependency on the source module just like an import, but

// the export_statement is otherwise only descended into (no declaration to

// extract), so a barrel that ONLY re-exports produced zero edges and showed

// 0 dependents. Link each re-exported name to its definition. Children are

// still visited (a non-re-export `export const X = …` has no `source` and

// falls through to its normal declaration extraction).

else if (

nodeType === 'export_statement' &&

(this.language === 'typescript' || this.language === 'tsx' ||

this.language === 'javascript' || this.language === 'jsx') &&

getChildByField(node, 'source')

) {

const parentId = this.nodeStack[this.nodeStack.length - 1];

if (parentId) this.emitReExportRefs(node, parentId);

}

// Check for function calls

else if (this.extractor.callTypes.includes(nodeType)) {

this.extractCall(node);

}

// `new Foo(...)` / `Foo::new(...)` / object_creation_expression —

// produce an `instantiates` reference. Children still walked so

// nested calls inside the constructor args (`new Foo(bar())`) get

// their own `calls` refs.

else if (INSTANTIATION_KINDS.has(nodeType)) {

this.extractInstantiation(node);

// Java/C# `new T(...) { ... }` — anonymous class with body. Without

// extracting it as a class node + its methods, the interface→impl

// synthesizer (Phase 5.5) can't bridge T's abstract methods to the

// anonymous overrides, and an agent investigating a call through T

// (`strategy.iterator(...)` where strategy is a Strategy lambda body)

// has to Read the file to find the actual implementation.

const anonBody = this.findAnonymousClassBody(node);

if (anonBody) {

this.extractAnonymousClass(node, anonBody);

skipChildren = true;

}

}

// (Decorator handling lives inside the symbol-creating extractors

// — extractClass / extractFunction / extractProperty — because the

// decorator node sits BEFORE the symbol in the AST and the walker

// would otherwise see the wrong nodeStack head.)

// Rust: `impl Trait for Type { ... }` — creates implements edge from Type to Trait

else if (nodeType === 'impl_item') {

this.extractRustImplItem(node);

}

// TypeScript interface members: property_signature (`foo: T`, `foo?: T`)

// and method_signature (`foo(arg: A): R`) both carry type annotations the

// interface walker would otherwise drop. Extract them as `references`

// edges from the interface so resolvers can wire callers/impact for

// types that only appear in interface members.

else if (

(nodeType === 'property_signature' || nodeType === 'method_signature') &&

this.isInsideClassLikeNode() &&

this.TYPE_ANNOTATION_LANGUAGES.has(this.language)

) {

const parentId = this.nodeStack[this.nodeStack.length - 1];

if (parentId) {

this.extractTypeAnnotations(node, parentId);

}

// don't skipChildren — nested signatures still need traversal

}

// Visit children (unless the extract method already visited them)

if (!skipChildren) {

for (let i = 0; i < node.namedChildCount; i++) {

const child = node.namedChild(i);

if (child) {

this.visitNode(child);

}

}

}

}

/**

* Create a Node object

*/

private createNode(

kind: NodeKind,

name: string,

node: SyntaxNode,

extra?: Partial<Node>

): Node | null {

// Skip nodes with empty/missing names — they are not meaningful symbols

// and would cause FK violations when edges reference them (see issue #42)

if (!name) {

return null;

}

const id = generateNodeId(this.filePath, kind, name, node.startPosition.row + 1);

// Some grammars (e.g. Dart) model a function/method body as a *sibling* of

// the signature node, so the declaration node's own range is just the

// signature line. Extend endLine to the resolved body when it sits beyond

// the node so the node spans its body — required for any body-level analysis

// (callees, the callback synthesizer's body scan, context slices). Guarded to

// only ever extend: for child-body grammars the body is within range (no-op).

let endLine = node.endPosition.row + 1;

if (kind === 'function' || kind === 'method') {

const body = this.extractor?.resolveBody?.(node, this.extractor.bodyField);

if (body && body.endPosition.row + 1 > endLine) {

endLine = body.endPosition.row + 1;

}

}

const newNode: Node = {

id,

kind,

name,

qualifiedName: this.buildQualifiedName(name),

filePath: this.filePath,

language: this.language,

startLine: node.startPosition.row + 1,

endLine,

startColumn: node.startPosition.column,

endColumn: node.endPosition.column,

updatedAt: Date.now(),

...extra,

};

// Persist extra symbol-level modifiers (e.g. Kotlin `expect`/`actual`) onto

// the node's decorators list so the resolver can pair multiplatform

// declarations with their implementations. Merged, not overwritten, so a

// language that also captures real annotations keeps both.

const mods = this.extractor?.extractModifiers?.(node);

if (mods && mods.length > 0) {

newNode.decorators = [...(newNode.decorators ?? []), ...mods];

}

this.nodes.push(newNode);

// Add containment edge from parent

if (this.nodeStack.length > 0) {

const parentId = this.nodeStack[this.nodeStack.length - 1];

if (parentId) {

this.edges.push({

source: parentId,

target: id,

kind: 'contains',

});

}

}

return newNode;

}

/**

* Find first named child whose type is in the given list.

* Used to locate inner type nodes (e.g. enum_specifier inside a typedef).

*/

private findChildByTypes(node: SyntaxNode, types: string[]): SyntaxNode | null {

for (let i = 0; i < node.namedChildCount; i++) {

const child = node.namedChild(i);

if (child && types.includes(child.type)) return child;

}

return null;

}

/**

* Find a `packageTypes` child under the root, create a `namespace` node

* for it, and return its id so the caller can scope top-level

* declarations underneath. Returns null when no package header is

* present (script files, .kts without a package).

*/

private extractFilePackage(rootNode: SyntaxNode): string | null {

const types = this.extractor?.packageTypes;

if (!types || types.length === 0 || !this.extractor?.extractPackage) return null;

let pkgNode: SyntaxNode | null = null;

for (let i = 0; i < rootNode.namedChildCount; i++) {

const child = rootNode.namedChild(i);

if (child && types.includes(child.type)) {

pkgNode = child;

break;

}

}

if (!pkgNode) return null;

const pkgName = this.extractor.extractPackage(pkgNode, this.source);

if (!pkgName) return null;

const ns = this.createNode('namespace', pkgName, pkgNode);

return ns?.id ?? null;

}

/**

* Build qualified name from node stack

*/

private buildQualifiedName(name: string): string {

// Build a qualified name from the semantic hierarchy only (no file path).

// The file path is stored separately in filePath and pollutes FTS if included here.

const parts: string[] = [];

for (const nodeId of this.nodeStack) {

const node = this.nodes.find((n) => n.id === nodeId);

if (node && node.kind !== 'file') {

parts.push(node.name);

}

}

parts.push(name);

return parts.join('::');

}

/**

* Build an ExtractorContext for passing to language-specific visitNode hooks.

*/

private makeExtractorContext(): ExtractorContext {

// eslint-disable-next-line @typescript-eslint/no-this-alias

const self = this;

return {

createNode: (kind, name, node, extra) => self.createNode(kind, name, node, extra),

visitNode: (node) => self.visitNode(node),

visitFunctionBody: (body, functionId) => self.visitFunctionBody(body, functionId),

addUnresolvedReference: (ref) => self.unresolvedReferences.push(ref),

pushScope: (nodeId) => self.nodeStack.push(nodeId),

popScope: () => self.nodeStack.pop(),

get filePath() { return self.filePath; },

get source() { return self.source; },

get nodeStack() { return self.nodeStack; },

get nodes() { return self.nodes; },

};

}

/**

* Check if the current node stack indicates we are inside a class-like node

* (class, struct, interface, trait). File nodes do not count as class-like.

*/

private isInsideClassLikeNode(): boolean {

if (this.nodeStack.length === 0) return false;

const parentId = this.nodeStack[this.nodeStack.length - 1];

if (!parentId) return false;

const parentNode = this.nodes.find((n) => n.id === parentId);

if (!parentNode) return false;

return (

parentNode.kind === 'class' ||

parentNode.kind === 'struct' ||

parentNode.kind === 'interface' ||

parentNode.kind === 'trait' ||

parentNode.kind === 'enum' ||

parentNode.kind === 'module'

);

}

/**

* Extract a function

*/

private extractFunction(node: SyntaxNode, nameOverride?: string): void {

if (!this.extractor) return;

// If the language provides getReceiverType and this function has a receiver

// (e.g., Rust function_item inside an impl block), extract as method instead

if (this.extractor.getReceiverType?.(node, this.source)) {

this.extractMethod(node);

return;

}

// nameOverride is supplied only for explicitly-named anonymous functions the

// caller resolved itself (e.g. arrow values of exported-const object members

// — SvelteKit actions). Inline-object arrows reached by the general walker

// get no override, so they still fall through to the <anonymous> skip below.

let name = nameOverride ?? extractName(node, this.source, this.extractor);

// For arrow functions and function expressions assigned to variables,

// resolve the name from the parent variable_declarator.

// e.g. `export const useAuth = () => { ... }` — the arrow_function node

// has no `name` field; the name lives on the variable_declarator.

if (

!nameOverride &&

name === '<anonymous>' &&

(node.type === 'arrow_function' || node.type === 'function_expression')

) {

const parent = node.parent;

if (parent?.type === 'variable_declarator') {

const varName = getChildByField(parent, 'name');

if (varName) {

name = getNodeText(varName, this.source);

}

}

}

if (name === '<anonymous>') {

// Don't emit a node for the anonymous wrapper itself, but still visit its

// body: AMD/RequireJS and CommonJS module wrappers (`define([], function(){…})`,

// `(function(){…})()`) hold named inner functions and calls that would

// otherwise be lost — the dispatcher set skipChildren, so nothing else

// descends into this subtree. (#528)

const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (body) {

this.visitFunctionBody(body, '');

}

return;

}

// Check for misparse artifacts (e.g. C++ macros causing "namespace detail" functions)

// Skip the node but still visit the body for calls and structural nodes

if (this.extractor.isMisparsedFunction?.(name, node)) {

const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (body) {

this.visitFunctionBody(body, '');

}

return;

}

const docstring = getPrecedingDocstring(node, this.source);

const signature = this.extractor.getSignature?.(node, this.source);

const visibility = this.extractor.getVisibility?.(node);

const isExported = this.extractor.isExported?.(node, this.source);

const isAsync = this.extractor.isAsync?.(node);

const isStatic = this.extractor.isStatic?.(node);

const funcNode = this.createNode('function', name, node, {

docstring,

signature,

visibility,

isExported,

isAsync,

isStatic,

});

if (!funcNode) return;

// Extract type annotations (parameter types and return type)

this.extractTypeAnnotations(node, funcNode.id);

// Extract decorators applied to the function (rare in JS/TS but

// present in Python `@decorator def f():` and Java/Kotlin

// annotations on free functions).

this.extractDecoratorsFor(node, funcNode.id);

// Push to stack and visit body

this.nodeStack.push(funcNode.id);

const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (body) {

this.visitFunctionBody(body, funcNode.id);

}

this.nodeStack.pop();

}

/**

* Extract a class

*/

private extractClass(node: SyntaxNode, kind: NodeKind = 'class'): void {

if (!this.extractor) return;

const name = extractName(node, this.source, this.extractor);

const docstring = getPrecedingDocstring(node, this.source);

const visibility = this.extractor.getVisibility?.(node);

const isExported = this.extractor.isExported?.(node, this.source);

const classNode = this.createNode(kind, name, node, {

docstring,

visibility,

isExported,

});

if (!classNode) return;

// Extract extends/implements

this.extractInheritance(node, classNode.id);

// C# primary-constructor parameter dependencies (`class Svc(IRepo r, …)`).

this.extractCsharpPrimaryCtorParamRefs(node, classNode.id);

// Extract decorators applied to the class (`@Foo class X {}`).

this.extractDecoratorsFor(node, classNode.id);

// Push to stack and visit body

this.nodeStack.push(classNode.id);

let body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (!body) body = node;

// Visit all children for methods and properties

for (let i = 0; i < body.namedChildCount; i++) {

const child = body.namedChild(i);

if (child) {

this.visitNode(child);

}

}

this.nodeStack.pop();

}

/**

* Extract a method

*/

private extractMethod(node: SyntaxNode): void {

if (!this.extractor) return;

// For languages with receiver types (Go, Rust), include receiver in qualified name

// so FTS can match "scrapeLoop.run" → qualified_name "...::scrapeLoop::run"

const receiverType = this.extractor.getReceiverType?.(node, this.source);

// For most languages, only extract as method if inside a class-like node

// Languages with methodsAreTopLevel (e.g. Go) always treat them as methods

// Languages with getReceiverType (e.g. Rust) extract as method when receiver is found

if (!this.isInsideClassLikeNode() && !this.extractor.methodsAreTopLevel && !receiverType) {

// Skip method_definition nodes inside object literals (getters/setters/methods

// in inline objects). These are ephemeral and create noise (e.g., Svelte context

// objects: `ctx.set({ get view() { ... } })`).

if (node.parent?.type === 'object' || node.parent?.type === 'object_expression') {

const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (body) {

this.visitFunctionBody(body, '');

}

return;

}

// Not inside a class-like node and no receiver type, treat as function

this.extractFunction(node);

return;

}

const name = extractName(node, this.source, this.extractor);

// Check for misparse artifacts (e.g. C++ "switch" inside macro-confused class body)

if (this.extractor.isMisparsedFunction?.(name, node)) {

const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (body) {

this.visitFunctionBody(body, '');

}

return;

}

const docstring = getPrecedingDocstring(node, this.source);

const signature = this.extractor.getSignature?.(node, this.source);

const visibility = this.extractor.getVisibility?.(node);

const isAsync = this.extractor.isAsync?.(node);

const isStatic = this.extractor.isStatic?.(node);

const extraProps: Partial<Node> = {

docstring,

signature,

visibility,

isAsync,

isStatic,

};

if (receiverType) {

extraProps.qualifiedName = `${receiverType}::${name}`;

}

const methodNode = this.createNode('method', name, node, extraProps);

if (!methodNode) return;

// For methods with a receiver type but no class-like parent on the stack

// (e.g., Rust impl blocks), add a contains edge from the owning struct/trait

if (receiverType && !this.isInsideClassLikeNode()) {

const ownerNode = this.nodes.find(

(n) =>

n.name === receiverType &&

n.filePath === this.filePath &&

(n.kind === 'struct' || n.kind === 'class' || n.kind === 'enum' || n.kind === 'trait')

);

if (ownerNode) {

this.edges.push({

source: ownerNode.id,

target: methodNode.id,

kind: 'contains',

});

}

}

// Extract type annotations (parameter types and return type)

this.extractTypeAnnotations(node, methodNode.id);

// Extract decorators (`@Get('/list') list() {}`).

this.extractDecoratorsFor(node, methodNode.id);

// Push to stack and visit body

this.nodeStack.push(methodNode.id);

const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)

?? getChildByField(node, this.extractor.bodyField);

if (body) {

this.visitFunctionBody(body, methodNode.id);

}

this.nodeStack.pop();

}

/**

* Extract an interface/protocol/trait

*/

private extractInterface(node: SyntaxNode): void {

if (!this.extractor) return;

const name = extractName(node, this.source, this.extractor);

const docstring = getPrecedingDocstring(node, this.source);

const isExported = this.extractor.isExported?.(node, this.source);

const kind: NodeKind = this.extractor.interfaceKind ?? 'interface';

const interfaceNode = this.createNode(kind, name, node, {

docstring,

isExported,

});

if (!interfaceNode) return;

// Extract extends (interface inheritance)

this.extractInheritance(node, interfaceNode.id);