gitnexus 1.6.11-rc.2 → 1.6.11-rc.21

package/dist/core/ingestion/languages/jvm/accessor-synthesis.js

@@ -0,0 +1,173 @@
+import { toZeroBasedLine } from '../../utils/line-base.js';
+export function createExistingMethodIndex(matching) {
+    return { matching, aritiesByName: new Map(), arityRangesByName: new Map() };
+}
+function methodKey(index, name) {
+    return index.matching === 'case-folded' ? name.toLowerCase() : name;
+}
+export function rememberExistingMethod(index, name, arity) {
+    const key = methodKey(index, name);
+    let arities = index.aritiesByName.get(key);
+    if (!arities) {
+        arities = new Set();
+        index.aritiesByName.set(key, arities);
+    }
+    arities.add(arity);
+}
+export function rememberExistingMethodRange(index, name, min, max) {
+    if (min === max) {
+        rememberExistingMethod(index, name, min);
+        return;
+    }
+    const key = methodKey(index, name);
+    const ranges = index.arityRangesByName.get(key) ?? [];
+    ranges.push({ min, max });
+    index.arityRangesByName.set(key, ranges);
+}
+export function hasExistingMethod(index, name, arity) {
+    const key = methodKey(index, name);
+    if (index.aritiesByName.get(key)?.has(arity) === true)
+        return true;
+    return (index.arityRangesByName.get(key)?.some((range) => range.min <= arity && arity <= range.max) ===
+        true);
+}
+export function createJvmAccessorSynthesis(config) {
+    return {
+        synthesize(tree, filePath, classOwnersById) {
+            const result = emptySyntheticAccessorResult();
+            for (const owner of config.planOwners(tree.rootNode)) {
+                const ownerId = classOwnersById.get(owner.node.id);
+                if (!ownerId)
+                    continue;
+                emitPlannedAccessors({
+                    planned: owner.accessors,
+                    filePath,
+                    ownerId,
+                    idPrefix: ownerIdNamePrefix(ownerId, filePath, owner.name),
+                    language: config.language,
+                    synthetic: config.synthetic,
+                    result,
+                });
+            }
+            return result;
+        },
+        captures(rootNode) {
+            return capturesForPlannedAccessors(config.planOwners(rootNode));
+        },
+    };
+}
+function emptySyntheticAccessorResult() {
+    return { symbols: [], nodes: [], relationships: [] };
+}
+function ownerIdNamePrefix(ownerId, filePath, fallback) {
+    const needle = `Class:${filePath}:`;
+    if (ownerId.startsWith(needle))
+        return ownerId.slice(needle.length);
+    const enumNeedle = `Enum:${filePath}:`;
+    if (ownerId.startsWith(enumNeedle))
+        return ownerId.slice(enumNeedle.length);
+    const ifaceNeedle = `Interface:${filePath}:`;
+    if (ownerId.startsWith(ifaceNeedle))
+        return ownerId.slice(ifaceNeedle.length);
+    return fallback;
+}
+export function jvmTypeSimpleName(node) {
+    const named = node.childForFieldName('name')?.text;
+    if (named)
+        return named;
+    for (const child of node.namedChildren) {
+        if (child.type === 'type_identifier' || child.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function emitPlannedAccessors(args) {
+    const emittedIds = new Set();
+    for (const acc of args.planned) {
+        const arity = acc.parameterTypes.length;
+        const qualifiedName = `${args.idPrefix}.${acc.name}`;
+        const nodeId = `Method:${args.filePath}:${qualifiedName}#${arity}`;
+        if (emittedIds.has(nodeId))
+            continue;
+        emittedIds.add(nodeId);
+        args.result.nodes.push({
+            id: nodeId,
+            label: 'Method',
+            properties: {
+                name: acc.name,
+                filePath: args.filePath,
+                startLine: toZeroBasedLine(acc.startLine),
+                endLine: toZeroBasedLine(acc.endLine),
+                language: args.language,
+                isExported: false,
+                synthetic: args.synthetic,
+                visibility: acc.visibility,
+                isStatic: acc.isStatic,
+                returnType: acc.returnType,
+                parameterTypes: acc.parameterTypes,
+                parameterCount: arity,
+                qualifiedName,
+            },
+        });
+        args.result.symbols.push({
+            filePath: args.filePath,
+            name: acc.name,
+            nodeId,
+            type: 'Method',
+            ownerId: args.ownerId,
+            qualifiedName,
+            parameterCount: arity,
+            requiredParameterCount: arity,
+            parameterTypes: acc.parameterTypes,
+            returnType: acc.returnType,
+            visibility: acc.visibility,
+            isStatic: acc.isStatic,
+            isAbstract: acc.isAbstract,
+            isFinal: false,
+        });
+        args.result.relationships.push({
+            id: `HAS_METHOD:${args.ownerId}->${nodeId}`,
+            sourceId: args.ownerId,
+            targetId: nodeId,
+            type: 'HAS_METHOD',
+            confidence: 1.0,
+            reason: acc.kind === 'getter' ? `${args.synthetic}-getter` : `${args.synthetic}-setter`,
+        });
+    }
+}
+function accessorCapture(name, acc, text) {
+    const node = acc.declaratorNode;
+    const startLine = node.startPosition.row + 1;
+    const startCol = node.startPosition.column;
+    const endLine = node.endPosition.row + 1;
+    const endCol = acc.kind === 'getter' ? node.endPosition.column : startCol;
+    return { name, range: { startLine, startCol, endLine, endCol }, text };
+}
+function capturesForPlannedAccessors(owners) {
+    const captures = [];
+    for (const owner of owners) {
+        const enclosing = owner.name;
+        const emitted = new Set();
+        for (const acc of owner.accessors) {
+            const arity = String(acc.parameterTypes.length);
+            const qualifiedName = `${enclosing}.${acc.name}`;
+            const identity = `${qualifiedName}#${arity}`;
+            if (emitted.has(identity))
+                continue;
+            emitted.add(identity);
+            captures.push({
+                '@scope.function': accessorCapture('@scope.function', acc, acc.name),
+            });
+            captures.push({
+                '@declaration.method': accessorCapture('@declaration.method', acc, acc.name),
+                '@declaration.name': accessorCapture('@declaration.name', acc, acc.name),
+                '@declaration.qualified_name': accessorCapture('@declaration.qualified_name', acc, qualifiedName),
+                '@declaration.parameter-count': accessorCapture('@declaration.parameter-count', acc, arity),
+                '@declaration.required-parameter-count': accessorCapture('@declaration.required-parameter-count', acc, arity),
+                '@declaration.return-type': accessorCapture('@declaration.return-type', acc, acc.returnType),
+                '@declaration.is-synthetic': accessorCapture('@declaration.is-synthetic', acc, 'true'),
+            });
+        }
+    }
+    return captures;
+}

package/dist/core/ingestion/languages/jvm/beanspec.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Language-neutral JVM JavaBeans naming primitives.
+ *
+ * Language adapters choose whether to invent/preserve an `is` prefix and
+ * which single-character capitalization policy their compiler uses.
+ */
+export declare function capitalizeBeanName(s: string): string;
+/**
+ * Primitive-boolean / Kotlin `is`-prefix fields whose name already starts with
+ * `is` plus a non-lowercase character keep that name for the getter and drop
+ * the `is` prefix for the setter base (`isEnabled` → `isEnabled()` /
+ * `setEnabled(...)`, `is1` → `is1()` / `set1(...)`). Digits and punctuation
+ * count as non-lowercase, matching Lombok `!Character.isLowerCase` and kotlinc.
+ */
+export declare function booleanIsPrefixBase(fieldName: string, useIsPrefix: boolean): string | null;
+export declare function jvmGetterName(fieldName: string, useIsPrefix: boolean, capitalize?: (name: string) => string): string;
+export declare function jvmSetterName(fieldName: string, useIsPrefix: boolean, capitalize?: (name: string) => string): string;

package/dist/core/ingestion/languages/jvm/beanspec.js

@@ -0,0 +1,42 @@
+/**
+ * Language-neutral JVM JavaBeans naming primitives.
+ *
+ * Language adapters choose whether to invent/preserve an `is` prefix and
+ * which single-character capitalization policy their compiler uses.
+ */
+export function capitalizeBeanName(s) {
+    if (s.length === 0)
+        return s;
+    const first = s.charAt(0);
+    const upper = first.toUpperCase();
+    // Java Character case conversion is one UTF-16 code unit. JavaScript
+    // full-case conversion may expand one unit (`ß` → `SS`), which would invent
+    // a method name no JVM compiler emits.
+    return (upper.length === 1 ? upper : first) + s.slice(1);
+}
+/**
+ * Primitive-boolean / Kotlin `is`-prefix fields whose name already starts with
+ * `is` plus a non-lowercase character keep that name for the getter and drop
+ * the `is` prefix for the setter base (`isEnabled` → `isEnabled()` /
+ * `setEnabled(...)`, `is1` → `is1()` / `set1(...)`). Digits and punctuation
+ * count as non-lowercase, matching Lombok `!Character.isLowerCase` and kotlinc.
+ */
+export function booleanIsPrefixBase(fieldName, useIsPrefix) {
+    if (!useIsPrefix || !fieldName.startsWith('is') || fieldName.length < 3)
+        return null;
+    const third = fieldName.charAt(2);
+    return third === third.toUpperCase() ? fieldName.slice(2) : null;
+}
+export function jvmGetterName(fieldName, useIsPrefix, capitalize = capitalizeBeanName) {
+    if (booleanIsPrefixBase(fieldName, useIsPrefix) !== null)
+        return fieldName;
+    if (useIsPrefix)
+        return `is${capitalize(fieldName)}`;
+    return `get${capitalize(fieldName)}`;
+}
+export function jvmSetterName(fieldName, useIsPrefix, capitalize = capitalizeBeanName) {
+    const stripped = booleanIsPrefixBase(fieldName, useIsPrefix);
+    if (stripped !== null)
+        return `set${stripped}`;
+    return `set${capitalize(fieldName)}`;
+}

package/dist/core/ingestion/languages/kotlin/capture-side-channel.d.ts

@@ -39,6 +39,7 @@
 import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
 import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
 import { type JvmPackageFact } from '../jvm/package-facts.js';
+import type { SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
 import type { KotlinSpringAopFact } from './spring-aop.js';
 import type { KotlinSpringConditionalFact } from './spring-conditionals.js';
 import type { KotlinSpringDiClassFact } from './spring-di.js';
@@ -63,6 +64,8 @@ export interface KotlinCaptureSideChannel {
     readonly springConditionalFacts?: readonly KotlinSpringConditionalFact[];
     /** Constructor, property, and method injection syntax captured per class. */
     readonly springDiFacts?: readonly KotlinSpringDiClassFact[];
+    /** Programmatic Spring bean lookups captured per callable. */
+    readonly springDynamicLookupFacts?: readonly SpringDynamicLookupFact[];
     /** Scheduled, event, messaging, and managed-job handler syntax captured per callable. */
     readonly springNonHttpHandlerFacts?: readonly KotlinSpringNonHttpHandlerFact[];
 }
@@ -75,6 +78,8 @@ export declare function setKotlinSpringConditionalFacts(filePath: string, facts:
 export declare function getKotlinSpringConditionalFacts(filePath: string): readonly KotlinSpringConditionalFact[];
 export declare function setKotlinSpringDiFacts(filePath: string, facts: readonly KotlinSpringDiClassFact[]): void;
 export declare function getKotlinSpringDiFacts(filePath: string): readonly KotlinSpringDiClassFact[];
+export declare function setKotlinSpringDynamicLookupFacts(filePath: string, facts: readonly SpringDynamicLookupFact[]): void;
+export declare function getKotlinSpringDynamicLookupFacts(filePath: string): readonly SpringDynamicLookupFact[];
 export declare function setKotlinSpringNonHttpHandlerFacts(filePath: string, facts: readonly KotlinSpringNonHttpHandlerFact[]): void;
 export declare function getKotlinSpringNonHttpHandlerFacts(filePath: string): readonly KotlinSpringNonHttpHandlerFact[];
 /**

package/dist/core/ingestion/languages/kotlin/capture-side-channel.js

@@ -44,12 +44,14 @@ const classAnnotations = createClassAnnotationFactStore();
 const springAopFacts = new Map();
 const springConditionalFacts = new Map();
 const springDiFacts = new Map();
+const springDynamicLookupFacts = new Map();
 const springNonHttpHandlerFacts = new Map();
 export function clearKotlinClassAnnotationFacts() {
     classAnnotations.clear();
     springAopFacts.clear();
     springConditionalFacts.clear();
     springDiFacts.clear();
+    springDynamicLookupFacts.clear();
     springNonHttpHandlerFacts.clear();
 }
 export function setKotlinSpringAopFacts(filePath, facts) {
@@ -85,6 +87,15 @@ export function setKotlinSpringDiFacts(filePath, facts) {
 export function getKotlinSpringDiFacts(filePath) {
     return springDiFacts.get(filePath) ?? [];
 }
+export function setKotlinSpringDynamicLookupFacts(filePath, facts) {
+    if (facts.length === 0)
+        springDynamicLookupFacts.delete(filePath);
+    else
+        springDynamicLookupFacts.set(filePath, facts);
+}
+export function getKotlinSpringDynamicLookupFacts(filePath) {
+    return springDynamicLookupFacts.get(filePath) ?? [];
+}
 export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
     if (facts.length === 0)
         springNonHttpHandlerFacts.delete(filePath);
@@ -105,6 +116,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
     const aopFacts = springAopFacts.get(filePath) ?? [];
     const conditionFacts = springConditionalFacts.get(filePath) ?? [];
     const diFacts = springDiFacts.get(filePath) ?? [];
+    const dynamicLookupFacts = springDynamicLookupFacts.get(filePath) ?? [];
     const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
     const packageFact = getKotlinPackageFact(filePath);
     if (companionScopes.length === 0 &&
@@ -112,6 +124,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
         aopFacts.length === 0 &&
         conditionFacts.length === 0 &&
         diFacts.length === 0 &&
+        dynamicLookupFacts.length === 0 &&
         nonHttpHandlerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
@@ -124,6 +137,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
         ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
         ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(dynamicLookupFacts.length > 0 ? { springDynamicLookupFacts: dynamicLookupFacts } : {}),
         ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
     };
 }
@@ -147,6 +161,7 @@ export function applyKotlinCaptureSideChannel(parsed) {
         setKotlinSpringAopFacts(parsed.filePath, []);
         setKotlinSpringConditionalFacts(parsed.filePath, []);
         setKotlinSpringDiFacts(parsed.filePath, []);
+        setKotlinSpringDynamicLookupFacts(parsed.filePath, []);
         setKotlinSpringNonHttpHandlerFacts(parsed.filePath, []);
         setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
@@ -158,6 +173,7 @@ export function applyKotlinCaptureSideChannel(parsed) {
     setKotlinSpringAopFacts(parsed.filePath, Array.isArray(data.springAopFacts) ? data.springAopFacts : []);
     setKotlinSpringConditionalFacts(parsed.filePath, Array.isArray(data.springConditionalFacts) ? data.springConditionalFacts : []);
     setKotlinSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
+    setKotlinSpringDynamicLookupFacts(parsed.filePath, Array.isArray(data.springDynamicLookupFacts) ? data.springDynamicLookupFacts : []);
     setKotlinSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
     setKotlinPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -10,10 +10,12 @@ import { normalizeKotlinType } from './interpret.js';
 import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
 import { getKotlinParser, getKotlinScopeQuery } from './query.js';
 import { markCompanionScope } from './companion-scopes.js';
-import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringDynamicLookupFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
 import { captureKotlinPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeLombokAccessorCaptures } from './lombok-synthesizer.js';
 import { captureKotlinSpringDiClassFact } from './spring-di.js';
+import { captureKotlinSpringDynamicLookupFact } from './spring-dynamic-lookup.js';
 import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { captureKotlinSpringAopFacts } from './spring-aop.js';
 import { captureKotlinSpringConditionalFacts, } from './spring-conditionals.js';
@@ -75,6 +77,8 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     const springNonHttpHandlerFacts = [];
     const springNonHttpHandlerTypeNodeIds = new Set();
     const springDiClassNodeIds = new Set();
+    const springDynamicLookupFacts = [];
+    const springDynamicLookupNodeIds = new Set();
     const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
@@ -97,6 +101,13 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        const dynamicLookupNode = nodeIfType(groupedNodes['@reference.call.member'], 'call_expression');
+        if (dynamicLookupNode !== null && !springDynamicLookupNodeIds.has(dynamicLookupNode.id)) {
+            springDynamicLookupNodeIds.add(dynamicLookupNode.id);
+            const fact = captureKotlinSpringDynamicLookupFact(dynamicLookupNode, filePath);
+            if (fact !== null)
+                springDynamicLookupFacts.push(fact);
+        }
         // tree-sitter-kotlin represents both classes and interfaces with
         // `class_declaration`; `object_declaration` is the separate object form.
         const springAopTypeNode = [
@@ -279,7 +290,9 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     setKotlinSpringAopFacts(filePath, springAopFacts);
     setKotlinSpringConditionalFacts(filePath, springConditionalFacts);
     setKotlinSpringDiFacts(filePath, springDiFacts);
+    setKotlinSpringDynamicLookupFacts(filePath, springDynamicLookupFacts);
     setKotlinSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
+    out.push(...synthesizeLombokAccessorCaptures(tree.rootNode));
     out.push(...synthesizeCallableFlowCaptures(tree.rootNode, KOTLIN_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }

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

@@ -0,0 +1,26 @@
+/**
+ * Kotlin accessor synthesizer (same provider-hook role as Java Lombok).
+ *
+ * kotlinc emits JavaBeans getters/setters for `val`/`var` properties. Those
+ * methods are absent from the tree-sitter AST, so Java (and Kotlin) calls
+ * like `user.getName()` miss CALLS edges. Planning is Kotlin-specific;
+ * naming and Method emission share `jvm/beanspec` + `jvm/accessor-synthesis`.
+ *
+ * ## Supported subset (v1)
+ * - Class / data class / object / companion / interface `val`/`var` properties
+ *   (interface accessors without a custom body are abstract JVM methods).
+ * - Primary-constructor `val`/`var` class parameters.
+ * - Names beginning with `is` + a non-lowercase character keep that getter name; all other
+ *   properties, including `Boolean`, use `get`.
+ * - Custom `get()`/`set()` bodies still emit their JVM accessor Methods.
+ * - Explicit `fun getX` / `@JvmField` / `const` skip synthesis.
+ * - `@JvmName`-renamed accessors are suppressed until custom-name emission lands.
+ * Unsupported: `@JvmStatic` renaming, file-facade top-level properties.
+ */
+import type Parser from 'tree-sitter';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntheticAccessorResult } from '../jvm/accessor-synthesis.js';
+export declare function kotlinGetterName(propertyName: string): string;
+export declare function kotlinSetterName(propertyName: string): string;
+export declare function synthesizeLombokAccessors(tree: Parser.Tree, filePath: string, classOwnersById: ReadonlyMap<number, string>): SyntheticAccessorResult;
+export declare function synthesizeLombokAccessorCaptures(rootNode: Parser.SyntaxNode): CaptureMatch[];