mirror of
https://github.com/abhigyanpatwari/GitNexus.git
synced 2026-10-06 02:49:56 +00:00
ba5de0bde4
* feat(cpp): C/C++ MethodExtractor config with pure virtual detection (#572) - Pure virtual (= 0) detected as isAbstract via token scanning - virtual/final/override via hasKeyword and virtual_specifier children - Access specifier visibility via backward sibling walk (public:/private:/protected:) - Pointer/reference parameter types extracted correctly - Constructor and destructor support via declaration node type - Static detection via storage_class_specifier - 16 new tests covering all acceptance criteria * fix(cpp): isVirtual infers from override/final + out-of-class resolution - isVirtual returns true for override/final methods (C++ mandates these are virtual) - Add findClassNodeByQualifiedName to parse-worker: resolves Foo::bar() back to the Foo class declaration for method extractor enrichment - Handles pointer/ref return types, constructors, destructors - Integration test for virtual/static/constructor inline methods - 233 unit+integration tests pass, 97 C++ resolver tests pass * fix(cpp): address review — deep pointers, templates, unions, trailing returns - Fix extractParamName: recursive unwrap for int** ptr → "ptr" (not "**ptr") - Fix findFunctionDeclarator: recursive unwrap for multi-level pointer chains - Template methods: generic extractor unwraps template_declaration to inner node - union_specifier: added to typeDeclarationNodes, visibility defaults to public - Trailing return type: auto foo() -> T now extracts T instead of "auto" - Fix version comment: ^0.22.4 → ^0.23.4 to match package.json - 4 new tests: double pointer params, template methods, union methods, trailing returns * fix(cpp): template method visibility + union isTypeDeclaration test extractCppVisibility now walks from the template_declaration parent when the node is wrapped by a template, restoring correct access- specifier resolution for templated class methods. Also adds missing isTypeDeclaration assertion for union_specifier and expands the template method test with explicit visibility checks. * fix(cpp): address deep gap analysis review findings - findClassNodeByQualifiedName: recursive pointer/reference declarator unwrap, fixing out-of-class linking for deep pointer return types (e.g. int** Foo::bar()) - findClassNodeByQualifiedName: recurse into namespace_definition blocks so namespace-wrapped classes resolve correctly - Suppress = delete / = default special members from extraction via delete_method_clause / default_method_clause node detection - Update known-gaps: namespace-wrapped classes, const-overload collapse - Add tree-sitter-c version comment for consistency - toBeFalsy() → toBe(undefined) for precise isVirtual assertion - Tests: = delete, = default, = 0 non-regression, operator overloads, deep pointer return types, default visibility (class vs struct), multiple access specifier sections
2398 lines
77 KiB
TypeScript
2398 lines
77 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import { createMethodExtractor } from '../../src/core/ingestion/method-extractors/generic.js';
|
|
import {
|
|
javaMethodConfig,
|
|
kotlinMethodConfig,
|
|
} from '../../src/core/ingestion/method-extractors/configs/jvm.js';
|
|
import { csharpMethodConfig } from '../../src/core/ingestion/method-extractors/configs/csharp.js';
|
|
import {
|
|
typescriptMethodConfig,
|
|
javascriptMethodConfig,
|
|
} from '../../src/core/ingestion/method-extractors/configs/typescript-javascript.js';
|
|
import { cppMethodConfig } from '../../src/core/ingestion/method-extractors/configs/c-cpp.js';
|
|
import type { MethodExtractorContext } from '../../src/core/ingestion/method-types.js';
|
|
import Parser from 'tree-sitter';
|
|
import Java from 'tree-sitter-java';
|
|
import CSharp from 'tree-sitter-c-sharp';
|
|
import CPP from 'tree-sitter-cpp';
|
|
import TypeScript from 'tree-sitter-typescript';
|
|
import JavaScript from 'tree-sitter-javascript';
|
|
import { SupportedLanguages } from '../../src/config/supported-languages.js';
|
|
|
|
let Kotlin: unknown;
|
|
try {
|
|
Kotlin = require('tree-sitter-kotlin');
|
|
} catch {
|
|
// Kotlin grammar may not be installed
|
|
}
|
|
|
|
const parser = new Parser();
|
|
|
|
const parseJava = (code: string) => {
|
|
parser.setLanguage(Java);
|
|
return parser.parse(code);
|
|
};
|
|
|
|
const parseKotlin = (code: string) => {
|
|
if (!Kotlin) throw new Error('tree-sitter-kotlin not available');
|
|
parser.setLanguage(Kotlin as Parser.Language);
|
|
return parser.parse(code);
|
|
};
|
|
|
|
const javaCtx: MethodExtractorContext = {
|
|
filePath: 'Test.java',
|
|
language: SupportedLanguages.Java,
|
|
};
|
|
|
|
const kotlinCtx: MethodExtractorContext = {
|
|
filePath: 'Test.kt',
|
|
language: SupportedLanguages.Kotlin,
|
|
};
|
|
|
|
const parseCSharp = (code: string) => {
|
|
parser.setLanguage(CSharp);
|
|
return parser.parse(code);
|
|
};
|
|
|
|
const csharpCtx: MethodExtractorContext = {
|
|
filePath: 'Test.cs',
|
|
language: SupportedLanguages.CSharp,
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Java
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('Java MethodExtractor', () => {
|
|
const extractor = createMethodExtractor(javaMethodConfig);
|
|
|
|
describe('isTypeDeclaration', () => {
|
|
it('recognizes class_declaration', () => {
|
|
const tree = parseJava('public class Foo { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes interface_declaration', () => {
|
|
const tree = parseJava('public interface Bar { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes enum_declaration', () => {
|
|
const tree = parseJava('public enum Color { RED, GREEN }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('rejects import_declaration', () => {
|
|
const tree = parseJava('import java.util.List;');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract from class', () => {
|
|
it('extracts public method with parameters', () => {
|
|
const tree = parseJava(`
|
|
public class UserService {
|
|
public User findById(Long id, boolean active) {
|
|
return null;
|
|
}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('UserService');
|
|
expect(result!.methods).toHaveLength(1);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('findById');
|
|
expect(m.returnType).toBe('User');
|
|
expect(m.visibility).toBe('public');
|
|
expect(m.isStatic).toBe(false);
|
|
expect(m.isAbstract).toBe(false);
|
|
expect(m.isFinal).toBe(false);
|
|
expect(m.parameters).toHaveLength(2);
|
|
expect(m.parameters[0]).toEqual({
|
|
name: 'id',
|
|
type: 'Long',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
expect(m.parameters[1]).toEqual({
|
|
name: 'active',
|
|
type: 'boolean',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
});
|
|
|
|
it('extracts static method', () => {
|
|
const tree = parseJava(`
|
|
public class MathUtils {
|
|
public static int add(int a, int b) {
|
|
return a + b;
|
|
}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods[0].isStatic).toBe(true);
|
|
});
|
|
|
|
it('extracts final method', () => {
|
|
const tree = parseJava(`
|
|
public class Base {
|
|
public final void doSomething() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods[0].isFinal).toBe(true);
|
|
});
|
|
|
|
it('extracts private method', () => {
|
|
const tree = parseJava(`
|
|
public class Foo {
|
|
private void helper() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('private');
|
|
});
|
|
|
|
it('detects package-private (default) visibility', () => {
|
|
const tree = parseJava(`
|
|
public class Foo {
|
|
void internalMethod() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('package');
|
|
});
|
|
|
|
it('extracts annotations', () => {
|
|
const tree = parseJava(`
|
|
public class Service {
|
|
@Override
|
|
public String toString() { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods[0].annotations).toContain('@Override');
|
|
});
|
|
|
|
it('extracts varargs parameter', () => {
|
|
const tree = parseJava(`
|
|
public class Formatter {
|
|
public String format(String template, Object... args) { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].isVariadic).toBe(false);
|
|
expect(params[1].isVariadic).toBe(true);
|
|
expect(params[1].name).toBe('args');
|
|
});
|
|
|
|
it('extracts void return type', () => {
|
|
const tree = parseJava(`
|
|
public class Foo {
|
|
public void doNothing() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods[0].returnType).toBe('void');
|
|
});
|
|
});
|
|
|
|
describe('extract overloaded methods', () => {
|
|
it('extracts all overloads without collision', () => {
|
|
const tree = parseJava(`
|
|
public class Repository {
|
|
public User find(Long id) { return null; }
|
|
public User find(String name, boolean active) { return null; }
|
|
public User find(String name, String email, int limit) { return null; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const finds = result!.methods.filter((m) => m.name === 'find');
|
|
expect(finds).toHaveLength(3);
|
|
expect(finds.map((m) => m.parameters.length).sort()).toEqual([1, 2, 3]);
|
|
});
|
|
});
|
|
|
|
describe('extract from abstract class', () => {
|
|
it('detects abstract methods', () => {
|
|
const tree = parseJava(`
|
|
public abstract class Shape {
|
|
public abstract double area();
|
|
public double perimeter() { return 0; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
|
|
const areaMethod = result!.methods.find((m) => m.name === 'area');
|
|
const perimeterMethod = result!.methods.find((m) => m.name === 'perimeter');
|
|
|
|
expect(areaMethod!.isAbstract).toBe(true);
|
|
expect(perimeterMethod!.isAbstract).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract from interface', () => {
|
|
it('marks bodyless methods as abstract', () => {
|
|
const tree = parseJava(`
|
|
public interface Repository {
|
|
User findById(Long id);
|
|
List findAll();
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
expect(result!.methods[0].isAbstract).toBe(true);
|
|
expect(result!.methods[1].isAbstract).toBe(true);
|
|
});
|
|
|
|
it('marks default methods as non-abstract', () => {
|
|
const tree = parseJava(`
|
|
public interface Greeting {
|
|
void greet();
|
|
default String name() { return "World"; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
const greet = result!.methods.find((m) => m.name === 'greet');
|
|
const name = result!.methods.find((m) => m.name === 'name');
|
|
|
|
expect(greet!.isAbstract).toBe(true);
|
|
expect(name!.isAbstract).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract from enum', () => {
|
|
it('extracts enum methods', () => {
|
|
const tree = parseJava(`
|
|
public enum Planet {
|
|
EARTH;
|
|
public double surfaceGravity() { return 9.8; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
const sg = result!.methods.find((m) => m.name === 'surfaceGravity');
|
|
expect(sg).toBeDefined();
|
|
expect(sg!.returnType).toBe('double');
|
|
});
|
|
|
|
it('extracts methods from enum constant anonymous class bodies', () => {
|
|
const tree = parseJava(`
|
|
public enum Operation {
|
|
PLUS {
|
|
public double apply(double x, double y) { return x + y; }
|
|
};
|
|
public abstract double apply(double x, double y);
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
const applies = result!.methods.filter((m) => m.name === 'apply');
|
|
expect(applies).toHaveLength(2);
|
|
const abstractApply = applies.find((m) => m.isAbstract);
|
|
const concreteApply = applies.find((m) => !m.isAbstract);
|
|
expect(abstractApply).toBeDefined();
|
|
expect(concreteApply).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('extract from annotation type', () => {
|
|
it('extracts annotation element declarations', () => {
|
|
const tree = parseJava(`
|
|
public @interface MyAnnotation {
|
|
String value();
|
|
int count() default 0;
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('MyAnnotation');
|
|
expect(result!.methods).toHaveLength(2);
|
|
expect(result!.methods.map((m) => m.name).sort()).toEqual(['count', 'value']);
|
|
});
|
|
});
|
|
|
|
describe('extract from record', () => {
|
|
it('extracts compact constructor', () => {
|
|
const tree = parseJava(`
|
|
public record Point(int x, int y) {
|
|
public Point {
|
|
if (x < 0) throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const ctor = result!.methods.find((m) => m.name === 'Point');
|
|
expect(ctor).toBeDefined();
|
|
// Compact constructors inherit parameters from the record components
|
|
expect(ctor!.parameters).toHaveLength(2);
|
|
expect(ctor!.parameters[0].name).toBe('x');
|
|
expect(ctor!.parameters[1].name).toBe('y');
|
|
});
|
|
});
|
|
|
|
describe('extract primitive varargs', () => {
|
|
it('extracts int... vararg type', () => {
|
|
const tree = parseJava(`
|
|
public class MathUtils {
|
|
public int sum(int... nums) { return 0; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.parameters).toHaveLength(1);
|
|
expect(m.parameters[0].type).toBe('int');
|
|
expect(m.parameters[0].isVariadic).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('no methods', () => {
|
|
it('returns null for class with no methods', () => {
|
|
const tree = parseJava(`
|
|
public class Empty {
|
|
public int x;
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, javaCtx);
|
|
|
|
// No method_declaration nodes → empty methods array
|
|
expect(result).not.toBeNull();
|
|
expect(result!.methods).toHaveLength(0);
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Kotlin
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const describeKotlin = Kotlin ? describe : describe.skip;
|
|
|
|
describeKotlin('Kotlin MethodExtractor', () => {
|
|
const extractor = createMethodExtractor(kotlinMethodConfig);
|
|
|
|
describe('extract from class', () => {
|
|
it('extracts public method with parameters', () => {
|
|
const tree = parseKotlin(`
|
|
class UserService {
|
|
fun findById(id: Long, active: Boolean): User? {
|
|
return null
|
|
}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('UserService');
|
|
expect(result!.methods).toHaveLength(1);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('findById');
|
|
expect(m.visibility).toBe('public');
|
|
expect(m.isStatic).toBe(false);
|
|
expect(m.isAbstract).toBe(false);
|
|
expect(m.parameters).toHaveLength(2);
|
|
});
|
|
|
|
it('extracts private method', () => {
|
|
const tree = parseKotlin(`
|
|
class Foo {
|
|
private fun helper(): Int = 42
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
const m = result!.methods.find((m) => m.name === 'helper');
|
|
expect(m).toBeDefined();
|
|
expect(m!.visibility).toBe('private');
|
|
});
|
|
});
|
|
|
|
describe('extract vararg parameter', () => {
|
|
it('detects vararg as isVariadic', () => {
|
|
const tree = parseKotlin(`
|
|
class Logger {
|
|
fun log(vararg messages: String) { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const m = result!.methods[0];
|
|
expect(m.parameters).toHaveLength(1);
|
|
expect(m.parameters[0].name).toBe('messages');
|
|
expect(m.parameters[0].isVariadic).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('extension functions', () => {
|
|
it('extracts receiverType for extension functions', () => {
|
|
const tree = parseKotlin(`
|
|
class StringUtils {
|
|
fun String.addBang(): String = this + "!"
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('addBang');
|
|
expect(m.receiverType).toBe('String');
|
|
});
|
|
|
|
it('returns null receiverType for regular methods', () => {
|
|
const tree = parseKotlin(`
|
|
class Foo {
|
|
fun bar(): Int = 42
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods[0].receiverType).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('extract from abstract class', () => {
|
|
it('detects abstract methods', () => {
|
|
const tree = parseKotlin(`
|
|
abstract class Shape {
|
|
abstract fun area(): Double
|
|
fun description(): String = "shape"
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
const area = result!.methods.find((m) => m.name === 'area');
|
|
const desc = result!.methods.find((m) => m.name === 'description');
|
|
|
|
expect(area).toBeDefined();
|
|
expect(area!.isAbstract).toBe(true);
|
|
expect(desc).toBeDefined();
|
|
expect(desc!.isAbstract).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract from interface', () => {
|
|
it('marks bodyless methods as abstract', () => {
|
|
const tree = parseKotlin(`
|
|
interface Repository {
|
|
fun findById(id: Long): Any?
|
|
fun findAll(): List<Any>
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
for (const m of result!.methods) {
|
|
expect(m.isAbstract).toBe(true);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('default visibility', () => {
|
|
it('defaults to public', () => {
|
|
const tree = parseKotlin(`
|
|
class Foo {
|
|
fun bar() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('public');
|
|
});
|
|
});
|
|
|
|
describe('isFinal semantics', () => {
|
|
it('regular methods are final by default', () => {
|
|
const tree = parseKotlin(`
|
|
class Foo {
|
|
fun bar() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods[0].isFinal).toBe(true);
|
|
});
|
|
|
|
it('open methods are not final', () => {
|
|
const tree = parseKotlin(`
|
|
open class Foo {
|
|
open fun bar() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods[0].isFinal).toBe(false);
|
|
});
|
|
|
|
it('abstract methods are not final', () => {
|
|
const tree = parseKotlin(`
|
|
abstract class Foo {
|
|
abstract fun bar(): Int
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods[0].isFinal).toBe(false);
|
|
expect(result!.methods[0].isAbstract).toBe(true);
|
|
});
|
|
|
|
it('interface methods are not final (domain invariant)', () => {
|
|
const tree = parseKotlin(`
|
|
interface Foo {
|
|
fun bar(): Int
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, kotlinCtx);
|
|
|
|
expect(result!.methods[0].isAbstract).toBe(true);
|
|
expect(result!.methods[0].isFinal).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('companion object', () => {
|
|
it('extracts methods from companion object', () => {
|
|
const tree = parseKotlin(`
|
|
class UserService {
|
|
companion object {
|
|
fun create(): UserService = UserService()
|
|
}
|
|
}
|
|
`);
|
|
// companion_object is inside class_body
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const classBody = classNode.namedChild(1)!;
|
|
const companion = classBody.namedChild(0)!;
|
|
const result = extractor.extract(companion, kotlinCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Companion');
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('create');
|
|
expect(result!.methods[0].isStatic).toBe(true);
|
|
});
|
|
|
|
it('extracts methods from named companion object', () => {
|
|
const tree = parseKotlin(`
|
|
class Foo {
|
|
companion object Factory {
|
|
fun build(): Foo = Foo()
|
|
}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const classBody = classNode.namedChild(1)!;
|
|
const companion = classBody.namedChild(0)!;
|
|
const result = extractor.extract(companion, kotlinCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Factory');
|
|
expect(result!.methods[0].name).toBe('build');
|
|
expect(result!.methods[0].isStatic).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// C#
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('C# MethodExtractor', () => {
|
|
const extractor = createMethodExtractor(csharpMethodConfig);
|
|
|
|
describe('isTypeDeclaration', () => {
|
|
it('recognizes class_declaration', () => {
|
|
const tree = parseCSharp('public class Foo { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes interface_declaration', () => {
|
|
const tree = parseCSharp('public interface IBar { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes struct_declaration', () => {
|
|
const tree = parseCSharp('public struct Point { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes record_declaration', () => {
|
|
const tree = parseCSharp('public record Person { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('rejects using_directive', () => {
|
|
const tree = parseCSharp('using System;');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract from class', () => {
|
|
it('extracts public method with parameters', () => {
|
|
const tree = parseCSharp(`
|
|
public class UserService {
|
|
public User FindById(int id, bool active) { return null; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('UserService');
|
|
expect(result!.methods).toHaveLength(1);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('FindById');
|
|
expect(m.returnType).toBe('User');
|
|
expect(m.visibility).toBe('public');
|
|
expect(m.isStatic).toBe(false);
|
|
expect(m.isAbstract).toBe(false);
|
|
expect(m.isFinal).toBe(false);
|
|
expect(m.parameters).toHaveLength(2);
|
|
expect(m.parameters[0]).toEqual({
|
|
name: 'id',
|
|
type: 'int',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
expect(m.parameters[1]).toEqual({
|
|
name: 'active',
|
|
type: 'bool',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
});
|
|
|
|
it('extracts static method', () => {
|
|
const tree = parseCSharp(`
|
|
public class MathUtils {
|
|
public static int Add(int a, int b) { return a + b; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].isStatic).toBe(true);
|
|
});
|
|
|
|
it('extracts private method (default visibility)', () => {
|
|
const tree = parseCSharp(`
|
|
public class Foo {
|
|
void InternalMethod() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('private');
|
|
});
|
|
|
|
it('extracts sealed method', () => {
|
|
const tree = parseCSharp(`
|
|
public class Derived {
|
|
public sealed override string ToString() { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].isFinal).toBe(true);
|
|
expect(result!.methods[0].isOverride).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('extract from abstract class', () => {
|
|
it('detects abstract methods', () => {
|
|
const tree = parseCSharp(`
|
|
public abstract class Shape {
|
|
public abstract double Area();
|
|
public double Perimeter() { return 0; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
|
|
const areaMethod = result!.methods.find((m) => m.name === 'Area');
|
|
const perimeterMethod = result!.methods.find((m) => m.name === 'Perimeter');
|
|
|
|
expect(areaMethod!.isAbstract).toBe(true);
|
|
expect(perimeterMethod!.isAbstract).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract from interface', () => {
|
|
it('marks bodyless methods as abstract', () => {
|
|
const tree = parseCSharp(`
|
|
public interface IRepository {
|
|
void Save(int id);
|
|
string FindAll();
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
expect(result!.methods[0].isAbstract).toBe(true);
|
|
expect(result!.methods[1].isAbstract).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('extract params (variadic)', () => {
|
|
it('detects params as isVariadic', () => {
|
|
const tree = parseCSharp(`
|
|
public class Formatter {
|
|
public string Format(string template, params object[] args) { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].isVariadic).toBe(false);
|
|
expect(params[1].isVariadic).toBe(true);
|
|
expect(params[1].name).toBe('args');
|
|
});
|
|
});
|
|
|
|
describe('extract out/ref parameters', () => {
|
|
it('handles out parameter (type prefixed with modifier)', () => {
|
|
const tree = parseCSharp(`
|
|
public class Parser {
|
|
public bool TryParse(string input, out int result) { return false; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].name).toBe('input');
|
|
expect(params[1].name).toBe('result');
|
|
expect(params[1].type).toBe('out int');
|
|
});
|
|
|
|
it('handles ref parameter', () => {
|
|
const tree = parseCSharp(`
|
|
public class Swapper {
|
|
public void Swap(ref int a, ref int b) { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].type).toBe('ref int');
|
|
expect(params[1].type).toBe('ref int');
|
|
});
|
|
});
|
|
|
|
describe('extract optional parameters', () => {
|
|
it('detects optional with defaults', () => {
|
|
const tree = parseCSharp(`
|
|
public class Logger {
|
|
public void Log(string message, int level = 0) { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].isOptional).toBe(false);
|
|
expect(params[1].isOptional).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('extract attributes', () => {
|
|
it('extracts attribute names', () => {
|
|
const tree = parseCSharp(`
|
|
public class Controller {
|
|
[HttpGet]
|
|
[Authorize]
|
|
public string GetAll() { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].annotations).toContain('@HttpGet');
|
|
expect(result!.methods[0].annotations).toContain('@Authorize');
|
|
});
|
|
|
|
it('skips targeted attributes like [return: NotNull]', () => {
|
|
const tree = parseCSharp(`
|
|
public class Service {
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[Obsolete]
|
|
public bool Check() { return true; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
// [Obsolete] is a method attribute, [return: MarshalAs(...)] targets the return value
|
|
expect(result!.methods[0].annotations).toContain('@Obsolete');
|
|
expect(result!.methods[0].annotations).not.toContain('@MarshalAs');
|
|
});
|
|
});
|
|
|
|
describe('extract constructor', () => {
|
|
it('extracts constructor', () => {
|
|
const tree = parseCSharp(`
|
|
public class Service {
|
|
public Service(string name) { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const ctor = result!.methods.find((m) => m.name === 'Service');
|
|
expect(ctor).toBeDefined();
|
|
expect(ctor!.returnType).toBeNull();
|
|
expect(ctor!.parameters).toHaveLength(1);
|
|
expect(ctor!.parameters[0].name).toBe('name');
|
|
});
|
|
|
|
it('extracts static constructor as isStatic: true with same name as class', () => {
|
|
const tree = parseCSharp(`
|
|
public class Config {
|
|
static Config() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
const ctor = result!.methods.find((m) => m.name === 'Config');
|
|
expect(ctor).toBeDefined();
|
|
expect(ctor!.isStatic).toBe(true);
|
|
expect(ctor!.parameters).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('extract from struct', () => {
|
|
it('extracts struct methods', () => {
|
|
const tree = parseCSharp(`
|
|
public struct Point {
|
|
public double Distance() { return 0; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Point');
|
|
expect(result!.methods).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe('extract from record', () => {
|
|
it('extracts record methods', () => {
|
|
const tree = parseCSharp(`
|
|
public record Person {
|
|
public string FullName() { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Person');
|
|
expect(result!.methods).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe('internal visibility', () => {
|
|
it('detects internal visibility', () => {
|
|
const tree = parseCSharp(`
|
|
public class Foo {
|
|
internal void InternalMethod() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('internal');
|
|
});
|
|
});
|
|
|
|
describe('extract destructor', () => {
|
|
it('extracts destructor declaration', () => {
|
|
const tree = parseCSharp(`
|
|
public class Resource {
|
|
~Resource() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const dtor = result!.methods.find((m) => m.name === '~Resource');
|
|
expect(dtor).toBeDefined();
|
|
expect(dtor!.returnType).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('extract operator overload', () => {
|
|
it('extracts operator+ declaration', () => {
|
|
const tree = parseCSharp(`
|
|
public class Vector {
|
|
public static Vector operator +(Vector a, Vector b) { return a; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const op = result!.methods.find((m) => m.name === 'operator +');
|
|
expect(op).toBeDefined();
|
|
expect(op!.isStatic).toBe(true);
|
|
expect(op!.returnType).toBe('Vector');
|
|
expect(op!.parameters).toHaveLength(2);
|
|
});
|
|
});
|
|
|
|
describe('extract conversion operator', () => {
|
|
it('extracts implicit conversion operator', () => {
|
|
const tree = parseCSharp(`
|
|
public class Celsius {
|
|
public static implicit operator double(Celsius c) { return 0; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const conv = result!.methods.find((m) => m.name === 'implicit operator double');
|
|
expect(conv).toBeDefined();
|
|
expect(conv!.isStatic).toBe(true);
|
|
expect(conv!.returnType).toBe('double');
|
|
expect(conv!.parameters).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe('extract in parameter modifier', () => {
|
|
it('handles in parameter (read-only ref)', () => {
|
|
const tree = parseCSharp(`
|
|
public class Calculator {
|
|
public double Calculate(in double value) { return value; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(1);
|
|
expect(params[0].name).toBe('value');
|
|
expect(params[0].type).toBe('in double');
|
|
});
|
|
});
|
|
|
|
describe('extract this parameter (extension methods)', () => {
|
|
it('prefixes type with this for extension method parameter', () => {
|
|
const tree = parseCSharp(`
|
|
public static class StringExtensions {
|
|
public static bool IsNullOrEmpty(this string s) { return false; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
const params = result!.methods[0].parameters;
|
|
|
|
expect(params).toHaveLength(1);
|
|
expect(params[0].name).toBe('s');
|
|
expect(params[0].type).toBe('this string');
|
|
});
|
|
});
|
|
|
|
describe('compound visibility', () => {
|
|
it('detects protected internal', () => {
|
|
const tree = parseCSharp(`
|
|
public class Foo {
|
|
protected internal void SharedMethod() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('protected internal');
|
|
});
|
|
|
|
it('detects private protected', () => {
|
|
const tree = parseCSharp(`
|
|
public class Foo {
|
|
private protected void RestrictedMethod() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('private protected');
|
|
});
|
|
});
|
|
|
|
describe('expression-bodied members', () => {
|
|
it('extracts expression-bodied method', () => {
|
|
const tree = parseCSharp(`
|
|
public class MathUtils {
|
|
public int Double(int x) => x * 2;
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('Double');
|
|
expect(result!.methods[0].returnType).toBe('int');
|
|
expect(result!.methods[0].parameters).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe('primary constructor (C# 12)', () => {
|
|
it('extracts primary constructor from class declaration', () => {
|
|
const tree = parseCSharp(`
|
|
public class Point(int x, int y) {
|
|
public double Distance() => 0;
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.methods).toHaveLength(2);
|
|
|
|
const ctor = result!.methods.find((m) => m.name === 'Point');
|
|
expect(ctor).toBeDefined();
|
|
expect(ctor!.returnType).toBeNull();
|
|
expect(ctor!.parameters).toHaveLength(2);
|
|
expect(ctor!.parameters[0]).toEqual({
|
|
name: 'x',
|
|
type: 'int',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
|
|
const method = result!.methods.find((m) => m.name === 'Distance');
|
|
expect(method).toBeDefined();
|
|
});
|
|
|
|
it('extracts primary constructor from record declaration', () => {
|
|
const tree = parseCSharp(`
|
|
public record Person(string Name, int Age);
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
const ctor = result!.methods.find((m) => m.name === 'Person');
|
|
expect(ctor).toBeDefined();
|
|
expect(ctor!.parameters).toHaveLength(2);
|
|
expect(ctor!.parameters[0].name).toBe('Name');
|
|
expect(ctor!.parameters[1].name).toBe('Age');
|
|
});
|
|
});
|
|
|
|
describe('virtual / override / async modifiers', () => {
|
|
it('detects virtual method', () => {
|
|
const tree = parseCSharp(`
|
|
public class Base {
|
|
public virtual void Process() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].isVirtual).toBe(true);
|
|
expect(result!.methods[0].isOverride).toBeUndefined();
|
|
});
|
|
|
|
it('detects override method', () => {
|
|
const tree = parseCSharp(`
|
|
public class Derived {
|
|
public override void Process() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].isOverride).toBe(true);
|
|
expect(result!.methods[0].isVirtual).toBeUndefined();
|
|
});
|
|
|
|
it('detects async method', () => {
|
|
const tree = parseCSharp(`
|
|
public class Service {
|
|
public async Task<string> FetchData() { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].isAsync).toBe(true);
|
|
});
|
|
|
|
it('regular method has no virtual/override/async', () => {
|
|
const tree = parseCSharp(`
|
|
public class Foo {
|
|
public void Bar() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].isVirtual).toBeUndefined();
|
|
expect(result!.methods[0].isOverride).toBeUndefined();
|
|
expect(result!.methods[0].isAsync).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('record struct', () => {
|
|
// tree-sitter-c-sharp ^0.23.1 emits record_declaration for 'record struct' —
|
|
// there is no separate record_struct_declaration node type.
|
|
it('recognizes record struct via record_declaration', () => {
|
|
const tree = parseCSharp('public record struct Point { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('extracts methods from record struct', () => {
|
|
const tree = parseCSharp(`
|
|
public record struct Measurement(double Value) {
|
|
public string Format() { return ""; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Measurement');
|
|
expect(result!.methods.find((m) => m.name === 'Format')).toBeDefined();
|
|
});
|
|
|
|
it('extracts primary constructor from record struct', () => {
|
|
const tree = parseCSharp('public record struct Point(int X, int Y);');
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
const ctor = result!.methods.find((m) => m.name === 'Point');
|
|
expect(ctor).toBeDefined();
|
|
expect(ctor!.parameters).toHaveLength(2);
|
|
});
|
|
});
|
|
|
|
describe('partial methods', () => {
|
|
it('detects partial method declaration (no body)', () => {
|
|
const tree = parseCSharp(`
|
|
public partial class Foo {
|
|
partial void OnChanged();
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
const m = result!.methods.find((m) => m.name === 'OnChanged');
|
|
expect(m).toBeDefined();
|
|
expect(m!.isPartial).toBe(true);
|
|
// partial declaration-only is not abstract — it's a compile-time slot
|
|
expect(m!.isAbstract).toBe(false);
|
|
});
|
|
|
|
it('detects partial method implementation (with body)', () => {
|
|
const tree = parseCSharp(`
|
|
public partial class Foo {
|
|
partial void OnChanged() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
const m = result!.methods.find((m) => m.name === 'OnChanged');
|
|
expect(m).toBeDefined();
|
|
expect(m!.isPartial).toBe(true);
|
|
});
|
|
|
|
// When both declaration and implementation coexist in the same
|
|
// declaration_list, two MethodInfo entries are produced (one per node).
|
|
// Deduplication across partial class files is the caller's responsibility.
|
|
it('produces two entries when declaration and implementation coexist', () => {
|
|
const tree = parseCSharp(`
|
|
public partial class Foo {
|
|
partial void OnChanged();
|
|
partial void OnChanged() { }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
const partials = result!.methods.filter((m) => m.name === 'OnChanged');
|
|
expect(partials).toHaveLength(2);
|
|
for (const m of partials) {
|
|
expect(m.isPartial).toBe(true);
|
|
}
|
|
});
|
|
|
|
// Generic method type parameters are stripped from the name.
|
|
// public T GetValue<T>() → name: 'GetValue' (no <T>).
|
|
// This is intentional — the call graph uses names, not signatures.
|
|
it('generic method type parameters are stripped from name', () => {
|
|
const tree = parseCSharp(`
|
|
public class Repo {
|
|
public T GetValue<T>() { return default; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, csharpCtx);
|
|
|
|
expect(result!.methods[0].name).toBe('GetValue');
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// TypeScript
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const parseTypeScript = (code: string) => {
|
|
parser.setLanguage(TypeScript.typescript);
|
|
return parser.parse(code);
|
|
};
|
|
|
|
const tsCtx: MethodExtractorContext = {
|
|
filePath: 'Test.ts',
|
|
language: SupportedLanguages.TypeScript,
|
|
};
|
|
|
|
describe('TypeScript MethodExtractor', () => {
|
|
const extractor = createMethodExtractor(typescriptMethodConfig);
|
|
|
|
describe('isTypeDeclaration', () => {
|
|
it('recognizes class_declaration', () => {
|
|
const tree = parseTypeScript('class Foo { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes abstract_class_declaration', () => {
|
|
const tree = parseTypeScript('abstract class Foo { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes interface_declaration', () => {
|
|
const tree = parseTypeScript('interface Bar { }');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('rejects function_declaration', () => {
|
|
const tree = parseTypeScript('function hello() {}');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract', () => {
|
|
it('extracts typed method with return type and parameters', () => {
|
|
const tree = parseTypeScript(`
|
|
class UserService {
|
|
greet(name: string, age: number): string {
|
|
return name;
|
|
}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('UserService');
|
|
expect(result!.methods).toHaveLength(1);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('greet');
|
|
expect(m.returnType).toBe('string');
|
|
expect(m.visibility).toBe('public');
|
|
expect(m.isStatic).toBe(false);
|
|
expect(m.isAbstract).toBe(false);
|
|
expect(m.parameters).toHaveLength(2);
|
|
expect(m.parameters[0]).toEqual({
|
|
name: 'name',
|
|
type: 'string',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
expect(m.parameters[1]).toEqual({
|
|
name: 'age',
|
|
type: 'number',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
});
|
|
|
|
it('extracts static method', () => {
|
|
const tree = parseTypeScript(`
|
|
class MathUtils {
|
|
static add(a: number, b: number): number { return a + b; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods[0].isStatic).toBe(true);
|
|
expect(result!.methods[0].name).toBe('add');
|
|
});
|
|
|
|
it('extracts abstract class with abstract and concrete methods', () => {
|
|
const tree = parseTypeScript(`
|
|
abstract class Shape {
|
|
abstract area(): number;
|
|
describe(): string { return "shape"; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.methods).toHaveLength(2);
|
|
|
|
const abstractMethod = result!.methods.find((m) => m.name === 'area');
|
|
const concreteMethod = result!.methods.find((m) => m.name === 'describe');
|
|
expect(abstractMethod!.isAbstract).toBe(true);
|
|
expect(abstractMethod!.returnType).toBe('number');
|
|
expect(concreteMethod!.isAbstract).toBe(false);
|
|
expect(concreteMethod!.returnType).toBe('string');
|
|
});
|
|
|
|
it('extracts interface methods as abstract', () => {
|
|
const tree = parseTypeScript(`
|
|
interface Printable {
|
|
print(format: string): void;
|
|
getLabel(): string;
|
|
}
|
|
`);
|
|
const interfaceNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(interfaceNode, tsCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Printable');
|
|
expect(result!.methods).toHaveLength(2);
|
|
expect(result!.methods.every((m) => m.isAbstract)).toBe(true);
|
|
|
|
const printMethod = result!.methods.find((m) => m.name === 'print');
|
|
expect(printMethod!.parameters[0]).toEqual({
|
|
name: 'format',
|
|
type: 'string',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
expect(printMethod!.returnType).toBe('void');
|
|
});
|
|
|
|
it('extracts private and protected visibility', () => {
|
|
const tree = parseTypeScript(`
|
|
class Account {
|
|
private secret(): void {}
|
|
protected validate(): boolean { return true; }
|
|
public display(): void {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods).toHaveLength(3);
|
|
const secret = result!.methods.find((m) => m.name === 'secret');
|
|
const validate = result!.methods.find((m) => m.name === 'validate');
|
|
const display = result!.methods.find((m) => m.name === 'display');
|
|
expect(secret!.visibility).toBe('private');
|
|
expect(validate!.visibility).toBe('protected');
|
|
expect(display!.visibility).toBe('public');
|
|
});
|
|
|
|
it('extracts optional and rest parameters', () => {
|
|
const tree = parseTypeScript(`
|
|
class Logger {
|
|
log(message: string, level?: string, ...tags: string[]): void {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(3);
|
|
expect(params[0]).toEqual({
|
|
name: 'message',
|
|
type: 'string',
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
expect(params[1].name).toBe('level');
|
|
expect(params[1].isOptional).toBe(true);
|
|
expect(params[1].isVariadic).toBe(false);
|
|
expect(params[2].name).toBe('tags');
|
|
expect(params[2].isOptional).toBe(false);
|
|
expect(params[2].isVariadic).toBe(true);
|
|
});
|
|
|
|
it('extracts default parameter as optional', () => {
|
|
const tree = parseTypeScript(`
|
|
class Formatter {
|
|
format(value: string, prefix: string = ">>") { return prefix + value; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(2);
|
|
expect(params[1].name).toBe('prefix');
|
|
expect(params[1].isOptional).toBe(true);
|
|
});
|
|
|
|
it('extracts decorators as annotations', () => {
|
|
const tree = parseTypeScript(`
|
|
class Controller {
|
|
@Log
|
|
@deprecated("use newMethod")
|
|
handle(req: Request): void {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const annotations = result!.methods[0].annotations;
|
|
expect(annotations).toContain('@Log');
|
|
expect(annotations).toContain('@deprecated');
|
|
});
|
|
|
|
it('extracts async method', () => {
|
|
const tree = parseTypeScript(`
|
|
class ApiClient {
|
|
async fetch(url: string): Promise<Response> { return new Response(); }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods[0].isAsync).toBe(true);
|
|
expect(result!.methods[0].name).toBe('fetch');
|
|
expect(result!.methods[0].returnType).toBe('Promise');
|
|
});
|
|
|
|
it('extracts constructor', () => {
|
|
const tree = parseTypeScript(`
|
|
class Person {
|
|
constructor(public name: string, private age: number) {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
const ctor = result!.methods[0];
|
|
expect(ctor.name).toBe('constructor');
|
|
expect(ctor.parameters).toHaveLength(2);
|
|
expect(ctor.parameters[0].name).toBe('name');
|
|
expect(ctor.parameters[0].type).toBe('string');
|
|
expect(ctor.parameters[1].name).toBe('age');
|
|
expect(ctor.parameters[1].type).toBe('number');
|
|
});
|
|
|
|
it('extracts override method', () => {
|
|
const tree = parseTypeScript(`
|
|
class Child extends Parent {
|
|
override toString(): string { return "child"; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods[0].name).toBe('toString');
|
|
expect(result!.methods[0].isOverride).toBe(true);
|
|
});
|
|
|
|
it('extracts getter and setter as methods', () => {
|
|
const tree = parseTypeScript(`
|
|
class Config {
|
|
get value(): number { return 1; }
|
|
set value(v: number) {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
// Getter and setter both have name 'value' (no get/set prefix from extractName)
|
|
expect(result!.methods).toHaveLength(2);
|
|
const getter = result!.methods[0];
|
|
const setter = result!.methods[1];
|
|
expect(getter.name).toBe('value');
|
|
expect(getter.parameters).toHaveLength(0);
|
|
expect(getter.returnType).toBe('number');
|
|
expect(setter.name).toBe('value');
|
|
expect(setter.parameters).toHaveLength(1);
|
|
expect(setter.parameters[0].name).toBe('v');
|
|
});
|
|
|
|
it('extracts destructured parameter', () => {
|
|
const tree = parseTypeScript(`
|
|
class Handler {
|
|
handle({ method, path }: Request): void {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(1);
|
|
// Destructured params extract the pattern text and type from annotation
|
|
expect(params[0].name).toBe('{ method, path }');
|
|
expect(params[0].type).toBe('Request');
|
|
});
|
|
|
|
it('extracts generator method as method_definition', () => {
|
|
const tree = parseTypeScript(`
|
|
class Stream {
|
|
*items(): Generator<number> { yield 1; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('items');
|
|
expect(result!.methods[0].returnType).toBe('Generator');
|
|
});
|
|
|
|
it('extracts async generator method with isAsync true', () => {
|
|
const tree = parseTypeScript(`
|
|
class Stream {
|
|
async *values(): AsyncGenerator<number> { yield 1; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('values');
|
|
expect(result!.methods[0].isAsync).toBe(true);
|
|
expect(result!.methods[0].returnType).toBe('AsyncGenerator');
|
|
});
|
|
|
|
it('extracts computed property name with brackets', () => {
|
|
const tree = parseTypeScript(`
|
|
class Iterable {
|
|
[Symbol.iterator](): Iterator<number> { return this; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
// Computed names include brackets — this is intentional for static analysis disambiguation
|
|
expect(result!.methods[0].name).toBe('[Symbol.iterator]');
|
|
});
|
|
|
|
it('extracts class-level method overloads', () => {
|
|
const tree = parseTypeScript(`
|
|
class Parser {
|
|
parse(input: string): string;
|
|
parse(input: number): number;
|
|
parse(input: string | number): string | number { return input; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
// Two overload signatures (method_signature) + one implementation (method_definition) = 3
|
|
const parseMethods = result!.methods.filter((m) => m.name === 'parse');
|
|
expect(parseMethods).toHaveLength(3);
|
|
// Overload signatures inside a class body are not abstract
|
|
for (const m of parseMethods) {
|
|
expect(m.isAbstract).toBe(false);
|
|
}
|
|
});
|
|
|
|
it('filters out this-parameter (compile-time constraint)', () => {
|
|
const tree = parseTypeScript(`
|
|
class Handler {
|
|
handle(this: void, event: Event): void {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
// 'this' is not a real parameter — only 'event' should appear
|
|
expect(params).toHaveLength(1);
|
|
expect(params[0].name).toBe('event');
|
|
expect(params[0].type).toBe('Event');
|
|
});
|
|
|
|
it('does not false-positive on methods named after soft keywords', () => {
|
|
const tree = parseTypeScript(`
|
|
class Foo {
|
|
static abstract() {}
|
|
static() {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const abstractMethod = result!.methods.find((m) => m.name === 'abstract');
|
|
expect(abstractMethod).toBeDefined();
|
|
expect(abstractMethod!.isStatic).toBe(true);
|
|
expect(abstractMethod!.isAbstract).toBe(false); // name, not keyword
|
|
|
|
const staticMethod = result!.methods.find((m) => m.name === 'static');
|
|
expect(staticMethod).toBeDefined();
|
|
expect(staticMethod!.isStatic).toBe(false); // name, not keyword
|
|
});
|
|
|
|
it('extracts destructured rest parameter via required_parameter + rest_pattern', () => {
|
|
const tree = parseTypeScript(`
|
|
class Router {
|
|
route(base: string, ...{ method, path }: RouteConfig): void {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].name).toBe('base');
|
|
expect(params[1].name).toBe('{ method, path }');
|
|
expect(params[1].isVariadic).toBe(true);
|
|
expect(params[1].type).toBe('RouteConfig');
|
|
});
|
|
|
|
it('extracts ES2022 #private method as visibility private', () => {
|
|
const tree = parseTypeScript(`
|
|
class Vault {
|
|
#decrypt(data: string): string { return data; }
|
|
public read(): string { return this.#decrypt("x"); }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const decrypt = result!.methods.find((m) => m.name === '#decrypt');
|
|
expect(decrypt).toBeDefined();
|
|
expect(decrypt!.visibility).toBe('private');
|
|
expect(decrypt!.parameters[0].type).toBe('string');
|
|
|
|
const read = result!.methods.find((m) => m.name === 'read');
|
|
expect(read!.visibility).toBe('public');
|
|
});
|
|
|
|
it('extracts generic method without type params in name', () => {
|
|
const tree = parseTypeScript(`
|
|
class Mapper {
|
|
transform<T, U>(input: T, fn: (x: T) => U): U { return fn(input); }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('transform');
|
|
expect(m.parameters).toHaveLength(2);
|
|
expect(m.parameters[0].name).toBe('input');
|
|
expect(m.parameters[0].type).toBe('T');
|
|
});
|
|
|
|
it('returns empty methods for class with no methods', () => {
|
|
const tree = parseTypeScript(`
|
|
class Empty {}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, tsCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Empty');
|
|
expect(result!.methods).toHaveLength(0);
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// JavaScript
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const parseJavaScript = (code: string) => {
|
|
parser.setLanguage(JavaScript);
|
|
return parser.parse(code);
|
|
};
|
|
|
|
const jsCtx: MethodExtractorContext = {
|
|
filePath: 'Test.js',
|
|
language: SupportedLanguages.JavaScript,
|
|
};
|
|
|
|
describe('JavaScript MethodExtractor', () => {
|
|
const extractor = createMethodExtractor(javascriptMethodConfig);
|
|
|
|
describe('extract', () => {
|
|
it('extracts class method with default public visibility and null types', () => {
|
|
const tree = parseJavaScript(`
|
|
class Greeter {
|
|
greet(name) { return "Hello " + name; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Greeter');
|
|
expect(result!.methods).toHaveLength(1);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('greet');
|
|
expect(m.returnType).toBeNull();
|
|
expect(m.visibility).toBe('public');
|
|
expect(m.isAbstract).toBe(false);
|
|
expect(m.parameters).toHaveLength(1);
|
|
expect(m.parameters[0]).toEqual({
|
|
name: 'name',
|
|
type: null,
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
});
|
|
|
|
it('extracts static method and constructor', () => {
|
|
const tree = parseJavaScript(`
|
|
class Factory {
|
|
constructor(type) { this.type = type; }
|
|
static create(type) { return new Factory(type); }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
const ctor = result!.methods.find((m) => m.name === 'constructor');
|
|
const create = result!.methods.find((m) => m.name === 'create');
|
|
expect(ctor).toBeDefined();
|
|
expect(create!.isStatic).toBe(true);
|
|
});
|
|
|
|
it('extracts default parameter as optional and rest as variadic', () => {
|
|
const tree = parseJavaScript(`
|
|
class EventEmitter {
|
|
emit(event, data = null, ...listeners) {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(3);
|
|
expect(params[0]).toEqual({
|
|
name: 'event',
|
|
type: null,
|
|
isOptional: false,
|
|
isVariadic: false,
|
|
});
|
|
expect(params[1].name).toBe('data');
|
|
expect(params[1].isOptional).toBe(true);
|
|
expect(params[2].name).toBe('listeners');
|
|
expect(params[2].isVariadic).toBe(true);
|
|
});
|
|
|
|
it('does not detect abstract or interface types (JS has neither)', () => {
|
|
const tree = parseJavaScript(`
|
|
class Shape {
|
|
area() { return 0; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
expect(result!.methods[0].isAbstract).toBe(false);
|
|
expect(result!.methods[0].isFinal).toBe(false);
|
|
});
|
|
|
|
it('extracts private field method with # prefix', () => {
|
|
const tree = parseJavaScript(`
|
|
class Encapsulated {
|
|
#internal() { return 42; }
|
|
expose() { return this.#internal(); }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
const internal = result!.methods.find((m) => m.name === '#internal');
|
|
expect(internal).toBeDefined();
|
|
expect(internal!.name).toBe('#internal');
|
|
// ES2022 private methods (#name) are inherently private
|
|
expect(internal!.visibility).toBe('private');
|
|
});
|
|
|
|
it('extracts destructured object parameter', () => {
|
|
const tree = parseJavaScript(`
|
|
class Handler {
|
|
handle({ method, path }) {}
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(1);
|
|
expect(params[0].name).toBe('{ method, path }');
|
|
expect(params[0].type).toBeNull();
|
|
});
|
|
|
|
it('extracts async method', () => {
|
|
const tree = parseJavaScript(`
|
|
class Client {
|
|
async fetch(url) { return null; }
|
|
}
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, jsCtx);
|
|
|
|
expect(result!.methods[0].isAsync).toBe(true);
|
|
expect(result!.methods[0].name).toBe('fetch');
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// C++
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const parseCPP = (code: string) => {
|
|
parser.setLanguage(CPP);
|
|
return parser.parse(code);
|
|
};
|
|
|
|
const cppCtx: MethodExtractorContext = {
|
|
filePath: 'Test.cpp',
|
|
language: SupportedLanguages.CPlusPlus,
|
|
};
|
|
|
|
describe('C++ MethodExtractor', () => {
|
|
const extractor = createMethodExtractor(cppMethodConfig);
|
|
|
|
describe('isTypeDeclaration', () => {
|
|
it('recognizes class_specifier', () => {
|
|
const tree = parseCPP('class Foo {};');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes struct_specifier', () => {
|
|
const tree = parseCPP('struct Bar {};');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('recognizes union_specifier', () => {
|
|
const tree = parseCPP('union Variant {};');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(true);
|
|
});
|
|
|
|
it('rejects function_definition', () => {
|
|
const tree = parseCPP('void foo() {}');
|
|
expect(extractor.isTypeDeclaration(tree.rootNode.child(0)!)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('extract', () => {
|
|
it('extracts pure virtual method as isAbstract and isVirtual', () => {
|
|
const tree = parseCPP(`
|
|
class Shape {
|
|
public:
|
|
virtual double area() const = 0;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Shape');
|
|
expect(result!.methods).toHaveLength(1);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('area');
|
|
expect(m.returnType).toBe('double');
|
|
expect(m.isAbstract).toBe(true);
|
|
expect(m.isVirtual).toBe(true);
|
|
expect(m.visibility).toBe('public');
|
|
});
|
|
|
|
it('extracts virtual non-pure method as isAbstract false', () => {
|
|
const tree = parseCPP(`
|
|
class Base {
|
|
public:
|
|
virtual void draw() {}
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
const m = result!.methods[0];
|
|
expect(m.name).toBe('draw');
|
|
expect(m.isAbstract).toBe(false);
|
|
expect(m.isVirtual).toBe(true);
|
|
});
|
|
|
|
it('extracts final method', () => {
|
|
const tree = parseCPP(`
|
|
class Derived {
|
|
public:
|
|
void process() final;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].name).toBe('process');
|
|
expect(result!.methods[0].isFinal).toBe(true);
|
|
// final is only legal on virtual functions — isVirtual must be true
|
|
expect(result!.methods[0].isVirtual).toBe(true);
|
|
});
|
|
|
|
it('extracts override method', () => {
|
|
const tree = parseCPP(`
|
|
class Child {
|
|
public:
|
|
void draw() override {}
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].name).toBe('draw');
|
|
expect(result!.methods[0].isOverride).toBe(true);
|
|
// override is only legal on virtual functions — isVirtual must be true
|
|
expect(result!.methods[0].isVirtual).toBe(true);
|
|
});
|
|
|
|
it('non-virtual method has isVirtual false', () => {
|
|
const tree = parseCPP(`
|
|
class Plain {
|
|
public:
|
|
void bar();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].isVirtual).toBe(undefined);
|
|
});
|
|
|
|
it('extracts static method', () => {
|
|
const tree = parseCPP(`
|
|
class Factory {
|
|
public:
|
|
static Factory* create();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].name).toBe('create');
|
|
expect(result!.methods[0].isStatic).toBe(true);
|
|
expect(result!.methods[0].returnType).toBe('Factory');
|
|
});
|
|
|
|
it('extracts parameters with types including pointer and reference', () => {
|
|
const tree = parseCPP(`
|
|
class Handler {
|
|
public:
|
|
void process(int x, const char* name, double& ref);
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(3);
|
|
expect(params[0].name).toBe('x');
|
|
expect(params[0].type).toBe('int');
|
|
expect(params[1].name).toBe('name');
|
|
expect(params[1].type).toBe('char');
|
|
expect(params[2].name).toBe('ref');
|
|
expect(params[2].type).toBe('double');
|
|
});
|
|
|
|
it('extracts optional parameter with default value', () => {
|
|
const tree = parseCPP(`
|
|
class Config {
|
|
public:
|
|
void set(int value, int priority = 0);
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].isOptional).toBe(false);
|
|
expect(params[1].name).toBe('priority');
|
|
expect(params[1].isOptional).toBe(true);
|
|
});
|
|
|
|
it('extracts access specifier visibility correctly', () => {
|
|
const tree = parseCPP(`
|
|
class Account {
|
|
public:
|
|
void deposit(int amount);
|
|
private:
|
|
void validate();
|
|
protected:
|
|
void notify();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(3);
|
|
const deposit = result!.methods.find((m) => m.name === 'deposit');
|
|
const validate = result!.methods.find((m) => m.name === 'validate');
|
|
const notify = result!.methods.find((m) => m.name === 'notify');
|
|
expect(deposit!.visibility).toBe('public');
|
|
expect(validate!.visibility).toBe('private');
|
|
expect(notify!.visibility).toBe('protected');
|
|
});
|
|
|
|
it('defaults to private for class without access specifier', () => {
|
|
const tree = parseCPP(`
|
|
class Foo {
|
|
void bar();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('private');
|
|
});
|
|
|
|
it('defaults to public for struct without access specifier', () => {
|
|
const tree = parseCPP(`
|
|
struct Foo {
|
|
void bar();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].visibility).toBe('public');
|
|
});
|
|
|
|
it('extracts destructor', () => {
|
|
const tree = parseCPP(`
|
|
class Resource {
|
|
public:
|
|
~Resource();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods[0].name).toBe('~Resource');
|
|
});
|
|
|
|
it('extracts constructor', () => {
|
|
const tree = parseCPP(`
|
|
class Point {
|
|
public:
|
|
Point(int x, int y);
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('Point');
|
|
expect(result!.methods[0].parameters).toHaveLength(2);
|
|
});
|
|
|
|
it('returns empty methods for class with only data members', () => {
|
|
const tree = parseCPP(`
|
|
class Data {
|
|
int x;
|
|
int y;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
// field_declaration without function_declarator → extractName returns undefined → skipped
|
|
expect(result).not.toBeNull();
|
|
expect(result!.methods).toHaveLength(0);
|
|
});
|
|
|
|
it('extracts double-pointer parameter name correctly', () => {
|
|
const tree = parseCPP(`
|
|
class Allocator {
|
|
public:
|
|
void alloc(int** ptr, char** argv);
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
const params = result!.methods[0].parameters;
|
|
expect(params).toHaveLength(2);
|
|
expect(params[0].name).toBe('ptr');
|
|
expect(params[0].type).toBe('int');
|
|
expect(params[1].name).toBe('argv');
|
|
});
|
|
|
|
it('extracts template methods from class body with correct visibility', () => {
|
|
const tree = parseCPP(`
|
|
class Buffer {
|
|
public:
|
|
template<typename T>
|
|
void push(T value);
|
|
template<typename T>
|
|
T get(int index) { return T(); }
|
|
private:
|
|
template<typename T>
|
|
void internal(T x);
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(3);
|
|
const push = result!.methods.find((m) => m.name === 'push');
|
|
const get = result!.methods.find((m) => m.name === 'get');
|
|
const internal = result!.methods.find((m) => m.name === 'internal');
|
|
expect(push).toBeDefined();
|
|
expect(push!.parameters).toHaveLength(1);
|
|
expect(push!.parameters[0].name).toBe('value');
|
|
expect(push!.visibility).toBe('public');
|
|
expect(get).toBeDefined();
|
|
expect(get!.parameters).toHaveLength(1);
|
|
expect(get!.parameters[0].name).toBe('index');
|
|
expect(get!.visibility).toBe('public');
|
|
expect(internal).toBeDefined();
|
|
expect(internal!.visibility).toBe('private');
|
|
});
|
|
|
|
it('extracts methods from union_specifier', () => {
|
|
const tree = parseCPP(`
|
|
union Variant {
|
|
void clear();
|
|
int asInt() const;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result!.ownerName).toBe('Variant');
|
|
expect(result!.methods).toHaveLength(2);
|
|
// Union default visibility is public (like struct)
|
|
expect(result!.methods[0].visibility).toBe('public');
|
|
expect(result!.methods[1].visibility).toBe('public');
|
|
});
|
|
|
|
it('suppresses = delete special members from extraction', () => {
|
|
const tree = parseCPP(`
|
|
class NonCopyable {
|
|
public:
|
|
void doWork();
|
|
NonCopyable(const NonCopyable&) = delete;
|
|
NonCopyable& operator=(const NonCopyable&) = delete;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('doWork');
|
|
});
|
|
|
|
it('suppresses = default special members from extraction', () => {
|
|
const tree = parseCPP(`
|
|
class Widget {
|
|
public:
|
|
Widget() = default;
|
|
~Widget() = default;
|
|
void paint();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('paint');
|
|
});
|
|
|
|
it('does not suppress = 0 (pure virtual) as deleted/defaulted', () => {
|
|
const tree = parseCPP(`
|
|
class Shape {
|
|
public:
|
|
virtual double area() = 0;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(1);
|
|
expect(result!.methods[0].name).toBe('area');
|
|
expect(result!.methods[0].isAbstract).toBe(true);
|
|
});
|
|
|
|
it('extracts operator overloads', () => {
|
|
const tree = parseCPP(`
|
|
class Vec {
|
|
public:
|
|
Vec operator+(const Vec& rhs) const;
|
|
bool operator==(const Vec& rhs) const;
|
|
Vec& operator<<(int val);
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(3);
|
|
const names = result!.methods.map((m) => m.name);
|
|
expect(names).toContain('operator+');
|
|
expect(names).toContain('operator==');
|
|
expect(names).toContain('operator<<');
|
|
|
|
const plus = result!.methods.find((m) => m.name === 'operator+')!;
|
|
expect(plus.returnType).toBe('Vec');
|
|
expect(plus.parameters).toHaveLength(1);
|
|
expect(plus.parameters[0].name).toBe('rhs');
|
|
});
|
|
|
|
it('extracts method with deep pointer return type', () => {
|
|
const tree = parseCPP(`
|
|
class Matrix {
|
|
public:
|
|
int** getBuffer();
|
|
const char* getName();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
expect(result!.methods[0].name).toBe('getBuffer');
|
|
expect(result!.methods[0].returnType).toBe('int');
|
|
expect(result!.methods[1].name).toBe('getName');
|
|
});
|
|
|
|
it('defaults to private visibility for class, public for struct', () => {
|
|
const classTree = parseCPP(`
|
|
class Foo {
|
|
void secret();
|
|
};
|
|
`);
|
|
const classResult = extractor.extract(classTree.rootNode.child(0)!, cppCtx);
|
|
expect(classResult!.methods[0].name).toBe('secret');
|
|
expect(classResult!.methods[0].visibility).toBe('private');
|
|
|
|
const structTree = parseCPP(`
|
|
struct Bar {
|
|
void open();
|
|
};
|
|
`);
|
|
const structResult = extractor.extract(structTree.rootNode.child(0)!, cppCtx);
|
|
expect(structResult!.methods[0].name).toBe('open');
|
|
expect(structResult!.methods[0].visibility).toBe('public');
|
|
});
|
|
|
|
it('tracks visibility across multiple access specifier sections', () => {
|
|
const tree = parseCPP(`
|
|
class Mixed {
|
|
public:
|
|
void pub1();
|
|
private:
|
|
void priv1();
|
|
void priv2();
|
|
protected:
|
|
void prot1();
|
|
public:
|
|
void pub2();
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(5);
|
|
const byName = Object.fromEntries(result!.methods.map((m) => [m.name, m.visibility]));
|
|
expect(byName['pub1']).toBe('public');
|
|
expect(byName['priv1']).toBe('private');
|
|
expect(byName['priv2']).toBe('private');
|
|
expect(byName['prot1']).toBe('protected');
|
|
expect(byName['pub2']).toBe('public');
|
|
});
|
|
|
|
it('extracts trailing return type instead of auto', () => {
|
|
const tree = parseCPP(`
|
|
class Container {
|
|
public:
|
|
auto begin() -> iterator;
|
|
auto size() -> size_t;
|
|
};
|
|
`);
|
|
const classNode = tree.rootNode.child(0)!;
|
|
const result = extractor.extract(classNode, cppCtx);
|
|
|
|
expect(result!.methods).toHaveLength(2);
|
|
expect(result!.methods[0].name).toBe('begin');
|
|
expect(result!.methods[0].returnType).toBe('iterator');
|
|
expect(result!.methods[1].name).toBe('size');
|
|
expect(result!.methods[1].returnType).toBe('size_t');
|
|
});
|
|
});
|
|
});
|