gitnexus 1.6.11-rc.18 → 1.6.11-rc.19

package/dist/core/ingestion/language-provider.d.ts

@@ -297,6 +297,49 @@ interface LanguageProviderConfig {
      * Default: undefined (no interface-inheritance route resolution).
      */
     readonly extractRouteInheritanceTypes?: (tree: Parser.Tree, filePath: string) => SharedSpringType[];
+    /**
+     * Optional post-capture emission of synthetic structure members (nodes,
+     * symbols, ownership edges) that have no AST method node — e.g. Lombok
+     * accessors. Called once per file after the capture loop, at the same
+     * post-capture site as {@link extractDecoratorRoutes}.
+     *
+     * `classOwnersByNodeId` maps in-memory tree-sitter node ids of type
+     * declarations materialized in THIS file's capture loop to their graph
+     * node ids. Keys are never persisted; they exist only for the duration
+     * of the worker pass.
+     *
+     * Default: undefined (no synthetic structure members).
+     */
+    readonly synthesizeStructureMembers?: (tree: Parser.Tree, filePath: string, classOwnersByNodeId: ReadonlyMap<number, string>) => {
+        nodes: ReadonlyArray<{
+            id: string;
+            label: string;
+            properties: Record<string, unknown>;
+        }>;
+        symbols: ReadonlyArray<{
+            filePath: string;
+            name: string;
+            nodeId: string;
+            type: string;
+            ownerId?: string;
+            parameterCount?: number;
+            requiredParameterCount?: number;
+            parameterTypes?: string[];
+            returnType?: string;
+            visibility?: string;
+            isStatic?: boolean;
+            isAbstract?: boolean;
+            isFinal?: boolean;
+        }>;
+        relationships: ReadonlyArray<{
+            id: string;
+            sourceId: string;
+            targetId: string;
+            type: string;
+            confidence: number;
+            reason: string;
+        }>;
+    };
     /**
      * Harvest this file's module-level string constants (#2391 core, #2980 Java
      * parity) into the language-agnostic {@link ModuleConstants} shape, so the

package/dist/core/ingestion/languages/java/captures.js

@@ -18,6 +18,7 @@ import { captureJavaSpringAopFacts } from './spring-aop.js';
 import { captureJavaSpringConditionalFacts, } from './spring-conditionals.js';
 import { captureJavaSpringNonHttpHandlerFacts, } from './spring-non-http-handlers.js';
 import { synthesizeJavaRecordComponentAccessorCaptures } from './record-components.js';
+import { synthesizeLombokAccessorCaptures } from './lombok-synthesizer.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
 /** tree-sitter-java node types that the method extractor accepts. */
@@ -305,6 +306,7 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
         ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
         ...synthesizeJavaAnonymousClassDeclarations(tree.rootNode),
         ...synthesizeJavaRecordComponentAccessorCaptures(tree.rootNode),
+        ...synthesizeLombokAccessorCaptures(tree.rootNode),
         ...synthesizeCallableFlowCaptures(tree.rootNode, JAVA_CALLABLE_CAPTURE_OPTIONS),
     ];
 }

package/dist/core/ingestion/languages/java/lombok-synthesizer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Lombok accessor synthesizer for Java.
+ *
+ * Lombok generates getters/setters at compile time. They are absent from the
+ * AST, so calls like `obj.getOrderId()` on a `@Data` class would otherwise
+ * leave unresolved CALLS edges. This module walks the tree-sitter Java AST
+ * and synthesizes Method graph members for the accessors Lombok would emit
+ * under the supported subset.
+ *
+ * ## Supported subset (v1)
+ * - Proven `lombok.Data` / `lombok.Getter` / `lombok.Setter` (FQN or import).
+ * - Class- or field-level enable; `AccessLevel.NONE` disables.
+ * - Default JavaBeans naming; primitive `boolean isX` → `isX` / `setX`.
+ * - Access levels PUBLIC/PROTECTED/PRIVATE/PACKAGE.
+ * - `@Accessors(chain=true)` modeled as setter return = declaring type.
+ * - `@Accessors(fluent=true)` / `prefix=…`: omit affected accessors (names
+ *   cannot be proven without full Lombok config).
+ * - External `lombok.config`: unsupported (may change semantics invisibly).
+ *
+ * ## Identity
+ * Owner lookup uses in-memory AST node ids only. Method ids are derived from
+ * the stable declaring-owner graph key (the Class node id's name segment),
+ * never from persisted tree-sitter node ids.
+ */
+import type Parser from 'tree-sitter';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type PlannedJvmAccessor, type SyntheticAccessorResult, type SyntheticVisibility } from '../jvm/accessor-synthesis.js';
+export type LombokVisibility = SyntheticVisibility;
+export type SyntheticSymbol = SyntheticAccessorResult['symbols'][number];
+export type SyntheticNode = SyntheticAccessorResult['nodes'][number];
+export type SyntheticRelationship = SyntheticAccessorResult['relationships'][number];
+export type LombokSynthesisResult = SyntheticAccessorResult;
+export type PlannedLombokAccessor = PlannedJvmAccessor;
+export interface AccessorConfig {
+    enabled: boolean;
+    visibility: LombokVisibility;
+}
+export declare function getterName(fieldName: string, fieldType: string): string;
+export declare function setterName(fieldName: string, fieldType: string): string;
+export declare function synthesizeLombokAccessors(tree: Parser.Tree, filePath: string, classOwnersById: ReadonlyMap<number, string>): LombokSynthesisResult;
+/** Scope captures for Lombok accessors (dual-path parity with record components). */
+export declare function synthesizeLombokAccessorCaptures(rootNode: Parser.SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/java/lombok-synthesizer.js

@@ -0,0 +1,439 @@
+/**
+ * Lombok accessor synthesizer for Java.
+ *
+ * Lombok generates getters/setters at compile time. They are absent from the
+ * AST, so calls like `obj.getOrderId()` on a `@Data` class would otherwise
+ * leave unresolved CALLS edges. This module walks the tree-sitter Java AST
+ * and synthesizes Method graph members for the accessors Lombok would emit
+ * under the supported subset.
+ *
+ * ## Supported subset (v1)
+ * - Proven `lombok.Data` / `lombok.Getter` / `lombok.Setter` (FQN or import).
+ * - Class- or field-level enable; `AccessLevel.NONE` disables.
+ * - Default JavaBeans naming; primitive `boolean isX` → `isX` / `setX`.
+ * - Access levels PUBLIC/PROTECTED/PRIVATE/PACKAGE.
+ * - `@Accessors(chain=true)` modeled as setter return = declaring type.
+ * - `@Accessors(fluent=true)` / `prefix=…`: omit affected accessors (names
+ *   cannot be proven without full Lombok config).
+ * - External `lombok.config`: unsupported (may change semantics invisibly).
+ *
+ * ## Identity
+ * Owner lookup uses in-memory AST node ids only. Method ids are derived from
+ * the stable declaring-owner graph key (the Class node id's name segment),
+ * never from persisted tree-sitter node ids.
+ */
+import { jvmGetterName, jvmSetterName } from '../jvm/beanspec.js';
+import { createExistingMethodIndex, createJvmAccessorSynthesis, hasExistingMethod, rememberExistingMethodRange, } from '../jvm/accessor-synthesis.js';
+const JAVA_TYPE_DECLS = new Set([
+    'class_declaration',
+    'enum_declaration',
+    'interface_declaration',
+    'record_declaration',
+]);
+const LOMBOK_ANNOTATION_PACKAGE = new Map([
+    ['Data', 'lombok'],
+    ['Getter', 'lombok'],
+    ['Setter', 'lombok'],
+    ['Accessors', 'lombok.experimental'],
+    ['Tolerate', 'lombok.experimental'],
+]);
+export function getterName(fieldName, fieldType) {
+    return jvmGetterName(fieldName, fieldType === 'boolean');
+}
+export function setterName(fieldName, fieldType) {
+    return jvmSetterName(fieldName, fieldType === 'boolean');
+}
+// ── Provenance / imports ──────────────────────────────────────────────────
+function annotationSimpleName(nameText) {
+    return nameText.split('.').pop() ?? nameText;
+}
+/**
+ * Compilation-unit imports only — Java `import` is never nested in a type body.
+ */
+function collectLombokImports(root) {
+    const bySimple = new Map();
+    const starPackages = new Set();
+    const shadowedSimpleNames = new Set();
+    for (const child of root.children) {
+        if (!JAVA_TYPE_DECLS.has(child.type) && child.type !== 'annotation_type_declaration')
+            continue;
+        const name = child.childForFieldName('name')?.text;
+        if (name)
+            shadowedSimpleNames.add(name);
+    }
+    for (const child of root.children) {
+        if (child.type !== 'import_declaration')
+            continue;
+        if (/^import\s+static\b/.test(child.text))
+            continue;
+        const text = child.text
+            .replace(/^import\s+/, '')
+            .replace(/;\s*$/, '')
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .replace(/\s+/g, '')
+            .trim();
+        if (text === 'lombok.*') {
+            starPackages.add('lombok');
+        }
+        else if (text === 'lombok.experimental.*') {
+            starPackages.add('lombok.experimental');
+        }
+        else if (!text.endsWith('.*')) {
+            bySimple.set(annotationSimpleName(text), text);
+        }
+    }
+    return { bySimple, starPackages, shadowedSimpleNames };
+}
+function isProvenLombokAnnotation(nameText, imports) {
+    const simple = annotationSimpleName(nameText);
+    const packageName = LOMBOK_ANNOTATION_PACKAGE.get(simple);
+    if (packageName === undefined)
+        return false;
+    if (nameText.includes('.'))
+        return nameText === `${packageName}.${simple}`;
+    const imported = imports.bySimple.get(simple);
+    if (imported !== undefined)
+        return imported === `${packageName}.${simple}`;
+    if (imports.shadowedSimpleNames.has(simple))
+        return false;
+    return imports.starPackages.has(packageName);
+}
+// ── AccessLevel / Accessors structural parse ──────────────────────────────
+function parseAccessLevelToken(text) {
+    const simple = annotationSimpleName(text.trim());
+    switch (simple) {
+        case 'PUBLIC':
+            return 'public';
+        case 'PROTECTED':
+            return 'protected';
+        case 'PRIVATE':
+            return 'private';
+        case 'PACKAGE':
+        case 'MODULE': // treated as package-private for graph metadata
+            return 'package';
+        case 'NONE':
+            return 'none';
+        default:
+            return null;
+    }
+}
+function findAccessLevelInAnnotation(ann) {
+    // Positional: @Getter(AccessLevel.PROTECTED) or @Getter(lombok.AccessLevel.NONE)
+    // Named: @Getter(value = AccessLevel.PRIVATE)
+    const stack = [...ann.children];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (!n)
+            break;
+        if (n.type === 'field_access' || n.type === 'identifier') {
+            const level = parseAccessLevelToken(n.text);
+            if (level !== null)
+                return level;
+        }
+        for (const c of n.children)
+            stack.push(c);
+    }
+    return null;
+}
+function defaultAccessors() {
+    return { fluent: false, hasPrefix: false, chain: false };
+}
+function parseAccessorsAnnotation(ann) {
+    const opts = defaultAccessors();
+    const stack = [...ann.children];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (!n)
+            break;
+        if (n.type === 'element_value_pair') {
+            const key = n.childForFieldName('key')?.text ?? n.children.find((c) => c.type === 'identifier')?.text;
+            const valueNode = n.childForFieldName('value') ??
+                n.children.find((c) => c.type === 'true' || c.type === 'false' || c.type === 'element_value_array_initializer');
+            if (key === 'fluent' && (valueNode?.type === 'true' || valueNode?.type === 'false')) {
+                opts.fluent = valueNode.type === 'true';
+            }
+            if (key === 'chain' && (valueNode?.type === 'true' || valueNode?.type === 'false')) {
+                opts.chain = valueNode.type === 'true';
+            }
+            if (key === 'prefix')
+                opts.hasPrefix = true;
+        }
+        for (const c of n.children)
+            stack.push(c);
+    }
+    const text = ann.text;
+    if (/\bprefix\s*=/.test(text))
+        opts.hasPrefix = true;
+    if (/\bfluent\s*=\s*true\b/.test(text))
+        opts.fluent = true;
+    if (/\bfluent\s*=\s*false\b/.test(text))
+        opts.fluent = false;
+    if (/\bchain\s*=\s*true\b/.test(text))
+        opts.chain = true;
+    if (/\bchain\s*=\s*false\b/.test(text))
+        opts.chain = false;
+    return opts;
+}
+function parseModifierAnnotations(modifiersNode, imports) {
+    const result = {
+        getter: null,
+        setter: null,
+        accessors: defaultAccessors(),
+        accessorsPresent: false,
+        tolerate: false,
+    };
+    if (!modifiersNode)
+        return result;
+    for (const child of modifiersNode.children) {
+        if (child.type !== 'marker_annotation' && child.type !== 'annotation')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        const nameText = nameNode?.text ?? '';
+        if (!isProvenLombokAnnotation(nameText, imports))
+            continue;
+        const simple = annotationSimpleName(nameText);
+        if (simple === 'Tolerate') {
+            result.tolerate = true;
+            continue;
+        }
+        if (simple === 'Accessors') {
+            result.accessors = parseAccessorsAnnotation(child);
+            result.accessorsPresent = true;
+            continue;
+        }
+        if (simple === 'Data') {
+            result.getter ??= { enabled: true, visibility: 'public' };
+            result.setter ??= { enabled: true, visibility: 'public' };
+            continue;
+        }
+        if (simple === 'Getter' || simple === 'Setter') {
+            const level = child.type === 'annotation' ? findAccessLevelInAnnotation(child) : null;
+            const cfg = level === 'none'
+                ? { enabled: false, visibility: 'public' }
+                : { enabled: true, visibility: level ?? 'public' };
+            if (simple === 'Getter')
+                result.getter = cfg;
+            else
+                result.setter = cfg;
+        }
+    }
+    return result;
+}
+function mergeAccessors(classOpts, fieldOpts, fieldAccessorsPresent) {
+    return fieldAccessorsPresent ? fieldOpts : classOpts;
+}
+function effectiveAccessor(classCfg, fieldCfg) {
+    if (fieldCfg !== null)
+        return fieldCfg;
+    return classCfg;
+}
+// ── Field / method collection ─────────────────────────────────────────────
+function parseFieldDeclaration(fieldNode, imports) {
+    const typeNode = fieldNode.childForFieldName('type');
+    const fieldType = typeNode?.text ?? 'Object';
+    const modifiers = fieldNode.children.find((c) => c.type === 'modifiers') ?? null;
+    let isStatic = false;
+    let isFinal = false;
+    if (modifiers) {
+        for (const mod of modifiers.children) {
+            if (mod.text === 'static')
+                isStatic = true;
+            else if (mod.text === 'final')
+                isFinal = true;
+        }
+    }
+    const fieldAnn = parseModifierAnnotations(modifiers, imports);
+    const declarators = [];
+    const declaratorField = fieldNode.childForFieldName('declarator');
+    if (declaratorField)
+        declarators.push(declaratorField);
+    for (const child of fieldNode.children) {
+        if (child.type === 'variable_declarator' && child !== declaratorField) {
+            declarators.push(child);
+        }
+    }
+    const startLine = fieldNode.startPosition.row + 1;
+    const endLine = fieldNode.endPosition.row + 1;
+    const out = [];
+    for (const declaratorNode of declarators) {
+        const nameNode = declaratorNode.childForFieldName('name');
+        if (!nameNode)
+            continue;
+        out.push({
+            name: nameNode.text,
+            type: fieldType,
+            isStatic,
+            isFinal,
+            startLine,
+            endLine,
+            declaratorNode,
+            fieldGetter: fieldAnn.getter,
+            fieldSetter: fieldAnn.setter,
+            accessors: fieldAnn.accessors,
+            accessorsPresent: fieldAnn.accessorsPresent,
+        });
+    }
+    return out;
+}
+function methodArityRange(methodNode) {
+    const params = methodNode.childForFieldName('parameters');
+    if (!params)
+        return { min: 0, max: 0 };
+    let count = 0;
+    for (const child of params.namedChildren) {
+        if (child.type === 'spread_parameter')
+            return { min: count, max: Number.POSITIVE_INFINITY };
+        if (child.type === 'formal_parameter')
+            count += 1;
+    }
+    return { min: count, max: count };
+}
+function collectExistingMethods(classBody, imports) {
+    const index = createExistingMethodIndex('case-folded');
+    if (!classBody)
+        return index;
+    const scan = (container) => {
+        for (const child of container.children) {
+            if (child.type === 'enum_body_declarations') {
+                scan(child);
+                continue;
+            }
+            if (child.type !== 'method_declaration')
+                continue;
+            const mods = child.children.find((c) => c.type === 'modifiers') ?? null;
+            const ann = parseModifierAnnotations(mods, imports);
+            if (ann.tolerate)
+                continue;
+            const nameNode = child.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            const arity = methodArityRange(child);
+            rememberExistingMethodRange(index, nameNode.text, arity.min, arity.max);
+        }
+    };
+    scan(classBody);
+    return index;
+}
+const TYPE_BODIES = new Set(['class_body', 'enum_body']);
+function findTypeBody(node) {
+    return node.children.find((c) => TYPE_BODIES.has(c.type)) ?? null;
+}
+function findLombokClasses(root, imports) {
+    const classes = [];
+    function walk(node) {
+        if (node.type === 'class_declaration' || node.type === 'enum_declaration') {
+            const modifiers = node.children.find((c) => c.type === 'modifiers') ?? null;
+            const classAnn = parseModifierAnnotations(modifiers, imports);
+            const nameNode = node.childForFieldName('name');
+            const className = nameNode?.text ?? '';
+            if (className) {
+                const body = findTypeBody(node);
+                const fields = [];
+                if (body) {
+                    const collectFields = (container) => {
+                        for (const child of container.children) {
+                            if (child.type === 'field_declaration') {
+                                for (const f of parseFieldDeclaration(child, imports)) {
+                                    if (f.isStatic)
+                                        continue;
+                                    fields.push(f);
+                                }
+                            }
+                            else if (child.type === 'enum_body_declarations') {
+                                collectFields(child);
+                            }
+                        }
+                    };
+                    collectFields(body);
+                }
+                const anyFieldEnable = fields.some((f) => f.fieldGetter?.enabled === true || f.fieldSetter?.enabled === true);
+                const classEnable = classAnn.getter?.enabled === true || classAnn.setter?.enabled === true;
+                // Class-level NONE alone is not enable — getter/setter configs may be disabled
+                if (classEnable || anyFieldEnable) {
+                    classes.push({
+                        node,
+                        name: className,
+                        classGetter: classAnn.getter,
+                        classSetter: classAnn.setter,
+                        classAccessors: classAnn.accessors,
+                        fields,
+                        existingMethods: collectExistingMethods(body, imports),
+                    });
+                }
+            }
+        }
+        for (const child of node.children)
+            walk(child);
+    }
+    walk(root);
+    return classes;
+}
+function planAccessors(cls) {
+    const planned = [];
+    for (const field of cls.fields) {
+        const accessors = mergeAccessors(cls.classAccessors, field.accessors, field.accessorsPresent);
+        // fluent/prefix change names — omit rather than invent wrong names
+        if (accessors.fluent || accessors.hasPrefix)
+            continue;
+        const getterCfg = effectiveAccessor(cls.classGetter, field.fieldGetter);
+        const setterCfg = effectiveAccessor(cls.classSetter, field.fieldSetter);
+        if (getterCfg?.enabled) {
+            const gName = getterName(field.name, field.type);
+            if (!hasExistingMethod(cls.existingMethods, gName, 0)) {
+                planned.push({
+                    kind: 'getter',
+                    name: gName,
+                    returnType: field.type,
+                    parameterTypes: [],
+                    visibility: getterCfg.visibility,
+                    isStatic: false,
+                    isAbstract: false,
+                    startLine: field.startLine,
+                    endLine: field.endLine,
+                    declaratorNode: field.declaratorNode,
+                });
+            }
+        }
+        if (setterCfg?.enabled && !field.isFinal) {
+            const sName = setterName(field.name, field.type);
+            if (!hasExistingMethod(cls.existingMethods, sName, 1)) {
+                // chain=true → setter returns declaring type; never emit void in that case
+                const returnType = accessors.chain ? cls.name : 'void';
+                planned.push({
+                    kind: 'setter',
+                    name: sName,
+                    returnType,
+                    parameterTypes: [field.type],
+                    visibility: setterCfg.visibility,
+                    isStatic: false,
+                    isAbstract: false,
+                    startLine: field.startLine,
+                    endLine: field.endLine,
+                    declaratorNode: field.declaratorNode,
+                });
+            }
+        }
+    }
+    return planned;
+}
+function planLombokAccessorOwners(root) {
+    const imports = collectLombokImports(root);
+    return findLombokClasses(root, imports).map((cls) => ({
+        node: cls.node,
+        name: cls.name,
+        accessors: planAccessors(cls),
+    }));
+}
+const lombokAccessorSynthesis = createJvmAccessorSynthesis({
+    language: 'java',
+    synthetic: 'lombok',
+    planOwners: planLombokAccessorOwners,
+});
+// ── Main API ──────────────────────────────────────────────────────────────
+export function synthesizeLombokAccessors(tree, filePath, classOwnersById) {
+    return lombokAccessorSynthesis.synthesize(tree, filePath, classOwnersById);
+}
+/** Scope captures for Lombok accessors (dual-path parity with record components). */
+export function synthesizeLombokAccessorCaptures(rootNode) {
+    return lombokAccessorSynthesis.captures(rootNode);
+}

package/dist/core/ingestion/languages/java.js

@@ -28,6 +28,7 @@ import { createJavaCfgVisitor } from '../cfg/visitors/java.js';
 import { assertCloneable } from '../workers/clone-safety.js';
 import { collectJavaCaptureSideChannel } from './java/capture-side-channel.js';
 import { javaRecordMethodExtractor, shouldSkipJavaRecordComponentDefinition, } from './java/record-components.js';
+import { synthesizeLombokAccessors } from './java/lombok-synthesizer.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
 /**
  * Java names the platform owns, matched against a BARE IDENTIFIER — a dropped
@@ -187,6 +188,7 @@ export const javaProvider = defineLanguage({
     // ── Route extraction ──
     extractDecoratorRoutes: extractSpringRoutes,
     extractRouteInheritanceTypes: extractSpringTypes,
+    synthesizeStructureMembers: synthesizeLombokAccessors,
     // ── #2980: constant harvest + qualified-ref fold for non-literal mapping
     // paths (`@PostMapping(ApiPaths.SAVE_V1)`) — kept behind provider hooks so
     // the shared ingestion layers stay language-agnostic. The heuristic is

package/dist/core/ingestion/languages/jvm/accessor-synthesis.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Shared planning orchestration and emission for synthetic JVM accessors.
+ *
+ * Language adapters discover accessor plans. This module owns method-collision
+ * policy, graph emission, and scope captures without naming any language.
+ */
+import type Parser from 'tree-sitter';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export type SyntheticVisibility = 'public' | 'protected' | 'private' | 'package';
+export type MethodNameMatching = 'exact' | 'case-folded';
+export interface ExistingMethodIndex {
+    readonly matching: MethodNameMatching;
+    readonly aritiesByName: Map<string, Set<number>>;
+    readonly arityRangesByName: Map<string, Array<{
+        min: number;
+        max: number;
+    }>>;
+}
+export declare function createExistingMethodIndex(matching: MethodNameMatching): ExistingMethodIndex;
+export declare function rememberExistingMethod(index: ExistingMethodIndex, name: string, arity: number): void;
+export declare function rememberExistingMethodRange(index: ExistingMethodIndex, name: string, min: number, max: number): void;
+export declare function hasExistingMethod(index: ExistingMethodIndex, name: string, arity: number): boolean;
+export interface SyntheticAccessorSymbol {
+    filePath: string;
+    name: string;
+    nodeId: string;
+    type: 'Method';
+    ownerId: string;
+    qualifiedName: string;
+    parameterCount: number;
+    requiredParameterCount: number;
+    parameterTypes: string[];
+    returnType: string;
+    visibility: SyntheticVisibility;
+    isStatic: boolean;
+    isAbstract: boolean;
+    isFinal: boolean;
+}
+export interface SyntheticAccessorNode {
+    id: string;
+    label: 'Method';
+    properties: {
+        name: string;
+        filePath: string;
+        startLine: number;
+        endLine: number;
+        language: string;
+        isExported: boolean;
+        synthetic: string;
+        visibility: SyntheticVisibility;
+        isStatic: boolean;
+        returnType: string;
+        parameterTypes: string[];
+        parameterCount: number;
+        qualifiedName: string;
+    };
+}
+export interface SyntheticAccessorRelationship {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    type: 'HAS_METHOD';
+    confidence: number;
+    reason: string;
+}
+export interface SyntheticAccessorResult {
+    symbols: SyntheticAccessorSymbol[];
+    nodes: SyntheticAccessorNode[];
+    relationships: SyntheticAccessorRelationship[];
+}
+export interface PlannedJvmAccessor {
+    kind: 'getter' | 'setter';
+    name: string;
+    returnType: string;
+    parameterTypes: string[];
+    visibility: SyntheticVisibility;
+    isStatic: boolean;
+    isAbstract: boolean;
+    startLine: number;
+    endLine: number;
+    declaratorNode: Parser.SyntaxNode;
+}
+export interface PlannedJvmAccessorOwner {
+    node: Parser.SyntaxNode;
+    name: string;
+    accessors: readonly PlannedJvmAccessor[];
+}
+interface JvmAccessorSynthesisConfig {
+    language: string;
+    synthetic: string;
+    planOwners(rootNode: Parser.SyntaxNode): readonly PlannedJvmAccessorOwner[];
+}
+export interface JvmAccessorSynthesis {
+    synthesize(tree: Parser.Tree, filePath: string, classOwnersById: ReadonlyMap<number, string>): SyntheticAccessorResult;
+    captures(rootNode: Parser.SyntaxNode): CaptureMatch[];
+}
+export declare function createJvmAccessorSynthesis(config: JvmAccessorSynthesisConfig): JvmAccessorSynthesis;
+export declare function jvmTypeSimpleName(node: Parser.SyntaxNode): string | undefined;
+export {};