/**

* Extraction Tests

*

* Tests for the tree-sitter extraction system.

*/

import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';

import * as fs from 'fs';

import * as path from 'path';

import * as os from 'os';

import { CodeGraph } from '../src';

import { extractFromSource, scanDirectory } from '../src/extraction';

import { detectLanguage, isLanguageSupported, getSupportedLanguages, initGrammars, loadAllGrammars, isSourceFile } from '../src/extraction/grammars';

import { normalizePath } from '../src/utils';

beforeAll(async () => {

await initGrammars();

await loadAllGrammars();

});

// Create a temporary directory for each test

function createTempDir(): string {

return fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-test-'));

}

// Clean up temporary directory

function cleanupTempDir(dir: string): void {

if (fs.existsSync(dir)) {

fs.rmSync(dir, { recursive: true, force: true });

}

}

describe('Language Detection', () => {

it('should detect TypeScript files', () => {

expect(detectLanguage('src/index.ts')).toBe('typescript');

expect(detectLanguage('components/Button.tsx')).toBe('tsx');

});

it('should detect JavaScript files', () => {

expect(detectLanguage('index.js')).toBe('javascript');

expect(detectLanguage('App.jsx')).toBe('jsx');

expect(detectLanguage('config.mjs')).toBe('javascript');

});

it('should detect Python files', () => {

expect(detectLanguage('main.py')).toBe('python');

});

it('should detect Go files', () => {

expect(detectLanguage('main.go')).toBe('go');

});

it('should detect Rust files', () => {

expect(detectLanguage('lib.rs')).toBe('rust');

});

it('should detect Java files', () => {

expect(detectLanguage('Main.java')).toBe('java');

});

it('should detect C files', () => {

expect(detectLanguage('main.c')).toBe('c');

expect(detectLanguage('utils.h')).toBe('c');

});

it('should detect C++ files', () => {

expect(detectLanguage('main.cpp')).toBe('cpp');

expect(detectLanguage('class.hpp')).toBe('cpp');

});

it('should detect C# files', () => {

expect(detectLanguage('Program.cs')).toBe('csharp');

});

it('should detect PHP files', () => {

expect(detectLanguage('index.php')).toBe('php');

});

it('should detect Ruby files', () => {

expect(detectLanguage('app.rb')).toBe('ruby');

});

it('should detect Swift files', () => {

expect(detectLanguage('ViewController.swift')).toBe('swift');

});

it('should detect Kotlin files', () => {

expect(detectLanguage('MainActivity.kt')).toBe('kotlin');

expect(detectLanguage('build.gradle.kts')).toBe('kotlin');

});

it('should detect Dart files', () => {

expect(detectLanguage('main.dart')).toBe('dart');

});

it('should detect Objective-C files', () => {

expect(detectLanguage('AppDelegate.m')).toBe('objc');

expect(detectLanguage('ViewController.mm')).toBe('objc');

const objcHeader = '@interface Foo : NSObject\n@end\n';

expect(detectLanguage('Foo.h', objcHeader)).toBe('objc');

expect(detectLanguage('stdio.h', '#ifndef STDIO_H\nvoid printf();\n#endif\n')).toBe('c');

});

it('should return unknown for unsupported extensions', () => {

expect(detectLanguage('styles.css')).toBe('unknown');

expect(detectLanguage('data.json')).toBe('unknown');

});

});

describe('Language Support', () => {

it('should report supported languages', () => {

expect(isLanguageSupported('typescript')).toBe(true);

expect(isLanguageSupported('python')).toBe(true);

expect(isLanguageSupported('go')).toBe(true);

expect(isLanguageSupported('unknown')).toBe(false);

});

it('should list all supported languages', () => {

const languages = getSupportedLanguages();

expect(languages).toContain('typescript');

expect(languages).toContain('javascript');

expect(languages).toContain('python');

expect(languages).toContain('go');

expect(languages).toContain('rust');

expect(languages).toContain('java');

expect(languages).toContain('csharp');

expect(languages).toContain('php');

expect(languages).toContain('ruby');

expect(languages).toContain('swift');

expect(languages).toContain('kotlin');

expect(languages).toContain('dart');

});

});

describe('TypeScript Extraction', () => {

it('should extract function declarations', () => {

const code = `

export function processPayment(amount: number): Promise<Receipt> {

return stripe.charge(amount);

}

`;

const result = extractFromSource('payment.ts', code);

// File node + function node

const fileNode = result.nodes.find((n) => n.kind === 'file');

expect(fileNode).toBeDefined();

expect(fileNode?.name).toBe('payment.ts');

const funcNode = result.nodes.find((n) => n.kind === 'function');

expect(funcNode).toMatchObject({

kind: 'function',

name: 'processPayment',

language: 'typescript',

isExported: true,

});

expect(funcNode?.signature).toContain('amount: number');

});

it('should extract class declarations', () => {

const code = `

export class PaymentService {

private stripe: StripeClient;

constructor(apiKey: string) {

this.stripe = new StripeClient(apiKey);

}

async charge(amount: number): Promise<Receipt> {

return this.stripe.charge(amount);

}

}

`;

const result = extractFromSource('service.ts', code);

const classNode = result.nodes.find((n) => n.kind === 'class');

const methodNodes = result.nodes.filter((n) => n.kind === 'method');

expect(classNode).toBeDefined();

expect(classNode?.name).toBe('PaymentService');

expect(classNode?.isExported).toBe(true);

expect(methodNodes.length).toBeGreaterThanOrEqual(1);

const chargeMethod = methodNodes.find((m) => m.name === 'charge');

expect(chargeMethod).toBeDefined();

});

it('should extract interfaces', () => {

const code = `

export interface User {

id: string;

name: string;

email: string;

}

`;

const result = extractFromSource('types.ts', code);

const fileNode = result.nodes.find((n) => n.kind === 'file');

expect(fileNode).toBeDefined();

const ifaceNode = result.nodes.find((n) => n.kind === 'interface');

expect(ifaceNode).toMatchObject({

kind: 'interface',

name: 'User',

isExported: true,

});

});

it('should extract type references from interface property signatures', () => {

const code = `

import type { IPage } from '../PromoterList';

import type { IOrderField } from '../types';

interface Hprops {

value?: Partial<IPage> & Partial<IOrderField>;

}

`;

const result = extractFromSource('HeaderFilter.ts', code);

const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'references');

expect(refs.some((r) => r.referenceName === 'IPage')).toBe(true);

expect(refs.some((r) => r.referenceName === 'IOrderField')).toBe(true);

});

it('should extract type references from interface method signatures', () => {

const code = `

import type { IPage } from '../PromoterList';

import type { IOrderField } from '../types';

interface MethodForm {

fetchPage(arg: IPage): IOrderField;

}

`;

const result = extractFromSource('MethodForm.ts', code);

const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'references');

expect(refs.some((r) => r.referenceName === 'IPage')).toBe(true);

expect(refs.some((r) => r.referenceName === 'IOrderField')).toBe(true);

});

it('should track function calls', () => {

const code = `

function main() {

const result = processData();

console.log(result);

}

`;

const result = extractFromSource('main.ts', code);

expect(result.unresolvedReferences.length).toBeGreaterThan(0);

const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');

expect(calls.some((c) => c.referenceName === 'processData')).toBe(true);

});

});

describe('Arrow Function Export Extraction', () => {

it('should extract exported arrow functions assigned to const', () => {

const code = `

export const useAuth = (): AuthContextValue => {

return useContext(AuthContext);

};

`;

const result = extractFromSource('hooks.ts', code);

const funcNode = result.nodes.find((n) => n.kind === 'function' && n.name === 'useAuth');

expect(funcNode).toBeDefined();

expect(funcNode).toMatchObject({

kind: 'function',

name: 'useAuth',

isExported: true,

});

});

it('should extract exported function expressions assigned to const', () => {

const code = `

export const processData = function(input: string): string {

return input.trim();

};

`;

const result = extractFromSource('utils.ts', code);

const funcNode = result.nodes.find((n) => n.kind === 'function' && n.name === 'processData');

expect(funcNode).toBeDefined();

expect(funcNode).toMatchObject({

kind: 'function',

name: 'processData',

isExported: true,

});

});

it('should not extract non-exported arrow functions as exported', () => {

const code = `

const internalHelper = () => {

return 42;

};

`;

const result = extractFromSource('internal.ts', code);

const helperNode = result.nodes.find((n) => n.name === 'internalHelper');

expect(helperNode).toBeDefined();

expect(helperNode?.isExported).toBeFalsy();

});

it('should still skip truly anonymous arrow functions', () => {

const code = `

const items = [1, 2, 3].map((x) => x * 2);

`;

const result = extractFromSource('anon.ts', code);

// The inline arrow function passed to .map() has no variable_declarator parent

// and should remain anonymous (skipped)

const anonFunctions = result.nodes.filter(

(n) => n.kind === 'function' && n.name === '<anonymous>'

);

expect(anonFunctions).toHaveLength(0);

});

it('should extract multiple exported arrow functions from the same file', () => {

const code = `

export const add = (a: number, b: number): number => a + b;

export const subtract = (a: number, b: number): number => a - b;

const internal = () => 'not exported';

`;

const result = extractFromSource('math.ts', code);

const exported = result.nodes.filter((n) => n.kind === 'function' && n.isExported);

expect(exported).toHaveLength(2);

expect(exported.map((n) => n.name).sort()).toEqual(['add', 'subtract']);

const internalNode = result.nodes.find((n) => n.name === 'internal');

expect(internalNode).toBeDefined();

expect(internalNode?.isExported).toBeFalsy();

});

it('should extract arrow functions in JavaScript files', () => {

const code = `

export const fetchData = async () => {

const response = await fetch('/api/data');

return response.json();

};

`;

const result = extractFromSource('api.js', code);

const funcNode = result.nodes.find((n) => n.kind === 'function' && n.name === 'fetchData');

expect(funcNode).toBeDefined();

expect(funcNode).toMatchObject({

kind: 'function',

name: 'fetchData',

isExported: true,

});

});

});

describe('Type Alias Extraction', () => {

it('should extract exported type aliases in TypeScript', () => {

const code = `

export type AuthContextValue = {

user: User | null;

login: () => void;

logout: () => void;

};

`;

const result = extractFromSource('types.ts', code);

const typeNode = result.nodes.find((n) => n.kind === 'type_alias');

expect(typeNode).toMatchObject({

kind: 'type_alias',

name: 'AuthContextValue',

isExported: true,

});

});

it('should extract non-exported type aliases', () => {

const code = `

type InternalState = {

loading: boolean;

error: string | null;

};

`;

const result = extractFromSource('internal.ts', code);

const typeNode = result.nodes.find((n) => n.kind === 'type_alias');

expect(typeNode).toMatchObject({

kind: 'type_alias',

name: 'InternalState',

isExported: false,

});

});

it('should extract multiple type aliases from the same file', () => {

const code = `

export type UnitSystem = 'metric' | 'imperial';

export type DateFormat = 'ISO' | 'US' | 'EU';

type Internal = string;

`;

const result = extractFromSource('config.ts', code);

const typeAliases = result.nodes.filter((n) => n.kind === 'type_alias');

expect(typeAliases).toHaveLength(3);

const exported = typeAliases.filter((n) => n.isExported);

expect(exported).toHaveLength(2);

expect(exported.map((n) => n.name).sort()).toEqual(['DateFormat', 'UnitSystem']);

});

});

describe('Exported Variable Extraction', () => {

it('should extract exported const with call expression (Zustand store)', () => {

const code = `

export const useUIStore = create<UIState>((set) => ({

isOpen: false,

toggle: () => set((s) => ({ isOpen: !s.isOpen })),

}));

`;

const result = extractFromSource('store.ts', code);

const varNode = result.nodes.find((n) => n.kind === 'constant' && n.name === 'useUIStore');

expect(varNode).toBeDefined();

expect(varNode?.isExported).toBe(true);

});

it('should extract exported const with object literal', () => {

const code = `

export const config = {

apiUrl: 'https://api.example.com',

timeout: 5000,

};

`;

const result = extractFromSource('config.ts', code);

const varNode = result.nodes.find((n) => n.kind === 'constant' && n.name === 'config');

expect(varNode).toBeDefined();

expect(varNode?.isExported).toBe(true);

});

it('should extract exported const with array literal', () => {

const code = `

export const SCREEN_NAMES = ['home', 'settings', 'profile'] as const;

`;

const result = extractFromSource('constants.ts', code);

const varNode = result.nodes.find((n) => n.kind === 'constant' && n.name === 'SCREEN_NAMES');

expect(varNode).toBeDefined();

expect(varNode?.isExported).toBe(true);

});

it('should extract exported const with primitive value', () => {

const code = `

export const MAX_RETRIES = 3;

export const API_VERSION = "v2";

`;

const result = extractFromSource('constants.ts', code);

const variables = result.nodes.filter((n) => n.kind === 'constant');

expect(variables).toHaveLength(2);

expect(variables.map((n) => n.name).sort()).toEqual(['API_VERSION', 'MAX_RETRIES']);

});

it('should NOT duplicate arrow functions as both function and variable', () => {

const code = `

export const useAuth = () => {

return useContext(AuthContext);

};

`;

const result = extractFromSource('hooks.ts', code);

// Should be extracted as function (from arrow function handler), NOT as variable

const funcNodes = result.nodes.filter((n) => n.kind === 'function' && n.name === 'useAuth');

const varNodes = result.nodes.filter((n) => n.kind === 'variable' && n.name === 'useAuth');

expect(funcNodes).toHaveLength(1);

expect(varNodes).toHaveLength(0);

});

it('should extract non-exported const as non-exported variable', () => {

const code = `

const internalConfig = {

debug: true,

};

`;

const result = extractFromSource('internal.ts', code);

// Non-exported const at file level should be extracted as a constant (not exported)

const varNodes = result.nodes.filter((n) => (n.kind === 'variable' || n.kind === 'constant') && n.name === 'internalConfig');

expect(varNodes).toHaveLength(1);

expect(varNodes[0]?.isExported).toBeFalsy();

});

it('should extract Zod schema exports', () => {

const code = `

export const userSchema = z.object({

id: z.string(),

name: z.string(),

email: z.string().email(),

});

`;

const result = extractFromSource('schemas.ts', code);

const varNode = result.nodes.find((n) => n.kind === 'constant' && n.name === 'userSchema');

expect(varNode).toBeDefined();

expect(varNode?.isExported).toBe(true);

});

it('should extract XState machine exports', () => {

const code = `

export const authMachine = createMachine({

id: "auth",

initial: "idle",

states: {

idle: {},

authenticated: {},

},

});

`;

const result = extractFromSource('machine.ts', code);

const varNode = result.nodes.find((n) => n.kind === 'constant' && n.name === 'authMachine');

expect(varNode).toBeDefined();

expect(varNode?.isExported).toBe(true);

});

it('should extract calls from a top-level variable initializer (issue #425)', () => {

const code = `

import { getTokenMp } from './api/upload';

const token = getTokenMp();

`;

const result = extractFromSource('app.ts', code);

const call = result.unresolvedReferences.find(

(ref) => ref.referenceKind === 'calls' && ref.referenceName === 'getTokenMp'

);

expect(call).toBeDefined();

});

});

describe('File Node Extraction', () => {

it('should create a file-kind node for each parsed file', () => {

const code = `

export function greet(name: string): string {

return "Hello " + name;

}

`;

const result = extractFromSource('greeter.ts', code);

const fileNode = result.nodes.find((n) => n.kind === 'file');

expect(fileNode).toBeDefined();

expect(fileNode?.name).toBe('greeter.ts');

expect(fileNode?.filePath).toBe('greeter.ts');

expect(fileNode?.language).toBe('typescript');

expect(fileNode?.startLine).toBe(1);

});

it('should create file nodes for Python files', () => {

const code = `

def main():

pass

`;

const result = extractFromSource('main.py', code);

const fileNode = result.nodes.find((n) => n.kind === 'file');

expect(fileNode).toBeDefined();

expect(fileNode?.name).toBe('main.py');

expect(fileNode?.language).toBe('python');

});

it('should create containment edges from file node to top-level declarations', () => {

const code = `

export function foo() {}

export function bar() {}

`;

const result = extractFromSource('fns.ts', code);

const fileNode = result.nodes.find((n) => n.kind === 'file');

expect(fileNode).toBeDefined();

// There should be contains edges from the file node to each function

const containsEdges = result.edges.filter(

(e) => e.source === fileNode?.id && e.kind === 'contains'

);

expect(containsEdges.length).toBeGreaterThanOrEqual(2);

});

});

describe('Python Extraction', () => {

it('should extract function definitions', () => {

const code = `

def calculate_total(items: list, tax_rate: float) -> float:

"""Calculate total with tax."""

subtotal = sum(item.price for item in items)

return subtotal * (1 + tax_rate)

`;

const result = extractFromSource('calc.py', code);

const fileNode = result.nodes.find((n) => n.kind === 'file');

expect(fileNode).toBeDefined();

const funcNode = result.nodes.find((n) => n.kind === 'function');

expect(funcNode).toMatchObject({

kind: 'function',

name: 'calculate_total',

language: 'python',

});

});

it('should extract class definitions', () => {

const code = `

class UserService:

"""Service for managing users."""

def __init__(self, db):

self.db = db

def get_user(self, user_id: str) -> User:

return self.db.find_user(user_id)

`;

const result = extractFromSource('service.py', code);

const classNode = result.nodes.find((n) => n.kind === 'class');

expect(classNode).toBeDefined();

expect(classNode?.name).toBe('UserService');

});

});

describe('Go Extraction', () => {

it('should extract function declarations', () => {

const code = `

package main

func ProcessOrder(order Order) (Receipt, error) {

// Process the order

return Receipt{}, nil

}

`;

const result = extractFromSource('main.go', code);

const funcNode = result.nodes.find((n) => n.kind === 'function');

expect(funcNode).toBeDefined();

expect(funcNode?.name).toBe('ProcessOrder');

});

it('should extract method declarations', () => {

const code = `

package main

type Service struct {

db *Database

}

func (s *Service) GetUser(id string) (*User, error) {

return s.db.FindUser(id)

}

`;

const result = extractFromSource('service.go', code);

const methodNode = result.nodes.find((n) => n.kind === 'method');

expect(methodNode).toBeDefined();

expect(methodNode?.name).toBe('GetUser');

});

});

describe('Rust Extraction', () => {

it('should extract function declarations', () => {

const code = `

pub fn process_data(input: &str) -> Result<Output, Error> {

// Process data

Ok(Output::new())

}

`;

const result = extractFromSource('lib.rs', code);

const funcNode = result.nodes.find((n) => n.kind === 'function');

expect(funcNode).toBeDefined();

expect(funcNode?.name).toBe('process_data');

expect(funcNode?.visibility).toBe('public');

});

it('should extract struct declarations', () => {

const code = `

pub struct User {

pub id: String,

pub name: String,

email: String,

}

`;

const result = extractFromSource('models.rs', code);

const structNode = result.nodes.find((n) => n.kind === 'struct');

expect(structNode).toBeDefined();

expect(structNode?.name).toBe('User');

});

it('should extract trait declarations', () => {

const code = `

pub trait Repository {

fn find(&self, id: &str) -> Option<Entity>;

fn save(&mut self, entity: Entity) -> Result<(), Error>;

}

`;

const result = extractFromSource('traits.rs', code);

const traitNode = result.nodes.find((n) => n.kind === 'trait');

expect(traitNode).toBeDefined();

expect(traitNode?.name).toBe('Repository');

});

it('should extract impl Trait for Type as implements edges', () => {

const code = `

pub struct MyCache {}

pub trait Cache {

fn get(&self, key: &str) -> Option<String>;

}

impl Cache for MyCache {

fn get(&self, key: &str) -> Option<String> {

None

}

}

`;

const result = extractFromSource('cache.rs', code);

// Should have an unresolved reference for implements

const implRef = result.unresolvedReferences.find(

(r) => r.referenceKind === 'implements' && r.referenceName === 'Cache'

);

expect(implRef).toBeDefined();

// The struct MyCache should be the source

const myCacheNode = result.nodes.find((n) => n.name === 'MyCache' && n.kind === 'struct');

expect(myCacheNode).toBeDefined();

expect(implRef?.fromNodeId).toBe(myCacheNode?.id);

});

it('should extract trait supertraits as extends references', () => {

const code = `

pub trait Display {}

pub trait Error: Display {

fn description(&self) -> &str;

}

`;

const result = extractFromSource('error.rs', code);

const extendsRef = result.unresolvedReferences.find(

(r) => r.referenceKind === 'extends' && r.referenceName === 'Display'

);

expect(extendsRef).toBeDefined();

const errorTrait = result.nodes.find((n) => n.name === 'Error' && n.kind === 'trait');

expect(errorTrait).toBeDefined();

expect(extendsRef?.fromNodeId).toBe(errorTrait?.id);

});

it('should not create implements edges for plain impl blocks', () => {

const code = `

pub struct Counter {

count: u32,

}

impl Counter {

pub fn new() -> Counter {

Counter { count: 0 }

}

pub fn increment(&mut self) {

self.count += 1;

}

}

`;

const result = extractFromSource('counter.rs', code);

// Should have no implements references (no trait involved)

const implRefs = result.unresolvedReferences.filter(

(r) => r.referenceKind === 'implements'

);

expect(implRefs).toHaveLength(0);

});

});

describe('Java Extraction', () => {

it('should extract class declarations', () => {

const code = `

public class UserService {

private final UserRepository repository;

public UserService(UserRepository repository) {

this.repository = repository;

}

public User getUser(String id) {

return repository.findById(id);

}

}

`;

const result = extractFromSource('UserService.java', code);

const classNode = result.nodes.find((n) => n.kind === 'class');

expect(classNode).toBeDefined();

expect(classNode?.name).toBe('UserService');

expect(classNode?.visibility).toBe('public');

});

it('should extract method declarations', () => {

const code = `

public class Calculator {

public static int add(int a, int b) {

return a + b;

}

}

`;

const result = extractFromSource('Calculator.java', code);

const methodNode = result.nodes.find((n) => n.kind === 'method' && n.name === 'add');

expect(methodNode).toBeDefined();

expect(methodNode?.isStatic).toBe(true);

});

it('wraps top-level declarations in a namespace from package_declaration', () => {

const code = `

package com.example.foo;

public class Bar {

public String greet() { return "hi"; }

}

`;

const result = extractFromSource('Bar.java', code);

const ns = result.nodes.find((n) => n.kind === 'namespace');

expect(ns?.name).toBe('com.example.foo');

const cls = result.nodes.find((n) => n.kind === 'class' && n.name === 'Bar');

expect(cls?.qualifiedName).toBe('com.example.foo::Bar');

const greet = result.nodes.find((n) => n.kind === 'method' && n.name === 'greet');

expect(greet?.qualifiedName).toBe('com.example.foo::Bar::greet');

});

it('does not wrap when no package is declared', () => {

const code = `

public class Bar {

public String greet() { return "hi"; }

}

`;

const result = extractFromSource('Bar.java', code);

expect(result.nodes.find((n) => n.kind === 'namespace')).toBeUndefined();

const cls = result.nodes.find((n) => n.kind === 'class' && n.name === 'Bar');

expect(cls?.qualifiedName).toBe('Bar');

});

it('extracts anonymous-class overrides from `new T() { ... }`', () => {

// The pattern that breaks the trace through `strategy.foo()` in

// libraries like guava's Splitter: the lambda-returned anonymous

// class overrides abstract methods on the base, but without

// extracting those overrides the interface→impl synthesizer has

// nothing to bridge.

const code = `

package com.example;

abstract class Base {

abstract int compute(int x);

}

public class Factory {

public Base make() {

return new Base() {

@Override

int compute(int x) { return x + 1; }

};

}

}

`;

const result = extractFromSource('Factory.java', code);

const anon = result.nodes.find((n) => n.kind === 'class' && /Base\$anon@/.test(n.name));

expect(anon, 'anonymous Base subclass should be extracted as a class').toBeDefined();

const compute = result.nodes.find(

(n) => n.kind === 'method' && n.name === 'compute' && n.qualifiedName.includes('$anon@')

);

expect(compute, 'override method should be a method on the anon class').toBeDefined();

expect(compute!.qualifiedName).toContain('Factory::make::<Base$anon@');

expect(compute!.qualifiedName.endsWith('::compute')).toBe(true);

// Anon class must extend Base so Phase 5.5 (interface-impl) can bridge.

const extendsRef = result.unresolvedReferences.find(

(r) => r.referenceKind === 'extends' && r.referenceName === 'Base' && r.fromNodeId === anon!.id

);

expect(extendsRef, 'anon class should carry an `extends Base` reference').toBeDefined();

// The enclosing `make` method still emits an instantiates edge to Base —

// anon extraction must not swallow that signal.

const instantiatesRef = result.unresolvedReferences.find(

(r) => r.referenceKind === 'instantiates' && r.referenceName === 'Base'

);

expect(instantiatesRef, 'enclosing method should still instantiate Base').toBeDefined();

});

it('extracts anonymous-class overrides inside a lambda body', () => {

// The exact guava pattern: a lambda is passed to a constructor, and the

// lambda body returns `new T() { @Override ... }`. The anon class must

// still surface even though it sits inside a lambda_expression node.

const code = `

package com.example;

interface Strategy {

java.util.Iterator<String> iterator(String s);

}

abstract class BaseIter implements java.util.Iterator<String> {

abstract int separatorStart(int start);

}

public class Splitter {

private final Strategy strategy;

public Splitter(Strategy s) { this.strategy = s; }

public static Splitter on(char c) {

return new Splitter((seq) ->

new BaseIter() {

@Override

int separatorStart(int start) { return start + 1; }

@Override public boolean hasNext() { return false; }

@Override public String next() { return null; }

});

}

}

`;

const result = extractFromSource('Splitter.java', code);

const anon = result.nodes.find((n) => n.kind === 'class' && /BaseIter\$anon@/.test(n.name));

expect(anon, 'anon BaseIter inside the lambda body should be extracted').toBeDefined();

const sepStart = result.nodes.find(

(n) =>

n.kind === 'method' &&

n.name === 'separatorStart' &&

n.qualifiedName.includes('$anon@')

);

expect(sepStart, 'override inside the lambda-returned anon class should be a method node').toBeDefined();

});

});

describe('C# Extraction', () => {

it('should extract class declarations', () => {

const code = `

public class OrderService

{

private readonly IOrderRepository _repository;

public OrderService(IOrderRepository repository)

{

_repository = repository;

}

public async Task<Order> GetOrderAsync(string id)

{

return await _repository.FindByIdAsync(id);

}

}

`;

const result = extractFromSource('OrderService.cs', code);

const classNode = result.nodes.find((n) => n.kind === 'class');

expect(classNode).toBeDefined();

expect(classNode?.name).toBe('OrderService');

expect(classNode?.visibility).toBe('public');

});

});

describe('PHP Extraction', () => {

it('should extract class declarations', () => {

const code = `<?php

class UserController

{

private UserService $userService;

public function __construct(UserService $userService)

{

$this->userService = $userService;

}

public function show(string $id): User

{

return $this->userService->find($id);

}

}

`;

const result = extractFromSource('UserController.php', code);

const classNode = result.nodes.find((n) => n.kind === 'class');

expect(classNode).toBeDefined();

expect(classNode?.name).toBe('UserController');

});

it('should extract class inheritance (extends) and interface implementation', () => {

const code = `<?php

class ChildController extends BaseController implements Serializable, JsonSerializable

{